[Constraint system] Extend SolutionApplicationTarget with an init pattern.

Initializer expressions are always type checked against a pattern, so also
include the pattern in the solution application target and use that to
compute the contextual type from the pattern type.

Author: DougGregor

lib/Sema/ConstraintSystem.cpp

@@ -3996,6 +3996,32 @@ SolutionApplicationTarget::SolutionApplicationTarget(
   expression.isDiscarded = isDiscarded;
 }
 
+SolutionApplicationTarget SolutionApplicationTarget::forInitialization(
+    Expr *initializer, Type patternType, Pattern *pattern) {
+  // Determine the contextual type for the initialization.
+  TypeLoc contextualType;
+  if (!isa<OptionalSomePattern>(pattern) &&
+      patternType && !patternType->isHole()) {
+    contextualType = TypeLoc::withoutLoc(patternType);
+
+    // Only provide a TypeLoc if it makes sense to allow diagnostics.
+    if (auto *typedPattern = dyn_cast<TypedPattern>(pattern)) {
+      const Pattern *inner = typedPattern->getSemanticsProvidingPattern();
+      if (isa<NamedPattern>(inner) || isa<AnyPattern>(inner)) {
+        contextualType = typedPattern->getTypeLoc();
+        if (!contextualType.getType())
+          contextualType.setType(patternType);
+      }
+    }
+  }
+
+  SolutionApplicationTarget target(
+      initializer, CTP_Initialization, contextualType,
+      /*isDiscarded=*/false);
+  target.expression.pattern = pattern;
+  return target;
+}
+
 bool SolutionApplicationTarget::contextualTypeIsOnlyAHint(
     bool isOpaqueReturnType) const {
   assert(kind == Kind::expression);

lib/Sema/ConstraintSystem.h

@@ -1147,6 +1147,7 @@ class SolutionApplicationTarget {
 
   union {
     struct {
+      /// The expression being type-checked.
       Expr *expression;
 
       /// The purpose of the contextual type.
@@ -1155,6 +1156,10 @@ class SolutionApplicationTarget {
       /// The type to which the expression should be converted.
       TypeLoc convertType;
 
+      /// When initializing a pattern from the expression, this is the
+      /// pattern.
+      Pattern *pattern = nullptr;
+
       /// Whether the expression result will be discarded at the end.
       bool isDiscarded;
     } expression;
@@ -1185,6 +1190,10 @@ class SolutionApplicationTarget {
     function.body = body;
   }
 
+  /// Form a target for the initialization of a pattern from an expression.
+  static SolutionApplicationTarget forInitialization(
+      Expr *initializer, Type patternType, Pattern *pattern);
+
   Expr *getAsExpr() const {
     switch (kind) {
     case Kind::expression:
@@ -1236,6 +1245,13 @@ class SolutionApplicationTarget {
     expression.convertType = type;
   }
 
+  /// For a pattern initialization target, retrieve the pattern.
+  Pattern *getInitializationPattern() const {
+    assert(kind == Kind::expression);
+    assert(expression.contextualPurpose == CTP_Initialization);
+    return expression.pattern;
+  }
+
   /// Whether the contextual type is only a hint, rather than a type
   bool contextualTypeIsOnlyAHint(bool isOpaqueReturnType) const;
 

lib/Sema/TypeCheckConstraints.cpp

@@ -2679,44 +2679,24 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
 
   if (isa<OptionalSomePattern>(pattern)) {
     flags |= TypeCheckExprFlags::ExpressionTypeMustBeOptional;
-  } else if (patternType && !patternType->isEqual(Context.TheUnresolvedType)) {
-    contextualType = TypeLoc::withoutLoc(patternType);
-
-    // If we already had an error, don't repeat the problem.
-    if (contextualType.getType()->hasError())
-      return true;
-    
-    // Allow the initializer expression to establish the underlying type of an
-    // opaque type.
-    if (auto opaqueType = patternType->getAs<OpaqueTypeArchetypeType>()){
-      flags |= TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType;
-    }
-
-    // Only provide a TypeLoc if it makes sense to allow diagnostics.
-    if (auto *typedPattern = dyn_cast<TypedPattern>(pattern)) {
-      const Pattern *inner = typedPattern->getSemanticsProvidingPattern();
-      if (isa<NamedPattern>(inner) || isa<AnyPattern>(inner)) {
-        contextualType = typedPattern->getTypeLoc();
-        if (!contextualType.getType())
-          contextualType.setType(patternType);
-      }
-    }
   }
 
   // Type-check the initializer.
-  auto resultTy = typeCheckExpression(initializer, DC, contextualType,
-                                      contextualPurpose, flags, &listener);
+  auto target = SolutionApplicationTarget::forInitialization(
+      initializer, patternType, pattern);
+  bool unresolvedTypeExprs = false;
+  auto resultTarget = typeCheckExpression(target, DC, unresolvedTypeExprs,
+                                          flags, &listener);
+
+  if (resultTarget) {
+    initializer = resultTarget->getAsExpr();
 
-  if (resultTy) {
     TypeResolutionOptions options =
         isa<EditorPlaceholderExpr>(initializer->getSemanticsProvidingExpr())
         ? TypeResolverContext::EditorPlaceholderExpr
         : TypeResolverContext::InExpression;
     options |= TypeResolutionFlags::OverrideType;
 
-    // FIXME: initTy should be the same as resultTy; now that typeCheckExpression()
-    // returns a Type and not bool, we should be able to simplify the listener
-    // implementation here.
     auto initTy = listener.getPatternInitType(nullptr);
     if (initTy->hasDependentMember())
       return true;
@@ -2730,15 +2710,17 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
     } else {
       return true;
     }
+  } else {
+    initializer = target.getAsExpr();
   }
 
-  if (!resultTy && !initializer->getType())
+  if (!resultTarget && !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 (!resultTy &&
+  if (!resultTarget &&
       (patternType->hasUnresolvedType() ||
        patternType->hasUnboundGenericType())) {
     pattern->setType(ErrorType::get(Context));
@@ -2754,7 +2736,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
     });
   }
 
-  return !resultTy;
+  return !resultTarget;
 }
 
 bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,