Sema: TypeChecker::computeCaptures() and friends should be static

Author: slavapestov

lib/Sema/DebuggerTestingTransform.cpp

@@ -242,7 +242,7 @@ class DebuggerTestingTransform : public ASTWalker {
 
     // Captures have to be computed after the closure is type-checked. This
     // ensures that the type checker can infer <noescape> for captured values.
-    TC.computeCaptures(Closure);
+    TypeChecker::computeCaptures(Closure);
 
     return {false, FinalExpr};
   }

lib/Sema/TypeCheckCaptures.cpp

@@ -32,7 +32,7 @@ using namespace swift;
 namespace {
 
 class FindCapturedVars : public ASTWalker {
-  TypeChecker &TC;
+  ASTContext &Context;
   SmallVector<CapturedValue, 4> Captures;
   llvm::SmallDenseMap<ValueDecl*, unsigned, 4> captureEntryNumber;
   SourceLoc GenericParamCaptureLoc;
@@ -44,12 +44,12 @@ class FindCapturedVars : public ASTWalker {
   bool NoEscape, ObjC;
 
 public:
-  FindCapturedVars(TypeChecker &tc,
+  FindCapturedVars(ASTContext &Context,
                    SourceLoc CaptureLoc,
                    DeclContext *CurDC,
                    bool NoEscape,
                    bool ObjC)
-      : TC(tc), CaptureLoc(CaptureLoc), CurDC(CurDC),
+      : Context(Context), CaptureLoc(CaptureLoc), CurDC(CurDC),
         NoEscape(NoEscape), ObjC(ObjC) {}
 
   CaptureInfo getCaptureInfo() const {
@@ -71,7 +71,7 @@ class FindCapturedVars : public ASTWalker {
     if (Captures.empty())
       result.setCaptures(None);
     else
-      result.setCaptures(TC.Context.AllocateCopy(Captures));
+      result.setCaptures(Context.AllocateCopy(Captures));
 
     return result;
   }
@@ -219,7 +219,7 @@ class FindCapturedVars : public ASTWalker {
     // can safely ignore them.
     // FIXME(TapExpr): This is probably caused by the scoping 
     // algorithm's ignorance of TapExpr. We should fix that.
-    if (D->getBaseName() == D->getASTContext().Id_dollarInterpolation)
+    if (D->getBaseName() == Context.Id_dollarInterpolation)
       return { false, DRE };
 
     // Capture the generic parameters of the decl, unless it's a
@@ -273,14 +273,14 @@ class FindCapturedVars : public ASTWalker {
         // This is not supported since nominal types cannot capture values.
         if (auto NTD = dyn_cast<NominalTypeDecl>(TmpDC)) {
           if (DC->isLocalContext()) {
-            TC.diagnose(DRE->getLoc(), diag::capture_across_type_decl,
-                        NTD->getDescriptiveKind(),
-                        D->getBaseName().getIdentifier());
+            Context.Diags.diagnose(DRE->getLoc(), diag::capture_across_type_decl,
+                                   NTD->getDescriptiveKind(),
+                                   D->getBaseName().getIdentifier());
 
-            TC.diagnose(NTD->getLoc(), diag::kind_declared_here,
-                        DescriptiveDeclKind::Type);
+            NTD->diagnose(diag::kind_declared_here,
+                          DescriptiveDeclKind::Type);
 
-            TC.diagnose(D, diag::decl_declared_here, D->getFullName());
+            D->diagnose(diag::decl_declared_here, D->getFullName());
             return { false, DRE };
           }
         }
@@ -328,7 +328,7 @@ class FindCapturedVars : public ASTWalker {
   }
 
   void propagateCaptures(AnyFunctionRef innerClosure, SourceLoc captureLoc) {
-    TC.computeCaptures(innerClosure);
+    TypeChecker::computeCaptures(innerClosure);
 
     auto &captureInfo = innerClosure.getCaptureInfo();
 
@@ -597,7 +597,8 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
   if (!AFR.getBody())
     return;
 
-  FindCapturedVars finder(*this,
+  auto &Context = AFR.getAsDeclContext()->getASTContext();
+  FindCapturedVars finder(Context,
                           AFR.getLoc(),
                           AFR.getAsDeclContext(),
                           AFR.isKnownNoEscape(),
@@ -624,27 +625,29 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
   if (AFD && finder.getGenericParamCaptureLoc().isValid()) {
     if (auto Clas = AFD->getParent()->getSelfClassDecl()) {
       if (Clas->usesObjCGenericsModel()) {
-        diagnose(AFD->getLoc(),
-                 diag::objc_generic_extension_using_type_parameter);
+        AFD->diagnose(diag::objc_generic_extension_using_type_parameter);
 
         // If it's possible, suggest adding @objc.
         Optional<ForeignErrorConvention> errorConvention;
         if (!AFD->isObjC() &&
             isRepresentableInObjC(AFD, ObjCReason::MemberOfObjCMembersClass,
                                   errorConvention)) {
-          diagnose(AFD->getLoc(),
+          AFD->diagnose(
                    diag::objc_generic_extension_using_type_parameter_try_objc)
             .fixItInsert(AFD->getAttributeInsertionLoc(false), "@objc ");
         }
 
-        diagnose(finder.getGenericParamCaptureLoc(),
-                 diag::objc_generic_extension_using_type_parameter_here);
+        Context.Diags.diagnose(
+            finder.getGenericParamCaptureLoc(),
+            diag::objc_generic_extension_using_type_parameter_here);
       }
     }
   }
 }
 
 void TypeChecker::checkPatternBindingCaptures(NominalTypeDecl *typeDecl) {
+  auto &ctx = typeDecl->getASTContext();
+
   for (auto member : typeDecl->getMembers()) {
     // Ignore everything other than PBDs.
     auto *PBD = dyn_cast<PatternBindingDecl>(member);
@@ -659,16 +662,16 @@ void TypeChecker::checkPatternBindingCaptures(NominalTypeDecl *typeDecl) {
       if (init == nullptr)
         continue;
 
-      FindCapturedVars finder(*this,
+      FindCapturedVars finder(ctx,
                               init->getLoc(),
                               PBD->getInitContext(i),
                               /*NoEscape=*/false,
                               /*ObjC=*/false);
       init->walk(finder);
 
       if (finder.getDynamicSelfCaptureLoc().isValid()) {
-        diagnose(finder.getDynamicSelfCaptureLoc(),
-                 diag::dynamic_self_stored_property_init);
+        ctx.Diags.diagnose(finder.getDynamicSelfCaptureLoc(),
+                           diag::dynamic_self_stored_property_init);
       }
 
       auto captures = finder.getCaptureInfo();

lib/Sema/TypeChecker.cpp

@@ -358,12 +358,12 @@ static void typeCheckFunctionsAndExternalDecls(SourceFile &SF, TypeChecker &TC)
 
   // Compute captures for functions and closures we visited.
   for (auto *closure : TC.ClosuresWithUncomputedCaptures) {
-    TC.computeCaptures(closure);
+    TypeChecker::computeCaptures(closure);
   }
   TC.ClosuresWithUncomputedCaptures.clear();
 
   for (AbstractFunctionDecl *FD : reversed(TC.definedFunctions)) {
-    TC.computeCaptures(FD);
+    TypeChecker::computeCaptures(FD);
   }
 
   // Check error-handling correctness for all the functions defined in

lib/Sema/TypeChecker.h

@@ -1430,10 +1430,10 @@ class TypeChecker final : public LazyResolver {
   bool typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt);
 
   /// Compute the set of captures for the given function or closure.
-  void computeCaptures(AnyFunctionRef AFR);
+  static void computeCaptures(AnyFunctionRef AFR);
 
   /// Check for invalid captures from stored property initializers.
-  void checkPatternBindingCaptures(NominalTypeDecl *typeDecl);
+  static void checkPatternBindingCaptures(NominalTypeDecl *typeDecl);
 
   /// Change the context of closures in the given initializer
   /// expression to the given context.