Merge pull request #75984 from slavapestov/clean-up-opened-archetype

Clean up OpenedArchetypeType construction and more

Author: slavapestov

include/swift/AST/LocalArchetypeRequirementCollector.h

@@ -50,6 +50,7 @@ struct MapLocalArchetypesOutOfContext {
                                  ArrayRef<GenericEnvironment *> capturedEnvs)
       : baseGenericSig(baseGenericSig), capturedEnvs(capturedEnvs) {}
 
+  Type getInterfaceType(Type interfaceTy, GenericEnvironment *genericEnv) const;
   Type operator()(SubstitutableType *type) const;
 };
 

include/swift/AST/Types.h

@@ -921,10 +921,6 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// bound.
   bool isClassExistentialType();
 
-  /// Opens an existential instance or meta-type and returns the opened type.
-  Type openAnyExistentialType(OpenedArchetypeType *&opened,
-                              GenericSignature parentSig);
-
   /// Break an existential down into a set of constraints.
   ExistentialLayout getExistentialLayout();
 
@@ -6821,27 +6817,21 @@ class OpenedArchetypeType final : public LocalArchetypeType,
   /// of an existential value.
   ///
   /// \param existential The existential type to open.
-  /// \param parentSig The generic signature of the context opening
-  /// this existential.
-  ///
   /// \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(CanType existential, GenericSignature parentSig,
-      std::optional<UUID> knownID = std::nullopt);
+  get(CanType existential, std::optional<UUID> knownID = std::nullopt);
 
   /// 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 parentSig The generic signature of the context opening
-  /// this existential.
   ///
   /// \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(CanType existential, Type interfaceType, GenericSignature parentSig,
+  get(CanType existential, Type interfaceType,
       std::optional<UUID> knownID = std::nullopt);
 
   /// Create a new archetype that represents the opened type
@@ -6853,10 +6843,7 @@ class OpenedArchetypeType final : public LocalArchetypeType,
   ///
   /// \param existential The existential type or existential metatype to open.
   /// \param interfaceType The interface type represented by this archetype.
-  /// \param parentSig The generic signature of the context opening
-  /// this existential.
-  static CanType getAny(CanType existential, Type interfaceType,
-                        GenericSignature parentSig);
+  static Type getAny(Type existential, Type interfaceType);
 
   /// Create a new archetype that represents the opened type
   /// of an existential value.
@@ -6866,9 +6853,7 @@ class OpenedArchetypeType final : public LocalArchetypeType,
   /// will unwrap any existential metatype containers.
   ///
   /// \param existential The existential type or existential metatype to open.
-  /// \param parentSig The generic signature of the context opening
-  /// this existential.
-  static CanType getAny(CanType existential, GenericSignature parentSig);
+  static Type getAny(Type existential);
 
   /// Retrieve the ID number of this opened existential.
   UUID getOpenedExistentialID() const;

include/swift/SIL/SILCloner.h

@@ -337,11 +337,10 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
   void remapRootOpenedType(CanOpenedArchetypeType archetypeTy) {
     assert(archetypeTy->isRoot());
 
-    auto sig = Builder.getFunction().getGenericSignature();
     auto origExistentialTy = archetypeTy->getExistentialType()
         ->getCanonicalType();
     auto substExistentialTy = getOpASTType(origExistentialTy);
-    auto replacementTy = OpenedArchetypeType::get(substExistentialTy, sig);
+    auto replacementTy = OpenedArchetypeType::get(substExistentialTy);
     registerLocalArchetypeRemapping(archetypeTy, replacementTy);
   }
 

lib/AST/ASTContext.cpp

@@ -5336,50 +5336,53 @@ CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::getNew(
 }
 
 CanTypeWrapper<OpenedArchetypeType>
-OpenedArchetypeType::get(CanType existential, GenericSignature parentSig,
-                         std::optional<UUID> knownID) {
+OpenedArchetypeType::get(CanType existential, std::optional<UUID> knownID) {
   assert(existential->isExistentialType());
   auto interfaceType = OpenedArchetypeType::getSelfInterfaceTypeFromContext(
-      parentSig, existential->getASTContext());
-  return get(existential, interfaceType, parentSig, knownID);
+      GenericSignature(), existential->getASTContext());
+  return get(existential, interfaceType, knownID);
 }
 
 CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
                                                 Type interfaceType,
-                                                GenericSignature parentSig,
                                                 std::optional<UUID> knownID) {
-  assert(!interfaceType->hasArchetype() && "must be interface type");
+  assert(!existential->hasTypeParameter());
 
   if (!knownID)
     knownID = UUID::fromTime();
 
   auto *genericEnv =
-      GenericEnvironment::forOpenedExistential(existential, parentSig, *knownID);
+    GenericEnvironment::forOpenedExistential(
+      existential, GenericSignature(), *knownID);
 
   // Map the interface type into that environment.
   auto result = genericEnv->mapTypeIntoContext(interfaceType)
       ->castTo<OpenedArchetypeType>();
   return CanOpenedArchetypeType(result);
 }
 
-CanType OpenedArchetypeType::getAny(CanType existential, Type interfaceType,
-                                    GenericSignature parentSig) {
+Type OpenedArchetypeType::getAny(Type existential, Type interfaceTy) {
   assert(existential->isAnyExistentialType());
   if (auto metatypeTy = existential->getAs<ExistentialMetatypeType>()) {
     auto instanceTy =
         metatypeTy->getExistentialInstanceType()->getCanonicalType();
-    return CanMetatypeType::get(
-        OpenedArchetypeType::getAny(instanceTy, interfaceType, parentSig));
+    auto openedInstanceTy = OpenedArchetypeType::getAny(
+        instanceTy, interfaceTy);
+    if (metatypeTy->hasRepresentation()) {
+      return MetatypeType::get(openedInstanceTy,
+                               metatypeTy->getRepresentation());
+    }
+    return MetatypeType::get(openedInstanceTy);
   }
   assert(existential->isExistentialType());
-  return OpenedArchetypeType::get(existential, interfaceType, parentSig);
+  return OpenedArchetypeType::get(existential->getCanonicalType(),
+                                  interfaceTy);
 }
 
-CanType OpenedArchetypeType::getAny(CanType existential,
-                                    GenericSignature parentSig) {
+Type OpenedArchetypeType::getAny(Type existential) {
   auto interfaceTy = OpenedArchetypeType::getSelfInterfaceTypeFromContext(
-      parentSig, existential->getASTContext());
-  return getAny(existential, interfaceTy, parentSig);
+      GenericSignature(), existential->getASTContext());
+  return getAny(existential, interfaceTy);
 }
 
 void SubstitutionMap::Storage::Profile(

lib/AST/ASTMangler.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/FileUnit.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/LazyResolver.h"
@@ -2248,12 +2249,15 @@ void ASTMangler::appendOpaqueTypeArchetype(ArchetypeType *archetype,
 
     appendOperator("Qo", Index(genericParam->getIndex()));
   } else {
+    auto *env = archetype->getGenericEnvironment();
+    appendType(env->mapTypeIntoContext(interfaceType->getRootGenericParam()),
+               sig, forDecl);
+
     // Mangle associated types of opaque archetypes like dependent member
     // types, so that they can be accurately demangled at runtime.
-    appendType(Type(archetype->getRoot()), sig, forDecl);
     bool isAssocTypeAtDepth = false;
     appendAssocType(
-        archetype->getInterfaceType()->castTo<DependentMemberType>(),
+        interfaceType->castTo<DependentMemberType>(),
         sig, isAssocTypeAtDepth);
     appendOperator(isAssocTypeAtDepth ? "QX" : "Qx");
   }

lib/AST/ASTPrinter.cpp

@@ -7021,16 +7021,17 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     Printer << "each ";
   }
 
-  void printArchetypeCommon(Type interfaceTy, ArchetypeType *archetypeTy) {
+  void printArchetypeCommon(Type interfaceTy, GenericEnvironment *env) {
     if (auto *paramTy = interfaceTy->getAs<GenericTypeParamType>()) {
-      assert(archetypeTy->isRoot());
-
       if (Options.AlternativeTypeNames) {
-        auto found = Options.AlternativeTypeNames->find(CanType(archetypeTy));
-        if (found != Options.AlternativeTypeNames->end()) {
-          if (paramTy->isParameterPack()) printEach();
-          Printer << found->second.str();
-          return;
+        auto archetypeTy = env->mapTypeIntoContext(paramTy)->getAs<GenericTypeParamType>();
+        if (archetypeTy) {
+          auto found = Options.AlternativeTypeNames->find(CanType(archetypeTy));
+          if (found != Options.AlternativeTypeNames->end()) {
+            if (paramTy->isParameterPack()) printEach();
+            Printer << found->second.str();
+            return;
+          }
         }
       }
 
@@ -7039,18 +7040,18 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
 
     auto *memberTy = interfaceTy->castTo<DependentMemberType>();
-    if (memberTy->getBase()->is<GenericTypeParamType>())
-      visitParentType(archetypeTy->getRoot());
+    if (auto *paramTy = memberTy->getBase()->getAs<GenericTypeParamType>())
+      visitParentType(env->mapTypeIntoContext(paramTy));
     else {
-      printArchetypeCommon(memberTy->getBase(), archetypeTy->getRoot());
+      printArchetypeCommon(memberTy->getBase(), env);
       Printer << ".";
     }
 
     printDependentMember(memberTy);
   }
 
   void visitPrimaryArchetypeType(PrimaryArchetypeType *T) {
-    printArchetypeCommon(T->getInterfaceType(), T);
+    printArchetypeCommon(T->getInterfaceType(), T->getGenericEnvironment());
   }
 
   void visitOpaqueTypeArchetypeType(OpaqueTypeArchetypeType *T) {
@@ -7059,7 +7060,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
     if (!paramTy) {
       assert(interfaceTy->is<DependentMemberType>());
-      printArchetypeCommon(interfaceTy, T);
+      printArchetypeCommon(interfaceTy, T->getGenericEnvironment());
       return;
     }
 
@@ -7144,7 +7145,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitPackArchetypeType(PackArchetypeType *T) {
-    printArchetypeCommon(T->getInterfaceType(), T);
+    printArchetypeCommon(T->getInterfaceType(), T->getGenericEnvironment());
   }
 
   void visitGenericTypeParamType(GenericTypeParamType *T) {

lib/AST/GenericEnvironment.cpp

@@ -149,53 +149,6 @@ UUID GenericEnvironment::getOpenedElementUUID() const {
   return getTrailingObjects<OpenedElementEnvironmentData>()->uuid;
 }
 
-namespace {
-
-struct FindOpenedElementParam {
-  ArrayRef<Type> openedPacks;
-  ArrayRef<GenericTypeParamType *> packElementParams;
-
-  FindOpenedElementParam(const GenericEnvironment *env,
-                         ArrayRef<Type> openedPacks)
-    : openedPacks(openedPacks),
-      packElementParams(
-        env->getGenericSignature().getInnermostGenericParams()) {
-    assert(openedPacks.size() == packElementParams.size());
-  }
-
-  GenericTypeParamType *operator()(Type packParam) {
-    for (auto i : indices(openedPacks)) {
-      if (openedPacks[i]->isEqual(packParam))
-        return packElementParams[i];
-    }
-    llvm_unreachable("parameter was not an opened pack parameter");
-  }
-};
-
-struct FindElementArchetypeForOpenedPackParam {
-  FindOpenedElementParam findElementParam;
-  QueryInterfaceTypeSubstitutions getElementArchetype;
-
-  FindElementArchetypeForOpenedPackParam(const GenericEnvironment *env,
-                                         ArrayRef<Type> openedPacks)
-    : findElementParam(env, openedPacks), getElementArchetype(env) {}
-
-
-  Type operator()(Type interfaceType) {
-    assert(interfaceType->isTypeParameter());
-    if (auto member = interfaceType->getAs<DependentMemberType>()) {
-      auto baseArchetype = (*this)(member->getBase())
-             ->castTo<ElementArchetypeType>();
-      return baseArchetype->getNestedType(member->getAssocType())
-               ->castTo<ElementArchetypeType>();
-    }
-    assert(interfaceType->is<GenericTypeParamType>());
-    return getElementArchetype(findElementParam(interfaceType));
-  }
-};
-
-}
-
 void GenericEnvironment::forEachPackElementArchetype(
           llvm::function_ref<void(ElementArchetypeType *)> function) const {
   auto packElements = getGenericSignature().getInnermostGenericParams();
@@ -652,6 +605,41 @@ Type GenericEnvironment::mapTypeIntoContext(GenericTypeParamType *type) const {
   return result;
 }
 
+namespace {
+
+struct FindElementArchetypeForOpenedPackParam {
+  ArrayRef<Type> openedPacks;
+  ArrayRef<GenericTypeParamType *> packElementParams;
+  const GenericEnvironment *env;
+
+  FindElementArchetypeForOpenedPackParam(const GenericEnvironment *env,
+                                         ArrayRef<Type> openedPacks)
+    : openedPacks(openedPacks),
+      packElementParams(env->getGenericSignature().getInnermostGenericParams()),
+      env(env) {}
+
+  Type getInterfaceType(Type interfaceType) const {
+    if (auto member = interfaceType->getAs<DependentMemberType>()) {
+      return DependentMemberType::get(getInterfaceType(member->getBase()),
+                                      member->getAssocType());
+    }
+
+    assert(interfaceType->is<GenericTypeParamType>());
+    for (auto i : indices(openedPacks)) {
+      if (openedPacks[i]->isEqual(interfaceType))
+        return packElementParams[i];
+    }
+
+    llvm_unreachable("parameter was not an opened pack parameter");
+  }
+
+  Type operator()(Type interfaceType) const {
+    return env->mapTypeIntoContext(getInterfaceType(interfaceType));
+  }
+};
+
+}
+
 /// 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