Drop TypeChecker out of some Code Completion utilities

Author: CodaFi

lib/Sema/CSRanking.cpp

@@ -313,8 +313,7 @@ static bool isDeclMoreConstrainedThan(ValueDecl *decl1, ValueDecl *decl2) {
 
 /// Determine whether one protocol extension is at least as specialized as
 /// another.
-static bool isProtocolExtensionAsSpecializedAs(TypeChecker &tc,
-                                               DeclContext *dc1,
+static bool isProtocolExtensionAsSpecializedAs(DeclContext *dc1,
                                                DeclContext *dc2) {
   assert(dc1->getExtendedProtocolDecl());
   assert(dc2->getExtendedProtocolDecl());
@@ -390,9 +389,6 @@ llvm::Expected<bool> CompareDeclSpecializationRequest::evaluate(
     Evaluator &eval, DeclContext *dc, ValueDecl *decl1, ValueDecl *decl2,
     bool isDynamicOverloadComparison) const {
   auto &C = decl1->getASTContext();
-  // FIXME: Remove dependency on the global type checker.
-      auto *tc = C.getLegacyGlobalTypeChecker();
-
   if (C.LangOpts.DebugConstraintSolver) {
     auto &log = C.TypeCheckerDebug->getStream();
     log << "Comparing declarations\n";
@@ -445,8 +441,8 @@ llvm::Expected<bool> CompareDeclSpecializationRequest::evaluate(
     // Both members are in protocol extensions.
     // Determine whether the 'Self' type from the first protocol extension
     // satisfies all of the requirements of the second protocol extension.
-    bool better1 = isProtocolExtensionAsSpecializedAs(*tc, outerDC1, outerDC2);
-    bool better2 = isProtocolExtensionAsSpecializedAs(*tc, outerDC2, outerDC1);
+    bool better1 = isProtocolExtensionAsSpecializedAs(outerDC1, outerDC2);
+    bool better2 = isProtocolExtensionAsSpecializedAs(outerDC2, outerDC1);
     if (better1 != better2) {
       return completeResult(better1);
     }

lib/Sema/TypeCheckConstraints.cpp

@@ -2449,7 +2449,7 @@ void TypeChecker::getPossibleTypesOfExpressionWithoutApplying(
 }
 
 static FunctionType *
-getTypeOfCompletionOperatorImpl(TypeChecker &TC, DeclContext *DC, Expr *expr,
+getTypeOfCompletionOperatorImpl(DeclContext *DC, Expr *expr,
                                 ConcreteDeclRef &referencedDecl) {
   auto &Context = DC->getASTContext();
 
@@ -2467,7 +2467,7 @@ getTypeOfCompletionOperatorImpl(TypeChecker &TC, DeclContext *DC, Expr *expr,
   if (!expr)
     return nullptr;
 
-  if (TC.getLangOpts().DebugConstraintSolver) {
+  if (Context.LangOpts.DebugConstraintSolver) {
     auto &log = Context.TypeCheckerDebug->getStream();
     log << "---Initial constraints for the given expression---\n";
     expr->dump(log);
@@ -2481,7 +2481,7 @@ getTypeOfCompletionOperatorImpl(TypeChecker &TC, DeclContext *DC, Expr *expr,
     return nullptr;
 
   auto &solution = viable[0];
-  if (TC.getLangOpts().DebugConstraintSolver) {
+  if (Context.LangOpts.DebugConstraintSolver) {
     auto &log = Context.TypeCheckerDebug->getStream();
     log << "---Solution---\n";
     solution.dump(log);
@@ -2516,7 +2516,7 @@ TypeChecker::getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
 
   // For the infix operator, find the actual LHS from pre-folded LHS.
   if (refKind == DeclRefKind::BinaryOperator)
-    LHS = findLHS(DC, LHS, opName);
+    LHS = TypeChecker::findLHS(DC, LHS, opName);
 
   if (!LHS)
     return nullptr;
@@ -2549,7 +2549,7 @@ TypeChecker::getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
     ParenExpr Args(SourceLoc(), LHS, SourceLoc(),
                    /*hasTrailingClosure=*/false);
     PostfixUnaryExpr postfixExpr(opExpr, &Args);
-    return getTypeOfCompletionOperatorImpl(*this, DC, &postfixExpr,
+    return getTypeOfCompletionOperatorImpl(DC, &postfixExpr,
                                            referencedDecl);
   }
 
@@ -2561,11 +2561,11 @@ TypeChecker::getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
     //     (code_completion_expr)))
     CodeCompletionExpr dummyRHS(Loc);
     auto Args = TupleExpr::create(
-        Context, SourceLoc(), {LHS, &dummyRHS}, {}, {}, SourceLoc(),
+        DC->getASTContext(), SourceLoc(), {LHS, &dummyRHS}, {}, {}, SourceLoc(),
         /*hasTrailingClosure=*/false, /*isImplicit=*/true);
     BinaryExpr binaryExpr(opExpr, Args, /*isImplicit=*/true);
 
-    return getTypeOfCompletionOperatorImpl(*this, DC, &binaryExpr,
+    return getTypeOfCompletionOperatorImpl(DC, &binaryExpr,
                                            referencedDecl);
   }
 

lib/Sema/TypeCheckDecl.cpp

@@ -2038,7 +2038,7 @@ static void checkDefaultArguments(TypeChecker &tc, ParameterList *params) {
     auto *initContext = param->getDefaultArgumentInitContext();
 
     auto resultTy =
-        tc.typeCheckParameterDefault(e, initContext, param->getType(),
+        typeCheckParameterDefault(e, initContext, param->getType(),
                                     /*isAutoClosure=*/param->isAutoClosure());
 
     if (resultTy) {

lib/Sema/TypeCheckExpr.cpp

@@ -237,7 +237,7 @@ Expr *TypeChecker::findLHS(DeclContext *DC, Expr *E, Identifier name) {
     if (!left)
       // LHS is not binary expression.
       return E;
-    switch (Context.associateInfixOperators(left, right)) {
+    switch (DC->getASTContext().associateInfixOperators(left, right)) {
       case swift::Associativity::None:
         return nullptr;
       case swift::Associativity::Left:

lib/Sema/TypeChecker.cpp

@@ -686,9 +686,9 @@ swift::getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
                                    ConcreteDeclRef &referencedDecl) {
   auto &ctx = DC->getASTContext();
   DiagnosticSuppression suppression(ctx.Diags);
-  TypeChecker &TC = createTypeChecker(ctx);
-  return TC.getTypeOfCompletionOperator(DC, LHS, opName, refKind,
-                                        referencedDecl);
+  (void)createTypeChecker(ctx);
+  return TypeChecker::getTypeOfCompletionOperator(DC, LHS, opName, refKind,
+                                                  referencedDecl);
 }
 
 bool swift::typeCheckExpression(DeclContext *DC, Expr *&parsedExpr) {

lib/Sema/TypeChecker.h

@@ -1190,10 +1190,10 @@ class TypeChecker final {
 
   /// Return the type of operator function for specified LHS, or a null
   /// \c Type on error.
-  FunctionType *getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
-                                            Identifier opName,
-                                            DeclRefKind refKind,
-                                            ConcreteDeclRef &referencedDecl);
+  static FunctionType *getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
+                                                   Identifier opName,
+                                                   DeclRefKind refKind,
+                                                   ConcreteDeclRef &refdDecl);
 
   /// Check the key-path expression.
   ///
@@ -1575,7 +1575,7 @@ class TypeChecker final {
 
   /// Given an pre-folded expression, find LHS from the expression if a binary
   /// operator \c name appended to the expression.
-  Expr *findLHS(DeclContext *DC, Expr *E, Identifier name);
+  static Expr *findLHS(DeclContext *DC, Expr *E, Identifier name);
 
   /// @}