[GenericEnvironment] Model opened pack element signatures as a complete clone

of the outer context signature, with an additional set of element type parameters
at depth + 1.

Author: hborla

include/swift/AST/Types.h

@@ -6177,14 +6177,6 @@ class GenericTypeParamType : public SubstitutableType {
   /// \endcode
   bool isParameterPack() const;
 
-  /// Returns a new GenericTypeParamType with the same depth and index
-  /// as this one, with the type parameter pack bit set.
-  GenericTypeParamType *asParameterPack(ASTContext &ctx) const;
-
-  /// Returns a new GenericTypeParamType with the same depth and index
-  /// as this one, removing the type parameter pack bit.
-  GenericTypeParamType *asScalar(ASTContext &ctx) const;
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::GenericTypeParam;

lib/AST/ASTContext.cpp

@@ -5629,41 +5629,76 @@ ASTContext::getOpenedElementSignature(CanGenericSignature baseGenericSig) {
   }
 #endif
 
-  SmallVector<GenericTypeParamType *, 2> genericParams;
+  // The pack element signature includes all type parameters and requirements
+  // from the outer context, plus a new set of type parameters representing
+  // open pack elements and their corresponding element requirements.
+
+  llvm::SmallMapVector<GenericTypeParamType *,
+                       GenericTypeParamType *, 2> packElementParams;
+  SmallVector<GenericTypeParamType *, 2> genericParams(
+      baseGenericSig.getGenericParams().begin(), baseGenericSig.getGenericParams().end());
   SmallVector<Requirement, 2> requirements;
 
+  auto packElementDepth =
+      baseGenericSig.getInnermostGenericParams().front()->getDepth() + 1;
+
   for (auto paramType : baseGenericSig.getGenericParams()) {
-    genericParams.push_back(paramType->asScalar(*this));
+    if (!paramType->isParameterPack())
+      continue;
+
+    auto *elementParam = GenericTypeParamType::get(/*isParameterPack*/false,
+                                                   packElementDepth,
+                                                   packElementParams.size(),
+                                                   *this);
+    genericParams.push_back(elementParam);
+    packElementParams[paramType] = elementParam;
   }
 
   auto eraseParameterPackRec = [&](Type type) -> Type {
     return type.transformRec([&](Type t) -> Optional<Type> {
-      if (auto *paramType = t->getAs<GenericTypeParamType>())
-        return Type(paramType->asScalar(*this));
+      if (auto *paramType = t->getAs<GenericTypeParamType>()) {
+        if (paramType->isParameterPack()) {
+          return Type(packElementParams[paramType]);
+        }
+
+        return t;
+      }
       return None;
     });
   };
 
   for (auto requirement : baseGenericSig.getRequirements()) {
+    requirements.push_back(requirement);
+
+    // If this requirement contains parameter packs, create a new requirement
+    // for the corresponding pack element.
     switch (requirement.getKind()) {
     case RequirementKind::SameShape:
       // Drop same-shape requirements from the element signature.
       break;
     case RequirementKind::Conformance:
     case RequirementKind::Superclass:
-    case RequirementKind::SameType:
-      requirements.emplace_back(
-          requirement.getKind(),
-          eraseParameterPackRec(requirement.getFirstType()),
-          eraseParameterPackRec(requirement.getSecondType()));
+    case RequirementKind::SameType: {
+      auto firstType = eraseParameterPackRec(requirement.getFirstType());
+      auto secondType = eraseParameterPackRec(requirement.getSecondType());
+      if (firstType->isEqual(requirement.getFirstType()) &&
+          secondType->isEqual(requirement.getSecondType()))
+        break;
+
+      requirements.emplace_back(requirement.getKind(),
+                                firstType, secondType);
       break;
-    case RequirementKind::Layout:
-      requirements.emplace_back(
-          requirement.getKind(),
-          eraseParameterPackRec(requirement.getFirstType()),
-          requirement.getLayoutConstraint());
+    }
+    case RequirementKind::Layout: {
+      auto firstType = eraseParameterPackRec(requirement.getFirstType());
+      if (firstType->isEqual(requirement.getFirstType()))
+        break;
+
+      requirements.emplace_back(requirement.getKind(), firstType,
+                                requirement.getLayoutConstraint());
       break;
     }
+    }
   }
 
   auto elementSig = buildGenericSignature(

lib/AST/GenericEnvironment.cpp

@@ -500,9 +500,24 @@ GenericEnvironment::mapPackTypeIntoElementContext(Type type) const {
   assert(!type->hasArchetype());
 
   auto sig = getGenericSignature();
-  ASTContext &ctx = sig->getASTContext();
   QueryInterfaceTypeSubstitutions substitutions(this);
 
+  llvm::SmallDenseMap<GenericParamKey,
+                      GenericTypeParamType *> elementParamForPack;
+  auto packElements = sig.getInnermostGenericParams();
+  auto elementDepth = packElements.front()->getDepth();
+
+  for (auto *genericParam : sig.getGenericParams()) {
+    if (genericParam->getDepth() == elementDepth)
+      break;
+
+    if (!genericParam->isParameterPack())
+      continue;
+
+    auto elementIndex = elementParamForPack.size();
+    elementParamForPack[{genericParam}] = packElements[elementIndex];
+  }
+
   // Map the interface type to the element type by stripping
   // away the isParameterPack bit before mapping type parameters
   // to archetypes.
@@ -511,7 +526,10 @@ GenericEnvironment::mapPackTypeIntoElementContext(Type type) const {
     if (!genericParam)
       return Type();
 
-    return substitutions(genericParam->asScalar(ctx));
+    if (auto *elementParam = elementParamForPack[{genericParam}])
+      return substitutions(elementParam);
+
+    return substitutions(genericParam);
   }, LookUpConformanceInSignature(sig.getPointer()));
 }
 
@@ -521,9 +539,23 @@ GenericEnvironment::mapElementTypeIntoPackContext(Type type) const {
   assert(!type->hasArchetype());
 
   auto sig = getGenericSignature();
-  ASTContext &ctx = sig->getASTContext();
   QueryInterfaceTypeSubstitutions substitutions(this);
 
+  llvm::SmallDenseMap<GenericParamKey, GenericTypeParamType *>
+      packParamForElement;
+  auto elementDepth =
+      sig.getInnermostGenericParams().front()->getDepth() + 1;
+
+  for (auto *genericParam : sig.getGenericParams()) {
+    if (!genericParam->isParameterPack())
+      continue;
+
+    GenericParamKey elementKey(/*isParameterPack*/false,
+                               /*depth*/elementDepth,
+                               /*index*/packParamForElement.size());
+    packParamForElement[elementKey] = genericParam;
+  }
+
   // Map element archetypes to the pack archetypes by converting
   // element types to interface types and adding the isParameterPack
   // bit. Then, map type parameters to archetypes.
@@ -532,7 +564,10 @@ GenericEnvironment::mapElementTypeIntoPackContext(Type type) const {
     if (!genericParam)
       return Type();
 
-    return substitutions(genericParam->asParameterPack(ctx));
+    if (auto *packParam = packParamForElement[{genericParam}])
+      return substitutions(packParam);
+
+    return substitutions(genericParam);
   }, LookUpConformanceInSignature(sig.getPointer()));
 }
 

lib/AST/ParameterPack.cpp

@@ -67,20 +67,6 @@ bool GenericTypeParamType::isParameterPack() const {
          GenericTypeParamType::TYPE_SEQUENCE_BIT;
 }
 
-GenericTypeParamType *
-GenericTypeParamType::asParameterPack(ASTContext &ctx) const {
-  return GenericTypeParamType::get(/*isParameterPack*/true,
-                                   getDepth(), getIndex(),
-                                   ctx);
-}
-
-GenericTypeParamType *
-GenericTypeParamType::asScalar(ASTContext &ctx) const {
-  return GenericTypeParamType::get(/*isParameterPack*/false,
-                                   getDepth(), getIndex(),
-                                   ctx);
-}
-
 /// G<{X1, ..., Xn}, {Y1, ..., Yn}>... => {G<X1, Y1>, ..., G<Xn, Yn>}...
 PackExpansionType *PackExpansionType::expand() {
   auto countType = getCountType();