Rework OpenedArchetypeType to generalize over interface types.

Form opened archetype types based on an interface type and existential
type, rather than assuming all OpenedArchetypeType instances only
represent the root. Sink the UUID, existential type, and actual creation
of the opened archetype into the opened generic environment, so we
consistently only create new archetype instances from the generic
environment. This slims down OpenedArchetypeType and makes it work
similarly to the other archetype kinds, as well as generalizing it
to support nested types.
Sink the existential type and UUID of an

Author: DougGregor

include/swift/AST/GenericEnvironment.h

@@ -23,6 +23,7 @@
 #include "swift/AST/GenericSignature.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/Debug.h"
+#include "swift/Basic/UUID.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TrailingObjects.h"
@@ -50,6 +51,12 @@ class QueryInterfaceTypeSubstitutions {
   Type operator()(SubstitutableType *type) const;
 };
 
+/// Extra data in a generic environment for an opened existentiak.
+struct OpenedGenericEnvironmentData {
+  Type existential;
+  UUID uuid;
+};
+
 /// Describes the mapping between archetypes and interface types for the
 /// generic parameters of a DeclContext.
 ///
@@ -60,7 +67,8 @@ class QueryInterfaceTypeSubstitutions {
 ///
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
     : private llvm::TrailingObjects<
-        GenericEnvironment, OpaqueTypeDecl *, SubstitutionMap, Type> {
+        GenericEnvironment, OpaqueTypeDecl *, SubstitutionMap,
+        OpenedGenericEnvironmentData, Type> {
 public:
   enum class Kind {
     /// A normal generic environment, determined only by its generic
@@ -85,6 +93,7 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   size_t numTrailingObjects(OverloadToken<OpaqueTypeDecl *>) const;
   size_t numTrailingObjects(OverloadToken<SubstitutionMap>) const;
   size_t numTrailingObjects(OverloadToken<Type>) const;
+  size_t numTrailingObjects(OverloadToken<OpenedGenericEnvironmentData>) const;
 
   /// Retrieve the array containing the context types associated with the
   /// generic parameters, stored in parallel with the generic parameters of the
@@ -99,7 +108,9 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// Get the nested type storage, allocating it if required.
   NestedTypeStorage &getOrCreateNestedTypeStorage();
 
-  explicit GenericEnvironment(GenericSignature signature, Kind kind);
+  explicit GenericEnvironment(GenericSignature signature);
+  explicit GenericEnvironment(
+      GenericSignature signature, Type existential, UUID uuid);
   explicit GenericEnvironment(
       GenericSignature signature, OpaqueTypeDecl *opaque, SubstitutionMap subs);
 
@@ -122,6 +133,12 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
   TypeArrayView<GenericTypeParamType> getGenericParams() const;
 
+  /// Retrieve the existential type for an opened existential environment.
+  Type getOpenedExistentialType() const;
+
+  /// Retrieve the UUID for an opened existential environment.
+  UUID getOpenedExistentialUUID() const;
+
   /// Retrieve the opaque type declaration for a generic environment describing
   /// opaque types.
   OpaqueTypeDecl *getOpaqueTypeDecl() const;
@@ -136,8 +153,7 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   GenericEnvironment *getIncomplete(GenericSignature signature);
 
   /// Create a new generic environment for an opened existential.
-  static GenericEnvironment *forOpenedExistential(
-      GenericSignature signature, const OpenedArchetypeType *type);
+  static GenericEnvironment *forOpenedExistential(Type existential, UUID uuid);
 
   /// Create a new generic environment for an opaque type with the given set of
   /// outer substitutions.

include/swift/AST/Types.h

@@ -5566,7 +5566,7 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::OpaqueTypeArchetype;
   }
-  
+
 private:
   OpaqueTypeArchetypeType(GenericEnvironment *environment,
                           RecursiveTypeProperties properties,
@@ -5630,21 +5630,49 @@ class OpenedArchetypeType final : public ArchetypeType,
 {
   friend TrailingObjects;
   friend ArchetypeType;
-  
+  friend GenericEnvironment;
+
   TypeBase *Opened;
   UUID ID;
 
+  /// Create a new opened archetype in the given environment representing
+  /// the interface type.
+  ///
+  /// This is only invoked by the generic environment when mapping the
+  /// interface type into context.
+  static CanTypeWrapper<OpenedArchetypeType>
+  getNew(GenericEnvironment *environment, Type interfaceType,
+         ArrayRef<ProtocolDecl *> conformsTo, Type superclass,
+         LayoutConstraint layout);
+
 public:
-  /// Create a new archetype that represents the opened type
+  /// Get or create an archetype that represents the opened type
   /// of an existential value.
   ///
   /// \param existential The existential type to open.
   ///
   /// \param knownID When non-empty, the known ID of the archetype. When empty,
   /// a fresh archetype with a unique ID will be opened.
-  static CanTypeWrapper<OpenedArchetypeType>
-                        get(Type existential,
-                            Optional<UUID> knownID = None);
+  static CanTypeWrapper<OpenedArchetypeType> get(
+      Type existential, Optional<UUID> knownID = None);
+
+  /// Get or create an archetype that represents the opened type
+  /// of an existential value.
+  ///
+  /// \param existential The existential type to open.
+  /// \param interfaceType The interface type represented by this archetype.
+  ///
+  /// \param knownID When non-empty, the known ID of the archetype. When empty,
+  /// a fresh archetype with a unique ID will be opened.
+  static CanTypeWrapper<OpenedArchetypeType> get(
+      Type existential, Type interfaceType, Optional<UUID> knownID = None);
+
+  /// Create a new archetype that represents the opened type
+  /// of an existential value.
+  ///
+  /// \param existential The existential type or existential metatype to open.
+  /// \param interfaceType The interface type represented by this archetype.
+  static CanType getAny(Type existential, Type interfaceType);
 
   /// Create a new archetype that represents the opened type
   /// of an existential value.
@@ -5653,22 +5681,19 @@ class OpenedArchetypeType final : public ArchetypeType,
   static CanType getAny(Type existential);
 
   /// Retrieve the ID number of this opened existential.
-  UUID getOpenedExistentialID() const { return ID; }
+  UUID getOpenedExistentialID() const;
 
   /// Retrieve the opened existential type
-  Type getOpenedExistentialType() const {
-    return Opened;
-  }
+  Type getOpenedExistentialType() const;
 
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::OpenedArchetype;
   }
 
 private:
-  OpenedArchetypeType(const ASTContext &Ctx,
-                      Type Existential,
-                      ArrayRef<ProtocolDecl *> ConformsTo, Type Superclass,
-                      LayoutConstraint Layout, UUID uuid);
+  OpenedArchetypeType(GenericEnvironment *environment, Type interfaceType,
+                      ArrayRef<ProtocolDecl *> conformsTo, Type superclass,
+                      LayoutConstraint layout);
 };
 BEGIN_CAN_TYPE_WRAPPER(OpenedArchetypeType, ArchetypeType)
 END_CAN_TYPE_WRAPPER(OpenedArchetypeType, ArchetypeType)

include/swift/SIL/SILCloner.h

@@ -250,7 +250,9 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
 
   void remapOpenedType(CanOpenedArchetypeType archetypeTy) {
     auto existentialTy = archetypeTy->getOpenedExistentialType()->getCanonicalType();
-    auto replacementTy = OpenedArchetypeType::get(getOpASTType(existentialTy));
+    auto replacementTy = OpenedArchetypeType::get(
+        getOpASTType(existentialTy),
+        archetypeTy->getInterfaceType());
     registerOpenedExistentialRemapping(archetypeTy, replacementTy);
   }
 

lib/AST/ASTContext.cpp

@@ -464,7 +464,7 @@ struct ASTContext::Implementation {
   llvm::DenseMap<BuiltinIntegerWidth, BuiltinIntegerType*> IntegerTypes;
   llvm::FoldingSet<BuiltinVectorType> BuiltinVectorTypes;
   llvm::FoldingSet<DeclName::CompoundDeclName> CompoundNames;
-  llvm::DenseMap<UUID, OpenedArchetypeType *> OpenedExistentialArchetypes;
+  llvm::DenseMap<UUID, GenericEnvironment *> OpenedExistentialEnvironments;
   llvm::FoldingSet<IndexSubset> IndexSubsets;
   llvm::FoldingSet<AutoDiffDerivativeFunctionIdentifier>
       AutoDiffDerivativeFunctionIdentifiers;
@@ -2498,7 +2498,7 @@ size_t ASTContext::getTotalMemory() const {
     // getImpl().BuiltinVectorTypes ?
     // getImpl().GenericSignatures ?
     // getImpl().CompoundNames ?
-    getImpl().OpenedExistentialArchetypes.getMemorySize() +
+    getImpl().OpenedExistentialEnvironments.getMemorySize() +
     getImpl().Permanent.getTotalMemory();
 
     Size += getSolverMemory();
@@ -4268,17 +4268,44 @@ Type OpaqueTypeArchetypeType::get(
   return env->getOrCreateArchetypeFromInterfaceType(interfaceType);
 }
 
+CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::getNew(
+    GenericEnvironment *environment, Type interfaceType,
+    ArrayRef<ProtocolDecl *> conformsTo, Type superclass,
+    LayoutConstraint layout) {
+  auto arena = AllocationArena::Permanent;
+  ASTContext &ctx = interfaceType->getASTContext();
+  void *mem = ctx.Allocate(
+    OpenedArchetypeType::totalSizeToAlloc<ProtocolDecl *,Type,LayoutConstraint>(
+      conformsTo.size(),
+      superclass ? 1 : 0,
+      layout ? 1 : 0),
+      alignof(OpenedArchetypeType), arena);
+
+  return CanOpenedArchetypeType(::new (mem) OpenedArchetypeType(
+      environment, interfaceType, conformsTo, superclass, layout));
+}
+
+CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::get(
+    Type existential, Optional<UUID> knownID) {
+  Type interfaceType = GenericTypeParamType::get(
+      /*isTypeSequence=*/false, 0, 0, existential->getASTContext());
+  return get(existential, interfaceType, knownID);
+}
+
 CanOpenedArchetypeType OpenedArchetypeType::get(Type existential,
+                                                Type interfaceType,
                                                 Optional<UUID> knownID) {
   auto &ctx = existential->getASTContext();
-  auto &openedExistentialArchetypes = ctx.getImpl().OpenedExistentialArchetypes;
+  auto &openedExistentialEnvironments =
+      ctx.getImpl().OpenedExistentialEnvironments;
   // If we know the ID already...
   if (knownID) {
     // ... and we already have an archetype for that ID, return it.
-    auto found = openedExistentialArchetypes.find(*knownID);
+    auto found = openedExistentialEnvironments.find(*knownID);
 
-    if (found != openedExistentialArchetypes.end()) {
-      auto result = found->second;
+    if (found != openedExistentialEnvironments.end()) {
+      auto result = found->second->mapTypeIntoContext(interfaceType)
+          ->castTo<OpenedArchetypeType>();
       assert(result->getOpenedExistentialType()->isEqual(existential) &&
              "Retrieved the wrong opened existential type?");
       return CanOpenedArchetypeType(result);
@@ -4288,52 +4315,32 @@ CanOpenedArchetypeType OpenedArchetypeType::get(Type existential,
     knownID = UUID::fromTime();
   }
 
-  auto layout = existential->getExistentialLayout();
-
-  SmallVector<ProtocolDecl *, 2> protos;
-  for (auto proto : layout.getProtocols())
-    protos.push_back(proto->getDecl());
-
-  auto layoutConstraint = layout.getLayoutConstraint();
-  if (!layoutConstraint && layout.requiresClass()) {
-    layoutConstraint = LayoutConstraint::getLayoutConstraint(
-        LayoutConstraintKind::Class);
-  }
-
-  auto layoutSuperclass = layout.getSuperclass();
-
-  auto arena = AllocationArena::Permanent;
-  void *mem = ctx.Allocate(
-    OpenedArchetypeType::totalSizeToAlloc<ProtocolDecl *, Type, LayoutConstraint>(
-      protos.size(),
-      layoutSuperclass ? 1 : 0,
-      layoutConstraint ? 1 : 0),
-      alignof(OpenedArchetypeType), arena);
-
-  auto result =
-      ::new (mem) OpenedArchetypeType(ctx, existential,
-                                protos, layoutSuperclass,
-                                layoutConstraint, *knownID);
-  result->InterfaceType =
-      GenericTypeParamType::get(/*type sequence*/ false,
-                                /*depth*/ 0, /*index*/ 0, ctx);
-
-  auto signature = ctx.getOpenedArchetypeSignature(existential);
-  result->Environment = GenericEnvironment::forOpenedExistential(
-      signature, result);
-
-  openedExistentialArchetypes[*knownID] = result;
+  /// Create a generic environment for this opened archetype.
+  auto genericEnv = GenericEnvironment::forOpenedExistential(
+      existential, *knownID);
+  openedExistentialEnvironments[*knownID] = genericEnv;
 
+  // Map the interface type into that environment.
+  auto result = genericEnv->mapTypeIntoContext(interfaceType)
+      ->castTo<OpenedArchetypeType>();
   return CanOpenedArchetypeType(result);
 }
 
-CanType OpenedArchetypeType::getAny(Type existential) {
+
+CanType OpenedArchetypeType::getAny(Type existential, Type interfaceType) {
   if (auto metatypeTy = existential->getAs<ExistentialMetatypeType>()) {
     auto instanceTy = metatypeTy->getExistentialInstanceType();
-    return CanMetatypeType::get(OpenedArchetypeType::getAny(instanceTy));
+    return CanMetatypeType::get(
+        OpenedArchetypeType::getAny(instanceTy, interfaceType));
   }
   assert(existential->isExistentialType());
-  return OpenedArchetypeType::get(existential);
+  return OpenedArchetypeType::get(existential, interfaceType);
+}
+
+CanType OpenedArchetypeType::getAny(Type existential) {
+  Type interfaceType = GenericTypeParamType::get(
+      /*isTypeSequence=*/false, 0, 0, existential->getASTContext());
+  return getAny(existential, interfaceType);
 }
 
 void SubstitutionMap::Storage::Profile(
@@ -4480,27 +4487,26 @@ GenericEnvironment *GenericEnvironment::getIncomplete(
 
   // Allocate and construct the new environment.
   unsigned numGenericParams = signature.getGenericParams().size();
-  size_t bytes = totalSizeToAlloc<OpaqueTypeDecl *, SubstitutionMap, Type>(
-      0, 0, numGenericParams);
+  size_t bytes = totalSizeToAlloc<OpaqueTypeDecl *, SubstitutionMap,
+                                  OpenedGenericEnvironmentData, Type>(
+      0, 0, 0, numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
-  return new (mem) GenericEnvironment(signature, Kind::Normal);
+  return new (mem) GenericEnvironment(signature);
 }
 
 /// Create a new generic environment for an opened archetype.
 GenericEnvironment *GenericEnvironment::forOpenedExistential(
-    GenericSignature signature, const OpenedArchetypeType *type) {
-  auto &ctx = signature->getASTContext();
+    Type existential, UUID uuid) {
+  auto &ctx = existential->getASTContext();
+  auto signature = ctx.getOpenedArchetypeSignature(existential);
 
   // Allocate and construct the new environment.
   unsigned numGenericParams = signature.getGenericParams().size();
-  size_t bytes = totalSizeToAlloc<OpaqueTypeDecl *, SubstitutionMap, Type>(
-      0, 0, numGenericParams);
+  size_t bytes = totalSizeToAlloc<OpaqueTypeDecl *, SubstitutionMap,
+                                  OpenedGenericEnvironmentData, Type>(
+      0, 0, 1, numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
-  auto env = new (mem) GenericEnvironment(signature, Kind::OpenedExistential);
-  env->addMapping(
-      signature.getGenericParams().front(),
-      Type(const_cast<OpenedArchetypeType *>(type)));
-  return env;
+  return new (mem) GenericEnvironment(signature, existential, uuid);
 }
 
 /// Create a new generic environment for an opaque type with the given set of
@@ -4512,8 +4518,9 @@ GenericEnvironment *GenericEnvironment::forOpaqueType(
   // Allocate and construct the new environment.
   auto signature = opaque->getOpaqueInterfaceGenericSignature();
   unsigned numGenericParams = signature.getGenericParams().size();
-  size_t bytes = totalSizeToAlloc<OpaqueTypeDecl *, SubstitutionMap, Type>(
-      1, 1, numGenericParams);
+  size_t bytes = totalSizeToAlloc<OpaqueTypeDecl *, SubstitutionMap,
+                                  OpenedGenericEnvironmentData, Type>(
+      1, 1, 0, numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment), arena);
   auto env = new (mem) GenericEnvironment(signature, opaque, subs);
   return env;