[CS] Formalize param flag handling for imploding params

By default avoid imploding params that have parameter
flags, but carve out exceptions for ownership flags,
which can be thunked, and `@_nonEphemeral` which can
be freely dropped without issue.

Author: hamishknight

include/swift/AST/Types.h

@@ -3005,7 +3005,11 @@ class AnyFunctionType : public TypeBase {
 
 public:
   /// Take an array of parameters and turn it into a tuple or paren type.
-  static Type composeTuple(ASTContext &ctx, ArrayRef<Param> params);
+  ///
+  /// \param wantParamFlags Whether to preserve the parameter flags from the
+  /// given set of parameters.
+  static Type composeTuple(ASTContext &ctx, ArrayRef<Param> params,
+                           bool wantParamFlags = true);
 
   /// Given two arrays of parameters determine if they are equal in their
   /// canonicalized form. Internal labels and type sugar is *not* taken into

lib/AST/ASTContext.cpp

@@ -3456,11 +3456,13 @@ Type AnyFunctionType::Param::getParameterType(bool forCanonical,
   return type;
 }
 
-Type AnyFunctionType::composeTuple(ASTContext &ctx, ArrayRef<Param> params) {
+Type AnyFunctionType::composeTuple(ASTContext &ctx, ArrayRef<Param> params,
+                                   bool wantParamFlags) {
   SmallVector<TupleTypeElt, 4> elements;
   for (const auto &param : params) {
-    elements.emplace_back(param.getParameterType(), param.getLabel(),
-                          param.getParameterFlags());
+    auto flags = wantParamFlags ? param.getParameterFlags()
+                                : ParameterTypeFlags();
+    elements.emplace_back(param.getParameterType(), param.getLabel(), flags);
   }
   return TupleType::get(elements, ctx);
 }

lib/Sema/CSSimplify.cpp

@@ -2209,16 +2209,27 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
     if (params.size() == 1)
       return false;
 
-    for (auto param : params)
-      if (param.isVariadic() || param.isInOut() || param.isAutoClosure())
+    for (auto &param : params) {
+      // We generally cannot handle parameter flags, though we can carve out an
+      // exception for ownership flags such as __owned, which we can thunk, and
+      // flags that can freely dropped from a function type such as
+      // @_nonEphemeral.
+      auto flags = param.getParameterFlags();
+      flags = flags.withValueOwnership(
+          param.isInOut() ? ValueOwnership::InOut : ValueOwnership::Default);
+      flags = flags.withNonEphemeral(false);
+      if (!flags.isNone())
         return false;
-
+    }
     return true;
   };
 
   auto implodeParams = [&](SmallVectorImpl<AnyFunctionType::Param> &params) {
-    auto input = AnyFunctionType::composeTuple(getASTContext(), params);
-
+    // Form an imploded tuple type, dropping the parameter flags as although
+    // canImplodeParams makes sure we're not dealing with vargs, inout, etc,
+    // we may still have e.g ownership flags left over, which we can drop.
+    auto input = AnyFunctionType::composeTuple(getASTContext(), params,
+                                               /*wantParamFlags*/ false);
     params.clear();
     // If fixes are disabled let's do an easy thing and implode
     // tuple directly into parameters list.

test/Concurrency/isolated_parameters.swift

@@ -102,3 +102,13 @@ actor TestActor {
 
 func redecl(_: TestActor) { } // expected-note{{'redecl' previously declared here}}
 func redecl(_: isolated TestActor) { } // expected-error{{invalid redeclaration of 'redecl'}}
+
+func tuplify<Ts>(_ fn: (Ts) -> Void) {} // expected-note {{in call to function 'tuplify'}}
+
+@available(SwiftStdlib 5.5, *)
+func testTuplingIsolated(_ a: isolated A, _ b: isolated A) {
+  // FIXME: We shouldn't duplicate the "cannot convert value of type" diagnostic (SR-15179)
+  tuplify(testTuplingIsolated)
+  // expected-error@-1 {{generic parameter 'Ts' could not be inferred}}
+  // expected-error@-2 2{{cannot convert value of type '(isolated A, isolated A) -> ()' to expected argument type '(Ts) -> Void'}}
+}

test/Constraints/function.swift

@@ -250,3 +250,16 @@ func test_passing_noescape_function_ref_to_generic_parameter() {
 func SR14784<T>(_ fs: () -> T..., a _ : Int) -> T {
   fs.first! // expected-error{{function produces expected type 'T'; did you mean to call it with '()'?}} {{11-11=()}}
 }
+
+func tuplify<Ts>(_ fn: (Ts) -> Void) {}
+
+func testInvalidTupleImplosions() {
+  func takesVargs(_ x: Int, _ y: String...) {}
+  tuplify(takesVargs) // expected-error {{cannot convert value of type '(Int, String...) -> ()' to expected argument type '(Int) -> Void'}}
+
+  func takesAutoclosure(_ x: @autoclosure () -> Int, y: String) {}
+  tuplify(takesAutoclosure) // expected-error {{cannot convert value of type '(@autoclosure () -> Int, String) -> ()' to expected argument type '(@escaping () -> Int) -> Void'}}
+
+  func takesInout(_ x: Int, _ y: inout String) {}
+  tuplify(takesInout) // expected-error {{cannot convert value of type '(Int, inout String) -> ()' to expected argument type '(Int) -> Void'}}
+}

test/Sema/diag_non_ephemeral.swift

@@ -525,3 +525,16 @@ func ambiguous_fn(_ ptr: UnsafeRawPointer) {} // expected-note {{found this cand
 func test_ambiguity_with_function_instead_of_argument(_ x: inout Int) {
   ambiguous_fn(&x) // expected-error {{ambiguous use of 'ambiguous_fn'}}
 }
+
+func tuplify<Ts>(_ fn: @escaping (Ts) -> Void) -> (Ts) -> Void { fn }
+
+func testTuplingNonEphemeral(_ ptr: UnsafePointer<Int>) {
+  // Make sure we drop @_nonEphemeral when imploding params. This is to ensure
+  // we don't accidently break any potentially valid code.
+  let fn = tuplify(takesTwoPointers)
+  fn((ptr, ptr))
+
+  // Note we can't perform X-to-pointer conversions in this case even if we
+  // wanted to.
+  fn(([1], ptr)) // expected-error {{tuple type '([Int], UnsafePointer<Int>)' is not convertible to tuple type '(UnsafePointer<Int>, UnsafePointer<Int>)'}}
+}