[ConstraintSystem] Use new "specify label" fix/diagnostic to warn about backward scan

Author: xedin

lib/Sema/CSDiagnostics.h

@@ -2215,7 +2215,7 @@ class MissingOptionalUnwrapKeyPathFailure final : public ContextualFailure {
 };
 
 /// Diagnose situations when trailing closure has been matched to a specific
-/// parameter via deprecated backward scan.
+/// parameter via a deprecated backward scan.
 ///
 /// \code
 /// func multiple_trailing_with_defaults(

lib/Sema/CSFix.cpp

@@ -1529,7 +1529,8 @@ UnwrapOptionalBaseKeyPathApplication::attempt(ConstraintSystem &cs, Type baseTy,
 
 bool SpecifyLabelToAssociateTrailingClosure::diagnose(const Solution &solution,
                                                       bool asNote) const {
-  return false;
+  TrailingClosureRequiresExplicitLabel failure(solution, getLocator());
+  return failure.diagnose(asNote);
 }
 
 SpecifyLabelToAssociateTrailingClosure *

lib/Sema/CSSimplify.cpp

@@ -1208,6 +1208,9 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
 
   // Match up the call arguments to the parameters.
   SmallVector<ParamBinding, 4> parameterBindings;
+  TrailingClosureMatching selectedTrailingMatching =
+      TrailingClosureMatching::Forward;
+
   {
     ArgumentFailureTracker listener(cs, argsWithLabels, params, locator);
     auto callArgumentMatch = constraints::matchCallArguments(
@@ -1224,10 +1227,10 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
       return cs.getTypeMatchAmbiguous();
     }
 
+    selectedTrailingMatching = callArgumentMatch->trailingClosureMatching;
     // Record the direction of matching used for this call.
-    cs.recordTrailingClosureMatch(
-        cs.getConstraintLocator(locator),
-        callArgumentMatch->trailingClosureMatching);
+    cs.recordTrailingClosureMatch(cs.getConstraintLocator(locator),
+                                  selectedTrailingMatching);
 
     // If there was a disjunction because both forward and backward were
     // possible, increase the score for forward matches to bias toward the
@@ -1316,6 +1319,15 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
         }
       }
 
+      // In case solver matched trailing based on the backward scan,
+      // let's produce a warning which would suggest to add a label
+      // to disambiguate in the future.
+      if (selectedTrailingMatching == TrailingClosureMatching::Backward &&
+          argIdx == *argInfo->UnlabeledTrailingClosureIndex) {
+        cs.recordFix(SpecifyLabelToAssociateTrailingClosure::create(
+            cs, cs.getConstraintLocator(loc)));
+      }
+
       // If argument comes for declaration it should loose
       // `@autoclosure` flag, because in context it's used
       // as a function type represented by autoclosure.
@@ -9963,7 +9975,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowKeyPathRootTypeMismatch:
   case FixKind::UnwrapOptionalBaseKeyPathApplication:
   case FixKind::AllowCoercionToForceCast:
-  case FixKind::SpecifyKeyPathRootType: {
+  case FixKind::SpecifyKeyPathRootType:
+  case FixKind::SpecifyLabelToAssociateTrailingClosure: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }
 

test/expr/postfix/call/forward_trailing_closure_ambiguity.swift

@@ -92,3 +92,33 @@ func notAmbiguous3(
 func testNotAmbiguous3() {
   notAmbiguous3 { $0 }
 }
+
+// Ambiguous subscript
+struct S {
+  subscript( // expected-note {{'subscript(a:_:_:)' declared here}}
+    a a: Int,
+    fn1: (() -> Void)? = nil,
+    fn2: (() -> Void)? = nil) -> Bool {
+    get { return true }
+  }
+
+  subscript( // expected-note {{'subscript(b:_:fn2:)' declared here}}
+    b b: Int,
+    fn1: (() -> Void)? = nil,
+    fn2 fn2: (() -> Void)? = nil) -> Bool {
+    get { return true }
+  }
+
+  static func foo( // expected-note {{'foo(c:fn1:fn2:)' declared here}}
+    c: Int,
+    fn1: (() -> Void)? = nil,
+    fn2: (() -> Void)? = nil) -> S {
+    return S()
+  }
+}
+
+func test_ambiguous_subscript_unresolved_member(s: S) {
+  _ = s[a: 42] {} // expected-warning {{backward matching of the unlabeled trailing closure is deprecated; label the argument with '_' to suppress this warning}} {{14-15=, }} {{18-18=]}}
+  _ = s[b: 42] {} // expected-warning {{backward matching of the unlabeled trailing closure is deprecated; label the argument with 'fn2' to suppress this warning}} {{14-15=, fn2: }} {{18-18=]}}
+  let _: S = .foo(c: 42) {} // expected-warning {{backward matching of the unlabeled trailing closure is deprecated; label the argument with 'fn2' to suppress this warning}} {{24-25=, fn2: }} {{28-28=)}}
+}