Merge pull request swiftlang#29655 from xedin/rdar-41416758

[ConstraintSystem] Make variadics work with anonymous closure parameters

Author: xedin

include/swift/AST/Types.h

@@ -2853,6 +2853,10 @@ class AnyFunctionType : public TypeBase {
     Param getWithoutLabel() const { return Param(Ty, Identifier(), Flags); }
 
     Param withType(Type newType) const { return Param(newType, Label, Flags); }
+
+    Param withFlags(ParameterTypeFlags flags) const {
+      return Param(Ty, Label, flags);
+    }
   };
 
   class CanParam : public Param {

lib/Sema/CSSimplify.cpp

@@ -6596,14 +6596,29 @@ static Type getFunctionBuilderTypeFor(ConstraintSystem &cs, unsigned paramIdx,
 bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
                                       Type contextualType,
                                       ConstraintLocatorBuilder locator) {
+  auto getContextualParamAt =
+      [&contextualType](unsigned index) -> Optional<AnyFunctionType::Param> {
+    auto *fnType = contextualType->getAs<FunctionType>();
+    return fnType && fnType->getNumParams() > index
+               ? fnType->getParams()[index]
+               : Optional<AnyFunctionType::Param>();
+  };
+
   auto *closureLocator = typeVar->getImpl().getLocator();
   auto *closure = cast<ClosureExpr>(closureLocator->getAnchor());
-
-  auto *closureType = getClosureType(closure);
+  auto *inferredClosureType = getClosureType(closure);
 
   auto *paramList = closure->getParameters();
+  SmallVector<AnyFunctionType::Param, 4> parameters;
   for (unsigned i = 0, n = paramList->size(); i != n; ++i) {
-    const auto &param = closureType->getParams()[i];
+    auto param = inferredClosureType->getParams()[i];
+
+    // In case of anonymous parameters let's infer flags from context
+    // that helps to infer variadic and inout earlier.
+    if (closure->hasAnonymousClosureVars()) {
+      if (auto contextualParam = getContextualParamAt(i))
+        param = param.withFlags(contextualParam->getParameterFlags());
+    }
 
     Type internalType;
 
@@ -6617,17 +6632,25 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
       auto *paramLoc =
           getConstraintLocator(closure, LocatorPathElt::TupleElement(i));
 
-      internalType = createTypeVariable(paramLoc, TVO_CanBindToLValue |
-                                                      TVO_CanBindToNoEscape);
+      auto *typeVar = createTypeVariable(paramLoc, TVO_CanBindToLValue |
+                                                       TVO_CanBindToNoEscape);
+
+      // If external parameter is variadic it translates into an array in
+      // the body of the closure.
+      internalType =
+          param.isVariadic() ? ArraySliceType::get(typeVar) : Type(typeVar);
 
       auto externalType = param.getOldType();
-      addConstraint(ConstraintKind::BindParam, externalType, internalType,
-                    paramLoc);
+      addConstraint(ConstraintKind::BindParam, externalType, typeVar, paramLoc);
     }
 
     setType(paramList->get(i), internalType);
+    parameters.push_back(param);
   }
 
+  auto closureType =
+      FunctionType::get(parameters, inferredClosureType->getResult(),
+                        inferredClosureType->getExtInfo());
   assignFixedType(typeVar, closureType, closureLocator);
 
   if (auto last = locator.last()) {

test/expr/closure/anonymous.swift

@@ -13,38 +13,27 @@ func takesIntArray(_: [Int]) { }
 func takesVariadicInt(_: (Int...) -> ()) { }
 func takesVariadicIntInt(_: (Int, Int...) -> ()) { }
 
-func takesVariadicGeneric<T>(_ f: (T...) -> ()) { }
+func takesVariadicGeneric<T>(_ f: (T...) -> ()) { } // expected-note {{in call to function 'takesVariadicGeneric'}}
 
 func variadic() {
   // These work
 
-  // FIXME: Not anymore: rdar://41416758
   takesVariadicInt({let _ = $0})
-  // expected-error@-1 {{cannot convert value of type '(_) -> ()' to expected argument type '(Int...) -> ()'}}
   takesVariadicInt({let _: [Int] = $0})
-  // expected-error@-1 {{cannot convert value of type '(_) -> ()' to expected argument type '(Int...) -> ()'}}
 
   let _: (Int...) -> () = {let _: [Int] = $0}
-  // expected-error@-1 {{cannot convert value of type '(_) -> ()' to specified type '(Int...) -> ()'}}
 
   takesVariadicInt({takesIntArray($0)})
-  // expected-error@-1 {{cannot pass array of type '[Int]' as variadic arguments of type 'Int'}}
 
   let _: (Int...) -> () = {takesIntArray($0)}
-  // expected-error@-1 {{cannot pass array of type '[Int]' as variadic arguments of type 'Int'}}
 
   takesVariadicGeneric({takesIntArray($0)})
-  // expected-error@-1 {{cannot pass array of type '[Int]' as variadic arguments of type 'Int'}}
-
-  // FIXME(diagnostics): Problems here are related to multi-statement closure bodies not being type-checked together with
-  // enclosing context.
 
+  // FIXME: Problem here is related to multi-statement closure body not being type-checked together with
+  // enclosing context. We could have inferred `$0` to be `[Int]` if `let` was a part of constraint system.
   takesVariadicGeneric({let _: [Int] = $0})
-  // expected-error@-1 {{cannot convert value of type '(_) -> ()' to expected argument type '(_...) -> ()'}}
+  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
 
   takesVariadicIntInt({_ = $0; takesIntArray($1)})
-  // expected-error@-1 {{cannot convert value of type '(_, _) -> ()' to expected argument type '(Int, Int...) -> ()'}}
-
   takesVariadicIntInt({_ = $0; let _: [Int] = $1})
-  // expected-error@-1 {{cannot convert value of type '(_, _) -> ()' to expected argument type '(Int, Int...) -> ()'}}
 }