SILGen: Handle nested opened archetypes and add tests

Author: AnthonyLatsis

include/swift/AST/Types.h

@@ -637,9 +637,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Determine whether the type is an opened existential type with Error inside
   bool isOpenedExistentialWithError();
 
-  /// Retrieve the set of opened existential archetypes that occur
-  /// within this type.
-  void getOpenedExistentials(SmallVectorImpl<OpenedArchetypeType *> &opened);
+  /// Retrieve the set of root opened archetypes that occur within this type.
+  void getRootOpenedExistentials(
+      SmallVectorImpl<OpenedArchetypeType *> &rootOpenedArchetypes) const;
 
   /// Replace opened archetypes with the given root with their most
   /// specific non-dependent upper bounds throughout this type.
@@ -5536,7 +5536,8 @@ class ArchetypeType : public SubstitutableType,
   /// primary archetype.
   ArchetypeType *getParent() const;
 
-  /// Return the root archetype parent of this archetype.
+  /// Return the archetype that represents the root generic parameter of its
+  /// interface type.
   ArchetypeType *getRoot() const;
 
   /// Determine whether this is a root archetype within the environment.
@@ -5773,6 +5774,12 @@ class OpenedArchetypeType final : public ArchetypeType,
   /// Retrieve the opened existential type
   Type getOpenedExistentialType() const;
 
+  /// Return the archetype that represents the root generic parameter of its
+  /// interface type.
+  OpenedArchetypeType *getRoot() const {
+    return cast<OpenedArchetypeType>(ArchetypeType::getRoot());
+  }
+
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::OpenedArchetype;
   }

include/swift/SIL/SILInstruction.h

@@ -1018,9 +1018,9 @@ class SingleValueInstruction : public SILInstruction, public ValueBase {
            node->getKind() <= SILNodeKind::Last_SingleValueInstruction;
   }
 
-  /// If this is an instruction which "defines" an opened archetype, it is
+  /// If this is an instruction which "defines" a root opened archetype, it is
   /// returned.
-  CanArchetypeType getOpenedArchetype() const;
+  CanOpenedArchetypeType getDefinedOpenedArchetype() const;
 
   SILInstruction *getPreviousInstruction() {
     return SILInstruction::getPreviousInstruction();

include/swift/SIL/SILModule.h

@@ -323,20 +323,21 @@ class SILModule {
   /// projections, shared between all functions in the module.
   std::unique_ptr<IndexTrieNode> indexTrieRoot;
 
-  /// A mapping from opened archetypes to the instructions which define them.
+  /// A mapping from root opened archetypes to the instructions which define
+  /// them.
   ///
   /// The value is either a SingleValueInstrution or a PlaceholderValue, in case
-  /// an opened-archetype definition is lookedup during parsing or deserializing
-  /// SIL, where opened archetypes can be forward referenced.
+  /// an opened archetype definition is looked up during parsing or
+  /// deserializing SIL, where opened archetypes can be forward referenced.
   ///
   /// In theory we wouldn't need to have the SILFunction in the key, because
-  /// opened archetypes _should_ be unique across the module. But currently
+  /// opened archetypes \em should be unique across the module. But currently
   /// in some rare cases SILGen re-uses the same opened archetype for multiple
   /// functions.
-  using OpenedArchetypeKey = std::pair<ArchetypeType*, SILFunction*>;
-  llvm::DenseMap<OpenedArchetypeKey, SILValue> openedArchetypeDefs;
+  using OpenedArchetypeKey = std::pair<OpenedArchetypeType *, SILFunction *>;
+  llvm::DenseMap<OpenedArchetypeKey, SILValue> RootOpenedArchetypeDefs;
 
-  /// The number of PlaceholderValues in openedArchetypeDefs.
+  /// The number of PlaceholderValues in RootOpenedArchetypeDefs.
   int numUnresolvedOpenedArchetypes = 0;
 
   /// The options passed into this SILModule.
@@ -408,24 +409,25 @@ class SILModule {
     regDeserializationNotificationHandlerForAllFuncOME = true;
   }
 
-  /// Returns the instruction which defines an opened archetype, e.g. an
-  /// open_existential_addr.
+  /// Returns the instruction which defines the given root opened archetype,
+  /// e.g. an open_existential_addr.
   ///
   /// In case the opened archetype is not defined yet (e.g. during parsing or
   /// deserilization), a PlaceholderValue is returned. This should not be the
   /// case outside of parsing or deserialization.
-  SILValue getOpenedArchetypeDef(CanArchetypeType archetype,
-                                 SILFunction *inFunction);
+  SILValue getRootOpenedArchetypeDef(CanOpenedArchetypeType archetype,
+                                     SILFunction *inFunction);
 
-  /// Returns the instruction which defines an opened archetype, e.g. an
-  /// open_existential_addr.
+  /// Returns the instruction which defines the given root opened archetype,
+  /// e.g. an open_existential_addr.
   ///
   /// In contrast to getOpenedArchetypeDef, it is required that all opened
   /// archetypes are resolved.
-  SingleValueInstruction *getOpenedArchetypeInst(CanArchetypeType archetype,
-                                                 SILFunction *inFunction) {
-    return cast<SingleValueInstruction>(getOpenedArchetypeDef(archetype,
-                                                              inFunction));
+  SingleValueInstruction *
+  getRootOpenedArchetypeDefInst(CanOpenedArchetypeType archetype,
+                                SILFunction *inFunction) {
+    return cast<SingleValueInstruction>(
+        getRootOpenedArchetypeDef(archetype, inFunction));
   }
 
   /// Returns true if there are unresolved opened archetypes in the module.

include/swift/SIL/SILType.h

@@ -46,8 +46,8 @@ namespace swift {
 /// It checks only the type itself, but does not try to
 /// recursively check any children of this type, because
 /// this is the task of the type visitor invoking it.
-/// \returns The found archetype or empty type otherwise.
-CanArchetypeType getOpenedArchetypeOf(CanType Ty);
+/// \returns The found opened archetype or empty type otherwise.
+CanOpenedArchetypeType getOpenedArchetypeOf(CanType Ty);
 
 /// How an existential type container is represented.
 enum class ExistentialRepresentation {

lib/AST/Type.cpp

@@ -455,19 +455,20 @@ bool TypeBase::hasOpenedExistentialWithRoot(
   });
 }
 
-void TypeBase::getOpenedExistentials(
-       SmallVectorImpl<OpenedArchetypeType *> &opened) {
+void TypeBase::getRootOpenedExistentials(
+    SmallVectorImpl<OpenedArchetypeType *> &rootOpenedArchetypes) const {
   if (!hasOpenedExistential())
     return;
 
-  SmallPtrSet<ArchetypeType *, 4> known;
+  SmallPtrSet<OpenedArchetypeType *, 4> known;
   getCanonicalType().findIf([&](Type type) -> bool {
-    auto archetype = dyn_cast<OpenedArchetypeType>(type.getPointer());
+    auto *archetype = dyn_cast<OpenedArchetypeType>(type.getPointer());
     if (!archetype)
       return false;
 
-    if (known.insert(archetype).second)
-      opened.push_back(archetype);
+    auto *root = archetype->getRoot();
+    if (known.insert(root).second)
+      rootOpenedArchetypes.push_back(root);
 
     return false;
   });
@@ -3329,6 +3330,10 @@ ArchetypeType *ArchetypeType::getParent() const {
 }
 
 ArchetypeType *ArchetypeType::getRoot() const {
+  if (isRoot()) {
+    return const_cast<ArchetypeType *>(this);
+  }
+
   auto gp = InterfaceType->getRootGenericParam();
   assert(gp && "Missing root generic parameter?");
   return getGenericEnvironment()->mapTypeIntoContext(
@@ -4447,16 +4452,16 @@ static Type substType(Type derivedType,
     if (isa<GenericTypeParamType>(substOrig))
       return ErrorType::get(type);
 
-    // Opened existentials cannot be substituted in this manner,
-    // but if they appear in the original type this is not an
-    // error.
     auto origArchetype = cast<ArchetypeType>(substOrig);
-    if (isa<OpenedArchetypeType>(origArchetype->getRoot()))
-      return Type(type);
-
-    // Root archetypes must already have been substituted above.
-    if (origArchetype->isRoot())
-      return ErrorType::get(type);
+    if (origArchetype->isRoot()) {
+      // Root opened archetypes are not required to be substituted. Other root
+      // archetypes must already have been substituted above.
+      if (isa<OpenedArchetypeType>(origArchetype)) {
+        return Type(type);
+      } else {
+        return ErrorType::get(type);
+      }
+    }
 
     // For nested archetypes, we can substitute the parent.
     auto parent = origArchetype->getParent();

lib/SIL/IR/SILInstruction.cpp

@@ -1571,21 +1571,21 @@ const ValueBase *SILInstructionResultArray::back() const {
 //                           SingleValueInstruction
 //===----------------------------------------------------------------------===//
 
-CanArchetypeType SingleValueInstruction::getOpenedArchetype() const {
+CanOpenedArchetypeType
+SingleValueInstruction::getDefinedOpenedArchetype() const {
   switch (getKind()) {
   case SILInstructionKind::OpenExistentialAddrInst:
   case SILInstructionKind::OpenExistentialRefInst:
   case SILInstructionKind::OpenExistentialBoxInst:
   case SILInstructionKind::OpenExistentialBoxValueInst:
   case SILInstructionKind::OpenExistentialMetatypeInst:
   case SILInstructionKind::OpenExistentialValueInst: {
-    auto Ty = getOpenedArchetypeOf(getType().getASTType());
-    assert(Ty && Ty->isOpenedExistential() &&
-           "Type should be an opened archetype");
+    const auto Ty = getOpenedArchetypeOf(getType().getASTType());
+    assert(Ty && Ty->isRoot() && "Type should be a root opened archetype");
     return Ty;
   }
   default:
-    return CanArchetypeType();
+    return CanOpenedArchetypeType();
   }
 }
 

lib/SIL/IR/SILInstructions.cpp

@@ -41,70 +41,69 @@ static void *allocateTrailingInst(SILFunction &F, CountTypes... counts) {
              alignof(Inst));
 }
 
-// Collect used open archetypes from a given type into the \p openedArchetypes.
-// \p openedArchetypes is being used as a set. We don't use a real set type here
-// for performance reasons.
-static void
-collectDependentTypeInfo(CanType Ty,
-                         SmallVectorImpl<CanArchetypeType> &openedArchetypes,
-                         bool &hasDynamicSelf) {
+/// Collect root open archetypes from a given type into \p RootOpenedArchetypes.
+/// \p RootOpenedArchetypes is being used as a set. We don't use a real set type
+/// here for performance reasons.
+static void collectDependentTypeInfo(
+    CanType Ty, SmallVectorImpl<CanOpenedArchetypeType> &RootOpenedArchetypes,
+    bool &hasDynamicSelf) {
   if (!Ty)
     return;
   if (Ty->hasDynamicSelfType())
     hasDynamicSelf = true;
   if (!Ty->hasOpenedExistential())
     return;
   Ty.visit([&](CanType t) {
-    if (t->isOpenedExistential()) {
-      // Add this opened archetype if it was not seen yet.
+    if (const auto opened = dyn_cast<OpenedArchetypeType>(t)) {
+      const auto root = cast<OpenedArchetypeType>(CanType(opened->getRoot()));
+
+      // Add this root opened archetype if it was not seen yet.
       // We don't use a set here, because the number of open archetypes
       // is usually very small and using a real set may introduce too
       // much overhead.
-      auto archetypeTy = cast<ArchetypeType>(t);
-      if (std::find(openedArchetypes.begin(), openedArchetypes.end(),
-                    archetypeTy) == openedArchetypes.end())
-        openedArchetypes.push_back(archetypeTy);
+      if (std::find(RootOpenedArchetypes.begin(), RootOpenedArchetypes.end(),
+                    root) == RootOpenedArchetypes.end())
+        RootOpenedArchetypes.push_back(root);
     }
   });
 }
 
-// Takes a set of open archetypes as input and produces a set of
-// references to open archetype definitions.
+/// Takes a set of root opened archetypes as input and produces a set of
+/// references to their definitions.
 static void buildTypeDependentOperands(
-    SmallVectorImpl<CanArchetypeType> &OpenedArchetypes,
-    bool hasDynamicSelf,
-    SmallVectorImpl<SILValue> &TypeDependentOperands, SILFunction &F) {
+    SmallVectorImpl<CanOpenedArchetypeType> &RootOpenedArchetypes,
+    bool hasDynamicSelf, SmallVectorImpl<SILValue> &TypeDependentOperands,
+    SILFunction &F) {
 
-  for (auto archetype : OpenedArchetypes) {
-    SILValue def = F.getModule().getOpenedArchetypeDef(archetype, &F);
+  for (const auto archetype : RootOpenedArchetypes) {
+    SILValue def = F.getModule().getRootOpenedArchetypeDef(archetype, &F);
     assert(def->getFunction() == &F &&
-           "def of opened archetype is in wrong function");
+           "def of root opened archetype is in wrong function");
     TypeDependentOperands.push_back(def);
   }
   if (hasDynamicSelf)
     TypeDependentOperands.push_back(F.getDynamicSelfMetadata());
 }
 
-// Collects all opened archetypes from a type and a substitutions list and form
-// a corresponding list of opened archetype operands.
-// We need to know the number of opened archetypes to estimate
-// the number of opened archetype operands for the instruction
-// being formed, because we need to reserve enough memory
-// for these operands.
+/// Collects all root opened archetypes from a type and a substitution list, and
+/// forms a corresponding list of operands.
+/// We need to know the number of root opened archetypes to estimate the number
+/// of corresponding operands for the instruction being formed, because we need
+/// to reserve enough memory for these operands.
 static void collectTypeDependentOperands(
                       SmallVectorImpl<SILValue> &TypeDependentOperands,
                       SILFunction &F,
                       CanType Ty,
                       SubstitutionMap subs = { }) {
-  SmallVector<CanArchetypeType, 4> openedArchetypes;
+  SmallVector<CanOpenedArchetypeType, 4> RootOpenedArchetypes;
   bool hasDynamicSelf = false;
-  collectDependentTypeInfo(Ty, openedArchetypes, hasDynamicSelf);
+  collectDependentTypeInfo(Ty, RootOpenedArchetypes, hasDynamicSelf);
   for (Type replacement : subs.getReplacementTypes()) {
     // Substitutions in SIL should really be canonical.
     auto ReplTy = replacement->getCanonicalType();
-    collectDependentTypeInfo(ReplTy, openedArchetypes, hasDynamicSelf);
+    collectDependentTypeInfo(ReplTy, RootOpenedArchetypes, hasDynamicSelf);
   }
-  buildTypeDependentOperands(openedArchetypes, hasDynamicSelf,
+  buildTypeDependentOperands(RootOpenedArchetypes, hasDynamicSelf,
                              TypeDependentOperands, F);
 }
 

lib/SIL/IR/SILModule.cpp

@@ -245,13 +245,14 @@ void *SILModule::allocateInst(unsigned Size, unsigned Align) const {
 }
 
 void SILModule::willDeleteInstruction(SILInstruction *I) {
-  // Update openedArchetypeDefs.
+  // Update RootOpenedArchetypeDefs.
   if (auto *svi = dyn_cast<SingleValueInstruction>(I)) {
-    if (CanArchetypeType archeTy = svi->getOpenedArchetype()) {
+    if (const CanOpenedArchetypeType archeTy =
+            svi->getDefinedOpenedArchetype()) {
       OpenedArchetypeKey key = {archeTy, svi->getFunction()};
-      assert(openedArchetypeDefs.lookup(key) == svi &&
+      assert(RootOpenedArchetypeDefs.lookup(key) == svi &&
              "archetype def was not registered");
-      openedArchetypeDefs.erase(key);
+      RootOpenedArchetypeDefs.erase(key);
     }
   }
 }
@@ -761,9 +762,11 @@ void SILModule::registerDeserializationNotificationHandler(
   deserializationNotificationHandlers.add(std::move(handler));
 }
 
-SILValue SILModule::getOpenedArchetypeDef(CanArchetypeType archetype,
-                                          SILFunction *inFunction) {
-  SILValue &def = openedArchetypeDefs[{archetype, inFunction}];
+SILValue SILModule::getRootOpenedArchetypeDef(CanOpenedArchetypeType archetype,
+                                              SILFunction *inFunction) {
+  assert(archetype->isRoot());
+
+  SILValue &def = RootOpenedArchetypeDefs[{archetype, inFunction}];
   if (!def) {
     numUnresolvedOpenedArchetypes++;
     def = ::new PlaceholderValue(SILType::getPrimitiveAddressType(archetype));
@@ -778,12 +781,13 @@ bool SILModule::hasUnresolvedOpenedArchetypeDefinitions() {
 
 void SILModule::notifyAddedInstruction(SILInstruction *inst) {
   if (auto *svi = dyn_cast<SingleValueInstruction>(inst)) {
-    if (CanArchetypeType archeTy = svi->getOpenedArchetype()) {
-      SILValue &val = openedArchetypeDefs[{archeTy, inst->getFunction()}];
+    if (const CanOpenedArchetypeType archeTy =
+            svi->getDefinedOpenedArchetype()) {
+      SILValue &val = RootOpenedArchetypeDefs[{archeTy, inst->getFunction()}];
       if (val) {
         if (!isa<PlaceholderValue>(val)) {
           // Print a useful error message (and not just abort with an assert).
-          llvm::errs() << "re-definition of opened archetype in function "
+          llvm::errs() << "re-definition of root opened archetype in function "
                        << svi->getFunction()->getName() << ":\n";
           svi->print(llvm::errs());
           llvm::errs() << "previously defined in function "
@@ -806,12 +810,13 @@ void SILModule::notifyAddedInstruction(SILInstruction *inst) {
 void SILModule::notifyMovedInstruction(SILInstruction *inst,
                                        SILFunction *fromFunction) {
   if (auto *svi = dyn_cast<SingleValueInstruction>(inst)) {
-    if (CanArchetypeType archeTy = svi->getOpenedArchetype()) {
+    if (const CanOpenedArchetypeType archeTy =
+            svi->getDefinedOpenedArchetype()) {
       OpenedArchetypeKey key = {archeTy, fromFunction};
-      assert(openedArchetypeDefs.lookup(key) == svi &&
+      assert(RootOpenedArchetypeDefs.lookup(key) == svi &&
              "archetype def was not registered");
-      openedArchetypeDefs.erase(key);
-      openedArchetypeDefs[{archeTy, svi->getFunction()}] = svi;
+      RootOpenedArchetypeDefs.erase(key);
+      RootOpenedArchetypeDefs[{archeTy, svi->getFunction()}] = svi;
     }
   }
 }