Remove nested archetypes

include/swift/AST/ASTMangler.h

@@ -365,6 +365,11 @@ class ASTMangler : public Mangler {
                                      ModuleDecl *fromModule);
   void appendImplFunctionType(SILFunctionType *fn, GenericSignature sig,
                               const ValueDecl *forDecl = nullptr);
+  void appendOpaqueTypeArchetype(ArchetypeType *archetype,
+                                 OpaqueTypeDecl *opaqueDecl,
+                                 SubstitutionMap subs,
+                                 GenericSignature sig,
+                                 const ValueDecl *forDecl);
 
   void appendContextOf(const ValueDecl *decl);
 

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
@@ -72,16 +80,20 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
     Opaque,
   };
 
+  class NestedTypeStorage;
+
 private:
   mutable llvm::PointerIntPair<GenericSignature, 2, Kind> SignatureAndKind{
       GenericSignature(), Kind::Normal};
+  NestedTypeStorage *nestedTypeStorage = nullptr;
 
   friend TrailingObjects;
   friend OpaqueTypeArchetypeType;
 
   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
@@ -93,7 +105,12 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// generic signature.
   ArrayRef<Type> getContextTypes() const;
 
-  explicit GenericEnvironment(GenericSignature signature, Kind kind);
+  /// Get the nested type storage, allocating it if required.
+  NestedTypeStorage &getOrCreateNestedTypeStorage();
+
+  explicit GenericEnvironment(GenericSignature signature);
+  explicit GenericEnvironment(
+      GenericSignature signature, Type existential, UUID uuid);
   explicit GenericEnvironment(
       GenericSignature signature, OpaqueTypeDecl *opaque, SubstitutionMap subs);
 
@@ -102,6 +119,10 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
   Type getOrCreateArchetypeFromInterfaceType(Type depType);
 
+  /// Add a mapping of a generic parameter to a specific type (which may be
+  /// an archetype)
+  void addMapping(GenericParamKey key, Type contextType);
+
   /// Retrieve the mapping for the given generic parameter, if present.
   ///
   /// This is only useful when lazily populating a generic environment.
@@ -116,6 +137,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;
@@ -130,18 +157,13 @@ 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.
   static GenericEnvironment *forOpaqueType(
       OpaqueTypeDecl *opaque, SubstitutionMap subs, AllocationArena arena);
 
-  /// Add a mapping of a generic parameter to a specific type (which may be
-  /// an archetype)
-  void addMapping(GenericParamKey key, Type contextType);
-
   /// Make vanilla new/delete illegal.
   void *operator new(size_t Bytes) = delete;
   void operator delete(void *Data) = delete;

include/swift/AST/GenericSignature.h

@@ -390,6 +390,8 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
 
   bool isCanonicalTypeInContext(Type type) const;
 
+  bool isValidTypeInContext(Type type) const;
+
   /// Retrieve the conformance access path used to extract the conformance of
   /// interface \c type to the given \c protocol.
   ///

include/swift/AST/TypeNodes.def

@@ -147,7 +147,6 @@ ABSTRACT_TYPE(Substitutable, Type)
     ALWAYS_CANONICAL_TYPE(PrimaryArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpaqueTypeArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpenedArchetype, ArchetypeType)
-    ALWAYS_CANONICAL_TYPE(NestedArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(SequenceArchetype, ArchetypeType)
     TYPE_RANGE(Archetype, PrimaryArchetype, SequenceArchetype)
   TYPE(GenericTypeParam, SubstitutableType)