Merge pull request #29635 from DougGregor/simplify-solution-target

Author: swift-ci

lib/Sema/CSApply.cpp

@@ -7321,6 +7321,7 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     Type convertType = target.getExprConversionType();
     auto shouldCoerceToContextualType = [&]() {
       return convertType &&
+          !target.isOptionalSomePatternInit() &&
           !(getType(resultExpr)->isUninhabited() &&
             getContextualTypePurpose(target.getAsExpr())
               == CTP_ReturnSingleExpr);

lib/Sema/CSGen.cpp

@@ -3831,8 +3831,7 @@ bool ConstraintSystem::generateConstraints(StmtCondition condition,
 
     case StmtConditionElement::CK_Boolean: {
       Expr *condExpr = condElement.getBoolean();
-      setContextualType(condExpr, TypeLoc::withoutLoc(boolTy), CTP_Condition,
-                        /*isOpaqueReturnType=*/false);
+      setContextualType(condExpr, TypeLoc::withoutLoc(boolTy), CTP_Condition);
 
       condExpr = generateConstraints(condExpr, dc);
       if (!condExpr) {

lib/Sema/CSSimplify.cpp

@@ -9140,57 +9140,57 @@ void ConstraintSystem::addConstraint(ConstraintKind kind, Type first,
 }
 
 void ConstraintSystem::addContextualConversionConstraint(
-    Expr *expr, ContextualTypeInfo contextualType) {
-  Type convertType = contextualType.getType();
-  if (convertType.isNull())
+    Expr *expr, Type conversionType, ContextualTypePurpose purpose,
+    bool isOpaqueReturnType) {
+  if (conversionType.isNull())
     return;
 
   // Determine the type of the constraint.
   auto constraintKind = ConstraintKind::Conversion;
-  switch (contextualType.purpose) {
-    case CTP_ReturnStmt:
-    case CTP_ReturnSingleExpr:
-    case CTP_Initialization:
-      if (contextualType.isOpaqueReturnType)
-        constraintKind = ConstraintKind::OpaqueUnderlyingType;
-      break;
+  switch (purpose) {
+  case CTP_ReturnStmt:
+  case CTP_ReturnSingleExpr:
+  case CTP_Initialization:
+    if (isOpaqueReturnType)
+      constraintKind = ConstraintKind::OpaqueUnderlyingType;
+    break;
 
-    case CTP_CallArgument:
-      constraintKind = ConstraintKind::ArgumentConversion;
-      break;
+  case CTP_CallArgument:
+    constraintKind = ConstraintKind::ArgumentConversion;
+    break;
 
-    case CTP_YieldByReference:
-      // In a by-reference yield, we expect the contextual type to be an
-      // l-value type, so the result must be bound to that.
-      constraintKind = ConstraintKind::Bind;
-      break;
+  case CTP_YieldByReference:
+    // In a by-reference yield, we expect the contextual type to be an
+    // l-value type, so the result must be bound to that.
+    constraintKind = ConstraintKind::Bind;
+    break;
 
-    case CTP_ArrayElement:
-    case CTP_AssignSource:
-    case CTP_CalleeResult:
-    case CTP_CannotFail:
-    case CTP_Condition:
-    case CTP_Unused:
-    case CTP_YieldByValue:
-    case CTP_ThrowStmt:
-    case CTP_EnumCaseRawValue:
-    case CTP_DefaultParameter:
-    case CTP_AutoclosureDefaultParameter:
-    case CTP_ClosureResult:
-    case CTP_DictionaryKey:
-    case CTP_DictionaryValue:
-    case CTP_CoerceOperand:
-    case CTP_SubscriptAssignSource:
-    case CTP_ForEachStmt:
-      break;
+  case CTP_ArrayElement:
+  case CTP_AssignSource:
+  case CTP_CalleeResult:
+  case CTP_CannotFail:
+  case CTP_Condition:
+  case CTP_Unused:
+  case CTP_YieldByValue:
+  case CTP_ThrowStmt:
+  case CTP_EnumCaseRawValue:
+  case CTP_DefaultParameter:
+  case CTP_AutoclosureDefaultParameter:
+  case CTP_ClosureResult:
+  case CTP_DictionaryKey:
+  case CTP_DictionaryValue:
+  case CTP_CoerceOperand:
+  case CTP_SubscriptAssignSource:
+  case CTP_ForEachStmt:
+    break;
   }
 
   // Add the constraint.
-  bool isForSingleExprFunction = (contextualType.purpose == CTP_ReturnSingleExpr);
+  bool isForSingleExprFunction = (purpose == CTP_ReturnSingleExpr);
   auto *convertTypeLocator = getConstraintLocator(
       expr, LocatorPathElt::ContextualType(isForSingleExprFunction));
-  addConstraint(constraintKind, getType(expr), convertType,
-               convertTypeLocator, /*isFavored*/ true);
+  addConstraint(constraintKind, getType(expr), conversionType,
+                convertTypeLocator, /*isFavored*/ true);
 }
 
 Type ConstraintSystem::addJoinConstraint(

lib/Sema/CSSolver.cpp

@@ -240,8 +240,7 @@ void ConstraintSystem::applySolution(const Solution &solution) {
   for (const auto &contextualType : solution.contextualTypes) {
     if (!getContextualTypeInfo(contextualType.first)) {
       setContextualType(contextualType.first, contextualType.second.typeLoc,
-                        contextualType.second.purpose,
-                        contextualType.second.isOpaqueReturnType);
+                        contextualType.second.purpose);
     }
   }
 
@@ -1243,8 +1242,6 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
   Expr *expr = target.getAsExpr();
   Timer.emplace(expr, *this);
 
-  Expr *origExpr = expr;
-
   // Try to shrink the system by reducing disjunction domains. This
   // goes through every sub-expression and generate its own sub-system, to
   // try to reduce the domains of those subexpressions.
@@ -1261,12 +1258,8 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
   // constraint.
   if (Type convertType = target.getExprConversionType()) {
     // 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) {
@@ -1281,9 +1274,8 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
       });
     }
 
-    ContextualTypeInfo info{
-        TypeLoc::withoutLoc(convertType), ctp, isOpaqueReturnType};
-    addContextualConversionConstraint(expr, info);
+    addContextualConversionConstraint(expr, convertType, ctp,
+                                      isOpaqueReturnType);
   }
 
   // Notify the listener that we've built the constraint system.

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

@@ -792,7 +792,6 @@ using OpenedTypeMap =
 struct ContextualTypeInfo {
   TypeLoc typeLoc;
   ContextualTypePurpose purpose;
-  bool isOpaqueReturnType = false;
 
   Type getType() const { return typeLoc.getType(); }
 };
@@ -1224,11 +1223,11 @@ class SolutionApplicationTarget {
     return expression.contextualPurpose;
   }
 
-  Type getExprConversionType() const {
-    return getExprConversionTypeLoc().getType();
+  Type getExprContextualType() const {
+    return getExprContextualTypeLoc().getType();
   }
 
-  TypeLoc getExprConversionTypeLoc() const {
+  TypeLoc getExprContextualTypeLoc() const {
     assert(kind == Kind::expression);
 
     // For an @autoclosure parameter, the conversion type is
@@ -1241,6 +1240,14 @@ class SolutionApplicationTarget {
     return expression.convertType;
   }
 
+  /// Retrieve the type to which an expression should be converted, or
+  /// a NULL type if no conversion constraint should be generated.
+  Type getExprConversionType() const {
+    if (contextualTypeIsOnlyAHint())
+      return Type();
+    return getExprContextualType();
+  }
+
   /// Returns the autoclosure parameter type, or \c nullptr if the
   /// expression has a different kind of context.
   FunctionType *getAsAutoclosureParamType() const {
@@ -2328,12 +2335,11 @@ class ConstraintSystem {
   }
 
   void setContextualType(
-      const Expr *expr, TypeLoc T, ContextualTypePurpose purpose,
-       bool isOpaqueReturnType) {
+      const Expr *expr, TypeLoc T, ContextualTypePurpose purpose) {
     assert(expr != nullptr && "Expected non-null expression!");
     assert(contextualTypes.count(expr) == 0 &&
            "Already set this contextual type");
-    contextualTypes[expr] = { T, purpose, isOpaqueReturnType };
+    contextualTypes[expr] = { T, purpose };
   }
 
   Optional<ContextualTypeInfo> getContextualTypeInfo(const Expr *expr) const {
@@ -2565,7 +2571,8 @@ class ConstraintSystem {
 
   /// Add the appropriate constraint for a contextual conversion.
   void addContextualConversionConstraint(
-      Expr *expr, ContextualTypeInfo contextualType);
+      Expr *expr, Type conversionType, ContextualTypePurpose purpose,
+      bool isOpaqueReturnType);
 
   /// Add a "join" constraint between a set of types, producing the common
   /// supertype.

lib/Sema/TypeCheckConstraints.cpp

@@ -2050,6 +2050,7 @@ TypeChecker::typeCheckExpression(
     target.setExpr(expr);
     return None;
   }
+  target.setExpr(expr);
 
   // Construct a constraint system from this expression.
   ConstraintSystemOptions csOptions = ConstraintSystemFlags::AllowFixes;
@@ -2070,46 +2071,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,
-      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();
+      contextualTypeExpr,
+      target.getExprContextualTypeLoc(),
+      target.getExprContextualTypePurpose());
 
   // 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.getExprContextualType() &&
+           "some pattern cannot have contextual type pre-configured");
     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;
@@ -2120,7 +2109,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.getExprConversionType() &&
+         target.getExprConversionType()->hasUnresolvedType()))) {
     // FIXME: This hack should only be needed for CSDiag.
     unresolvedTypeExprs = true;
     return target;
@@ -2134,10 +2124,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.