Sema: Compute captures when contextualizing closures

Author: slavapestov

lib/Sema/CSApply.cpp

@@ -4494,10 +4494,6 @@ namespace {
       outerClosure->setType(outerClosureTy);
       cs.cacheType(outerClosure);
 
-      // The inner closure at least will definitely have a capture.
-      cs.getTypeChecker().ClosuresWithUncomputedCaptures.push_back(outerClosure);
-      cs.getTypeChecker().ClosuresWithUncomputedCaptures.push_back(closure);
-
       // let outerApply = "\( outerClosure )( \(E) )"
       auto outerApply = CallExpr::createImplicit(ctx, outerClosure, {E}, {});
       outerApply->setType(closureTy);
@@ -7268,12 +7264,6 @@ namespace {
           ClosuresToTypeCheck.push_back(closure);
         }
 
-        // Don't try to register captures if constraint system is used to
-        // produce diagnostics for one of the sub-expressions.
-        if (!cs.Options.contains(
-                ConstraintSystemFlags::SubExpressionDiagnostics))
-          cs.getTypeChecker().ClosuresWithUncomputedCaptures.push_back(closure);
-
         return { false, closure };
       }
 

lib/Sema/ConstraintSystem.cpp

@@ -3494,7 +3494,6 @@ Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
       expr, newClosureType, AutoClosureExpr::InvalidDiscriminator, DC);
 
   closure->setParameterList(ParameterList::createEmpty(Context));
-  getTypeChecker().ClosuresWithUncomputedCaptures.push_back(closure);
 
   Expr *result = closure;
 

lib/Sema/TypeCheckStmt.cpp

@@ -112,6 +112,8 @@ namespace {
         ParentDC = CE;
         CE->getBody()->walk(*this);
         ParentDC = oldParentDC;
+
+        TypeChecker::computeCaptures(CE);
         return { false, E };
       } 
 
@@ -148,7 +150,7 @@ namespace {
         if (CE->hasSingleExpressionBody())
           CE->getBody()->walk(ContextualizeClosures(CE));
 
-        // In neither case do we need to continue the *current* walk.
+        TypeChecker::computeCaptures(CE);
         return { false, E };
       }
 

lib/Sema/TypeChecker.cpp

@@ -302,12 +302,6 @@ static void typeCheckFunctionsAndExternalDecls(SourceFile &SF, TypeChecker &TC)
     }
   } while (currentFunctionIdx < TC.definedFunctions.size());
 
-  // Compute captures for functions and closures we visited.
-  for (auto *closure : TC.ClosuresWithUncomputedCaptures) {
-    TypeChecker::computeCaptures(closure);
-  }
-  TC.ClosuresWithUncomputedCaptures.clear();
-
   for (AbstractFunctionDecl *FD : llvm::reverse(TC.definedFunctions)) {
     TypeChecker::computeCaptures(FD);
   }

lib/Sema/TypeChecker.h

@@ -462,10 +462,6 @@ class TypeChecker final {
   /// The list of function definitions we've encountered.
   std::vector<AbstractFunctionDecl *> definedFunctions;
 
-  /// A list of closures for the most recently type-checked function, which we
-  /// will need to compute captures for.
-  std::vector<AbstractClosureExpr *> ClosuresWithUncomputedCaptures;
-
 private:
   TypeChecker() = default;
   ~TypeChecker() = default;