[ConstraintSystem] Adjust openType and openUnboundGenericType to open pack expansion types

Replace all `PackExpansionType` with a special type variable
which would be resolved once the solver determines that there
is enough contextual information.

Author: xedin

lib/Sema/ConstraintSystem.cpp

@@ -835,7 +835,11 @@ Type ConstraintSystem::openUnboundGenericType(GenericTypeDecl *decl,
     result = DC->mapTypeIntoContext(result);
   }
 
-  return result;
+  return result.transform([&](Type type) {
+    if (auto *expansion = dyn_cast<PackExpansionType>(type.getPointer()))
+      return openPackExpansionType(expansion, replacements);
+    return type;
+  });
 }
 
 static void checkNestedTypeConstraints(ConstraintSystem &cs, Type type,
@@ -968,6 +972,24 @@ Type ConstraintSystem::openType(Type type, OpenedTypeMap &replacements) {
   return type.transform([&](Type type) -> Type {
       assert(!type->is<GenericFunctionType>());
 
+      // Preserve single element tuples if their element is
+      // pack expansion, otherwise it wouldn't be expanded.
+      if (auto *tuple = type->getAs<TupleType>()) {
+        if (tuple->getNumElements() == 1) {
+          const auto &elt = tuple->getElement(0);
+          if (!elt.hasName() && elt.getType()->is<PackExpansionType>()) {
+            return TupleType::get(
+                {openPackExpansionType(
+                    elt.getType()->castTo<PackExpansionType>(), replacements)},
+                tuple->getASTContext());
+          }
+        }
+      }
+
+      if (auto *expansion = type->getAs<PackExpansionType>()) {
+        return openPackExpansionType(expansion, replacements);
+      }
+
       // Replace a generic type parameter with its corresponding type variable.
       if (auto genericParam = type->getAs<GenericTypeParamType>()) {
         auto known = replacements.find(

test/Constraints/pack-expansion-expressions.swift

@@ -408,3 +408,16 @@ func test_no_unused_result_warning(arr: inout [Any]) {
     ((repeat arr.append(each value))) // no warning
   }
 }
+
+func test_partually_flattened_expansions() {
+  struct S<each T> {
+    init() {}
+
+    func fn<each U>(t: repeat each T, u: repeat each U) -> (repeat (each T, each U)) {
+      return (repeat (each t, each u))
+    }
+  }
+
+  _ = S().fn(t: 1, "hi", u: false, 1.0) // Ok
+  _ = S<Int, String>().fn(t: 1, "hi", u: false, 1.0) // Ok
+}