Sema: Move buildAutoClosureExpr() from TypeChecker to ConstraintSystem

Author: slavapestov

lib/Sema/CSApply.cpp

@@ -5411,8 +5411,7 @@ Expr *ExprRewriter::coerceCallArguments(Expr *arg, AnyFunctionType *funcType,
           arg, closureType->getResult(),
           locator.withPathElement(ConstraintLocator::AutoclosureResult));
 
-      convertedArg = TypeChecker::buildAutoClosureExpr(dc, arg, closureType);
-      cs.cacheExprTypes(convertedArg);
+      convertedArg = cs.buildAutoClosureExpr(arg, closureType);
     } else {
       convertedArg = coerceToType(
           arg, paramType,

lib/Sema/ConstraintSystem.cpp

@@ -3474,3 +3474,38 @@ ConstraintSystem::isConversionEphemeral(ConversionRestrictionKind conversion,
     return ConversionEphemeralness::NonEphemeral;
   }
 }
+
+Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
+                                             FunctionType *closureType) {
+  auto &Context = DC->getASTContext();
+  bool isInDefaultArgumentContext = false;
+  if (auto *init = dyn_cast<Initializer>(DC))
+    isInDefaultArgumentContext =
+        init->getInitializerKind() == InitializerKind::DefaultArgument;
+
+  auto info = closureType->getExtInfo();
+  auto newClosureType = closureType;
+
+  if (isInDefaultArgumentContext && info.isNoEscape())
+    newClosureType = closureType->withExtInfo(info.withNoEscape(false))
+                         ->castTo<FunctionType>();
+
+  auto *closure = new (Context) AutoClosureExpr(
+      expr, newClosureType, AutoClosureExpr::InvalidDiscriminator, DC);
+
+  closure->setParameterList(ParameterList::createEmpty(Context));
+  getTypeChecker().ClosuresWithUncomputedCaptures.push_back(closure);
+
+  Expr *result = closure;
+
+  if (!newClosureType->isEqual(closureType)) {
+    assert(isInDefaultArgumentContext);
+    assert(newClosureType
+               ->withExtInfo(newClosureType->getExtInfo().withNoEscape(true))
+               ->isEqual(closureType));
+    result = new (Context) FunctionConversionExpr(closure, closureType);
+  }
+
+  cacheExprTypes(result);
+  return result;
+}

lib/Sema/ConstraintSystem.h

@@ -3026,6 +3026,10 @@ class ConstraintSystem {
                                          ConstraintLocator *memberLocator,
                                          bool includeInaccessibleMembers);
 
+  /// Build implicit autoclosure expression wrapping a given expression.
+  /// Given expression represents computed result of the closure.
+  Expr *buildAutoClosureExpr(Expr *expr, FunctionType *closureType);
+
 private:
   /// Determines whether or not a given conversion at a given locator requires
   /// the creation of a temporary value that's only valid for a limited scope.

lib/Sema/TypeCheckConstraints.cpp

@@ -2308,24 +2308,21 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
 
   if (isAutoClosure) {
     class AutoClosureListener : public ExprTypeCheckListener {
-      DeclContext *DC;
       FunctionType *ParamType;
 
     public:
-      AutoClosureListener(DeclContext *DC, FunctionType *paramType)
-          : DC(DC), ParamType(paramType) {}
+      AutoClosureListener(FunctionType *paramType)
+          : ParamType(paramType) {}
 
       Expr *appliedSolution(constraints::Solution &solution,
                             Expr *expr) override {
         auto &cs = solution.getConstraintSystem();
-        auto *closure = TypeChecker::buildAutoClosureExpr(DC, expr, ParamType);
-        cs.cacheExprTypes(closure);
-        return closure;
+        return cs.buildAutoClosureExpr(expr, ParamType);
       }
     };
 
     auto *fnType = paramType->castTo<FunctionType>();
-    AutoClosureListener listener(DC, fnType);
+    AutoClosureListener listener(fnType);
     return typeCheckExpression(defaultValue, DC,
                                TypeLoc::withoutLoc(fnType->getResult()),
                                canFail ? CTP_DefaultParameter : CTP_CannotFail,

lib/Sema/TypeCheckExpr.cpp

@@ -617,41 +617,6 @@ Expr *TypeChecker::buildRefExpr(ArrayRef<ValueDecl *> Decls,
   return result;
 }
 
-Expr *TypeChecker::buildAutoClosureExpr(DeclContext *DC, Expr *expr,
-                                        FunctionType *closureType) {
-  auto &Context = DC->getASTContext();
-  bool isInDefaultArgumentContext = false;
-  if (auto *init = dyn_cast<Initializer>(DC))
-    isInDefaultArgumentContext =
-        init->getInitializerKind() == InitializerKind::DefaultArgument;
-
-  auto info = closureType->getExtInfo();
-  auto newClosureType = closureType;
-
-  if (isInDefaultArgumentContext && info.isNoEscape())
-    newClosureType = closureType->withExtInfo(info.withNoEscape(false))
-                         ->castTo<FunctionType>();
-
-  auto *closure = new (Context) AutoClosureExpr(
-      expr, newClosureType, AutoClosureExpr::InvalidDiscriminator, DC);
-
-  closure->setParameterList(ParameterList::createEmpty(Context));
-
-  // FIXME: Remove global type checker dependency.
-  auto *TC = Context.getLegacyGlobalTypeChecker();
-  TC->ClosuresWithUncomputedCaptures.push_back(closure);
-
-  if (!newClosureType->isEqual(closureType)) {
-    assert(isInDefaultArgumentContext);
-    assert(newClosureType
-               ->withExtInfo(newClosureType->getExtInfo().withNoEscape(true))
-               ->isEqual(closureType));
-    return new (Context) FunctionConversionExpr(closure, closureType);
-  }
-
-  return closure;
-}
-
 static Type lookupDefaultLiteralType(const DeclContext *dc,
                                      StringRef name) {
   auto &ctx = dc->getASTContext();

lib/Sema/TypeChecker.h

@@ -1333,11 +1333,6 @@ class TypeChecker final {
   static Expr *buildRefExpr(ArrayRef<ValueDecl *> Decls, DeclContext *UseDC,
                             DeclNameLoc NameLoc, bool Implicit,
                             FunctionRefKind functionRefKind);
-
-  /// Build implicit autoclosure expression wrapping a given expression.
-  /// Given expression represents computed result of the closure.
-  static Expr *buildAutoClosureExpr(DeclContext *DC, Expr *expr,
-                                    FunctionType *closureType);
   /// @}
 
   /// Retrieve a specific, known protocol.