Move preCheckExpression to ConstraintSystem

Author: CodaFi

lib/Sema/BuilderTransform.cpp

@@ -582,7 +582,7 @@ ConstraintSystem::TypeMatchResult ConstraintSystem::applyFunctionBuilder(
   // that CSGen might have.
   //
   // TODO: just build the AST the way we want it in the first place.
-  if (getTypeChecker().preCheckExpression(singleExpr, closure))
+  if (ConstraintSystem::preCheckExpression(singleExpr, closure))
     return getTypeMatchFailure(locator);
 
   singleExpr = generateConstraints(singleExpr, closure);
@@ -617,13 +617,12 @@ namespace {
 
 /// Pre-check all the expressions in the closure body.
 class PreCheckFunctionBuilderClosure : public ASTWalker {
-  TypeChecker &TC;
   ClosureExpr *Closure;
   bool HasReturnStmt = false;
   bool HasError = false;
 public:
-  PreCheckFunctionBuilderClosure(TypeChecker &tc, ClosureExpr *closure)
-    : TC(tc), Closure(closure) {}
+  PreCheckFunctionBuilderClosure(ClosureExpr *closure)
+    : Closure(closure) {}
 
   FunctionBuilderClosurePreCheck run() {
     Stmt *oldBody = Closure->getBody();
@@ -649,7 +648,7 @@ class PreCheckFunctionBuilderClosure : public ASTWalker {
     // Pre-check the expression.  If this fails, abort the walk immediately.
     // Otherwise, replace the expression with the result of pre-checking.
     // In either case, don't recurse into the expression.
-    if (TC.preCheckExpression(E, /*DC*/ Closure)) {
+    if (ConstraintSystem::preCheckExpression(E, /*DC*/ Closure)) {
       HasError = true;
       return std::make_pair(false, nullptr);
     }
@@ -682,7 +681,7 @@ TypeChecker::preCheckFunctionBuilderClosureBody(ClosureExpr *closure) {
   if (it != precheckedFunctionBuilderClosures.end())
     return it->second;
 
-  auto result = PreCheckFunctionBuilderClosure(*this, closure).run();
+  auto result = PreCheckFunctionBuilderClosure(closure).run();
 
   // Cache the result.
   precheckedFunctionBuilderClosures.insert(std::make_pair(closure, result));

lib/Sema/CSDiag.cpp

@@ -4068,7 +4068,7 @@ diagnoseAmbiguousMultiStatementClosure(ClosureExpr *closure) {
       if (hasUnresolvedParams)
         continue;
 
-      CS.getTypeChecker().preCheckExpression(resultExpr, CS.DC);
+      ConstraintSystem::preCheckExpression(resultExpr, CS.DC);
 
       // Obtain type of the result expression without applying solutions,
       // because otherwise this might result in leaking of type variables,

lib/Sema/ConstraintSystem.h

@@ -3588,6 +3588,10 @@ class ConstraintSystem {
                           = FreeTypeVariableBinding::Disallow);
 
 public:
+  /// Pre-check the expression, validating any types that occur in the
+  /// expression and folding sequence expressions.
+  static bool preCheckExpression(Expr *&expr, DeclContext *dc);
+        
   /// Solve the system of constraints generated from provided expression.
   ///
   /// The expression should have already been pre-checked with

lib/Sema/TypeCheckConstraints.cpp

@@ -2013,7 +2013,7 @@ Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {
 
 /// Pre-check the expression, validating any types that occur in the
 /// expression and folding sequence expressions.
-bool TypeChecker::preCheckExpression(Expr *&expr, DeclContext *dc) {
+bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc) {
   PreCheckExpression preCheck(dc, expr);
   // Perform the pre-check.
   if (auto result = expr->walk(preCheck)) {
@@ -2177,7 +2177,7 @@ Type TypeChecker::typeCheckExpressionImpl(Expr *&expr, DeclContext *dc,
 
   // First, pre-check the expression, validating any types that occur in the
   // expression and folding sequence expressions.
-  if (preCheckExpression(expr, dc)) {
+  if (ConstraintSystem::preCheckExpression(expr, dc)) {
     listener.preCheckFailed(expr);
     return Type();
   }

lib/Sema/TypeChecker.cpp

@@ -16,6 +16,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Subsystems.h"
+#include "ConstraintSystem.h"
 #include "TypeChecker.h"
 #include "TypeCheckObjC.h"
 #include "TypeCheckType.h"
@@ -623,12 +624,11 @@ void swift::typeCheckPatternBinding(PatternBindingDecl *PBD,
 }
 
 static Optional<Type> getTypeOfCompletionContextExpr(
-                        TypeChecker &TC,
                         DeclContext *DC,
                         CompletionTypeCheckKind kind,
                         Expr *&parsedExpr,
                         ConcreteDeclRef &referencedDecl) {
-  if (TC.preCheckExpression(parsedExpr, DC))
+  if (constraints::ConstraintSystem::preCheckExpression(parsedExpr, DC))
     return None;
 
   switch (kind) {
@@ -672,10 +672,10 @@ Optional<Type> swift::getTypeOfCompletionContextExpr(
                         Expr *&parsedExpr,
                         ConcreteDeclRef &referencedDecl) {
   DiagnosticSuppression suppression(Ctx.Diags);
-  TypeChecker &TC = createTypeChecker(Ctx);
+  (void)createTypeChecker(Ctx);
 
   // Try to solve for the actual type of the expression.
-  return ::getTypeOfCompletionContextExpr(TC, DC, kind, parsedExpr,
+  return ::getTypeOfCompletionContextExpr(DC, kind, parsedExpr,
                                           referencedDecl);
 }
 

lib/Sema/TypeChecker.h

@@ -1075,10 +1075,6 @@ class TypeChecker final {
   /// struct or class.
   static void addImplicitConstructors(NominalTypeDecl *typeDecl);
 
-  /// Pre-check the expression, validating any types that occur in the
-  /// expression and folding sequence expressions.
-  bool preCheckExpression(Expr *&expr, DeclContext *dc);
-
   /// Pre-check the body of the given closure, which we are about to
   /// generate constraints for.
   ///