[Constraint solver] One SolutionApplicationTarget instance to rule them all.

Capture the peculiarities of contextual types vs. types used to generate
conversion constraints, as well as the behavior of “optional some” patterns
as used by if let / while let, within SolutionApplicationTarget. This allows
us to use a single target throughout setup / solving / application, rather
than mapping between two similar-but-disjoint targets.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -7320,9 +7320,10 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     // We are supposed to use contextual type only if it is present and
     // this expression doesn't represent the implicit return of the single
     // expression function which got deduced to be `Never`.
-    Type convertType = target.getExprConversionType();
+    Type convertType = target.getExprConversionTypeForConstraint();
     auto shouldCoerceToContextualType = [&]() {
       return convertType &&
+          !target.isOptionalSomePatternInit() &&
           !(getType(resultExpr)->isUninhabited() &&
             getContextualTypePurpose(target.getAsExpr())
               == CTP_ReturnSingleExpr);

lib/Sema/CSSolver.cpp

@@ -1259,14 +1259,10 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
 
   // If there is a type that we're expected to convert to, add the conversion
   // constraint.
-  if (Type convertType = target.getExprConversionType()) {
+  if (Type convertType = target.getExprConversionTypeForConstraint()) {
     // Determine whether we know more about the contextual type.
-    ContextualTypePurpose ctp = CTP_Unused;
-    bool isOpaqueReturnType = false;
-    if (auto contextualInfo = getContextualTypeInfo(origExpr)) {
-      ctp = contextualInfo->purpose;
-      isOpaqueReturnType = contextualInfo->isOpaqueReturnType;
-    }
+    ContextualTypePurpose ctp = target.getExprContextualTypePurpose();
+    bool isOpaqueReturnType = target.infersOpaqueReturnType();
 
     // Substitute type variables in for unresolved types.
     if (allowFreeTypeVariables == FreeTypeVariableBinding::UnresolvedType) {

lib/Sema/ConstraintSystem.cpp

@@ -4053,7 +4053,7 @@ bool SolutionApplicationTarget::contextualTypeIsOnlyAHint() const {
   assert(kind == Kind::expression);
   switch (expression.contextualPurpose) {
   case CTP_Initialization:
-    return !infersOpaqueReturnType();
+    return !infersOpaqueReturnType() && !isOptionalSomePatternInit();
   case CTP_ForEachStmt:
     return true;
   case CTP_Unused:

lib/Sema/ConstraintSystem.h

@@ -1241,6 +1241,12 @@ class SolutionApplicationTarget {
     return expression.convertType;
   }
 
+  Type getExprConversionTypeForConstraint() const {
+    if (contextualTypeIsOnlyAHint())
+      return Type();
+    return getExprConversionType();
+  }
+
   /// Returns the autoclosure parameter type, or \c nullptr if the
   /// expression has a different kind of context.
   FunctionType *getAsAutoclosureParamType() const {

lib/Sema/TypeCheckConstraints.cpp

@@ -2107,6 +2107,7 @@ TypeChecker::typeCheckExpression(
     target.setExpr(expr);
     return None;
   }
+  target.setExpr(expr);
 
   // Construct a constraint system from this expression.
   ConstraintSystemOptions csOptions = ConstraintSystemFlags::AllowFixes;
@@ -2127,46 +2128,34 @@ TypeChecker::typeCheckExpression(
   // diagnostics and is a hint for various performance optimizations.
   // FIXME: Look through LoadExpr. This is an egregious hack due to the
   // way typeCheckExprIndependently works.
-  TypeLoc convertType = target.getExprConversionTypeLoc();
   Expr *contextualTypeExpr = expr;
   if (auto loadExpr = dyn_cast_or_null<LoadExpr>(contextualTypeExpr))
     contextualTypeExpr = loadExpr->getSubExpr();
   cs.setContextualType(
-      contextualTypeExpr, convertType,
+      contextualTypeExpr,
+      target.getExprConversionTypeLoc(),
       target.getExprContextualTypePurpose(),
       target.infersOpaqueReturnType());
 
-  // If the convertType is *only* provided for that hint, then null it out so
-  // that we don't later treat it as an actual conversion constraint.
-  if (target.contextualTypeIsOnlyAHint())
-    convertType = TypeLoc();
-
   // If the client can handle unresolved type variables, leave them in the
   // system.
   auto allowFreeTypeVariables = FreeTypeVariableBinding::Disallow;
   if (options.contains(TypeCheckExprFlags::AllowUnresolvedTypeVariables))
     allowFreeTypeVariables = FreeTypeVariableBinding::UnresolvedType;
 
-  Type convertTo = convertType.getType();
-
+  // If the target requires an optional of some type, form a new appropriate
+  // type variable and update the target's type with an optional of that
+  // type variable.
   if (target.isOptionalSomePatternInit()) {
-    assert(!convertTo && "convertType and type check options conflict");
+    assert(!target.getExprConversionType() && "convertType and type check options conflict");
     auto *convertTypeLocator =
         cs.getConstraintLocator(expr, LocatorPathElt::ContextualType());
     Type var = cs.createTypeVariable(convertTypeLocator, TVO_CanBindToNoEscape);
-    convertTo = getOptionalType(expr->getLoc(), var);
-  } else if (target.getExprContextualTypePurpose()
-                 == CTP_AutoclosureDefaultParameter) {
-    // FIXME: Hack around the convertTo adjustment below, which we want to
-    // eliminate.
-    convertTo = Type(target.getAsAutoclosureParamType());
+    target.setExprConversionType(getOptionalType(expr->getLoc(), var));
   }
 
   // Attempt to solve the constraint system.
-  SolutionApplicationTarget innerTarget(
-      expr, dc, target.getExprContextualTypePurpose(), convertTo,
-      target.isDiscardedExpr());
-  auto viable = cs.solve(innerTarget, listener, allowFreeTypeVariables);
+  auto viable = cs.solve(target, listener, allowFreeTypeVariables);
   if (!viable) {
     target.setExpr(expr);
     return None;
@@ -2177,7 +2166,8 @@ TypeChecker::typeCheckExpression(
   // because they will leak out into arbitrary places in the resultant AST.
   if (options.contains(TypeCheckExprFlags::AllowUnresolvedTypeVariables) &&
        (viable->size() != 1 ||
-       (convertType.getType() && convertType.getType()->hasUnresolvedType()))) {
+        (target.getExprConversionTypeForConstraint() &&
+         target.getExprConversionTypeForConstraint()->hasUnresolvedType()))) {
     // FIXME: This hack should only be needed for CSDiag.
     unresolvedTypeExprs = true;
     return target;
@@ -2191,10 +2181,6 @@ TypeChecker::typeCheckExpression(
   // Apply the solution to the expression.
   bool performingDiagnostics =
       options.contains(TypeCheckExprFlags::SubExpressionDiagnostics);
-  // FIXME: HACK! Copy over the inner target's expression info.
-  target.setExpr(innerTarget.getAsExpr());
-  if (convertTo.isNull())
-    target.setExprConversionType(convertTo);
   auto resultTarget = cs.applySolution(solution, target, performingDiagnostics);
   if (!resultTarget) {
     // Failure already diagnosed, above, as part of applying the solution.