[Constraint system] Factor out application to a SolutionApplicationTarget.

Pull out the core operation of rewriting a given SolutionApplicationTarget
into into a method on the ExprWalker that does the overall rewrite, so it
can be called multiple times within application.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -290,7 +290,7 @@ namespace {
   public:
     ConstraintSystem &cs;
     DeclContext *dc;
-    const Solution &solution;
+    Solution &solution;
     bool SuppressDiagnostics;
 
     /// Coerce the given tuple to another tuple type.
@@ -1792,7 +1792,7 @@ namespace {
     }
 
   public:
-    ExprRewriter(ConstraintSystem &cs, const Solution &solution,
+    ExprRewriter(ConstraintSystem &cs, Solution &solution,
                  bool suppressDiagnostics)
         : cs(cs), dc(cs.DC), solution(solution),
           SuppressDiagnostics(suppressDiagnostics) {}
@@ -7142,6 +7142,10 @@ namespace {
 
     /// Ignore declarations.
     bool walkToDeclPre(Decl *decl) override { return false; }
+
+    /// Rewrite the target, producing a new target.
+    Optional<SolutionApplicationTarget>
+    rewriteTarget(SolutionApplicationTarget target);
   };
 } // end anonymous namespace
 
@@ -7305,41 +7309,14 @@ static Optional<SolutionApplicationTarget> applySolutionToInitialization(
   return resultTarget;
 }
 
-/// Apply a given solution to the expression, producing a fully
-/// type-checked expression.
-Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
-    Solution &solution, SolutionApplicationTarget target,
-    bool performingDiagnostics) {
-  // If any fixes needed to be applied to arrive at this solution, resolve
-  // them to specific expressions.
-  if (!solution.Fixes.empty()) {
-    if (shouldSuppressDiagnostics())
-      return None;
-
-    bool diagnosedErrorsViaFixes = applySolutionFixes(solution);
-    // If all of the available fixes would result in a warning,
-    // we can go ahead and apply this solution to AST.
-    if (!llvm::all_of(solution.Fixes, [](const ConstraintFix *fix) {
-          return fix->isWarning();
-        })) {
-      // If we already diagnosed any errors via fixes, that's it.
-      if (diagnosedErrorsViaFixes)
-        return None;
-
-      // If we didn't manage to diagnose anything well, so fall back to
-      // diagnosing mining the system to construct a reasonable error message.
-      diagnoseFailureFor(target);
-      return None;
-    }
-  }
-
-  ExprRewriter rewriter(*this, solution, shouldSuppressDiagnostics());
-  ExprWalker walker(rewriter);
+Optional<SolutionApplicationTarget>
+ExprWalker::rewriteTarget(SolutionApplicationTarget target) {
+  auto &solution = Rewriter.solution;
 
   // Apply the solution to the target.
   SolutionApplicationTarget result = target;
   if (auto expr = target.getAsExpr()) {
-    Expr *rewrittenExpr = expr->walk(walker);
+    Expr *rewrittenExpr = expr->walk(*this);
     if (!rewrittenExpr)
       return None;
 
@@ -7358,19 +7335,19 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     auto fn = *target.getAsFunction();
 
     // Dig out the function builder transformation we applied.
-    auto transform = rewriter.getAppliedBuilderTransform(fn);
+    auto transform = Rewriter.getAppliedBuilderTransform(fn);
     assert(transform);
 
     auto newBody = applyFunctionBuilderTransform(
         solution, *transform, fn.getBody(), fn.getAsDeclContext(),
         [&](Expr *expr) {
-          Expr *result = expr->walk(walker);
+          Expr *result = expr->walk(*this);
           if (result)
             solution.setExprTypes(result);
           return result;
         },
         [&](Expr *expr, Type toType, ConstraintLocator *locator) {
-          return rewriter.coerceToType(expr, toType, locator);
+          return Rewriter.coerceToType(expr, toType, locator);
         });
 
     if (!newBody)
@@ -7379,26 +7356,8 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     result.setFunctionBody(newBody);
   }
 
-  // If we're re-typechecking an expression for diagnostics, don't
-  // visit closures that have non-single expression bodies.
-  if (!performingDiagnostics) {
-    bool hadError = false;
-    for (auto *closure : walker.getClosuresToTypeCheck())
-      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 |= TypeChecker::typeCheckTapBody(tap, tapDC);
-    }
-
-    // If any of them failed to type check, bail.
-    if (hadError)
-      return None;
-  }
-
+  // Follow-up tasks.
+  auto &cs = solution.getConstraintSystem();
   if (auto resultExpr = result.getAsExpr()) {
     Expr *expr = target.getAsExpr();
     assert(expr && "Can't have expression result without expression target");
@@ -7410,23 +7369,24 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     auto shouldCoerceToContextualType = [&]() {
       return convertType &&
           !target.isOptionalSomePatternInit() &&
-          !(getType(resultExpr)->isUninhabited() &&
-            getContextualTypePurpose(target.getAsExpr())
+          !(solution.getType(resultExpr)->isUninhabited() &&
+            cs.getContextualTypePurpose(target.getAsExpr())
               == CTP_ReturnSingleExpr);
     };
 
     // If we're supposed to convert the expression to some particular type,
     // do so now.
     if (shouldCoerceToContextualType()) {
-      resultExpr = rewriter.coerceToType(resultExpr,
-                                         simplifyType(convertType),
-                                         getConstraintLocator(expr));
-    } else if (getType(resultExpr)->hasLValueType() &&
+      resultExpr = Rewriter.coerceToType(resultExpr,
+                                         solution.simplifyType(convertType),
+                                         cs.getConstraintLocator(expr));
+    } else if (cs.getType(resultExpr)->hasLValueType() &&
                !target.isDiscardedExpr()) {
       // We referenced an lvalue. Load it.
-      resultExpr = rewriter.coerceToType(resultExpr,
-                                         getType(resultExpr)->getRValueType(),
-                                         getConstraintLocator(expr));
+      resultExpr = Rewriter.coerceToType(
+          resultExpr,
+          cs.getType(resultExpr)->getRValueType(),
+          cs.getConstraintLocator(expr));
     }
 
     if (!resultExpr)
@@ -7436,28 +7396,86 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     // conversion.
     if (FunctionType *autoclosureParamType =
             target.getAsAutoclosureParamType()) {
-      resultExpr = buildAutoClosureExpr(resultExpr, autoclosureParamType);
+      resultExpr = cs.buildAutoClosureExpr(resultExpr, autoclosureParamType);
     }
 
     solution.setExprTypes(resultExpr);
     result.setExpr(resultExpr);
 
-    if (Context.TypeCheckerOpts.DebugConstraintSolver) {
-      auto &log = Context.TypeCheckerDebug->getStream();
+    auto &ctx = cs.getASTContext();
+    if (ctx.TypeCheckerOpts.DebugConstraintSolver) {
+      auto &log = ctx.TypeCheckerDebug->getStream();
       log << "---Type-checked expression---\n";
       resultExpr->dump(log);
       log << "\n";
     }
   }
 
+  return result;
+}
+
+/// Apply a given solution to the expression, producing a fully
+/// type-checked expression.
+Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
+    Solution &solution, SolutionApplicationTarget target,
+    bool performingDiagnostics) {
+  // If any fixes needed to be applied to arrive at this solution, resolve
+  // them to specific expressions.
+  if (!solution.Fixes.empty()) {
+    if (shouldSuppressDiagnostics())
+      return None;
+
+    bool diagnosedErrorsViaFixes = applySolutionFixes(solution);
+    // If all of the available fixes would result in a warning,
+    // we can go ahead and apply this solution to AST.
+    if (!llvm::all_of(solution.Fixes, [](const ConstraintFix *fix) {
+          return fix->isWarning();
+        })) {
+      // If we already diagnosed any errors via fixes, that's it.
+      if (diagnosedErrorsViaFixes)
+        return None;
+
+      // If we didn't manage to diagnose anything well, so fall back to
+      // diagnosing mining the system to construct a reasonable error message.
+      diagnoseFailureFor(target);
+      return None;
+    }
+  }
+
+  ExprRewriter rewriter(*this, solution, shouldSuppressDiagnostics());
+  ExprWalker walker(rewriter);
+  auto resultTarget = walker.rewriteTarget(target);
+  if (!resultTarget)
+    return None;
+
+  // If we're re-typechecking an expression for diagnostics, don't
+  // visit closures that have non-single expression bodies.
+  if (!performingDiagnostics) {
+    bool hadError = false;
+    for (auto *closure : walker.getClosuresToTypeCheck())
+      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 |= TypeChecker::typeCheckTapBody(tap, tapDC);
+    }
+
+    // If any of them failed to type check, bail.
+    if (hadError)
+      return None;
+  }
+
   rewriter.finalize();
 
-  return result;
+  return resultTarget;
 }
 
 Expr *Solution::coerceToType(Expr *expr, Type toType,
                              ConstraintLocator *locator,
-                             Optional<Pattern*> typeFromPattern) const {
+                             Optional<Pattern*> typeFromPattern) {
   auto &cs = getConstraintSystem();
   ExprRewriter rewriter(cs, *this, /*suppressDiagnostics=*/false);
   Expr *result = rewriter.coerceToType(expr, toType, locator, typeFromPattern);

lib/Sema/ConstraintSystem.h

@@ -886,7 +886,7 @@ class Solution {
   /// \returns the coerced expression, which will have type \c ToType.
   Expr *coerceToType(Expr *expr, Type toType,
                      ConstraintLocator *locator,
-                     Optional<Pattern*> typeFromPattern = None) const;
+                     Optional<Pattern*> typeFromPattern = None);
 
   /// Compute the set of substitutions for a generic signature opened at the
   /// given locator.