AST: Re-implement mapPackTypeIntoElementContext() in terms of mapContextualPackTypeIntoElementContext()

Author: slavapestov

lib/AST/GenericEnvironment.cpp

@@ -659,6 +659,10 @@ Type GenericEnvironment::mapTypeIntoContext(GenericTypeParamType *type) const {
   return result;
 }
 
+/// So this expects a type written with the archetypes of the original generic
+/// environment, not 'this', the opened element environment, because it is the
+/// original PackArchetypes that become ElementArchetypes. Also this function
+/// does not apply outer substitutions, which might not be what you expect.
 Type
 GenericEnvironment::mapContextualPackTypeIntoElementContext(Type type) const {
   assert(getKind() == Kind::OpenedElement);
@@ -689,41 +693,23 @@ GenericEnvironment::mapContextualPackTypeIntoElementContext(CanType type) const
   return CanType(mapContextualPackTypeIntoElementContext(Type(type)));
 }
 
+/// Unlike mapContextualPackTypeIntoElementContext(), this also applies outer
+/// substitutions, so it behaves like mapTypeIntoContext() in that respect.
 Type
 GenericEnvironment::mapPackTypeIntoElementContext(Type type) const {
   assert(getKind() == Kind::OpenedElement);
   assert(!type->hasArchetype());
 
-  auto sig = getGenericSignature();
-  auto shapeClass = getOpenedElementShapeClass();
-
-  FindElementArchetypeForOpenedPackParam
-    findElementArchetype(this, getOpenedPackParams());
-
-  // Map the interface type to the element type by stripping
-  // away the isParameterPack bit before mapping type parameters
-  // to archetypes.
-  return type.transformRec([&](TypeBase *ty) -> llvm::Optional<Type> {
-    // We're only directly substituting pack parameters.
-    if (!ty->isTypeParameter()) {
-      // Don't recurse into nested pack expansions; just map it into
-      // context.
-      if (ty->is<PackExpansionType>())
-        return mapTypeIntoContext(ty);
-
-      // Recurse into any other type.
-      return llvm::None;
-    }
+  if (!type->hasTypeParameter()) return type;
 
-    // Just do normal mapping for types that are not rooted in
-    // opened type parameters.
-    auto rootParam = ty->getRootGenericParam();
-    if (!rootParam->isParameterPack() ||
-        !sig->haveSameShape(rootParam, shapeClass))
-      return mapTypeIntoContext(ty);
+  // Get a contextual type in the original generic environment, not the
+  // substituted one, which is what mapContextualPackTypeIntoElementContext()
+  // expects.
+  auto contextualType = getPackElementContextSubstitutions()
+    .getGenericSignature().getGenericEnvironment()->mapTypeIntoContext(type);
 
-    return Type(findElementArchetype(ty));
-  });
+  contextualType = mapContextualPackTypeIntoElementContext(contextualType);
+  return maybeApplyOuterContextSubstitutions(contextualType);
 }
 
 Type

validation-test/compiler_crashers_2_fixed/rdar112108253.swift

@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend -emit-ir %s -disable-availability-checking
+
+public protocol P {
+  associatedtype A
+}
+
+public struct G<each T> {}
+
+public struct S<T: P, each U: P> where repeat T.A == G<repeat each U> {
+    public init(predicate: repeat each U) {}
+}
+