[Constraint solver] Sink down initialization pattern constraint generation.

Sink the constraint generation for initialization patterns, including all
of the logic for property wrappers, from the high-level entry point
`typeCheckBinding` down into the lower-level constraint generation for
solution application targets.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -7265,6 +7265,10 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     if (!rewrittenExpr)
       return None;
 
+    if (target.getExprContextualTypePurpose() == CTP_Initialization) {
+
+    }
+
     result.setExpr(rewrittenExpr);
   } else {
     auto fn = *target.getAsFunction();

lib/Sema/CSGen.cpp

@@ -3831,6 +3831,68 @@ static Expr *generateConstraintsFor(ConstraintSystem &cs, Expr *expr,
   return result;
 }
 
+/// Generate constraints to produce the wrapped value type given the property
+/// that has an attached property wrapper.
+///
+/// \param initializerType The type of the adjusted initializer, which
+/// initializes the underlying storage variable.
+/// \param wrappedVar The property that has a property wrapper.
+/// \returns the type of the property.
+static Type generateWrappedPropertyTypeConstraints(
+   ConstraintSystem &cs, Type initializerType,
+   VarDecl *wrappedVar, ConstraintLocator *locator) {
+  Type valueType = LValueType::get(initializerType);
+  auto dc = wrappedVar->getInnermostDeclContext();
+
+  for (unsigned i : indices(wrappedVar->getAttachedPropertyWrappers())) {
+    auto wrapperInfo = wrappedVar->getAttachedPropertyWrapperTypeInfo(i);
+    if (!wrapperInfo)
+      break;
+
+    locator = cs.getConstraintLocator(locator, ConstraintLocator::Member);
+    Type memberType = cs.createTypeVariable(locator, TVO_CanBindToLValue);
+    cs.addValueMemberConstraint(
+        valueType, wrapperInfo.valueVar->createNameRef(),
+        memberType, dc, FunctionRefKind::Unapplied, { }, locator);
+    valueType = memberType;
+  }
+
+  // Set up an equality constraint to drop the lvalue-ness of the value
+  // type we produced.
+  Type propertyType = cs.createTypeVariable(locator, 0);
+  cs.addConstraint(ConstraintKind::Equal, propertyType, valueType, locator);
+  return propertyType;
+}
+
+/// Generate additional constraints for the pattern of an initialization.
+static bool generateInitPatternConstraints(
+    ConstraintSystem &cs, SolutionApplicationTarget target, Expr *initializer) {
+  auto pattern = target.getInitializationPattern();
+  auto locator =
+      cs.getConstraintLocator(initializer, LocatorPathElt::ContextualType());
+  Type patternType = cs.generateConstraints(pattern, locator);
+  if (!patternType)
+    return true;
+
+  // Record the type of this pattern.
+  cs.setType(pattern, patternType);
+
+  if (auto wrappedVar = target.getInitializationWrappedVar()) {
+    // Add an equal constraint between the pattern type and the
+    // property wrapper's "value" type.
+    Type propertyType = generateWrappedPropertyTypeConstraints(
+        cs, cs.getType(target.getAsExpr()), wrappedVar, locator);
+    cs.addConstraint(ConstraintKind::Equal, patternType,
+                     propertyType, locator, /*isFavored*/ true);
+  } else if (!patternType->is<OpaqueTypeArchetypeType>()) {
+    // Add a conversion constraint between the types.
+    cs.addConstraint(ConstraintKind::Conversion, cs.getType(target.getAsExpr()),
+                     patternType, locator, /*isFavored*/true);
+  }
+
+  return false;
+}
+
 bool ConstraintSystem::generateConstraints(
     SolutionApplicationTarget &target,
     FreeTypeVariableBinding allowFreeTypeVariables) {
@@ -3873,6 +3935,12 @@ bool ConstraintSystem::generateConstraints(
                                         isOpaqueReturnType);
     }
 
+    // For an initialization target, generate constraints for the pattern.
+    if (target.getExprContextualTypePurpose() == CTP_Initialization &&
+        generateInitPatternConstraints(*this, target, expr)) {
+      return true;
+    }
+
     return false;
   }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -2423,9 +2423,6 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
     /// The locator we're using.
     ConstraintLocator *Locator;
 
-    /// The type of the initializer.
-    Type initType;
-
     /// The variable to that has property wrappers that have been applied to the initializer expression.
     VarDecl *wrappedVar = nullptr;
 
@@ -2435,80 +2432,20 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
       wrappedVar = target.getInitializationWrappedVar();
     }
 
-    /// Retrieve the type to which the pattern should be coerced.
-    Type getPatternInitType(ConstraintSystem *cs) const {
-      if (!wrappedVar || initType->hasError() ||
-          initType->is<TypeVariableType>())
-        return initType;
-
-      // When we have an active constraint system, form value-member
-      // constraints to dig in to the appropriate resulting property.
-      if (cs) {
-        Type valueType = LValueType::get(initType);
-        auto dc = wrappedVar->getInnermostDeclContext();
-        auto *loc = cs->getConstraintLocator(target.getAsExpr());
-
-        for (unsigned i : indices(wrappedVar->getAttachedPropertyWrappers())) {
-          auto wrapperInfo = wrappedVar->getAttachedPropertyWrapperTypeInfo(i);
-          if (!wrapperInfo)
-            break;
-
-          loc = cs->getConstraintLocator(loc, ConstraintLocator::Member);
-          Type memberType = cs->createTypeVariable(loc, TVO_CanBindToLValue);
-          cs->addValueMemberConstraint(
-              valueType, wrapperInfo.valueVar->createNameRef(),
-              memberType, dc, FunctionRefKind::Unapplied, { }, loc);
-          valueType = memberType;
-        }
-        
-        // Set up an equality constraint to drop the lvalue-ness of the value
-        // type we produced.
-        Type propertyType = cs->createTypeVariable(loc, 0);
-        cs->addConstraint(ConstraintKind::Equal, propertyType, valueType, loc);
-        return propertyType;
-      }
-
-      // Otherwise, compute the wrapped value type directly.
-      return computeWrappedValueType(wrappedVar, initType);
-    }
-
     bool builtConstraints(ConstraintSystem &cs, Expr *expr) override {
-      assert(!expr->isSemanticallyInOutExpr());
-
-      // Save the locator we're using for the expression.
+      // The expression has been pre-checked; save it in case we fail later.
       Locator = cs.getConstraintLocator(expr, LocatorPathElt::ContextualType());
+      return false;
+    }
 
-      // Collect constraints from the pattern.
-      Type patternType =
-          cs.generateConstraints(target.getInitializationPattern(), Locator);
-      if (!patternType)
-        return true;
-
+    Expr *appliedSolution(Solution &solution, Expr *expr) override {
+      Type initType;
       if (wrappedVar) {
-        // When we have applied a property wrapper, the initializer type
-        // is the initialization of the property wrapper instance.
-        initType = cs.getType(expr);
-
-        // Add an equal constraint between the pattern type and the
-        // property wrapper's "value" type.
-        cs.addConstraint(ConstraintKind::Equal, patternType,
-                         getPatternInitType(&cs), Locator, /*isFavored*/ true);
+        initType = solution.getType(expr);
       } else {
-        // The initializer type is the type of the pattern.
-        initType = patternType;
-
-        // Add a conversion constraint between the types.
-        if (!initType->is<OpaqueTypeArchetypeType>()) {
-          cs.addConstraint(ConstraintKind::Conversion, cs.getType(expr),
-                           patternType, Locator, /*isFavored*/true);
-        }
+        initType = solution.getType(target.getInitializationPattern());
       }
 
-      // The expression has been pre-checked; save it in case we fail later.
-      return false;
-    }
-
-    Expr *appliedSolution(Solution &solution, Expr *expr) override {
       {
         // Figure out what type the constraints decided on.
         auto ty = solution.simplifyType(initType);
@@ -2520,8 +2457,6 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
       if (!expr)
         return nullptr;
 
-      assert(solution.getConstraintSystem().getType(expr)->isEqual(initType));
-
       // Record the property wrapper type and note that the initializer has
       // been subsumed by the backing property.
       if (wrappedVar) {
@@ -2542,7 +2477,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
   auto target = SolutionApplicationTarget::forInitialization(
       initializer, DC, patternType, pattern);
   initializer = target.getAsExpr();
-  
+
   BindingListener listener(Context, target);
   if (!initializer)
     return true;
@@ -2561,10 +2496,17 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
         : TypeResolverContext::InExpression;
     options |= TypeResolutionFlags::OverrideType;
 
-    auto initTy = listener.getPatternInitType(nullptr);
+    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);