Migrate getTypeOfExpressionWithoutApplying

Author: CodaFi

lib/Sema/CSDiag.cpp

@@ -167,7 +167,7 @@ class FailureDiagnosis :public ASTVisitor<FailureDiagnosis, /*exprresult*/bool>{
       FreeTypeVariableBinding allowFreeTypeVariables =
           FreeTypeVariableBinding::Disallow,
       ExprTypeCheckListener *listener = nullptr) {
-    CS.TC.getPossibleTypesOfExpressionWithoutApplying(
+    TypeChecker::getPossibleTypesOfExpressionWithoutApplying(
         expr, dc, types, allowFreeTypeVariables, listener);
     CS.cacheExprTypes(expr);
   }
@@ -177,8 +177,11 @@ class FailureDiagnosis :public ASTVisitor<FailureDiagnosis, /*exprresult*/bool>{
       FreeTypeVariableBinding allowFreeTypeVariables =
           FreeTypeVariableBinding::Disallow,
       ExprTypeCheckListener *listener = nullptr) {
-    auto type = CS.TC.getTypeOfExpressionWithoutApplying(expr, dc, referencedDecl,
-                                                         allowFreeTypeVariables, listener);
+    auto type =
+        TypeChecker::getTypeOfExpressionWithoutApplying(expr, dc,
+                                                        referencedDecl,
+                                                        allowFreeTypeVariables,
+                                                        listener);
     CS.cacheExprTypes(expr);
     return type;
   }
@@ -1757,7 +1760,8 @@ bool FailureDiagnosis::diagnoseImplicitSelfErrors(
     for (unsigned i = 0, e = argTuple->getNumElements(); i < e; ++i) {
       ConcreteDeclRef ref = nullptr;
       auto *el = argTuple->getElement(i);
-      auto typeResult = getTypeOfExpressionWithoutApplying(el, CS.DC, ref);
+      auto typeResult =
+          TypeChecker::getTypeOfExpressionWithoutApplying(el, CS.DC, ref);
       if (!typeResult)
         return false;
       auto flags = ParameterTypeFlags().withInOut(typeResult->is<InOutType>());
@@ -2097,7 +2101,7 @@ bool FailureDiagnosis::diagnoseSubscriptErrors(SubscriptExpr *SE,
         ConcreteDeclRef decl = nullptr;
         message = diag::cannot_subscript_with_index;
 
-        if (getTypeOfExpressionWithoutApplying(expr, CS.DC, decl))
+        if (TypeChecker::getTypeOfExpressionWithoutApplying(expr, CS.DC, decl))
           return false;
 
         // If we are down to a single candidate but with an unresolved
@@ -2587,7 +2591,7 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
              "unexpected declaration reference");
 
       ConcreteDeclRef decl = nullptr;
-      Type type = getTypeOfExpressionWithoutApplying(
+      Type type = TypeChecker::getTypeOfExpressionWithoutApplying(
           fnExpr, CS.DC, decl, FreeTypeVariableBinding::UnresolvedType,
           &listener);
 
@@ -3213,7 +3217,7 @@ bool FailureDiagnosis::diagnoseClosureExpr(
       // diagnose situations where contextual type expected one result
       // type but actual closure produces a different one without explicitly
       // declaring it (e.g. by using anonymous parameters).
-      auto type = getTypeOfExpressionWithoutApplying(
+      auto type = TypeChecker::getTypeOfExpressionWithoutApplying(
           closure, CS.DC, decl, FreeTypeVariableBinding::Disallow);
 
       if (type && resultTypeProcessor(type, expectedResultType))
@@ -4072,7 +4076,7 @@ diagnoseAmbiguousMultiStatementClosure(ClosureExpr *closure) {
       // successfully type-checked its type cleanup is going to be disabled
       // (we are allowing unresolved types), and as a side-effect it might
       // also be transformed e.g. OverloadedDeclRefExpr -> DeclRefExpr.
-      auto type = getTypeOfExpressionWithoutApplying(
+      auto type = TypeChecker::getTypeOfExpressionWithoutApplying(
           resultExpr, CS.DC, decl, FreeTypeVariableBinding::UnresolvedType);
       if (type)
         resultType = type->getRValueType();

lib/Sema/TypeChecker.cpp

@@ -645,7 +645,7 @@ static Optional<Type> getTypeOfCompletionContextExpr(
   }
 
   Type originalType = parsedExpr->getType();
-  if (auto T = TC.getTypeOfExpressionWithoutApplying(parsedExpr, DC,
+  if (auto T = TypeChecker::getTypeOfExpressionWithoutApplying(parsedExpr, DC,
                  referencedDecl, FreeTypeVariableBinding::UnresolvedType))
     return T;
 

lib/Sema/TypeChecker.h

@@ -1175,14 +1175,14 @@ class TypeChecker final {
   ///
   /// \returns the type of \p expr on success, Type() otherwise.
   /// FIXME: expr may still be modified...
-  Type getTypeOfExpressionWithoutApplying(
+  static Type getTypeOfExpressionWithoutApplying(
       Expr *&expr, DeclContext *dc,
       ConcreteDeclRef &referencedDecl,
       FreeTypeVariableBinding allowFreeTypeVariables =
                               FreeTypeVariableBinding::Disallow,
       ExprTypeCheckListener *listener = nullptr);
 
-  void getPossibleTypesOfExpressionWithoutApplying(
+  static void getPossibleTypesOfExpressionWithoutApplying(
       Expr *&expr, DeclContext *dc, SmallPtrSetImpl<TypeBase *> &types,
       FreeTypeVariableBinding allowFreeTypeVariables =
           FreeTypeVariableBinding::Disallow,