Merge pull request #82020 from AnthonyLatsis/camellia-sinensis

Sema: Never record argument label mismatches for unlabeled trailing closures

Author: AnthonyLatsis

include/swift/Sema/ConstraintSystem.h

@@ -6665,12 +6665,6 @@ bool isSIMDOperator(ValueDecl *value);
 
 std::string describeGenericType(ValueDecl *GP, bool includeName = false);
 
-/// Whether the given parameter requires an argument.
-bool parameterRequiresArgument(
-    ArrayRef<AnyFunctionType::Param> params,
-    const ParameterListInfo &paramInfo,
-    unsigned paramIdx);
-
 } // end namespace swift
 
 namespace llvm {

lib/Sema/CSSimplify.cpp

@@ -279,10 +279,9 @@ static ConstraintSystem::TypeMatchOptions getDefaultDecompositionOptions(
 }
 
 /// Whether the given parameter requires an argument.
-bool swift::parameterRequiresArgument(
-    ArrayRef<AnyFunctionType::Param> params,
-    const ParameterListInfo &paramInfo,
-    unsigned paramIdx) {
+static bool parameterRequiresArgument(ArrayRef<AnyFunctionType::Param> params,
+                                      const ParameterListInfo &paramInfo,
+                                      unsigned paramIdx) {
   return !paramInfo.hasDefaultArgument(paramIdx)
       && !params[paramIdx].isVariadic();
 }
@@ -374,8 +373,15 @@ static bool matchCallArgumentsImpl(
   auto claim = [&](Identifier expectedName, unsigned argIdx,
                    bool ignoreNameClash = false)  -> unsigned {
     // Make sure we can claim this argument.
-    assert(argIdx != numArgs && "Must have a valid index to claim");
-    assert(!claimedArgs[argIdx] && "Argument already claimed");
+    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.

lib/Sema/MiscDiagnostics.cpp

@@ -2701,8 +2701,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}}
+  }
+}

validation-test/compiler_crashers_2/34a73a7299992de3.swift renamed to validation-test/compiler_crashers_2_fixed/34a73a7299992de3.swift

@@ -1,4 +1,3 @@
 // {"signature":"(anonymous namespace)::OpaqueUnderlyingTypeChecker::check()"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
-// REQUIRES: asserts
+// RUN: not %target-swift-frontend -typecheck %s
 Array {