[CSSimplify] Type matching should maintain tuples when matching types with pack expansions

Pack expansion flattening could result in lose of tuple structure
or introduce a single element tuples (which are effectively parens),
to aid in matching `matchTypes` should introduce/maintain tuples on
both sides of the comparison until the structure is known.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -6529,6 +6529,9 @@ ConstraintSystem::TypeMatchResult
 ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                              TypeMatchOptions flags,
                              ConstraintLocatorBuilder locator) {
+  auto origType1 = type1;
+  auto origType2 = type2;
+
   // If we have type variables that have been bound to fixed types, look through
   // to the fixed type.
   type1 = getFixedTypeRecursive(type1, flags, kind == ConstraintKind::Equal);
@@ -6792,11 +6795,32 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     return formUnsolvedResult();
   }
 
-  // If either side is a tuple that has unresolved pack expansions,
-  // delay matching until more is inferred about type structure.
-  if (isTupleWithUnresolvedPackExpansion(desugar1) ||
-      isTupleWithUnresolvedPackExpansion(desugar2))
-    return formUnsolvedResult();
+  // If the original type on one side consisted of a tuple type with
+  // unresolved pack expansion(s), let's make sure that both sides are
+  // tuples to enable proper pack matching for situations like:
+  //
+  // `Int <conversion> (_: $T3)`
+  // where `$T3` is pack expansion of pattern type `$T2`
+  //
+  // `Int` should be wrapped in a one-element tuple to make sure
+  // that tuple matcher can form a pack expansion type that would
+  // match `$T3` and propagate `Pack{Int}` to `$T2`.
+  //
+  // This is also important for situations like: `$T2 conv (Int, $T_exp)`
+  // becuase expansion could be defaulted to an empty pack which means
+  // that under substitution that element would disappear and the type
+  // would be just `(Int)`.
+  if (isTupleWithUnresolvedPackExpansion(origType1) ||
+      isTupleWithUnresolvedPackExpansion(origType2)) {
+    if (desugar1->is<TupleType>() != desugar2->is<TupleType>()) {
+      return matchTypes(
+          desugar1->is<TupleType>() ? type1
+                                    : TupleType::get({type1}, getASTContext()),
+          desugar2->is<TupleType>() ? type2
+                                    : TupleType::get({type2}, getASTContext()),
+          kind, flags, locator);
+    }
+  }
 
   llvm::SmallVector<RestrictionOrFix, 4> conversionsOrFixes;
 

test/Constraints/pack_expansion_types.swift

@@ -1,10 +1,10 @@
 // RUN: %target-typecheck-verify-swift
 
 func returnTuple1<each T>() -> (repeat each T) { fatalError() }
-// expected-note@-1 3 {{in call to function 'returnTuple1()'}}
+// expected-note@-1 {{in call to function 'returnTuple1()'}}
 
 func returnTuple2<each T>() -> (Int, repeat each T) { fatalError() }
-// expected-note@-1 3 {{in call to function 'returnTuple2()'}}
+// expected-note@-1 2 {{in call to function 'returnTuple2()'}}
 
 func returnTupleLabel1<each T>() -> (x: repeat each T) { fatalError() }
 // expected-error@-1 {{cannot use label with pack expansion tuple element}}
@@ -26,16 +26,10 @@ func returnTupleLabel6<each T, each U>() -> (Int, x: repeat each T, y: repeat ea
 
 func concreteReturnTupleValid() {
   let _: () = returnTuple1()
-  // FIXME: consider propagating 'Int' through the conversion constraint
-  // as a binding for the parameter pack expanded in the tuple return type.
   let _: Int = returnTuple1()
-  // expected-error@-1 {{generic parameter 'each T' could not be inferred}}
-  // expected-error@-2 {{cannot convert value of type '(repeat each T)' to specified type 'Int'}}
   let _: (Int, String) = returnTuple1()
 
   let _: Int = returnTuple2()
-  // expected-error@-1 {{generic parameter 'each T' could not be inferred}}
-  // expected-error@-2 {{cannot convert value of type '(Int, repeat each T)' to specified type 'Int'}}
   let _: (Int, String) = returnTuple2()
   let _: (Int, String, Float) = returnTuple2()
 
@@ -72,8 +66,6 @@ func concreteReturnTupleValid() {
 
 func concreteReturnTypeInvalid() {
   let _: Int = returnTuple1()
-  // expected-error@-1 {{cannot convert value of type '(repeat each T)' to specified type 'Int'}}
-  // expected-error@-2 {{generic parameter 'each T' could not be inferred}}
 
   let _: () = returnTuple2()
   // expected-error@-1 {{'(Int, repeat each T)' is not convertible to '()', tuples have a different number of elements}}
@@ -218,28 +210,20 @@ func concreteReturnFunctionInvalid() {
 }
 
 func patternInstantiationTupleTest1<each T>() -> (repeat Array<each T>) {}
-// expected-note@-1 3 {{in call to function 'patternInstantiationTupleTest1()'}}
+// expected-note@-1 2 {{in call to function 'patternInstantiationTupleTest1()'}}
 func patternInstantiationTupleTest2<each T, each U>() -> (repeat Dictionary<each T, each U>) {}
-// expected-note@-1 {{in call to function 'patternInstantiationTupleTest2()'}}
 
 func patternInstantiationFunctionTest1<each T>() -> (repeat Array<each T>) -> () {}
 func patternInstantiationFunctionTest2<each T, each U>() -> (repeat Dictionary<each T, each U>) -> () {}
 
 func patternInstantiationConcreteValid() {
   let _: () = patternInstantiationTupleTest1()
-  // FIXME
   let _: Array<Int> = patternInstantiationTupleTest1()
-  // expected-error@-1 {{generic parameter 'each T' could not be inferred}}
-  // expected-error@-2 {{cannot convert value of type '(repeat Array<each T>)' to specified type 'Array<Int>'}}
   let _: (Array<Int>, Array<String>) = patternInstantiationTupleTest1()
   let _: (Array<Int>, Array<String>, Array<Float>) = patternInstantiationTupleTest1()
 
   let _: () = patternInstantiationTupleTest2()
-  // FIXME
   let _: Dictionary<Int, String> = patternInstantiationTupleTest2()
-  // expected-error@-1 {{generic parameter 'each T' could not be inferred}}
-  // expected-error@-2 {{generic parameter 'each U' could not be inferred}}
-  // expected-error@-3 {{cannot convert value of type '(repeat Dictionary<each T, each U>)' to specified type 'Dictionary<Int, String>'}}
   let _: (Dictionary<Int, String>, Dictionary<Float, Bool>) = patternInstantiationTupleTest2()
   let _: (Dictionary<Int, String>, Dictionary<Float, Bool>, Dictionary<Double, Character>) = patternInstantiationTupleTest2()
 
@@ -291,3 +275,26 @@ func patternInstantiationGenericInvalid<each T: Hashable>(t: repeat each T) {
 
   let _: (repeat Array<each T>, Set<String>) = patternInstantiationTupleTest1() // expected-error {{type of expression is ambiguous without more context}}
 }
+
+// rdar://107996926 - Vanishing metatype of tuple not supported
+func test_one_element_tuple_vs_non_tuple_matching() {
+  struct S {
+    func test<each T>(_: (repeat each T).Type) -> (repeat each T) { fatalError() }
+    func testVanishing<each T>(_: (Int, repeat each T)) {}
+  }
+
+  let _ = S().test(Int.self) // Ok
+  let _: Int = S().test(Int.self) // Ok
+  let _ = S().test((Int, String).self) // Ok
+  let _ = S().testVanishing(42) // Ok
+
+  do {
+    struct V<T> {}
+
+    func test<each T>(_: V<(repeat each T)>?) {}
+    func test<each T>(_: V<(repeat each T)>.Type) {}
+
+    test(V<Int>()) // Ok
+    test(V<Int>.self) // Ok
+  }
+}