Change SIL to track all LocalArchetypes and not just OpenedArchetypes.

Author: rjmccall

include/swift/SIL/SILInstruction.h

@@ -685,13 +685,13 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
     return getResultsImpl().getTypes();
   }
 
-  /// Run the given function for each opened archetype this instruction
+  /// Run the given function for each local archetype this instruction
   /// defines, passing the value that should be used to record the
   /// dependency.
-  void forEachDefinedOpenedArchetype(
-      llvm::function_ref<void(CanOpenedArchetypeType archetype,
+  void forEachDefinedLocalArchetype(
+      llvm::function_ref<void(CanLocalArchetypeType archetype,
                               SILValue typeDependency)> function) const;
-  bool definesOpenedArchetypes() const;
+  bool definesLocalArchetypes() const;
 
   MemoryBehavior getMemoryBehavior() const;
   ReleasingBehavior getReleasingBehavior() const;

include/swift/SIL/SILModule.h

@@ -345,22 +345,22 @@ class SILModule {
   /// projections, shared between all functions in the module.
   std::unique_ptr<IndexTrieNode> indexTrieRoot;
 
-  /// A mapping from root opened archetypes to the instructions which define
+  /// A mapping from root local archetypes to the instructions which define
   /// them.
   ///
-  /// The value is either a SingleValueInstruction or a PlaceholderValue, in case
-  /// an opened archetype definition is looked up during parsing or
-  /// deserializing SIL, where opened archetypes can be forward referenced.
+  /// The value is either a SingleValueInstruction or a PlaceholderValue,
+  /// in case a local archetype definition is looked up during parsing or
+  /// deserializing SIL, where local archetypes can be forward referenced.
   ///
   /// In theory we wouldn't need to have the SILFunction in the key, because
-  /// opened archetypes \em should be unique across the module. But currently
-  /// in some rare cases SILGen re-uses the same opened archetype for multiple
+  /// local archetypes \em should be unique across the module. But currently
+  /// in some rare cases SILGen re-uses the same local archetype for multiple
   /// functions.
-  using OpenedArchetypeKey = std::pair<OpenedArchetypeType *, SILFunction *>;
-  llvm::DenseMap<OpenedArchetypeKey, SILValue> RootOpenedArchetypeDefs;
+  using LocalArchetypeKey = std::pair<LocalArchetypeType *, SILFunction *>;
+  llvm::DenseMap<LocalArchetypeKey, SILValue> RootLocalArchetypeDefs;
 
-  /// The number of PlaceholderValues in RootOpenedArchetypeDefs.
-  int numUnresolvedOpenedArchetypes = 0;
+  /// The number of PlaceholderValues in RootLocalArchetypeDefs.
+  int numUnresolvedLocalArchetypes = 0;
 
   /// The options passed into this SILModule.
   const SILOptions &Options;
@@ -444,31 +444,31 @@ class SILModule {
     regDeserializationNotificationHandlerForAllFuncOME = true;
   }
 
-  /// Returns the instruction which defines the given root opened archetype,
+  /// Returns the instruction which defines the given root local archetype,
   /// e.g. an open_existential_addr.
   ///
-  /// In case the opened archetype is not defined yet (e.g. during parsing or
+  /// In case the local archetype is not defined yet (e.g. during parsing or
   /// deserialization), a PlaceholderValue is returned. This should not be the
   /// case outside of parsing or deserialization.
-  SILValue getRootOpenedArchetypeDef(CanOpenedArchetypeType archetype,
-                                     SILFunction *inFunction);
+  SILValue getRootLocalArchetypeDef(CanLocalArchetypeType archetype,
+                                    SILFunction *inFunction);
 
-  /// Returns the instruction which defines the given root opened archetype,
+  /// Returns the instruction which defines the given root local archetype,
   /// e.g. an open_existential_addr.
   ///
-  /// In contrast to getOpenedArchetypeDef, it is required that all opened
+  /// In contrast to getLocalArchetypeDef, it is required that all local
   /// archetypes are resolved.
   SingleValueInstruction *
-  getRootOpenedArchetypeDefInst(CanOpenedArchetypeType archetype,
-                                SILFunction *inFunction) {
+  getRootLocalArchetypeDefInst(CanLocalArchetypeType archetype,
+                               SILFunction *inFunction) {
     return cast<SingleValueInstruction>(
-        getRootOpenedArchetypeDef(archetype, inFunction));
+        getRootLocalArchetypeDef(archetype, inFunction));
   }
 
-  /// Returns true if there are unresolved opened archetypes in the module.
+  /// Returns true if there are unresolved local archetypes in the module.
   ///
   /// This should only be the case during parsing or deserialization.
-  bool hasUnresolvedOpenedArchetypeDefinitions();
+  bool hasUnresolvedLocalArchetypeDefinitions();
 
   /// Get a unique index for a struct or class field in layout order.
   ///

include/swift/SIL/SILType.h

@@ -50,6 +50,7 @@ namespace swift {
 /// this is the task of the type visitor invoking it.
 /// \returns The found opened archetype or empty type otherwise.
 CanOpenedArchetypeType getOpenedArchetypeOf(CanType Ty);
+CanLocalArchetypeType getLocalArchetypeOf(CanType Ty);
 
 /// How an existential type container is represented.
 enum class ExistentialRepresentation {

lib/SIL/IR/SILInstruction.cpp

@@ -1531,17 +1531,17 @@ const ValueBase *SILInstructionResultArray::back() const {
 //                          Defined opened archetypes
 //===----------------------------------------------------------------------===//
 
-bool SILInstruction::definesOpenedArchetypes() const {
+bool SILInstruction::definesLocalArchetypes() const {
   bool definesAny = false;
-  forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType type,
-                                    SILValue dependency) {
+  forEachDefinedLocalArchetype([&](CanLocalArchetypeType type,
+                                   SILValue dependency) {
     definesAny = true;
   });
   return definesAny;
 }
 
-void SILInstruction::forEachDefinedOpenedArchetype(
-      llvm::function_ref<void(CanOpenedArchetypeType, SILValue)> fn) const {
+void SILInstruction::forEachDefinedLocalArchetype(
+      llvm::function_ref<void(CanLocalArchetypeType, SILValue)> fn) const {
   switch (getKind()) {
 #define SINGLE_VALUE_SINGLE_OPEN(TYPE)                                    \
   case SILInstructionKind::TYPE: {                                        \

lib/SIL/IR/SILInstructions.cpp

@@ -45,7 +45,7 @@ static void *allocateTrailingInst(SILFunction &F, CountTypes... counts) {
 
 namespace {
 class TypeDependentOperandCollector {
-  SmallVector<CanOpenedArchetypeType, 4> rootOpenedArchetypes;
+  SmallVector<CanLocalArchetypeType, 4> rootLocalArchetypes;
   bool hasDynamicSelf = false;
 public:
   void collect(CanType type);
@@ -72,27 +72,27 @@ class TypeDependentOperandCollector {
 
 }
 
-/// 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
+/// Collect root open archetypes from a given type into \p RootLocalArchetypes.
+/// \p RootLocalArchetypes is being used as a set. We don't use a real set type
 /// here for performance reasons.
 void TypeDependentOperandCollector::collect(CanType type) {
   if (!type)
     return;
   if (type->hasDynamicSelfType())
     hasDynamicSelf = true;
-  if (!type->hasOpenedExistential())
+  if (!type->hasLocalArchetype())
     return;
   type.visit([&](CanType t) {
-    if (const auto opened = dyn_cast<OpenedArchetypeType>(t)) {
-      const auto root = opened.getRoot();
+    if (const auto local = dyn_cast<LocalArchetypeType>(t)) {
+      const auto root = local.getRoot();
 
-      // Add this root opened archetype if it was not seen yet.
+      // Add this root local 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.
-      if (std::find(rootOpenedArchetypes.begin(), rootOpenedArchetypes.end(),
-                    root) == rootOpenedArchetypes.end())
-        rootOpenedArchetypes.push_back(root);
+      if (std::find(rootLocalArchetypes.begin(), rootLocalArchetypes.end(),
+                    root) == rootLocalArchetypes.end())
+        rootLocalArchetypes.push_back(root);
     }
   });
 }
@@ -112,12 +112,12 @@ void TypeDependentOperandCollector::collect(SubstitutionMap subs) {
 void TypeDependentOperandCollector::addTo(SmallVectorImpl<SILValue> &operands,
                                           SILFunction &F) {
   size_t firstArchetypeOperand = operands.size();
-  for (CanOpenedArchetypeType archetype : rootOpenedArchetypes) {
-    SILValue def = F.getModule().getRootOpenedArchetypeDef(archetype, &F);
+  for (CanLocalArchetypeType archetype : rootLocalArchetypes) {
+    SILValue def = F.getModule().getRootLocalArchetypeDef(archetype, &F);
     assert(def->getFunction() == &F &&
-           "def of root opened archetype is in wrong function");
+           "def of root local archetype is in wrong function");
 
-    // The archetypes in rootOpenedArchetypes have already been uniqued,
+    // The archetypes in rootLocalArchetypes have already been uniqued,
     // but a single instruction can open multiple archetypes (e.g.
     // open_pack_element), so we also unique the actual operand values.
     // As above, we assume there are very few values in practice and so
@@ -130,9 +130,9 @@ void TypeDependentOperandCollector::addTo(SmallVectorImpl<SILValue> &operands,
     operands.push_back(F.getDynamicSelfMetadata());
 }
 
-/// Collects all root opened archetypes from a type and a substitution list, and
+/// Collects all root local 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
+/// We need to know the number of root local archetypes to estimate the number
 /// of corresponding operands for the instruction being formed, because we need
 /// to reserve enough memory for these operands.
 template <class... Sources>

lib/SIL/IR/SILModule.cpp

@@ -124,7 +124,7 @@ SILModule::~SILModule() {
   assert(numAllocatedSlabs == freeSlabs.size() && "leaking slabs in SILModule");
 #endif
 
-  assert(!hasUnresolvedOpenedArchetypeDefinitions());
+  assert(!hasUnresolvedLocalArchetypeDefinitions());
 
   // Decrement ref count for each SILGlobalVariable with static initializers.
   for (SILGlobalVariable &v : silGlobals) {
@@ -259,15 +259,15 @@ void *SILModule::allocateInst(unsigned Size, unsigned Align) const {
 }
 
 void SILModule::willDeleteInstruction(SILInstruction *I) {
-  // Update RootOpenedArchetypeDefs.
-  I->forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType archeTy,
-                                       SILValue dependency) {
-    OpenedArchetypeKey key = {archeTy, I->getFunction()};
+  // Update RootLocalArchetypeDefs.
+  I->forEachDefinedLOcalArchetype([&](CanLocalArchetypeType archeTy,
+                                      SILValue dependency) {
+    LocalArchetypeKey key = {archeTy, I->getFunction()};
     // In case `willDeleteInstruction` is called twice for the
     // same instruction, we need to check if the archetype is really
     // still in the map for this instruction.
-    if (RootOpenedArchetypeDefs.lookup(key) == dependency)
-      RootOpenedArchetypeDefs.erase(key);
+    if (RootLocalArchetypeDefs.lookup(key) == dependency)
+      RootLocalArchetypeDefs.erase(key);
   });
 }
 
@@ -704,21 +704,21 @@ void SILModule::registerDeserializationNotificationHandler(
   deserializationNotificationHandlers.add(std::move(handler));
 }
 
-SILValue SILModule::getRootOpenedArchetypeDef(CanOpenedArchetypeType archetype,
-                                              SILFunction *inFunction) {
+SILValue SILModule::getRootLocalArchetypeDef(CanLocalArchetypeType archetype,
+                                             SILFunction *inFunction) {
   assert(archetype->isRoot());
 
-  SILValue &def = RootOpenedArchetypeDefs[{archetype, inFunction}];
+  SILValue &def = RootLocalArchetypeDefs[{archetype, inFunction}];
   if (!def) {
-    numUnresolvedOpenedArchetypes++;
+    numUnresolvedLocalArchetypes++;
     def = ::new PlaceholderValue(SILType::getPrimitiveAddressType(archetype));
   }
 
   return def;
 }
 
-bool SILModule::hasUnresolvedOpenedArchetypeDefinitions() {
-  return numUnresolvedOpenedArchetypes != 0;
+bool SILModule::hasUnresolvedLocalArchetypeDefinitions() {
+  return numUnresolvedLocalArchetypes != 0;
 }
 
 /// Get a unique index for a struct or class field in layout order.
@@ -764,40 +764,40 @@ unsigned SILModule::getCaseIndex(EnumElementDecl *enumElement) {
 }
 
 void SILModule::notifyAddedInstruction(SILInstruction *inst) {
-  inst->forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType archeTy,
-                                          SILValue dependency) {
-    SILValue &val = RootOpenedArchetypeDefs[{archeTy, inst->getFunction()}];
+  inst->forEachDefinedLocalArchetype([&](CanLocalArchetypeType archeTy,
+                                         SILValue dependency) {
+    SILValue &val = RootLocalArchetypeDefs[{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 root opened archetype in function "
+        llvm::errs() << "re-definition of root local archetype in function "
                      << inst->getFunction()->getName() << ":\n";
         inst->print(llvm::errs());
         llvm::errs() << "previously defined in function "
                      << val->getFunction()->getName() << ":\n";
         val->print(llvm::errs());
         abort();
       }
-      // The opened archetype was unresolved so far. Replace the placeholder
+      // The local archetype was unresolved so far. Replace the placeholder
       // by inst.
       auto *placeholder = cast<PlaceholderValue>(val);
       placeholder->replaceAllUsesWith(dependency);
       ::delete placeholder;
-      numUnresolvedOpenedArchetypes--;
+      numUnresolvedLocalArchetypes--;
     }
     val = dependency;
   });
 }
 
 void SILModule::notifyMovedInstruction(SILInstruction *inst,
                                        SILFunction *fromFunction) {
-  inst->forEachDefinedOpenedArchetype([&](CanOpenedArchetypeType archeTy,
-                                          SILValue dependency) {
-    OpenedArchetypeKey key = {archeTy, fromFunction};
-    assert(RootOpenedArchetypeDefs.lookup(key) == dependency &&
+  inst->forEachDefinedLocalArchetype([&](CanLocalArchetypeType archeTy,
+                                         SILValue dependency) {
+    LocalArchetypeKey key = {archeTy, fromFunction};
+    assert(RootLocalArchetypeDefs.lookup(key) == dependency &&
            "archetype def was not registered");
-    RootOpenedArchetypeDefs.erase(key);
-    RootOpenedArchetypeDefs[{archeTy, inst->getFunction()}] = dependency;
+    RootLocalArchetypeDefs.erase(key);
+    RootLocalArchetypeDefs[{archeTy, inst->getFunction()}] = dependency;
   });
 }
 

lib/SIL/IR/SILType.cpp

@@ -27,7 +27,7 @@
 using namespace swift;
 using namespace swift::Lowering;
 
-/// Find an opened archetype represented by this type.
+/// Find a local archetype represented by this type.
 /// It is assumed by this method that the type contains
 /// at most one opened archetype.
 /// Typically, it would be called from a type visitor.
@@ -36,13 +36,14 @@ using namespace swift::Lowering;
 /// this is the task of the type visitor invoking it.
 /// \returns The found archetype or empty type otherwise.
 CanOpenedArchetypeType swift::getOpenedArchetypeOf(CanType Ty) {
+  return dyn_cast_or_null<CanLocalArchetypeType>(getLocalArchetypeOf(Ty));
+}
+CanLocalArchetypeType swift::getLocalArchetypeOf(CanType Ty) {
   if (!Ty)
-    return CanOpenedArchetypeType();
+    return CanLocalArchetypeType();
   while (auto MetaTy = dyn_cast<AnyMetatypeType>(Ty))
     Ty = MetaTy.getInstanceType();
-  if (Ty->isOpenedExistential())
-    return cast<OpenedArchetypeType>(Ty);
-  return CanOpenedArchetypeType();
+  return dyn_cast<LocalArchetypeType>(Ty);
 }
 
 SILType SILType::getExceptionType(const ASTContext &C) {