Sema: Don't 'tuple splat' parameter lists with @autoclosure parameters

Fixes <https://bugs.swift.org/browse/SR-9991>.

Author: slavapestov

lib/Sema/CSSimplify.cpp

@@ -1182,10 +1182,11 @@ static bool isSingleTupleParam(ASTContext &ctx,
     return false;
 
   const auto &param = params.front();
-  if (param.isVariadic() || param.isInOut())
+  if (param.isVariadic() || param.isInOut() || param.hasLabel())
     return false;
 
   auto paramType = param.getPlainType();
+
   // Support following case which was allowed until 5:
   //
   // func bar(_: (Int, Int) -> Void) {}
@@ -1195,11 +1196,9 @@ static bool isSingleTupleParam(ASTContext &ctx,
   if (!ctx.isSwiftVersionAtLeast(5))
     paramType = paramType->lookThroughAllOptionalTypes();
 
-  // Parameter should not have a label and be either a tuple,
-  // type variable or a dependent member, which might later be
-  // assigned (or resolved to) a tuple type, e.g. opened generic parameter.
-  return !param.hasLabel() &&
-         (paramType->is<TupleType>() || paramType->isTypeVariableOrMember());
+  // Parameter type should either a tuple or something that can become a
+  // tuple later on.
+  return (paramType->is<TupleType>() || paramType->isTypeVariableOrMember());
 }
 
 /// Attempt to fix missing arguments by introducing type variables
@@ -1359,7 +1358,7 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
       return false;
 
     for (auto param : params)
-      if (param.isVariadic() || param.isInOut())
+      if (param.isVariadic() || param.isInOut() || param.isAutoClosure())
         return false;
 
     return true;

test/Constraints/tuple_arguments.swift

@@ -1718,3 +1718,23 @@ func rdar48443263() {
     foo(s2, fn) // expected-error {{cannot convert value of type '() -> Void' to expected argument type '(_) -> Void'}}
   }
 }
+
+func autoclosureSplat() {
+  func takeFn<T>(_: (T) -> ()) {}
+
+  takeFn { (fn: @autoclosure () -> Int) in }
+  // This type checks because we find a solution T:= @escaping () -> Int and
+  // wrap the closure in a function conversion.
+
+  takeFn { (fn: @autoclosure () -> Int, x: Int) in }
+  // expected-error@-1 {{contextual closure type '(_) -> ()' expects 1 argument, but 2 were used in closure body}}
+
+  takeFn { (fn: @autoclosure @escaping () -> Int) in }
+  // FIXME: It looks like matchFunctionTypes() does not check @autoclosure at all.
+  // Perhaps this is intentional, but we should document it eventually. In the
+  // interim, this test serves as "documentation"; if it fails, please investigate why
+  // instead of changing the test.
+
+  takeFn { (fn: @autoclosure @escaping () -> Int, x: Int) in }
+  // expected-error@-1 {{contextual closure type '(_) -> ()' expects 1 argument, but 2 were used in closure body}}
+}