---

yaml
---
r: 343399
b: refs/heads/master-rebranch
c: fdbc219
h: refs/heads/master
i:
  343397: 7d6d0d1
  343395: 88845b0
  343391: 6c9f0c5

Author: hamishknight

[refs]

@@ -1455,7 +1455,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: abbf052780ae4190eeb866842698fcf5241f2ef6
+refs/heads/master-rebranch: fdbc21911b37651a70f64fbff462acd7abc3ca83
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec

branches/master-rebranch/lib/Sema/CSApply.cpp

@@ -2272,6 +2272,17 @@ namespace {
       auto *choiceLocator = cs.getConstraintLocator(locator.withPathElement(
           ConstraintLocator::ImplicitlyUnwrappedDisjunctionChoice));
 
+      // We won't have a disjunction choice if we have an IUO function call
+      // wrapped in parens (i.e. '(s.foo)()'), because we only create a
+      // single constraint to bind to an optional type. So, we can just return
+      // false here as there's no need to force unwrap.
+      if (!solution.DisjunctionChoices.count(choiceLocator)) {
+        auto type = choice.getDecl()->getInterfaceType();
+        assert((type && type->is<AnyFunctionType>()) &&
+               "expected a function type");
+        return false;
+      }
+
       return solution.getDisjunctionChoice(choiceLocator);
     }
 

branches/master-rebranch/lib/Sema/CSDiag.cpp

@@ -820,7 +820,7 @@ bool FailureDiagnosis::diagnoseGeneralOverloadFailure(Constraint *constraint) {
   // Get the referenced expression from the failed constraint.
   auto anchor = expr;
   if (auto locator = bindOverload->getLocator()) {
-    anchor = simplifyLocatorToAnchor(CS, locator);
+    anchor = simplifyLocatorToAnchor(locator);
     if (!anchor)
       return false;
   }
@@ -1002,7 +1002,7 @@ bool FailureDiagnosis::diagnoseGeneralConversionFailure(Constraint *constraint){
   bool resolvedAnchorToExpr = false;
 
   if (auto locator = constraint->getLocator()) {
-    anchor = simplifyLocatorToAnchor(CS, locator);
+    anchor = simplifyLocatorToAnchor(locator);
     if (anchor)
       resolvedAnchorToExpr = true;
     else
@@ -5390,7 +5390,7 @@ bool FailureDiagnosis::visitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
   Constraint *memberConstraint = nullptr;
   auto checkConstraint = [&](Constraint *C) {
     if (C->getKind() == ConstraintKind::UnresolvedValueMember &&
-        simplifyLocatorToAnchor(CS, C->getLocator()) == E)
+        simplifyLocatorToAnchor(C->getLocator()) == E)
       memberConstraint = C;
   };
 

branches/master-rebranch/lib/Sema/CSDiagnostics.cpp

@@ -212,7 +212,7 @@ FailureDiagnostic::getFunctionArgApplyInfo(ConstraintLocator *locator) const {
   auto *argLocator = cs.getConstraintLocator(
       anchor, argPath, ConstraintLocator::getSummaryFlagsForPath(argPath));
 
-  auto *argExpr = simplifyLocatorToAnchor(cs, argLocator);
+  auto *argExpr = simplifyLocatorToAnchor(argLocator);
 
   // If we were unable to simplify down to the argument expression, we don't
   // know what this is.

branches/master-rebranch/lib/Sema/CSSimplify.cpp

@@ -2161,7 +2161,7 @@ static ConstraintFix *fixPropertyWrapperFailure(
       baseExpr = SE->getBase();
     else if (auto *MRE = dyn_cast<MemberRefExpr>(anchor))
       baseExpr = MRE->getBase();
-    else if (auto *anchor = simplifyLocatorToAnchor(cs, locator))
+    else if (auto *anchor = simplifyLocatorToAnchor(locator))
       baseExpr = anchor;
   }
 
@@ -2300,9 +2300,7 @@ bool ConstraintSystem::repairFailures(
     // default values, let's see whether error is related to missing
     // explicit call.
     if (fnType->getNumParams() > 0) {
-      auto *anchor =
-          simplifyLocatorToAnchor(*this, getConstraintLocator(locator));
-
+      auto *anchor = simplifyLocatorToAnchor(getConstraintLocator(locator));
       if (!anchor)
         return false;
 

branches/master-rebranch/lib/Sema/ConstraintSystem.cpp

@@ -2190,9 +2190,34 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
                                               openedFullType,
                                               refType};
 
+  // If we have something like '(s.foo)()', where 's.foo()' returns an IUO,
+  // then we need to only create a single constraint that binds the
+  // type to an optional.
+  auto isIUOCallWrappedInParens = [&]() {
+    auto decl = choice.getDecl();
+    auto type = decl ? decl->getInterfaceType() : nullptr;
+    if (!type || !type->is<AnyFunctionType>())
+      return false;
+
+    auto expr = locator->getAnchor();
+    if (!expr)
+      return false;
+
+    if (isa<CallExpr>(expr)) {
+      return false;
+    }
+
+    auto parentExpr = getParentExpr(expr);
+    if (parentExpr && isa<ParenExpr>(parentExpr))
+      return true;
+
+    return false;
+  };
+
   // In some cases we already created the appropriate bind constraints.
   if (!bindConstraintCreated) {
-    if (choice.isImplicitlyUnwrappedValueOrReturnValue()) {
+    if (choice.isImplicitlyUnwrappedValueOrReturnValue() &&
+        !isIUOCallWrappedInParens()) {
       // Build the disjunction to attempt binding both T? and T (or
       // function returning T? and function returning T).
       buildDisjunctionForImplicitlyUnwrappedOptional(boundType, refType,
@@ -2600,7 +2625,7 @@ bool ConstraintSystem::diagnoseAmbiguity(Expr *expr,
 
     // If we can't resolve the locator to an anchor expression with no path,
     // we can't diagnose this well.
-    auto *anchor = simplifyLocatorToAnchor(*this, overload.locator);
+    auto *anchor = simplifyLocatorToAnchor(overload.locator);
     if (!anchor)
       continue;
     auto it = indexMap.find(anchor);
@@ -2641,7 +2666,7 @@ bool ConstraintSystem::diagnoseAmbiguity(Expr *expr,
   if (bestOverload) {
     auto &overload = diff.overloads[*bestOverload];
     auto name = getOverloadChoiceName(overload.choices);
-    auto anchor = simplifyLocatorToAnchor(*this, overload.locator);
+    auto anchor = simplifyLocatorToAnchor(overload.locator);
 
     // Emit the ambiguity diagnostic.
     auto &tc = getTypeChecker();
@@ -2693,17 +2718,21 @@ bool ConstraintSystem::diagnoseAmbiguity(Expr *expr,
   return false;
 }
 
-Expr *constraints::simplifyLocatorToAnchor(ConstraintSystem &cs,
-                                           ConstraintLocator *locator) {
-  if (!locator || !locator->getAnchor())
+Expr *constraints::simplifyLocatorToAnchor(ConstraintLocator *locator) {
+  if (!locator)
     return nullptr;
 
-  SourceRange range;
-  locator = simplifyLocator(cs, locator, range);
-  if (!locator->getAnchor() || !locator->getPath().empty())
+  auto *anchor = locator->getAnchor();
+  if (!anchor)
     return nullptr;
 
-  return locator->getAnchor();
+  SourceRange range;
+  auto path = locator->getPath();
+  simplifyLocator(anchor, path, range);
+
+  // We only want the new anchor if all the path elements have been simplified
+  // away.
+  return path.empty() ? anchor : nullptr;
 }
 
 Expr *constraints::getArgumentExpr(Expr *expr, unsigned index) {

branches/master-rebranch/lib/Sema/ConstraintSystem.h

@@ -3950,7 +3950,7 @@ void simplifyLocator(Expr *&anchor,
 ///
 /// \returns the anchor expression if it fully describes the locator, or
 /// null otherwise.
-Expr *simplifyLocatorToAnchor(ConstraintSystem &cs, ConstraintLocator *locator);
+Expr *simplifyLocatorToAnchor(ConstraintLocator *locator);
 
 /// Retrieve argument at specified index from given expression.
 /// The expression could be "application", "subscript" or "member" call.

branches/master-rebranch/test/Constraints/iuo.swift

@@ -223,3 +223,26 @@ var y: Int = 2
 
 let r = sr6988(x: x, y: y)
 let _: Int = r
+
+// SR-10492
+
+struct SR_10492_S {
+  func foo() -> Int! { return 0 }
+}
+
+let sr_10492_s = SR_10492_S()
+let sr_10492_int1: Int = (sr_10492_s.foo)() // expected-error {{value of optional type 'Int?' must be unwrapped to a value of type 'Int'}}
+// expected-note@-1 {{coalesce}}{{44-44= ?? <#default value#>}}
+// expected-note@-2 {{force-unwrap}}{{44-44=!}}
+let sr_10492_int2: Int? = (sr_10492_s.foo)() // Okay
+
+
+class SR_10492_C1 {
+  init!() {}
+}
+
+class SR_10492_C2 {
+  init(_ foo: SR_10492_C1) {}
+}
+
+let bar = SR_10492_C2(SR_10492_C1()) // Okay

branches/master-rebranch/validation-test/compiler_crashers_2_fixed/sr10492.swift

@@ -0,0 +1,8 @@
+// RUN: not %target-swift-frontend -emit-silgen %s
+
+struct S {
+  func foo() -> Int! { return 0 }
+}
+
+let s = S()
+let x: Int = (s.foo)()