Merge pull request swiftlang#32561 from slavapestov/code-completion-entry-points

Sema: Move code completion entry points to TypeCheckCodeCompletion.cpp

Author: slavapestov

lib/Sema/CMakeLists.txt

@@ -40,6 +40,7 @@ add_swift_host_library(swiftSema STATIC
   TypeCheckAvailability.cpp
   TypeCheckCaptures.cpp
   TypeCheckCircularity.cpp
+  TypeCheckCodeCompletion.cpp
   TypeCheckConstraints.cpp
   TypeCheckDecl.cpp
   TypeCheckDeclObjC.cpp

lib/Sema/CSApply.cpp

@@ -5777,16 +5777,9 @@ Expr *ExprRewriter::coerceCallArguments(Expr *arg, AnyFunctionType *funcType,
   return cs.cacheType(arg);
 }
 
-static ClosureExpr *getClosureLiteralExpr(Expr *expr) {
+static bool isClosureLiteralExpr(Expr *expr) {
   expr = expr->getSemanticsProvidingExpr();
-
-  if (auto *captureList = dyn_cast<CaptureListExpr>(expr))
-    return captureList->getClosureBody();
-
-  if (auto *closure = dyn_cast<ClosureExpr>(expr))
-    return closure;
-
-  return nullptr;
+  return (isa<CaptureListExpr>(expr) || isa<ClosureExpr>(expr));
 }
 
 /// If the expression is an explicit closure expression (potentially wrapped in
@@ -7329,7 +7322,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
   }
 
   // An immediate application of a closure literal is always noescape.
-  if (getClosureLiteralExpr(fn)) {
+  if (isClosureLiteralExpr(fn)) {
     if (auto fnTy = cs.getType(fn)->getAs<FunctionType>()) {
       fnTy = cast<FunctionType>(
         fnTy->withExtInfo(fnTy->getExtInfo().withNoEscape()));

lib/Sema/CSGen.cpp

@@ -3776,30 +3776,26 @@ namespace {
     }
   };
 
-  /// AST walker that "sanitizes" an expression for the
-  /// constraint-based type checker.
+  /// AST walker that "sanitizes" an expression for re-typechecking during
+  /// code completion.
   ///
-  /// This is necessary because Sema fills in too much type information before
-  /// the type-checker runs, causing redundant work, and for expression that
-  /// have already been typechecked and may contain unhandled AST nodes.
-  ///
-  /// FIXME: Remove this one we no longer re-type check expressions during
-  /// diagnostics and code completion.
+  /// FIXME: Remove this.
   class SanitizeExpr : public ASTWalker {
-    ConstraintSystem &CS;
+    ASTContext &C;
+    bool ShouldReusePrecheckedType;
     llvm::SmallDenseMap<OpaqueValueExpr *, Expr *, 4> OpenExistentials;
 
   public:
-    SanitizeExpr(ConstraintSystem &cs) : CS(cs){ }
-
-    ASTContext &getASTContext() const { return CS.getASTContext(); }
+    SanitizeExpr(ASTContext &C,
+                 bool shouldReusePrecheckedType)
+      : C(C), ShouldReusePrecheckedType(shouldReusePrecheckedType) { }
 
     std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
       while (true) {
 
         // If we should reuse pre-checked types, don't sanitize the expression
         // if it's already type-checked.
-        if (CS.shouldReusePrecheckedType() && expr->getType())
+        if (ShouldReusePrecheckedType && expr->getType())
           return { false, expr };
 
         // OpenExistentialExpr contains OpaqueValueExpr in its sub expression.
@@ -3892,7 +3888,7 @@ namespace {
             };
 
             if (TE->isImplicit() && TE->getNumElements() == 1 &&
-                TE->getElementName(0) == getASTContext().Id_dynamicMember &&
+                TE->getElementName(0) == C.Id_dynamicMember &&
                 isImplicitKeyPathExpr(TE->getElement(0))) {
               auto *keyPathExpr = cast<KeyPathExpr>(TE->getElement(0));
               auto *componentExpr = keyPathExpr->getParsedPath();
@@ -3957,15 +3953,15 @@ namespace {
           argList.labels[0].empty() &&
           !isa<VarargExpansionExpr>(argList.args[0])) {
         auto *result =
-          new (getASTContext()) ParenExpr(argList.lParenLoc,
-                                          argList.args[0],
-                                          argList.rParenLoc,
-                                          argList.hasTrailingClosure);
+          new (C) ParenExpr(argList.lParenLoc,
+                            argList.args[0],
+                            argList.rParenLoc,
+                            argList.hasTrailingClosure);
         result->setImplicit();
         return result;
       }
 
-      return TupleExpr::create(getASTContext(),
+      return TupleExpr::create(C,
                                argList.lParenLoc,
                                argList.args,
                                argList.labels,
@@ -3976,32 +3972,18 @@ namespace {
     }
 
     Expr *walkToExprPost(Expr *expr) override {
-      if (CS.hasType(expr)) {
-        Type type = CS.getType(expr);
-        if (type->hasOpenedExistential()) {
-          type = type.transform([&](Type type) -> Type {
-            if (auto archetype = type->getAs<OpenedArchetypeType>())
-              return archetype->getOpenedExistentialType();
-            return type;
-          });
-          CS.setType(expr, type);
-          // Set new type to the expression directly.
-          expr->setType(type);
-        }
-      }
-
       assert(!isa<ImplicitConversionExpr>(expr) &&
              "ImplicitConversionExpr should be eliminated in walkToExprPre");
 
       auto buildMemberRef = [&](Type memberType, Expr *base, SourceLoc dotLoc,
                                 ConcreteDeclRef member, DeclNameLoc memberLoc,
                                 bool implicit) -> Expr * {
-        auto *memberRef = new (getASTContext())
+        auto *memberRef = new (C)
             MemberRefExpr(base, dotLoc, member, memberLoc, implicit);
 
         if (memberType) {
           memberRef->setType(memberType);
-          return CS.cacheType(memberRef);
+          return memberRef;
         }
 
         return memberRef;
@@ -4188,7 +4170,8 @@ namespace {
 static Expr *generateConstraintsFor(ConstraintSystem &cs, Expr *expr,
                                     DeclContext *DC) {
   // Remove implicit conversions from the expression.
-  expr = expr->walk(SanitizeExpr(cs));
+  expr = expr->walk(SanitizeExpr(cs.getASTContext(),
+                                 cs.shouldReusePrecheckedType()));
 
   // Walk the expression, generating constraints.
   ConstraintGenerator cg(cs, DC);