AST: Opened existential environments store outer substitutions

Author: slavapestov

include/swift/AST/GenericEnvironment.h

@@ -58,21 +58,18 @@ class QueryInterfaceTypeSubstitutions {
 /// Extra data in a generic environment for an opaque type.
 struct OpaqueEnvironmentData {
   OpaqueTypeDecl *decl;
-  SubstitutionMap subMap;
 };
 
 /// Extra data in a generic environment for an opened existential.
 struct OpenedExistentialEnvironmentData {
   Type existential;
-  GenericSignature parentSig;
   UUID uuid;
 };
 
 /// Extra data in a generic environment for an opened pack element.
 struct OpenedElementEnvironmentData {
   UUID uuid;
   CanGenericTypeParamType shapeClass;
-  SubstitutionMap outerSubstitutions;
 };
 
 /// Describes the mapping between archetypes and interface types for the
@@ -86,6 +83,7 @@ struct OpenedElementEnvironmentData {
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
     : private llvm::TrailingObjects<
         GenericEnvironment,
+        SubstitutionMap,
         OpaqueEnvironmentData,
         OpenedExistentialEnvironmentData,
         OpenedElementEnvironmentData,
@@ -114,6 +112,7 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   friend TrailingObjects;
   friend OpaqueTypeArchetypeType;
 
+  size_t numTrailingObjects(OverloadToken<SubstitutionMap>) const;
   size_t numTrailingObjects(OverloadToken<OpaqueEnvironmentData>) const;
   size_t numTrailingObjects(OverloadToken<OpenedExistentialEnvironmentData>) const;
   size_t numTrailingObjects(OverloadToken<OpenedElementEnvironmentData>) const;
@@ -147,8 +146,7 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
   /// Private constructor for opened existential environments.
   explicit GenericEnvironment(
-      GenericSignature signature,
-      Type existential, GenericSignature parentSig, UUID uuid);
+      GenericSignature signature, Type existential, SubstitutionMap subs, UUID uuid);
 
   /// Private constructor for opened element environments.
   explicit GenericEnvironment(GenericSignature signature,
@@ -185,20 +183,16 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// Retrieve the UUID for an opened existential environment.
   UUID getOpenedExistentialUUID() const;
 
-  /// Retrieve the parent signature for an opened existential environment.
-  GenericSignature getOpenedExistentialParentSignature() const;
-
   /// Retrieve the opaque type declaration for a generic environment describing
   /// opaque types.
   OpaqueTypeDecl *getOpaqueTypeDecl() const;
 
-  /// Retrieve the substitutions applied to an opaque type declaration to
-  /// create a generic environment.
-  SubstitutionMap getOpaqueSubstitutions() const;
-
-  /// Retrieve the substitutions for the outer generic parameters of an
-  /// opened pack element generic environment.
-  SubstitutionMap getPackElementContextSubstitutions() const;
+  /// Retrieve the outer substitutions for an opaque or local environment.
+  ///
+  /// Applying a substitution map to a local or opaque archetype outputs
+  /// an archetype with the same interface type, and composed outer
+  /// substitutions.
+  SubstitutionMap getOuterSubstitutions() const;
 
   /// Retrieve the shape equivalence class for an opened element environment.
   /// This is always a pack parameter.
@@ -238,10 +232,11 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// Create a new generic environment for an opened existential.
   ///
   /// \param existential The subject existential type
-  /// \param parentSig The signature of the context where this existential type is being opened
+  /// \param outerSubs The substitution map containing archetypes from the
+  /// outer generic context
   /// \param uuid The unique identifier for this opened existential
   static GenericEnvironment *
-  forOpenedExistential(Type existential, GenericSignature parentSig, UUID uuid);
+  forOpenedExistential(Type existential, SubstitutionMap outerSubs, UUID uuid);
 
   /// Create a new generic environment for an opened element.
   ///
@@ -251,7 +246,7 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// \param uuid The unique identifier for this opened element
   /// \param shapeClass The shape equivalence class for the originating packs
   /// \param outerSubs The substitution map containing archetypes from the
-  /// outer generic context.
+  /// outer generic context
   static GenericEnvironment *
   forOpenedElement(GenericSignature signature,
                    UUID uuid, CanGenericTypeParamType shapeClass,
@@ -271,9 +266,6 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// substitutions.
   Type maybeApplyOuterContextSubstitutions(Type type) const;
 
-  /// Compute the canonical interface type within this environment.
-  Type getCanonicalInterfaceType(Type interfaceType);
-
   /// Map an interface type to a contextual type.
   static Type mapTypeIntoContext(GenericEnvironment *genericEnv,
                                  Type type);

include/swift/SIL/SILCloner.h

@@ -2870,7 +2870,7 @@ void SILCloner<ImplClass>::visitOpenPackElementInst(
 
   // Substitute the contextual substitutions.
   auto newContextSubs =
-    getOpSubstitutionMap(origEnv->getPackElementContextSubstitutions());
+    getOpSubstitutionMap(origEnv->getOuterSubstitutions());
 
   // The opened shape class is a parameter of the original signature,
   // which is unchanged.

lib/AST/ASTContext.cpp

@@ -606,6 +606,8 @@ struct ASTContext::Implementation {
     void dump(llvm::raw_ostream &out) const;
   };
 
+  using OpenedExistentialKey = std::pair<SubstitutionMap, UUID>;
+
   llvm::DenseMap<ModuleDecl*, ModuleType*> ModuleTypes;
   llvm::DenseMap<std::pair<unsigned, unsigned>, GenericTypeParamType *>
     GenericParamTypes;
@@ -618,7 +620,8 @@ struct ASTContext::Implementation {
   llvm::DenseMap<BuiltinIntegerWidth, BuiltinIntegerType*> IntegerTypes;
   llvm::FoldingSet<BuiltinVectorType> BuiltinVectorTypes;
   llvm::FoldingSet<DeclName::CompoundDeclName> CompoundNames;
-  llvm::DenseMap<UUID, GenericEnvironment *> OpenedExistentialEnvironments;
+  llvm::DenseMap<OpenedExistentialKey, GenericEnvironment *>
+      OpenedExistentialEnvironments;
   llvm::DenseMap<UUID, GenericEnvironment *> OpenedElementEnvironments;
   llvm::FoldingSet<IndexSubset> IndexSubsets;
   llvm::FoldingSet<AutoDiffDerivativeFunctionIdentifier>
@@ -5295,7 +5298,7 @@ OpaqueTypeArchetypeType *OpaqueTypeArchetypeType::getNew(
     ArrayRef<ProtocolDecl *> conformsTo, Type superclass,
     LayoutConstraint layout) {
   auto properties = getOpaqueTypeArchetypeProperties(
-      environment->getOpaqueSubstitutions());
+      environment->getOuterSubstitutions());
   auto arena = getArena(properties);
   auto size = OpaqueTypeArchetypeType::totalSizeToAlloc<
       ProtocolDecl *, Type, LayoutConstraint>(
@@ -5353,7 +5356,7 @@ CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
 
   auto *genericEnv =
     GenericEnvironment::forOpenedExistential(
-      existential, GenericSignature(), *knownID);
+      existential, SubstitutionMap(), *knownID);
 
   // Map the interface type into that environment.
   auto result = genericEnv->mapTypeIntoContext(interfaceType)
@@ -5508,10 +5511,11 @@ GenericEnvironment *GenericEnvironment::forPrimary(GenericSignature signature) {
 
   // Allocate and construct the new environment.
   unsigned numGenericParams = signature.getGenericParams().size();
-  size_t bytes = totalSizeToAlloc<OpaqueEnvironmentData,
+  size_t bytes = totalSizeToAlloc<SubstitutionMap,
+                                  OpaqueEnvironmentData,
                                   OpenedExistentialEnvironmentData,
                                   OpenedElementEnvironmentData, Type>(
-      0, 0, 0, numGenericParams);
+      0, 0, 0, 0, numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
   return new (mem) GenericEnvironment(signature);
 }
@@ -5537,10 +5541,11 @@ GenericEnvironment *GenericEnvironment::forOpaqueType(
     // Allocate and construct the new environment.
     auto signature = opaque->getOpaqueInterfaceGenericSignature();
     unsigned numGenericParams = signature.getGenericParams().size();
-    size_t bytes = totalSizeToAlloc<OpaqueEnvironmentData,
+    size_t bytes = totalSizeToAlloc<SubstitutionMap,
+                                  OpaqueEnvironmentData,
                                     OpenedExistentialEnvironmentData,
                                     OpenedElementEnvironmentData, Type>(
-        1, 0, 0, numGenericParams);
+        1, 1, 0, 0, numGenericParams);
     void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment), arena);
     env = new (mem) GenericEnvironment(signature, opaque, subs);
 
@@ -5553,7 +5558,7 @@ GenericEnvironment *GenericEnvironment::forOpaqueType(
 /// Create a new generic environment for an opened archetype.
 GenericEnvironment *
 GenericEnvironment::forOpenedExistential(
-    Type existential, GenericSignature parentSig, UUID uuid) {
+    Type existential, SubstitutionMap subs, UUID uuid) {
   assert(existential->isExistentialType());
   // FIXME: Opened archetypes can't be transformed because the
   // the identity of the archetype has to be preserved. This
@@ -5567,32 +5572,36 @@ GenericEnvironment::forOpenedExistential(
 
   auto &ctx = existential->getASTContext();
 
+  auto key = std::make_pair(subs, uuid);
+
   auto &openedExistentialEnvironments =
       ctx.getImpl().OpenedExistentialEnvironments;
-  auto found = openedExistentialEnvironments.find(uuid);
+  auto found = openedExistentialEnvironments.find(key);
 
   if (found != openedExistentialEnvironments.end()) {
     auto *existingEnv = found->second;
     assert(existingEnv->getOpenedExistentialType()->isEqual(existential));
-    assert(existingEnv->getOpenedExistentialParentSignature().getPointer() == parentSig.getPointer());
+    assert(existingEnv->getOuterSubstitutions() == subs);
     assert(existingEnv->getOpenedExistentialUUID() == uuid);
 
     return existingEnv;
   }
 
+  auto parentSig = subs.getGenericSignature().getCanonicalSignature();
   auto signature = ctx.getOpenedExistentialSignature(existential, parentSig);
 
   // Allocate and construct the new environment.
   unsigned numGenericParams = signature.getGenericParams().size();
-  size_t bytes = totalSizeToAlloc<OpaqueEnvironmentData,
+  size_t bytes = totalSizeToAlloc<SubstitutionMap,
+                                  OpaqueEnvironmentData,
                                   OpenedExistentialEnvironmentData,
                                   OpenedElementEnvironmentData, Type>(
-      0, 1, 0, numGenericParams);
+      1, 0, 1, 0, numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
   auto *genericEnv =
-      new (mem) GenericEnvironment(signature, existential, parentSig, uuid);
+      new (mem) GenericEnvironment(signature, existential, subs, uuid);
 
-  openedExistentialEnvironments[uuid] = genericEnv;
+  openedExistentialEnvironments[key] = genericEnv;
 
   return genericEnv;
 }
@@ -5621,11 +5630,12 @@ GenericEnvironment::forOpenedElement(GenericSignature signature,
   // Allocate and construct the new environment.
   unsigned numGenericParams = signature.getGenericParams().size();
   unsigned numOpenedParams = signature.getInnermostGenericParams().size();
-  size_t bytes = totalSizeToAlloc<OpaqueEnvironmentData,
+  size_t bytes = totalSizeToAlloc<SubstitutionMap,
+                                  OpaqueEnvironmentData,
                                   OpenedExistentialEnvironmentData,
                                   OpenedElementEnvironmentData,
                                   Type>(
-      0, 0, 1, numGenericParams + numOpenedParams);
+      1, 0, 0, 1, numGenericParams + numOpenedParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
   auto *genericEnv = new (mem) GenericEnvironment(signature,
                                                   uuid, shapeClass,

lib/AST/ASTPrinter.cpp

@@ -6955,7 +6955,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     // the generic signature of the contextual substitution map in the
     // opened element environment.
     auto env = T->getGenericEnvironment();
-    auto subs = env->getPackElementContextSubstitutions();
+    auto subs = env->getOuterSubstitutions();
     auto sig = subs.getGenericSignature();
     auto params = sig.getGenericParams();
 

lib/AST/GenericEnvironment.cpp

@@ -24,6 +24,19 @@
 
 using namespace swift;
 
+size_t GenericEnvironment::numTrailingObjects(
+    OverloadToken<SubstitutionMap>) const {
+  switch (getKind()) {
+  case Kind::Primary:
+    return 0;
+
+  case Kind::OpenedExistential:
+  case Kind::OpenedElement:
+  case Kind::Opaque:
+    return 1;
+  }
+}
+
 size_t GenericEnvironment::numTrailingObjects(
     OverloadToken<OpaqueEnvironmentData>) const {
   switch (getKind()) {
@@ -104,21 +117,14 @@ GenericEnvironment::getGenericParams() const {
   return getGenericSignature().getGenericParams();
 }
 
-OpaqueTypeDecl *GenericEnvironment::getOpaqueTypeDecl() const {
-  assert(getKind() == Kind::Opaque);
-  return getTrailingObjects<OpaqueEnvironmentData>()->decl;
+SubstitutionMap GenericEnvironment::getOuterSubstitutions() const {
+  assert(getKind() != Kind::Primary);
+  return *getTrailingObjects<SubstitutionMap>();
 }
 
-SubstitutionMap GenericEnvironment::getOpaqueSubstitutions() const {
+OpaqueTypeDecl *GenericEnvironment::getOpaqueTypeDecl() const {
   assert(getKind() == Kind::Opaque);
-  return getTrailingObjects<OpaqueEnvironmentData>()->subMap;
-}
-
-SubstitutionMap
-GenericEnvironment::getPackElementContextSubstitutions() const {
-  assert(getKind() == Kind::OpenedElement);
-  auto environmentData = getTrailingObjects<OpenedElementEnvironmentData>();
-  return environmentData->outerSubstitutions;
+  return getTrailingObjects<OpaqueEnvironmentData>()->decl;
 }
 
 CanGenericTypeParamType
@@ -138,12 +144,6 @@ UUID GenericEnvironment::getOpenedExistentialUUID() const {
   return getTrailingObjects<OpenedExistentialEnvironmentData>()->uuid;
 }
 
-GenericSignature
-GenericEnvironment::getOpenedExistentialParentSignature() const {
-  assert(getKind() == Kind::OpenedExistential);
-  return getTrailingObjects<OpenedExistentialEnvironmentData>()->parentSig;
-}
-
 UUID GenericEnvironment::getOpenedElementUUID() const {
   assert(getKind() == Kind::OpenedElement);
   return getTrailingObjects<OpenedElementEnvironmentData>()->uuid;
@@ -212,11 +212,12 @@ GenericEnvironment::GenericEnvironment(GenericSignature signature)
 
 GenericEnvironment::GenericEnvironment(
     GenericSignature signature,
-    Type existential, GenericSignature parentSig, UUID uuid)
+    Type existential, SubstitutionMap subs, UUID uuid)
   : SignatureAndKind(signature, Kind::OpenedExistential)
 {
+  *getTrailingObjects<SubstitutionMap>() = subs;
   new (getTrailingObjects<OpenedExistentialEnvironmentData>())
-    OpenedExistentialEnvironmentData{ existential, parentSig, uuid };
+    OpenedExistentialEnvironmentData{ existential, uuid };
 
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
@@ -227,8 +228,9 @@ GenericEnvironment::GenericEnvironment(
       GenericSignature signature, OpaqueTypeDecl *opaque, SubstitutionMap subs)
   : SignatureAndKind(signature, Kind::Opaque)
 {
+  *getTrailingObjects<SubstitutionMap>() = subs;
   new (getTrailingObjects<OpaqueEnvironmentData>())
-    OpaqueEnvironmentData{opaque, subs};
+    OpaqueEnvironmentData{opaque};
 
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
@@ -241,8 +243,9 @@ GenericEnvironment::GenericEnvironment(GenericSignature signature,
                                        SubstitutionMap outerSubs)
   : SignatureAndKind(signature, Kind::OpenedElement)
 {
+  *getTrailingObjects<SubstitutionMap>() = outerSubs;
   new (getTrailingObjects<OpenedElementEnvironmentData>())
-    OpenedElementEnvironmentData{uuid, shapeClass, outerSubs};
+    OpenedElementEnvironmentData{uuid, shapeClass};
 
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
@@ -337,20 +340,12 @@ GenericEnvironment::maybeApplyOuterContextSubstitutions(Type type) const {
   case Kind::OpenedExistential:
     return type;
 
-  case Kind::OpenedElement: {
+  case Kind::OpenedElement:
+  case Kind::Opaque: {
     auto packElements = getGenericSignature().getInnermostGenericParams();
     auto elementDepth = packElements.front()->getDepth();
     SubstituteOuterFromSubstitutionMap replacer{
-        getPackElementContextSubstitutions(), elementDepth};
-    return type.subst(replacer, replacer);
-  }
-
-  case Kind::Opaque: {
-    // Substitute outer generic parameters of an opaque archetype environment.
-    unsigned opaqueDepth =
-      getOpaqueTypeDecl()->getOpaqueGenericParams().front()->getDepth();
-    SubstituteOuterFromSubstitutionMap replacer{
-        getOpaqueSubstitutions(), opaqueDepth};
+        getOuterSubstitutions(), elementDepth};
     return type.subst(replacer, replacer);
   }
   }
@@ -686,7 +681,7 @@ GenericEnvironment::mapPackTypeIntoElementContext(Type type) const {
   // Get a contextual type in the original generic environment, not the
   // substituted one, which is what mapContextualPackTypeIntoElementContext()
   // expects.
-  auto contextualType = getPackElementContextSubstitutions()
+  auto contextualType = getOuterSubstitutions()
     .getGenericSignature().getGenericEnvironment()->mapTypeIntoContext(type);
 
   contextualType = mapContextualPackTypeIntoElementContext(contextualType);

lib/AST/Type.cpp

@@ -3569,7 +3569,7 @@ OpaqueTypeDecl *OpaqueTypeArchetypeType::getDecl() const {
 }
 
 SubstitutionMap OpaqueTypeArchetypeType::getSubstitutions() const {
-  return Environment->getOpaqueSubstitutions();
+  return Environment->getOuterSubstitutions();
 }
 
 OpenedArchetypeType::OpenedArchetypeType(