Merge pull request #30160 from xedin/rdar-59773317

[ConstraintSystem] Don't record general contextual mismatch if there are restrictions present

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -1878,6 +1878,12 @@ bool ContextualFailure::diagnoseAsError() {
     if (diagnoseCoercionToUnrelatedType())
       return true;
 
+    if (isa<OptionalTryExpr>(anchor)) {
+      emitDiagnostic(anchor->getLoc(), diag::cannot_convert_initializer_value,
+                     getFromType(), getToType());
+      return true;
+    }
+
     return false;
   }
 

lib/Sema/CSSimplify.cpp

@@ -3609,6 +3609,10 @@ bool ConstraintSystem::repairFailures(
     if (lhs->isHole() || rhs->isHole())
       return true;
 
+    // If either side is not yet resolved, it's too early for this fix.
+    if (lhs->isTypeVariableOrMember() || rhs->isTypeVariableOrMember())
+      break;
+
     auto purpose = getContextualTypePurpose(anchor);
     if (rhs->isVoid() &&
         (purpose == CTP_ReturnStmt || purpose == CTP_ReturnSingleExpr)) {
@@ -3649,33 +3653,16 @@ bool ConstraintSystem::repairFailures(
       break;
     }
 
-    // If either side is not yet resolved, it's too early for this fix.
-    if (lhs->isTypeVariableOrMember() || rhs->isTypeVariableOrMember())
-      break;
-
-    // If contextual type is an existential value, it's handled
-    // after conversion restriction is attempted.
-    if (rhs->isExistentialType())
-      break;
-
     if (repairViaOptionalUnwrap(*this, lhs, rhs, matchKind, conversionsOrFixes,
                                 locator))
       break;
 
-    // If there is a deep equality, superclass restriction
-    // already recorded, let's not add bother ignoring
-    // contextual type, because actual fix is going to
-    // be performed once restriction is applied.
-    if (hasConversionOrRestriction(ConversionRestrictionKind::Superclass))
-      break;
-
-    if (hasConversionOrRestriction(
-            ConversionRestrictionKind::MetatypeToExistentialMetatype))
-      break;
-
-    if (hasConversionOrRestriction(ConversionRestrictionKind::DeepEquality) &&
-        !hasConversionOrRestriction(
-            ConversionRestrictionKind::OptionalToOptional))
+    // If there are any restrictions here we need to wait and let
+    // `simplifyRestrictedConstraintImpl` handle them.
+    if (llvm::any_of(conversionsOrFixes,
+                     [](const RestrictionOrFix &correction) {
+                       return bool(correction.getRestriction());
+                     }))
       break;
 
     conversionsOrFixes.push_back(IgnoreContextualType::create(
@@ -8532,7 +8519,8 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     auto impact = 2;
     if (loc->isForAssignment() || loc->isForCoercion() ||
         loc->isForContextualType() ||
-        loc->isLastElement<LocatorPathElt::ApplyArgToParam>()) {
+        loc->isLastElement<LocatorPathElt::ApplyArgToParam>() ||
+        loc->isForOptionalTry()) {
       if (restriction == ConversionRestrictionKind::Superclass) {
         if (auto *fix =
                 CoerceToCheckedCast::attempt(*this, fromType, toType, loc))

lib/Sema/ConstraintLocator.cpp

@@ -234,13 +234,15 @@ bool ConstraintLocator::isForContextualType() const {
 }
 
 bool ConstraintLocator::isForAssignment() const {
-  auto *anchor = getAnchor();
-  return anchor && isa<AssignExpr>(anchor) && getPath().empty();
+  return directlyAt<AssignExpr>();
 }
 
 bool ConstraintLocator::isForCoercion() const {
-  auto *anchor = getAnchor();
-  return anchor && isa<CoerceExpr>(anchor) && getPath().empty();
+  return directlyAt<CoerceExpr>();
+}
+
+bool ConstraintLocator::isForOptionalTry() const {
+  return directlyAt<OptionalTryExpr>();
 }
 
 GenericTypeParamType *ConstraintLocator::getGenericParameter() const {

lib/Sema/ConstraintLocator.h

@@ -371,6 +371,15 @@ class ConstraintLocator : public llvm::FoldingSetNode {
   /// Determine whether this locator points to the coercion expression.
   bool isForCoercion() const;
 
+  /// Determine whether this locator points to the `try?` expression.
+  bool isForOptionalTry() const;
+
+  /// Determine whether this locator points directly to a given expression.
+  template <class E> bool directlyAt() const {
+    auto *anchor = getAnchor();
+    return anchor && isa<E>(anchor) && getPath().empty();
+  }
+
   /// Attempts to cast the first path element of the locator to a specific
   /// \c LocatorPathElt subclass, returning \c None if either unsuccessful or
   /// the locator has no path elements.

test/Constraints/enum_cases.swift

@@ -93,17 +93,16 @@ foo(Foo.a, Foo.b) // Ok in Swift 4 because we strip labels from the arguments
 
 // rdar://problem/32551313 - Useless SE-0110 diagnostic
 
-enum E_32551313<L, R> { // expected-note {{'R' declared as parameter to type 'E_32551313'}}
+enum E_32551313<L, R> {
   case Left(L)
   case Right(R)
 }
 
 struct Foo_32551313 {
-  // FIXME(diagnostics): We should be able to figure out L and R from contextual type
   static func bar() -> E_32551313<(String, Foo_32551313?), (String, String)>? {
-    return E_32551313.Left("", Foo_32551313()) // expected-error {{extra argument in call}}
-    // expected-error@-1 {{generic parameter 'R' could not be inferred}} expected-note@-1 {{explicitly specify the generic arguments to fix this issue}}
-    // expected-error@-2 {{cannot convert return expression of type 'E_32551313<String, R>' to return type 'E_32551313<(String, Foo_32551313?), (String, String)>?'}}
+    return E_32551313.Left("", Foo_32551313())
+    // expected-error@-1 {{cannot convert value of type 'String' to expected argument type '(String, Foo_32551313?)'}}
+    // expected-error@-2 {{extra argument in call}}
   }
 }
 

test/Constraints/fixes.swift

@@ -159,17 +159,15 @@ struct Q {
 }
 let q = Q(s: nil)
 let a: Int? = q.s.utf8 // expected-error{{value of optional type 'String?' must be unwrapped to refer to member 'utf8' of wrapped base type 'String'}}
-// expected-error@-1 {{cannot convert value of type 'String.UTF8View' to specified type 'Int?'}}
+// expected-error@-1 {{cannot convert value of type 'String.UTF8View?' to specified type 'Int?'}}
 // expected-note@-2{{chain the optional using '?'}}{{18-18=?}}
-// expected-note@-3{{force-unwrap using '!'}}{{18-18=!}}
 let b: Int = q.s.utf8 // expected-error{{value of optional type 'String?' must be unwrapped to refer to member 'utf8' of wrapped base type 'String'}}
 // expected-error@-1 {{cannot convert value of type 'String.UTF8View' to specified type 'Int'}}
 // expected-note@-2{{chain the optional using '?'}}{{17-17=?}}
 // expected-note@-3{{force-unwrap using '!'}}{{17-17=!}}
 let d: Int! = q.s.utf8 // expected-error{{value of optional type 'String?' must be unwrapped to refer to member 'utf8' of wrapped base type 'String'}}
-// expected-error@-1 {{cannot convert value of type 'String.UTF8View' to specified type 'Int?'}}
+// expected-error@-1 {{cannot convert value of type 'String.UTF8View?' to specified type 'Int?'}}
 // expected-note@-2{{chain the optional using '?'}}{{18-18=?}}
-// expected-note@-3{{force-unwrap using '!'}}{{18-18=!}}
 let c = q.s.utf8 // expected-error{{value of optional type 'String?' must be unwrapped to refer to member 'utf8' of wrapped base type 'String'}}
 // expected-note@-1{{chain the optional using '?' to access member 'utf8' only for non-'nil' base values}}{{12-12=?}}
 // expected-note@-2{{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}{{12-12=!}}

test/Constraints/function_conversion.swift

@@ -63,3 +63,8 @@ noEscapeParam = escapingParam // expected-error {{converting non-escaping value
 
 escapingParam = takesAny
 noEscapeParam = takesAny // expected-error {{converting non-escaping value to 'Any' may allow it to escape}}
+
+// rdar://problem/59773317 - Improve type error message when returning (or escaping) a function-typed value as an optional of that type
+func rdar_59773317(x: () -> Int) -> (() -> Int)? { // expected-note {{parameter 'x' is implicitly non-escaping}}
+  return x // expected-error {{using non-escaping parameter 'x' in a context expecting an @escaping closure}}
+}

test/FixCode/fixits-apply-objc.swift.result

@@ -107,5 +107,5 @@ func foo1(_ an : Any) {
 }
 
 func foo2(_ messageData: Any?) -> AnyObject? {
-  return messageData as AnyObject?
+  return messageData as AnyObject
 }