Sema: Clean up openType() and openUnboundGenericType()

Fixes:
- rdar://112785081
- #67906
- #68160

Author: slavapestov

lib/AST/ParameterPack.cpp

@@ -453,8 +453,11 @@ PackType::getExpandedGenericArgs(ArrayRef<GenericTypeParamType *> params,
 }
 
 PackType *PackType::getSingletonPackExpansion(Type param) {
-  assert(param->isParameterPack() || param->is<PackArchetypeType>());
-  return get(param->getASTContext(), {PackExpansionType::get(param, param)});
+  SmallVector<Type, 2> rootParameterPacks;
+  param->getTypeParameterPacks(rootParameterPacks);
+  assert(rootParameterPacks.size() >= 1);
+  auto count = rootParameterPacks[0];
+  return get(param->getASTContext(), {PackExpansionType::get(param, count)});
 }
 
 CanPackType CanPackType::getSingletonPackExpansion(CanType param) {

lib/Sema/CSSimplify.cpp

@@ -1807,7 +1807,14 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
         }
 
         auto *argPack = PackType::get(cs.getASTContext(), argTypes);
-        auto *argPackExpansion = PackExpansionType::get(argPack, argPack);
+        auto argPackExpansion = [&]() {
+          if (argPack->getNumElements() == 1 &&
+              argPack->getElementType(0)->is<PackExpansionType>()) {
+            return argPack->getElementType(0)->castTo<PackExpansionType>();
+          }
+
+          return PackExpansionType::get(argPack, argPack);
+        }();
 
         auto firstArgIdx =
             argTypes.empty() ? paramIdx : parameterBindings[paramIdx].front();

lib/Sema/ConstraintSystem.cpp

@@ -855,25 +855,7 @@ Type ConstraintSystem::openUnboundGenericType(GenericTypeDecl *decl,
     result = DC->mapTypeIntoContext(result);
   }
 
-  return result.transform([&](Type type) -> Type {
-    // Although generic parameters are declared with just `each`
-    // their interface types introduce a pack expansion which
-    // means that the solver has to extact generic argument type
-    // variable from Pack{repeat ...} and drop that structure to
-    // make sure that generic argument gets inferred to a pack type.
-    if (auto *packTy = type->getAs<PackType>()) {
-      assert(packTy->getNumElements() == 1);
-      auto *expansion = packTy->getElementType(0)->castTo<PackExpansionType>();
-      auto *typeVar = expansion->getPatternType()->castTo<TypeVariableType>();
-      assert(typeVar->getImpl().getGenericParameter() &&
-             typeVar->getImpl().canBindToPack());
-      return typeVar;
-    }
-
-    if (auto *expansion = dyn_cast<PackExpansionType>(type.getPointer()))
-      return openPackExpansionType(expansion, replacements, locator);
-    return type;
-  });
+  return result;
 }
 
 static void checkNestedTypeConstraints(ConstraintSystem &cs, Type type,
@@ -1022,18 +1004,6 @@ Type ConstraintSystem::openType(Type type, OpenedTypeMap &replacements,
         }
       }
 
-      // While opening variadic generic types that appear in other types
-      // we need to extract generic parameter from Pack{repeat ...} structure
-      // that gets introduced by the interface type, see
-      // \c openUnboundGenericType for more details.
-      if (auto *packTy = type->getAs<PackType>()) {
-        if (auto expansionTy = packTy->unwrapSingletonPackExpansion()) {
-          auto patternTy = expansionTy->getPatternType();
-          if (patternTy->isTypeParameter())
-            return openType(patternTy, replacements, locator);
-        }
-      }
-
       if (auto *expansion = type->getAs<PackExpansionType>()) {
         return openPackExpansionType(expansion, replacements, locator);
       }
@@ -3927,6 +3897,14 @@ struct TypeSimplifier {
       auto countType = expansion->getCountType().transform(
           TypeSimplifier(CS, GetFixedTypeFn));
 
+      if (!countType->is<PackType>() &&
+          !countType->is<PackArchetypeType>()) {
+        SmallVector<Type, 2> rootParameterPacks;
+        countType->getTypeParameterPacks(rootParameterPacks);
+        if (!rootParameterPacks.empty())
+          countType = rootParameterPacks[0];
+      }
+
       // If both pattern and count are resolves, let's just return
       // the pattern type for `transformWithPosition` to take care
       // of the rest.

test/Constraints/issue-67906.swift

@@ -0,0 +1,25 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking
+
+struct G<each T>: Sequence {
+  typealias Element = Int
+  typealias Iterator = [Int].Iterator
+
+  consuming func makeIterator() -> Iterator {
+    fatalError()
+  }
+}
+
+// expected-note@+1 {{in call to function 'foo'}}
+func foo<each T>(_: repeat each T) -> G<repeat each T> {
+  .init()
+}
+
+// expected-error@+2 {{for-in loop requires '(repeat each T) -> G<repeat each T>' to conform to 'Sequence'}}
+// expected-error@+1 {{generic parameter 'each T' could not be inferred}}
+for a in foo {
+  print(a)
+}
+
+for a in foo() {
+  print(a)
+}

test/Constraints/variadic_generic_init.swift

@@ -0,0 +1,84 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking
+
+// These test cases exercise variants of rdar://problem/112785081
+// and https://github.com/apple/swift/issues/68160.
+
+protocol P {}
+
+protocol Q {
+  associatedtype A: Q
+
+  var a: A { get }
+}
+
+struct S1<each T: Q>: P {
+  init(_: repeat each T) {}
+}
+
+func foo1a<each T: Q>(_ t: repeat each T) -> some P {
+  return S1(repeat each t)
+}
+
+func foo2a<each T: Q>(_ t: repeat each T) -> S1<repeat each T> {
+  return S1(repeat each t)
+}
+
+func foo3a<each T: Q>(_ t: repeat each T) -> some P {
+  return S1(repeat (each t).a)
+}
+
+func foo4a<each T: Q>(_ t: repeat each T) -> S1<repeat (each T).A> {
+  return S1(repeat (each t).a)
+}
+
+func foo1b<each T: Q>(_ t: repeat each T) -> some P {
+  return S1.init(repeat each t)
+}
+
+func foo2b<each T: Q>(_ t: repeat each T) -> S1<repeat each T> {
+  return S1.init(repeat each t)
+}
+
+func foo3b<each T: Q>(_ t: repeat each T) -> some P {
+  return S1.init(repeat (each t).a)
+}
+
+func foo4b<each T: Q>(_ t: repeat each T) -> S1<repeat (each T).A> {
+  return S1.init(repeat (each t).a)
+}
+
+struct S2<each T: Q>: P {
+  init(arg: (repeat each T)) {}
+}
+
+func bar1a<each T: Q>(_ t: repeat each T) -> some P {
+  return S2(arg: (repeat each t))
+}
+
+func bar2a<each T: Q>(_ t: repeat each T) -> S2<repeat each T> {
+  return S2(arg: (repeat each t))
+}
+
+func bar3a<each T: Q>(_ t: repeat each T) -> some P {
+  return S2(arg: (repeat (each t).a))
+}
+
+func bar4a<each T: Q>(_ t: repeat each T) -> S2<repeat (each T).A> {
+  return S2(arg: (repeat (each t).a))
+}
+
+func bar1b<each T: Q>(_ t: repeat each T) -> some P {
+  return S2.init(arg: (repeat each t))
+}
+
+func bar2b<each T: Q>(_ t: repeat each T) -> S2<repeat each T> {
+  return S2.init(arg: (repeat each t))
+}
+
+func bar3b<each T: Q>(_ t: repeat each T) -> some P {
+  return S2.init(arg: (repeat (each t).a))
+}
+
+func bar4b<each T: Q>(_ t: repeat each T) -> S2<repeat (each T).A> {
+  return S2.init(arg: (repeat (each t).a))
+}

test/Constraints/variadic_generic_types.swift

@@ -56,6 +56,7 @@ do {
     return Test<String, Int, repeat each T>("a", 42, repeat each v) // Ok
   }
 }
+
 // rdar://107479662 - variadic tuple of Sendable elements does not conform to Sendable
 do {
   struct Test<each T> : Sendable {
@@ -65,3 +66,14 @@ do {
   struct TestProperty<T> : Sendable {
   }
 }
+
+// https://github.com/apple/swift/issues/68160
+do {
+  struct G<each T, U> {
+    let f: (repeat Optional<each T>) -> U
+
+    init(f: @escaping (repeat Optional<each T>) -> U) {
+      self.f = f
+    }
+  }
+}

validation-test/compiler_crashers_2_fixed/rdar113463759.swift

@@ -0,0 +1,16 @@
+// RUN: %target-swift-frontend -emit-ir %s -disable-availability-checking
+
+protocol SomeObjectProtocol {}
+
+struct SomeObject: SomeObjectProtocol {}
+
+protocol ObjectProviding {
+    associatedtype Object: SomeObjectProtocol
+    var object: Object { get }
+}
+
+struct ConformingObject<each B>: ObjectProviding {
+    var object: some SomeObjectProtocol {
+        SomeObject()
+    }
+}