[Type checker] Factor "type check function body until" into a request.

DougGregor · DougGregor · commit ff2cb3305d4b · 2019-07-12T17:40:53.000-07:00
Extend the "type check function body" request to also cover the case
where we have a specific ending source location. Fold all of this
functionality into a single request, so we consistently go through a
request to compute a type-checked function body.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -5798,14 +5798,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     setBodyKind(BodyKind::MemberwiseInitializer);
   }
 
-  /// If a body has been loaded, flag that it's been type-checked.
-  /// This is kindof a hacky operation, but it avoids some unnecessary
-  /// duplication of work.
-  void setBodyTypeCheckedIfPresent() {
-    if (getBodyKind() == BodyKind::Parsed)
-      setBodyKind(BodyKind::TypeChecked);
-  }
-
   /// Gets the body of this function, stripping the unused portions of #if
   /// configs inside the body. If this function was not deserialized from a
   /// .swiftmodule, this body is reconstructed from the original
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -689,13 +689,14 @@ class LazyStoragePropertyRequest :
   bool isCached() const { return true; }
 };
 
-/// Request to type check the body of the given function.
+/// Request to type check the body of the given function up to the given
+/// source location.
 ///
 /// Produces true if an error occurred, false otherwise.
 /// FIXME: it would be far better to return the type-checked body.
-class TypeCheckFunctionBodyRequest :
-    public SimpleRequest<TypeCheckFunctionBodyRequest,
-                         bool(AbstractFunctionDecl *),
+class TypeCheckFunctionBodyUntilRequest :
+    public SimpleRequest<TypeCheckFunctionBodyUntilRequest,
+                         bool(AbstractFunctionDecl *, SourceLoc),
                          CacheKind::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -705,7 +706,8 @@ class TypeCheckFunctionBodyRequest :
 
   // Evaluation.
   llvm::Expected<bool>
-  evaluate(Evaluator &evaluator, AbstractFunctionDecl *func) const;
+  evaluate(Evaluator &evaluator, AbstractFunctionDecl *func,
+           SourceLoc endTypeCheckLoc) const;
 
 public:
   bool isCached() const { return true; }
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -40,4 +40,4 @@ SWIFT_TYPEID(IsGetterMutatingRequest)
 SWIFT_TYPEID(IsSetterMutatingRequest)
 SWIFT_TYPEID(OpaqueReadOwnershipRequest)
 SWIFT_TYPEID(LazyStoragePropertyRequest)
-SWIFT_TYPEID(TypeCheckFunctionBodyRequest)
+SWIFT_TYPEID(TypeCheckFunctionBodyUntilRequest)
diff --git a/include/swift/Basic/SourceLoc.h b/include/swift/Basic/SourceLoc.h
@@ -78,6 +78,14 @@ class SourceLoc {
   }
 
   void dump(const SourceManager &SM) const;
+
+	friend size_t hash_value(SourceLoc loc) {
+		return reinterpret_cast<uintptr_t>(loc.getOpaquePointerValue());
+	}
+
+	friend void simple_display(raw_ostream &OS, const SourceLoc &loc) {
+		// Nothing meaningful to print.
+	}
 };
 
 /// SourceRange in swift is a pair of locations.  However, note that the end
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
@@ -2235,23 +2235,26 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
   TypeChecker &TC;
   AbstractFunctionDecl *Implementation;
   OpaqueTypeDecl *OpaqueDecl;
+  BraceStmt *Body;
   SmallVector<std::pair<Expr*, Type>, 4> Candidates;
 
   bool HasInvalidReturn = false;
 
 public:
   OpaqueUnderlyingTypeChecker(TypeChecker &TC,
                               AbstractFunctionDecl *Implementation,
-                              OpaqueTypeDecl *OpaqueDecl)
+                              OpaqueTypeDecl *OpaqueDecl,
+                              BraceStmt *Body)
     : TC(TC),
       Implementation(Implementation),
-      OpaqueDecl(OpaqueDecl)
+      OpaqueDecl(OpaqueDecl),
+      Body(Body)
   {
     
   }
   
   void check() {
-    Implementation->getBody()->walk(*this);
+    Body->walk(*this);
 
     // If given function has any invalid returns in the body
     // let's not try to validate the types, since it wouldn't
@@ -2835,26 +2838,27 @@ performTopLevelDeclDiagnostics(TypeChecker &TC, TopLevelCodeDecl *TLCD) {
 
 /// Perform diagnostics for func/init/deinit declarations.
 void swift::performAbstractFuncDeclDiagnostics(TypeChecker &TC,
-                                               AbstractFunctionDecl *AFD) {
-  assert(AFD->getBody() && "Need a body to check");
+                                               AbstractFunctionDecl *AFD,
+                                               BraceStmt *body) {
+  assert(body && "Need a body to check");
   
   // Don't produce these diagnostics for implicitly generated code.
   if (AFD->getLoc().isInvalid() || AFD->isImplicit() || AFD->isInvalid())
     return;
   
   // Check for unused variables, as well as variables that are could be
   // declared as constants.
-  AFD->getBody()->walk(VarDeclUsageChecker(TC, AFD));
+  body->walk(VarDeclUsageChecker(TC, AFD));
   
   // If the function has an opaque return type, check the return expressions
   // to determine the underlying type.
   if (auto opaqueResultTy = AFD->getOpaqueResultTypeDecl()) {
-    OpaqueUnderlyingTypeChecker(TC, AFD, opaqueResultTy).check();
+    OpaqueUnderlyingTypeChecker(TC, AFD, opaqueResultTy, body).check();
   } else if (auto accessor = dyn_cast<AccessorDecl>(AFD)) {
     if (accessor->isGetter()) {
       if (auto opaqueResultTy
                           = accessor->getStorage()->getOpaqueResultTypeDecl()) {
-        OpaqueUnderlyingTypeChecker(TC, AFD, opaqueResultTy).check();
+        OpaqueUnderlyingTypeChecker(TC, AFD, opaqueResultTy, body).check();
       }
     }
   }
diff --git a/lib/Sema/MiscDiagnostics.h b/lib/Sema/MiscDiagnostics.h
@@ -43,7 +43,8 @@ void performSyntacticExprDiagnostics(TypeChecker &TC, const Expr *E,
 void performStmtDiagnostics(TypeChecker &TC, const Stmt *S);
 
 void performAbstractFuncDeclDiagnostics(TypeChecker &TC,
-                                        AbstractFunctionDecl *AFD);
+                                        AbstractFunctionDecl *AFD,
+                                        BraceStmt *body);
 
 /// Perform diagnostics on the top level code declaration.
 void performTopLevelDeclDiagnostics(TypeChecker &TC, TopLevelCodeDecl *TLCD);
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
@@ -1925,49 +1925,7 @@ static Type getFunctionBuilderType(FuncDecl *FD) {
 }
 
 bool TypeChecker::typeCheckAbstractFunctionBody(AbstractFunctionDecl *AFD) {
-  return evaluateOrDefault(Context.evaluator,
-                           TypeCheckFunctionBodyRequest{AFD},
-                           true);
-}
-
-llvm::Expected<bool>
-TypeCheckFunctionBodyRequest::evaluate(Evaluator &evaluator,
-                                       AbstractFunctionDecl *func) const {
-  ASTContext &ctx = func->getASTContext();
-  if (!func->hasInterfaceType()) {
-    TypeChecker &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
-    tc.validateDecl(func);
-  }
-
-  // HACK: don't type-check the same function body twice. This will eventually
-  // be handled by the request-evaluator's caching mechanism.
-  (void)func->getBody();
-  if (func->isBodyTypeChecked())
-    return false;
-
-  FrontendStatsTracer StatsTracer(ctx.Stats, "typecheck-fn", func);
-  PrettyStackTraceDecl StackEntry("type-checking", func);
-
-  if (ctx.Stats)
-    ctx.Stats->getFrontendCounters().NumFunctionsTypechecked++;
-
-  Optional<FunctionBodyTimer> timer;
-  TypeChecker &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
-  if (tc.DebugTimeFunctionBodies || tc.WarnLongFunctionBodies)
-    timer.emplace(func, tc.DebugTimeFunctionBodies, tc.WarnLongFunctionBodies);
-
-  tc.requestRequiredNominalTypeLayoutForParameters(func->getParameters());
-
-  bool error = tc.typeCheckAbstractFunctionBodyUntil(func, SourceLoc());
-  func->setBodyTypeCheckedIfPresent();
-
-  if (error)
-    return true;
-
-  if (func->getBody())
-    performAbstractFuncDeclDiagnostics(tc, func);
-
-  return false;
+  return typeCheckAbstractFunctionBodyUntil(AFD, SourceLoc());
 }
 
 static Expr* constructCallToSuperInit(ConstructorDecl *ctor,
@@ -2163,18 +2121,37 @@ static void checkClassConstructorBody(ClassDecl *classDecl,
   }
 }
 
-bool TypeChecker::typeCheckAbstractFunctionBodyUntil(AbstractFunctionDecl *AFD,
-                                                     SourceLoc EndTypeCheckLoc) {
-  validateDecl(AFD);
-  checkDefaultArguments(AFD->getParameters(), AFD);
+llvm::Expected<bool>
+TypeCheckFunctionBodyUntilRequest::evaluate(Evaluator &evaluator,
+                                            AbstractFunctionDecl *AFD,
+                                            SourceLoc endTypeCheckLoc) const {
+  ASTContext &ctx = AFD->getASTContext();
+
+  // Accounting for type checking of function bodies.
+  // FIXME: We could probably take this away, given that the request-evaluator
+  // does much of it for us.
+  FrontendStatsTracer StatsTracer(ctx.Stats, "typecheck-fn", AFD);
+  PrettyStackTraceDecl StackEntry("type-checking", AFD);
+
+  if (ctx.Stats)
+    ctx.Stats->getFrontendCounters().NumFunctionsTypechecked++;
+
+  Optional<FunctionBodyTimer> timer;
+  TypeChecker &tc = *static_cast<TypeChecker *>(ctx.getLazyResolver());
+  if (tc.DebugTimeFunctionBodies || tc.WarnLongFunctionBodies)
+    timer.emplace(AFD, tc.DebugTimeFunctionBodies, tc.WarnLongFunctionBodies);
+
+  tc.validateDecl(AFD);
+  tc.requestRequiredNominalTypeLayoutForParameters(AFD->getParameters());
+  tc.checkDefaultArguments(AFD->getParameters(), AFD);
 
   BraceStmt *body = AFD->getBody();
   if (!body || AFD->isBodyTypeChecked())
     return false;
 
   if (auto *func = dyn_cast<FuncDecl>(AFD)) {
     if (Type builderType = getFunctionBuilderType(func)) {
-      body = applyFunctionBuilderBodyTransform(func, body, builderType);
+      body = tc.applyFunctionBuilderBodyTransform(func, body, builderType);
       if (!body)
         return true;
     } else if (func->hasSingleExpressionBody()) {
@@ -2195,15 +2172,15 @@ bool TypeChecker::typeCheckAbstractFunctionBodyUntil(AbstractFunctionDecl *AFD,
     // simplifies SILGen.
     SmallVector<ASTNode, 8> Elts(body->getElements().begin(),
                                  body->getElements().end());
-    Elts.push_back(new (Context) ReturnStmt(body->getRBraceLoc(),
-                                            /*value*/nullptr,
-                                            /*implicit*/true));
-    body = BraceStmt::create(Context, body->getLBraceLoc(), Elts,
+    Elts.push_back(new (ctx) ReturnStmt(body->getRBraceLoc(),
+                                        /*value*/nullptr,
+                                        /*implicit*/true));
+    body = BraceStmt::create(ctx, body->getLBraceLoc(), Elts,
                              body->getRBraceLoc(), body->isImplicit());
   }
 
-  StmtChecker SC(*this, AFD);
-  SC.EndTypeCheckLoc = EndTypeCheckLoc;
+  StmtChecker SC(tc, AFD);
+  SC.EndTypeCheckLoc = endTypeCheckLoc;
   bool hadError = SC.typeCheckBody(body);
 
   // If this was a function with a single expression body, let's see
@@ -2222,16 +2199,30 @@ bool TypeChecker::typeCheckAbstractFunctionBodyUntil(AbstractFunctionDecl *AFD,
     }
   }
 
+  // Class constructor checking.
   if (auto *ctor = dyn_cast<ConstructorDecl>(AFD)) {
     if (auto classDecl = ctor->getDeclContext()->getSelfClassDecl()) {
       checkClassConstructorBody(classDecl, ctor, body);
     }
   }
 
+  // If nothing went wrong yet, perform extra checking.
+  if (!hadError && endTypeCheckLoc.isInvalid())
+    performAbstractFuncDeclDiagnostics(tc, AFD, body);
+
+  // Wire up the function body now.
   AFD->setBody(body, AbstractFunctionDecl::BodyKind::TypeChecked);
   return hadError;
 }
 
+bool TypeChecker::typeCheckAbstractFunctionBodyUntil(AbstractFunctionDecl *AFD,
+                                                     SourceLoc EndTypeCheckLoc) {
+  return evaluateOrDefault(
+             Context.evaluator,
+             TypeCheckFunctionBodyUntilRequest{AFD, EndTypeCheckLoc},
+             true);
+}
+
 bool TypeChecker::typeCheckClosureBody(ClosureExpr *closure) {
   checkParameterAttributes(closure->getParameters());
 
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -626,7 +626,7 @@ class TypeChecker final : public LazyResolver {
   TypeChecker(ASTContext &Ctx);
   friend class ASTContext;
   friend class constraints::ConstraintSystem;
-  friend class TypeCheckFunctionBodyRequest;
+  friend class TypeCheckFunctionBodyUntilRequest;
   
 public:
   /// Create a new type checker instance for the given ASTContext, if it
