[Trailing closures] Allow the unlabeled closure for variadic closure parameters.

Once the first argument for a variadic function-typed parameter has been
matched, allow an unlabeled trailing closure to match, rather than
banning all uses of the unlabeled trailing closure with variadic
parameters.

Author: DougGregor

lib/AST/Type.cpp

@@ -829,8 +829,9 @@ static bool allowsUnlabeledTrailingClosureParameter(const ParamDecl *param) {
   if (param->isInOut())
     return false;
 
-  Type paramType =
-      param->getInterfaceType()->getRValueType()->lookThroughAllOptionalTypes();
+  Type paramType = param->isVariadic() ? param->getVarargBaseTy()
+                                       : param->getInterfaceType();
+  paramType = paramType->getRValueType()->lookThroughAllOptionalTypes();
 
   // For autoclosure parameters, look through the autoclosure result type
   // to get the actual argument type.

lib/Sema/CSSimplify.cpp

@@ -199,6 +199,15 @@ static ConstraintSystem::TypeMatchOptions getDefaultDecompositionOptions(
   return flags | ConstraintSystem::TMF_GenerateConstraints;
 }
 
+/// Whether the given parameter requires an argument.
+static bool parameterRequiresArgument(
+    ArrayRef<AnyFunctionType::Param> params,
+    const ParameterListInfo &paramInfo,
+    unsigned paramIdx) {
+  return !paramInfo.hasDefaultArgument(paramIdx)
+      && !params[paramIdx].isVariadic();
+}
+
 /// Determine whether any parameter from the given index up until the end
 /// requires an argument to be provided.
 ///
@@ -221,8 +230,7 @@ static bool anyParameterRequiresArgument(
       break;
 
     // If this parameter requires an argument, tell the caller.
-    if (!paramInfo.hasDefaultArgument(paramIdx)
-        && !params[paramIdx].isVariadic())
+    if (parameterRequiresArgument(params, paramInfo, paramIdx))
       return true;
   }
 
@@ -315,13 +323,6 @@ matchCallArguments(SmallVectorImpl<AnyFunctionType::Param> &args,
     if (numClaimedArgs == numArgs)
       return None;
 
-    // If we're claiming variadic arguments, do not claim an unlabeled trailing
-    // closure argument.
-    if (forVariadic &&
-        unlabeledTrailingClosureArgIndex &&
-        nextArgIdx == *unlabeledTrailingClosureArgIndex)
-      return None;
-
     // Go hunting for an unclaimed argument whose name does match.
     Optional<unsigned> claimedWithSameName;
     for (unsigned i = nextArgIdx; i != numArgs; ++i) {
@@ -424,10 +425,10 @@ matchCallArguments(SmallVectorImpl<AnyFunctionType::Param> &args,
         return;
       }
 
-      // If this parameter has a default argument, consider applying a "fuzzy"
-      // match rule that skips this parameter if doing so is the only way to
-      // satisfy
-      if (paramInfo.hasDefaultArgument(paramIdx) &&
+      // If this parameter does not require an argument, consider applying a
+      // "fuzzy" match rule that skips this parameter if doing so is the only
+      // way to successfully match arguments to parameters.
+      if (!parameterRequiresArgument(params, paramInfo, paramIdx) &&
           param.getPlainType()->getASTContext().LangOpts
               .EnableFuzzyForwardScanTrailingClosureMatching &&
           anyParameterRequiresArgument(
@@ -468,10 +469,21 @@ matchCallArguments(SmallVectorImpl<AnyFunctionType::Param> &args,
       auto currentNextArgIdx = nextArgIdx;
       {
         nextArgIdx = *claimed;
+
         // Claim any additional unnamed arguments.
-        while (
-            (claimed = claimNextNamed(nextArgIdx, Identifier(), false, true))) {
-          parameterBindings[paramIdx].push_back(*claimed);
+        while (true) {
+          // If the next argument is the unlabeled trailing closure and the
+          // variadic parameter does not accept the unlabeled trailing closure
+          // argument, we're done.
+          if (unlabeledTrailingClosureArgIndex &&
+              skipClaimedArgs(nextArgIdx) == *unlabeledTrailingClosureArgIndex &&
+              !paramInfo.acceptsUnlabeledTrailingClosureArgument(paramIdx))
+            break;
+
+          if ((claimed = claimNextNamed(nextArgIdx, Identifier(), false, true)))
+            parameterBindings[paramIdx].push_back(*claimed);
+          else
+            break;
         }
       }
 

test/expr/postfix/call/forward_trailing_closure.swift

@@ -81,3 +81,13 @@ func testForwardMatchWithAutoclosure2(i: Int, s: String) {
     return i
   }
 }
+
+// Match a closure parameter to a variadic parameter.
+func acceptsVariadicClosureParameter(closures: ((Int, Int) -> Int)...) {
+}
+
+func testVariadicClosureParameter() {
+  acceptsVariadicClosureParameter { x, y in x % y }
+  acceptsVariadicClosureParameter() { x, y in x % y }
+  acceptsVariadicClosureParameter(closures: +, -, *, /) { x, y in x % y }
+}