[Constraint solver] Sink remaining logic from typeCheckBinding.

Move the remaining logic of typeCheckBinding, which consists of applying
the solution to the pattern, down into the normal solution application
path. typeCheckBinding() is now a thin shell over the normal
typeCheckExpression() convenience function.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -22,6 +22,7 @@
 #include "MiscDiagnostics.h"
 #include "SolutionResult.h"
 #include "TypeCheckProtocol.h"
+#include "TypeCheckType.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/ExistentialLayout.h"
@@ -7230,12 +7231,13 @@ bool ConstraintSystem::applySolutionFixes(const Solution &solution) {
 /// Apply the given solution to the initialization target.
 ///
 /// \returns the resulting initialiation expression.
-static Expr *applySolutionToInitialization(
-    Solution &solution, SolutionApplicationTarget target, Expr *expr) {
+static Optional<SolutionApplicationTarget> applySolutionToInitialization(
+    Solution &solution, SolutionApplicationTarget target,
+    Expr *initializer) {
   auto wrappedVar = target.getInitializationWrappedVar();
   Type initType;
   if (wrappedVar) {
-    initType = solution.getType(expr);
+    initType = solution.getType(initializer);
   } else {
     initType = solution.getType(target.getInitializationPattern());
   }
@@ -7249,10 +7251,13 @@ static Expr *applySolutionToInitialization(
   // Convert the initializer to the type of the pattern.
   auto &cs = solution.getConstraintSystem();
   auto locator =
-      cs.getConstraintLocator(expr, LocatorPathElt::ContextualType());
-  expr = solution.coerceToType(expr, initType, locator);
-  if (!expr)
-    return nullptr;
+      cs.getConstraintLocator(initializer, LocatorPathElt::ContextualType());
+  initializer = solution.coerceToType(initializer, initType, locator);
+  if (!initializer)
+    return None;
+
+  SolutionApplicationTarget resultTarget = target;
+  resultTarget.setExpr(initializer);
 
   // Record the property wrapper type and note that the initializer has
   // been subsumed by the backing property.
@@ -7264,10 +7269,40 @@ static Expr *applySolutionToInitialization(
 
     // Record the semantic initializer on the outermost property wrapper.
     wrappedVar->getAttachedPropertyWrappers().front()
-        ->setSemanticInit(expr);
+        ->setSemanticInit(initializer);
   }
 
-  return expr;
+  // Coerce the pattern to the type of the initializer.
+  TypeResolutionOptions options =
+      isa<EditorPlaceholderExpr>(initializer->getSemanticsProvidingExpr())
+      ? TypeResolverContext::EditorPlaceholderExpr
+      : TypeResolverContext::InExpression;
+  options |= TypeResolutionFlags::OverrideType;
+
+  // Determine the type of the pattern.
+  Type finalPatternType = initializer->getType();
+  if (wrappedVar) {
+    if (!finalPatternType->hasError() && !finalPatternType->is<TypeVariableType>())
+      finalPatternType = computeWrappedValueType(wrappedVar, finalPatternType);
+  }
+
+  if (finalPatternType->hasDependentMember())
+    return None;
+
+  finalPatternType = finalPatternType->reconstituteSugar(/*recursive =*/false);
+
+  // Apply the solution to the pattern as well.
+  auto contextualPattern =
+      ContextualPattern::forRawPattern(target.getInitializationPattern(),
+                                       target.getDeclContext());
+  if (auto coercedPattern = TypeChecker::coercePatternToType(
+          contextualPattern, finalPatternType, options)) {
+    resultTarget.setPattern(coercedPattern);
+  } else {
+    return None;
+  }
+
+  return resultTarget;
 }
 
 /// Apply a given solution to the expression, producing a fully
@@ -7310,13 +7345,15 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
 
     /// Handle application for initializations.
     if (target.getExprContextualTypePurpose() == CTP_Initialization) {
-      rewrittenExpr = applySolutionToInitialization(
+      auto initResultTarget = applySolutionToInitialization(
           solution, target, rewrittenExpr);
-      if (!rewrittenExpr)
+      if (!initResultTarget)
         return None;
-    }
 
-    result.setExpr(rewrittenExpr);
+      result = *initResultTarget;
+    } else {
+      result.setExpr(rewrittenExpr);
+    }
   } else {
     auto fn = *target.getAsFunction();
 

lib/Sema/ConstraintSystem.h

@@ -1314,6 +1314,12 @@ class SolutionApplicationTarget {
     expression.expression = expr;
   }
 
+  void setPattern(Pattern *pattern) {
+    assert(kind == Kind::expression);
+    assert(expression.contextualPurpose == CTP_Initialization);
+    expression.pattern = pattern;
+  }
+
   Optional<AnyFunctionRef> getAsFunction() const {
     switch (kind) {
     case Kind::expression:

lib/Sema/TypeCheckConstraints.cpp

@@ -2413,57 +2413,29 @@ TypeChecker::getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
 bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
                                    DeclContext *DC,
                                    Type patternType) {
-  auto &Context = DC->getASTContext();
   auto target = SolutionApplicationTarget::forInitialization(
       initializer, DC, patternType, pattern);
-  initializer = target.getAsExpr();
 
   // Type-check the initializer.
   bool unresolvedTypeExprs = false;
   auto resultTarget = typeCheckExpression(target, unresolvedTypeExprs);
 
   if (resultTarget) {
     initializer = resultTarget->getAsExpr();
-
-    TypeResolutionOptions options =
-        isa<EditorPlaceholderExpr>(initializer->getSemanticsProvidingExpr())
-        ? TypeResolverContext::EditorPlaceholderExpr
-        : TypeResolverContext::InExpression;
-    options |= TypeResolutionFlags::OverrideType;
-
-    Type initTy = initializer->getType();
-    if (auto wrappedVar = target.getInitializationWrappedVar()) {
-      if (!initTy->hasError() && !initTy->is<TypeVariableType>())
-        initTy = computeWrappedValueType(wrappedVar, initTy);
-    }
-
-    if (initTy->hasDependentMember())
-      return true;
-
-    initTy = initTy->reconstituteSugar(/*recursive =*/false);
-
-    // Apply the solution to the pattern as well.
-    auto contextualPattern =
-        ContextualPattern::forRawPattern(pattern, DC);
-    if (auto coercedPattern = TypeChecker::coercePatternToType(
-            contextualPattern, initTy, options)) {
-      pattern = coercedPattern;
-    } else {
-      return true;
-    }
-  } else {
-    initializer = target.getAsExpr();
+    return false;
   }
 
-  if (!resultTarget && !initializer->getType())
+  auto &Context = DC->getASTContext();
+  initializer = target.getAsExpr();
+
+  if (!initializer->getType())
     initializer->setType(ErrorType::get(Context));
 
   // If the type of the pattern is inferred, assign error types to the pattern
   // and its variables, to prevent it from being referenced by the constraint
   // system.
-  if (!resultTarget &&
-      (patternType->hasUnresolvedType() ||
-       patternType->hasUnboundGenericType())) {
+  if (patternType->hasUnresolvedType() ||
+      patternType->hasUnboundGenericType()) {
     pattern->setType(ErrorType::get(Context));
     pattern->forEachVariable([&](VarDecl *var) {
       // Don't change the type of a variable that we've been able to
@@ -2476,8 +2448,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
       var->setInvalid();
     });
   }
-
-  return !resultTarget;
+  return true;
 }
 
 bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,