[Constraint system] Remove typeCheckBinding’s ExprTypeCheckListener.

Sink the solution-application code from typeCheckBinding’s
ExprTypeCheckListener subclass into normal solution application, allowing
us to eliminate this subclass entirely. Down to one…

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -7227,6 +7227,49 @@ bool ConstraintSystem::applySolutionFixes(const Solution &solution) {
   return diagnosedAnyErrors;
 }
 
+/// Apply the given solution to the initialization target.
+///
+/// \returns the resulting initialiation expression.
+static Expr *applySolutionToInitialization(
+    Solution &solution, SolutionApplicationTarget target, Expr *expr) {
+  auto wrappedVar = target.getInitializationWrappedVar();
+  Type initType;
+  if (wrappedVar) {
+    initType = solution.getType(expr);
+  } else {
+    initType = solution.getType(target.getInitializationPattern());
+  }
+
+  {
+    // Figure out what type the constraints decided on.
+    auto ty = solution.simplifyType(initType);
+    initType = ty->getRValueType()->reconstituteSugar(/*recursive =*/false);
+  }
+
+  // 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;
+
+  // Record the property wrapper type and note that the initializer has
+  // been subsumed by the backing property.
+  if (wrappedVar) {
+    ASTContext &ctx = cs.getASTContext();
+    wrappedVar->getParentPatternBinding()->setInitializerSubsumed(0);
+    ctx.setSideCachedPropertyWrapperBackingPropertyType(
+        wrappedVar, initType->mapTypeOutOfContext());
+
+    // Record the semantic initializer on the outermost property wrapper.
+    wrappedVar->getAttachedPropertyWrappers().front()
+        ->setSemanticInit(expr);
+  }
+
+  return expr;
+}
+
 /// Apply a given solution to the expression, producing a fully
 /// type-checked expression.
 Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
@@ -7265,6 +7308,14 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     if (!rewrittenExpr)
       return None;
 
+    /// Handle application for initializations.
+    if (target.getExprContextualTypePurpose() == CTP_Initialization) {
+      rewrittenExpr = applySolutionToInitialization(
+          solution, target, rewrittenExpr);
+      if (!rewrittenExpr)
+        return None;
+    }
+
     result.setExpr(rewrittenExpr);
   } else {
     auto fn = *target.getAsFunction();

lib/Sema/TypeCheckConstraints.cpp

@@ -2413,79 +2413,14 @@ TypeChecker::getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
 bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
                                    DeclContext *DC,
                                    Type patternType) {
-
-  /// Type checking listener for pattern binding initializers.
-  class BindingListener : public ExprTypeCheckListener {
-    ASTContext &context;
-
-    SolutionApplicationTarget target;
-
-    /// The locator we're using.
-    ConstraintLocator *Locator;
-
-    /// The variable to that has property wrappers that have been applied to the initializer expression.
-    VarDecl *wrappedVar = nullptr;
-
-  public:
-    explicit BindingListener(ASTContext &ctx, SolutionApplicationTarget target)
-        : context(ctx), target(target), Locator(nullptr) {
-      wrappedVar = target.getInitializationWrappedVar();
-    }
-
-    bool builtConstraints(ConstraintSystem &cs, Expr *expr) override {
-      // The expression has been pre-checked; save it in case we fail later.
-      Locator = cs.getConstraintLocator(expr, LocatorPathElt::ContextualType());
-      return false;
-    }
-
-    Expr *appliedSolution(Solution &solution, Expr *expr) override {
-      Type initType;
-      if (wrappedVar) {
-        initType = solution.getType(expr);
-      } else {
-        initType = solution.getType(target.getInitializationPattern());
-      }
-
-      {
-        // Figure out what type the constraints decided on.
-        auto ty = solution.simplifyType(initType);
-        initType = ty->getRValueType()->reconstituteSugar(/*recursive =*/false);
-      }
-
-      // Convert the initializer to the type of the pattern.
-      expr = solution.coerceToType(expr, initType, Locator);
-      if (!expr)
-        return nullptr;
-
-      // Record the property wrapper type and note that the initializer has
-      // been subsumed by the backing property.
-      if (wrappedVar) {
-        wrappedVar->getParentPatternBinding()->setInitializerSubsumed(0);
-        context.setSideCachedPropertyWrapperBackingPropertyType(
-            wrappedVar, initType->mapTypeOutOfContext());
-
-        // Record the semantic initializer on the outermost property wrapper.
-        wrappedVar->getAttachedPropertyWrappers().front()
-            ->setSemanticInit(expr);
-      }
-
-      return expr;
-    }
-  };
-
   auto &Context = DC->getASTContext();
   auto target = SolutionApplicationTarget::forInitialization(
       initializer, DC, patternType, pattern);
   initializer = target.getAsExpr();
 
-  BindingListener listener(Context, target);
-  if (!initializer)
-    return true;
-
   // Type-check the initializer.
   bool unresolvedTypeExprs = false;
-  auto resultTarget = typeCheckExpression(target, unresolvedTypeExprs,
-                                          None, &listener);
+  auto resultTarget = typeCheckExpression(target, unresolvedTypeExprs);
 
   if (resultTarget) {
     initializer = resultTarget->getAsExpr();