Remove some ancillary TypeCheckers

Author: CodaFi

lib/Sema/CSApply.cpp

@@ -2818,7 +2818,7 @@ namespace {
       //
       // The result is that in Swift 5, 'try?' avoids producing nested optionals.
 
-      if (!cs.getTypeChecker().getLangOpts().isSwiftVersionAtLeast(5)) {
+      if (!cs.getASTContext().LangOpts.isSwiftVersionAtLeast(5)) {
         // Nothing to do for Swift 4 and earlier!
         return simplifyExprType(expr);
       }
@@ -5408,7 +5408,7 @@ Expr *ExprRewriter::coerceCallArguments(Expr *arg, AnyFunctionType *funcType,
           arg, closureType->getResult(),
           locator.withPathElement(ConstraintLocator::AutoclosureResult));
 
-      convertedArg = cs.getTypeChecker().buildAutoClosureExpr(dc, arg, closureType);
+      convertedArg = TypeChecker::buildAutoClosureExpr(dc, arg, closureType);
       cs.cacheExprTypes(convertedArg);
     } else {
       convertedArg = coerceToType(
@@ -7441,14 +7441,14 @@ Expr *ConstraintSystem::applySolution(Solution &solution, Expr *expr,
   if (!skipClosures) {
     bool hadError = false;
     for (auto *closure : walker.getClosuresToTypeCheck())
-      hadError |= getTypeChecker().typeCheckClosureBody(closure);
+      hadError |= TypeChecker::typeCheckClosureBody(closure);
 
     // Tap expressions too; they should or should not be
     // type-checked under the same conditions as closure bodies.
     for (auto tuple : walker.getTapsToTypeCheck()) {
       auto tap = std::get<0>(tuple);
       auto tapDC = std::get<1>(tuple);
-      hadError |= getTypeChecker().typeCheckTapBody(tap, tapDC);
+      hadError |= TypeChecker::typeCheckTapBody(tap, tapDC);
     }
 
     // If any of them failed to type check, bail.

lib/Sema/CSDiagnostics.cpp

@@ -4891,7 +4891,6 @@ bool MissingGenericArgumentsFailure::diagnoseParameter(
 void MissingGenericArgumentsFailure::emitGenericSignatureNote(
     Anchor anchor) const {
   auto &cs = getConstraintSystem();
-  auto &TC = getTypeChecker();
   auto *paramDC = getDeclContext();
 
   if (!paramDC)
@@ -4937,8 +4936,8 @@ void MissingGenericArgumentsFailure::emitGenericSignatureNote(
 
   SmallString<64> paramsAsString;
   auto baseType = anchor.get<TypeRepr *>();
-  if (TC.getDefaultGenericArgumentsString(paramsAsString, GTD,
-                                          getPreferredType)) {
+  if (TypeChecker::getDefaultGenericArgumentsString(paramsAsString, GTD,
+                                                    getPreferredType)) {
     auto diagnostic = emitDiagnostic(
         baseType->getLoc(), diag::unbound_generic_parameter_explicit_fix);
 

lib/Sema/TypeCheckConstraints.cpp

@@ -2314,7 +2314,7 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
       Expr *appliedSolution(constraints::Solution &solution,
                             Expr *expr) override {
         auto &cs = solution.getConstraintSystem();
-        auto *closure = cs.getTypeChecker().buildAutoClosureExpr(DC, expr, ParamType);
+        auto *closure = TypeChecker::buildAutoClosureExpr(DC, expr, ParamType);
         cs.cacheExprTypes(closure);
         return closure;
       }

lib/Sema/TypeCheckExpr.cpp

@@ -619,6 +619,7 @@ Expr *TypeChecker::buildRefExpr(ArrayRef<ValueDecl *> Decls,
 
 Expr *TypeChecker::buildAutoClosureExpr(DeclContext *DC, Expr *expr,
                                         FunctionType *closureType) {
+  auto &Context = DC->getASTContext();
   bool isInDefaultArgumentContext = false;
   if (auto *init = dyn_cast<Initializer>(DC))
     isInDefaultArgumentContext =
@@ -636,7 +637,9 @@ Expr *TypeChecker::buildAutoClosureExpr(DeclContext *DC, Expr *expr,
 
   closure->setParameterList(ParameterList::createEmpty(Context));
 
-  ClosuresWithUncomputedCaptures.push_back(closure);
+  // FIXME: Remove global type checker dependency.
+  auto *TC = Context.getLegacyGlobalTypeChecker();
+  TC->ClosuresWithUncomputedCaptures.push_back(closure);
 
   if (!newClosureType->isEqual(closureType)) {
     assert(isInDefaultArgumentContext);

lib/Sema/TypeCheckREPL.cpp

@@ -257,7 +257,7 @@ void REPLChecker::generatePrintOfExpression(StringRef NameStr, Expr *E) {
 
   // FIXME: Remove TypeChecker dependency.
   auto &TC = *Context.getLegacyGlobalTypeChecker();
-  TC.typeCheckClosureBody(CE);
+  TypeChecker::typeCheckClosureBody(CE);
   TC.ClosuresWithUncomputedCaptures.push_back(CE);
 
   auto *TheCall = CallExpr::createImplicit(Context, CE, { E }, { });

lib/Sema/TypeCheckStmt.cpp

@@ -740,15 +740,13 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
       return nullptr;
     }
 
-    // FIXME: Remove TypeChecker dependency.
-    auto &TC = *Ctx.getLegacyGlobalTypeChecker();
     if (TypeChecker::typeCheckPattern(S->getPattern(), DC, options)) {
       // FIXME: Handle errors better.
       S->getPattern()->setType(ErrorType::get(getASTContext()));
       return nullptr;
     }
 
-    if (TC.typeCheckForEachBinding(DC, S))
+    if (TypeChecker::typeCheckForEachBinding(DC, S))
       return nullptr;
 
     if (auto *Where = S->getWhere()) {
@@ -880,8 +878,8 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
       OpaqueValueExpr *elementExpr =
           new (getASTContext()) OpaqueValueExpr(S->getInLoc(), nextResultType);
       Expr *convertElementExpr = elementExpr;
-      if (TC.convertToType(convertElementExpr, optPatternType, DC,
-                           S->getPattern())) {
+      if (TypeChecker::convertToType(convertElementExpr, optPatternType, DC,
+                                     S->getPattern())) {
         return nullptr;
       }
       S->setElementExpr(elementExpr);
@@ -2206,9 +2204,11 @@ bool TypeChecker::typeCheckClosureBody(ClosureExpr *closure) {
 
   BraceStmt *body = closure->getBody();
 
+  auto *TC = closure->getASTContext().getLegacyGlobalTypeChecker();
   Optional<FunctionBodyTimer> timer;
-  if (DebugTimeFunctionBodies || WarnLongFunctionBodies)
-    timer.emplace(closure, DebugTimeFunctionBodies, WarnLongFunctionBodies);
+  if (TC->DebugTimeFunctionBodies || TC->WarnLongFunctionBodies)
+    timer.emplace(closure, TC->DebugTimeFunctionBodies,
+                  TC->WarnLongFunctionBodies);
 
   bool HadError = StmtChecker(closure).typeCheckBody(body);
   if (body) {

lib/Sema/TypeChecker.cpp

@@ -406,7 +406,7 @@ void swift::performTypeChecking(SourceFile &SF, TopLevelContext &TLC,
     if (!Ctx.LangOpts.DisableAvailabilityChecking) {
       // Build the type refinement hierarchy for the primary
       // file before type checking.
-      TC.buildTypeRefinementContextHierarchy(SF, StartElem);
+      TypeChecker::buildTypeRefinementContextHierarchy(SF, StartElem);
     }
 
     // Resolve extensions. This has to occur first during type checking,
@@ -418,7 +418,7 @@ void swift::performTypeChecking(SourceFile &SF, TopLevelContext &TLC,
     for (auto D : llvm::makeArrayRef(SF.Decls).slice(StartElem)) {
       if (auto *TLCD = dyn_cast<TopLevelCodeDecl>(D)) {
         // Immediately perform global name-binding etc.
-        TC.typeCheckTopLevelCodeDecl(TLCD);
+        TypeChecker::typeCheckTopLevelCodeDecl(TLCD);
         TypeChecker::contextualizeTopLevelCode(TLC, TLCD);
       } else {
         TypeChecker::typeCheckDecl(D);
@@ -428,7 +428,7 @@ void swift::performTypeChecking(SourceFile &SF, TopLevelContext &TLC,
     // If we're in REPL mode, inject temporary result variables and other stuff
     // that the REPL needs to synthesize.
     if (SF.Kind == SourceFileKind::REPL && !Ctx.hadError())
-      TC.processREPLTopLevel(SF, TLC, StartElem);
+      TypeChecker::processREPLTopLevel(SF, TLC, StartElem);
 
     typeCheckFunctionsAndExternalDecls(SF, TC);
   }
@@ -713,8 +713,8 @@ bool swift::typeCheckAbstractFunctionBodyUntil(AbstractFunctionDecl *AFD,
 bool swift::typeCheckTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {
   auto &Ctx = static_cast<Decl *>(TLCD)->getASTContext();
   DiagnosticSuppression suppression(Ctx.Diags);
-  TypeChecker &TC = createTypeChecker(Ctx);
-  TC.typeCheckTopLevelCodeDecl(TLCD);
+  (void)createTypeChecker(Ctx);
+  TypeChecker::typeCheckTopLevelCodeDecl(TLCD);
   return true;
 }
 

lib/Sema/TypeChecker.h

@@ -946,19 +946,19 @@ class TypeChecker final {
   static BraceStmt *applyFunctionBuilderBodyTransform(FuncDecl *FD,
                                                       BraceStmt *body,
                                                       Type builderType);
-  bool typeCheckClosureBody(ClosureExpr *closure);
+  static bool typeCheckClosureBody(ClosureExpr *closure);
 
-  bool typeCheckTapBody(TapExpr *expr, DeclContext *DC);
+  static bool typeCheckTapBody(TapExpr *expr, DeclContext *DC);
 
   static Type typeCheckParameterDefault(Expr *&defaultValue, DeclContext *DC,
                                         Type paramType,
                                         bool isAutoClosure = false,
                                         bool canFail = true);
 
-  void typeCheckTopLevelCodeDecl(TopLevelCodeDecl *TLCD);
+  static void typeCheckTopLevelCodeDecl(TopLevelCodeDecl *TLCD);
 
-  void processREPLTopLevel(SourceFile &SF, TopLevelContext &TLC,
-                           unsigned StartElem);
+  static void processREPLTopLevel(SourceFile &SF, TopLevelContext &TLC,
+                                  unsigned StartElem);
 
   static void typeCheckDecl(Decl *D);
 
@@ -1577,8 +1577,8 @@ class TypeChecker final {
 
   /// Build implicit autoclosure expression wrapping a given expression.
   /// Given expression represents computed result of the closure.
-  Expr *buildAutoClosureExpr(DeclContext *DC, Expr *expr,
-                             FunctionType *closureType);
+  static Expr *buildAutoClosureExpr(DeclContext *DC, Expr *expr,
+                                    FunctionType *closureType);
   /// @}
 
   /// Retrieve a specific, known protocol.