Sema: Never record argument label mismatches for unlabeled trailing closures

Fixes a crash on invalid. The previous logic was causing a label
mismatch constraint fix to be recorded for an unlabeled trailing closure
argument matching a variadic paramater after a late recovery argument
claim in `matchCallArgumentsImpl`, because the recovery claiming skips
arguments matching defaulted parameters, but not variadic ones. We may
want to reconsider that last part, but currently it regresses the
quality of some diagnostics, and this is a targeted fix.

The previous behavior is fine because the diagnosis routine associate
with the constraint fix (`diagnoseArgumentLabelError`) skips unlabeled
trailing closures when tallying labeling issues — *unless* there are no
other issues and the tally is zero, which we assert it is not.

Fixes rdar://152313388.

(cherry picked from commit f2e1420)

Author: AnthonyLatsis

lib/Sema/CSSimplify.cpp

@@ -377,6 +377,13 @@ static bool matchCallArgumentsImpl(
     assert(argIdx != numArgs && "Must have a valid index to claim");
     assert(!claimedArgs[argIdx] && "Argument already claimed");
 
+    // Prevent recording of an argument label mismatche for an unlabeled
+    // trailing closure. An unlabeled trailing closure is necessarily the first
+    // one and vice versa, per language syntax.
+    if (unlabeledTrailingClosureArgIndex == argIdx) {
+      expectedName = Identifier();
+    }
+
     if (!actualArgNames.empty()) {
       // We're recording argument names; record this one.
       actualArgNames[argIdx] = expectedName;

lib/Sema/MiscDiagnostics.cpp

@@ -2697,8 +2697,10 @@ bool swift::diagnoseArgumentLabelError(ASTContext &ctx,
     }
   }
 
+  assert((numMissing + numExtra + numWrong > 0) &&
+         "Should not call this function with nothing to diagnose");
+
   // Emit the diagnostic.
-  assert(numMissing > 0 || numExtra > 0 || numWrong > 0);
   llvm::SmallString<16> haveBuffer; // note: diagOpt has references to this
   llvm::SmallString<16> expectedBuffer; // note: diagOpt has references to this
 

test/expr/closure/trailing.swift

@@ -488,3 +488,39 @@ func rdar92521618() {
   if let _ = { foo {} }() {}
   guard let _ = { foo {} }() else { return }
 }
+
+// Argument matching never binds trailing closure arguments to
+// defaulted/variadic parameters of non-function type.
+do {
+  // Trailing closure not considered fulfilled by 'arg'.
+  // Note: Used to crash.
+  do {
+    func variadic(arg: Int...) {} // expected-note@:10 {{'variadic(arg:)' declared here}}{{none}}
+    func defaulted(arg: Int = 0) {}
+
+    let _ = variadic { return () }
+    // expected-error@-1:22 {{trailing closure passed to parameter of type 'Int' that does not accept a closure}}{{none}}
+    let _ = defaulted { return () }
+    // expected-error@-1:23 {{extra trailing closure passed in call}}{{none}}
+  }
+  // Trailing closure considered fulfilled by 'x' instead of 'arg'.
+  do {
+    func variadic(arg: Int..., x: String) {} // expected-note@:10 {{'variadic(arg:x:)' declared here}}{{none}}
+    func defaulted(arg: Int = 0, x: String) {} // expected-note@:10 {{'defaulted(arg:x:)' declared here}}{{none}}
+
+    let _ = variadic { return () }
+    // expected-error@-1:22 {{trailing closure passed to parameter of type 'String' that does not accept a closure}}{{none}}
+    let _ = defaulted { return () }
+    // expected-error@-1:23 {{trailing closure passed to parameter of type 'String' that does not accept a closure}}{{none}}
+  }
+  // Trailing closure considered fulfilled by 'arg'; has function type.
+  do {
+    func variadic(arg: ((Int) -> Void)...) {}
+    func defaulted(arg: ((Int) -> Void) = { _ in }) {}
+
+    let _ = variadic { return () }
+    // expected-error@-1:22 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}}{{23-23= _ in}}
+    let _ = defaulted { return () }
+    // expected-error@-1:23 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}}{{24-24= _ in}}
+  }
+}