Move ConstraintSystem::setExprTypes() over to Solution

It belongs on Solutionn, which should contain all of the information
needed to perform the operation. Simplify the implementation slightly
while doing this, eliminating some dead code.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -3566,7 +3566,7 @@ namespace {
         // Convert the subexpression.
         Expr *sub = expr->getSubExpr();
 
-        cs.setExprTypes(sub);
+        solution.setExprTypes(sub);
 
         if (tc.convertToType(sub, toType, cs.DC))
           return nullptr;
@@ -5600,7 +5600,7 @@ ClosureExpr *ExprRewriter::coerceClosureExprToVoid(ClosureExpr *closureExpr) {
       cs.setType(singleExpr,
                  cs.getType(singleExpr)->getWithoutSpecifierType());
 
-    cs.setExprTypes(singleExpr);
+    solution.setExprTypes(singleExpr);
     TypeChecker::checkIgnoredExpr(singleExpr);
 
     SmallVector<ASTNode, 2> elements;
@@ -5639,7 +5639,7 @@ ClosureExpr *ExprRewriter::coerceClosureExprFromNever(ClosureExpr *closureExpr)
     auto returnStmt = cast<ReturnStmt>(member.get<Stmt *>());
     auto singleExpr = returnStmt->getResult();
 
-    cs.setExprTypes(singleExpr);
+    solution.setExprTypes(singleExpr);
     TypeChecker::checkIgnoredExpr(singleExpr);
 
     SmallVector<ASTNode, 1> elements;
@@ -7035,7 +7035,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, ConcreteDeclRef callee,
     cs.setType(apply, fnType->getResult());
     apply->setIsSuper(isSuper);
 
-    cs.setExprTypes(apply);
+    solution.setExprTypes(apply);
     Expr *result = TypeChecker::substituteInputSugarTypeForResult(apply);
     cs.cacheExprTypes(result);
 
@@ -7336,7 +7336,7 @@ namespace {
         } else {
           // For other closures, type-check the body once we've finished with
           // the expression.
-          cs.setExprTypes(closure);
+          Rewriter.solution.setExprTypes(closure);
           ClosuresToTypeCheck.push_back(closure);
         }
 
@@ -7557,9 +7557,7 @@ Expr *ConstraintSystem::applySolution(Solution &solution, Expr *expr,
                                    getConstraintLocator(expr));
   }
 
-  if (result)
-    setExprTypes(result);
-
+  solution.setExprTypes(result);
   rewriter.finalize();
 
   return result;
@@ -7574,7 +7572,59 @@ Expr *Solution::coerceToType(Expr *expr, Type toType,
   if (!result)
     return nullptr;
 
-  cs.setExprTypes(result);
+  setExprTypes(result);
   rewriter.finalize();
   return result;
 }
+
+namespace {
+class SetExprTypes : public ASTWalker {
+  const Solution &solution;
+
+public:
+  explicit SetExprTypes(const Solution &solution)
+      : solution(solution) {}
+
+  Expr *walkToExprPost(Expr *expr) override {
+    auto &cs = solution.getConstraintSystem();
+    auto exprType = cs.getType(expr);
+    exprType = solution.simplifyType(exprType);
+    // assert((!expr->getType() || expr->getType()->isEqual(exprType)) &&
+    //       "Mismatched types!");
+    assert(!exprType->hasTypeVariable() &&
+           "Should not write type variable into expression!");
+    expr->setType(exprType);
+
+    if (auto kp = dyn_cast<KeyPathExpr>(expr)) {
+      for (auto i : indices(kp->getComponents())) {
+        Type componentType;
+        if (cs.hasType(kp, i)) {
+          componentType = solution.simplifyType(cs.getType(kp, i));
+          assert(!componentType->hasTypeVariable() &&
+                 "Should not write type variable into key-path component");
+        }
+
+        kp->getMutableComponents()[i].setComponentType(componentType);
+      }
+    }
+
+    return expr;
+  }
+
+  /// Ignore statements.
+  std::pair<bool, Stmt *> walkToStmtPre(Stmt *stmt) override {
+    return { false, stmt };
+  }
+
+  /// Ignore declarations.
+  bool walkToDeclPre(Decl *decl) override { return false; }
+};
+}
+
+void Solution::setExprTypes(Expr *expr) const {
+  if (!expr)
+    return;
+
+  SetExprTypes SET(*this);
+  expr->walk(SET);
+}

lib/Sema/ConstraintSystem.h

@@ -741,6 +741,8 @@ class Solution {
     return None;
   }
 
+  void setExprTypes(Expr *expr) const;
+
   SWIFT_DEBUG_DUMP;
 
   /// Dump this solution.
@@ -1508,58 +1510,7 @@ class ConstraintSystem {
     bool walkToDeclPre(Decl *decl) override { return false; }
   };
 
-  class SetExprTypes : public ASTWalker {
-    Expr *RootExpr;
-    ConstraintSystem &CS;
-    bool ExcludeRoot;
-
-  public:
-    SetExprTypes(Expr *expr, ConstraintSystem &cs, bool excludeRoot)
-        : RootExpr(expr), CS(cs), ExcludeRoot(excludeRoot) {}
-
-    Expr *walkToExprPost(Expr *expr) override {
-      if (ExcludeRoot && expr == RootExpr)
-        return expr;
-
-      //assert((!expr->getType() || CS.getType(expr)->isEqual(expr->getType()))
-      //       && "Mismatched types!");
-      assert(!CS.getType(expr)->hasTypeVariable() &&
-             "Should not write type variable into expression!");
-      expr->setType(CS.getType(expr));
-
-      if (auto kp = dyn_cast<KeyPathExpr>(expr)) {
-        for (auto i : indices(kp->getComponents())) {
-          Type componentType;
-          if (CS.hasType(kp, i))
-            componentType = CS.getType(kp, i);
-          kp->getMutableComponents()[i].setComponentType(componentType);
-        }
-      }
-
-      return expr;
-    }
-
-    /// Ignore statements.
-    std::pair<bool, Stmt *> walkToStmtPre(Stmt *stmt) override {
-      return { false, stmt };
-    }
-
-    /// Ignore declarations.
-    bool walkToDeclPre(Decl *decl) override { return false; }
-  };
-
 public:
-
-  void setExprTypes(Expr *expr) {
-    SetExprTypes SET(expr, *this, /* excludeRoot = */ false);
-    expr->walk(SET);
-  }
-
-  void setSubExprTypes(Expr *expr) {
-    SetExprTypes SET(expr, *this, /* excludeRoot = */ true);
-    expr->walk(SET);
-  }
-
   /// Cache the types of the given expression and all subexpressions.
   void cacheExprTypes(Expr *expr) {
     bool excludeRoot = false;

lib/Sema/TypeCheckConstraints.cpp

@@ -2980,7 +2980,7 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
       Stmt->setPattern(pattern);
       Stmt->setSequence(expr);
 
-      cs.setExprTypes(expr);
+      solution.setExprTypes(expr);
       return expr;
     }
   };
@@ -3464,7 +3464,7 @@ bool TypeChecker::convertToType(Expr *&expr, Type type, DeclContext *dc,
     return true;
   }
 
-  cs.setExprTypes(expr);
+  solution.setExprTypes(expr);
 
   if (getLangOpts().DebugConstraintSolver) {
     auto &log = Context.TypeCheckerDebug->getStream();