AST: Remove a few easy usages of getAll{Nested,}Archetypes(), NFC

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -206,8 +206,8 @@ class ASTContext {
   /// The name of the SwiftShims module "SwiftShims".
   Identifier SwiftShimsModuleName;
 
-  /// Note: in non-NDEBUG builds, tracks the context of each archetype
-  /// type, which can be very useful for debugging.
+  /// Note: in non-NDEBUG builds, tracks the context of each primary
+  /// archetype type, which can be very useful for debugging.
   llvm::DenseMap<ArchetypeType *, DeclContext *> ArchetypeContexts;
 
   // Define the set of known identifiers.

include/swift/AST/Types.h

@@ -3748,12 +3748,10 @@ class ArchetypeType final : public SubstitutableType,
   /// True if this is the 'Self' parameter of a protocol or an associated type
   /// of 'Self'.
   bool isSelfDerived() {
-    ArchetypeType *t = this;
+    ArchetypeType *t = getPrimary();
 
-    do {
-      if (t->getSelfProtocol())
-        return true;
-    } while ((t = t->getParent()));
+    if (t && t->getSelfProtocol())
+      return true;
 
     return false;
   }
@@ -3810,6 +3808,16 @@ class ArchetypeType final : public SubstitutableType,
     return ParentOrOpened.isNull();
   }
 
+  /// getPrimary - Return the primary archetype parent of this archetype.
+  ArchetypeType *getPrimary() const {
+    assert(!getOpenedExistentialType() && "Check for opened existential first");
+
+    auto *archetype = this;
+    while (auto *parent = archetype->getParent())
+      archetype = parent;
+    return const_cast<ArchetypeType *>(archetype);
+  }
+
   /// Retrieve the ID number of this opened existential.
   UUID getOpenedExistentialID() const {
     assert(getOpenedExistentialType() && "Not an opened existential archetype");

lib/AST/ASTContext.cpp

@@ -2601,6 +2601,10 @@ void ASTContext::dumpArchetypeContext(ArchetypeType *archetype,
 void ASTContext::dumpArchetypeContext(ArchetypeType *archetype,
                                       llvm::raw_ostream &os,
                                       unsigned indent) const {
+  archetype = archetype->getPrimary();
+  if (!archetype)
+    return;
+
   auto knownDC = ArchetypeContexts.find(archetype);
   if (knownDC != ArchetypeContexts.end())
     knownDC->second->printContext(os, indent);

lib/AST/ASTVerifier.cpp

@@ -78,7 +78,7 @@ struct ASTNodeBase {};
     using ScopeLike = llvm::PointerUnion<DeclContext *, BraceStmt *>;
     SmallVector<ScopeLike, 4> Scopes;
 
-    /// The set of archetypes that are currently available.
+    /// The set of primary archetypes that are currently available.
     SmallPtrSet<ArchetypeType *, 4> ActiveArchetypes;
 
     /// \brief The stack of optional evaluations active at this point.
@@ -106,8 +106,8 @@ struct ASTNodeBase {};
       for (auto genericParams = dc->getGenericParamsOfContext();
            genericParams;
            genericParams = genericParams->getOuterParameters()) {
-        ActiveArchetypes.insert(genericParams->getAllArchetypes().begin(),
-                                genericParams->getAllArchetypes().end());
+        for (auto *param : genericParams->getParams())
+          ActiveArchetypes.insert(param->getArchetype());
       }
     }
 
@@ -446,8 +446,11 @@ struct ASTNodeBase {};
             return false;
           }
 
+          // Get the primary archetype.
+          auto *parent = archetype->getPrimary();
+
           // Otherwise, the archetype needs to be from this scope.
-          if (ActiveArchetypes.count(archetype) == 0) {
+          if (ActiveArchetypes.count(parent) == 0) {
             // FIXME: Make an exception for serialized extensions, which don't
             // currently have the correct archetypes.
             if (auto activeScope = Scopes.back().dyn_cast<DeclContext *>()) {
@@ -463,7 +466,7 @@ struct ASTNodeBase {};
             Out << "AST verification error: archetype "
                 << archetype->getString() << " not allowed in this context\n";
 
-            auto knownDC = Ctx.ArchetypeContexts.find(archetype);
+            auto knownDC = Ctx.ArchetypeContexts.find(parent);
             if (knownDC != Ctx.ArchetypeContexts.end()) {
               llvm::errs() << "archetype came from:\n";
               knownDC->second->dumpContext();
@@ -534,8 +537,9 @@ struct ASTNodeBase {};
 
       // Add any archetypes from this scope into the set of active archetypes.
       if (auto genericParams = getImmediateGenericParams(scope))
-        ActiveArchetypes.insert(genericParams->getAllArchetypes().begin(),
-                                genericParams->getAllArchetypes().end());
+        for (auto *param : genericParams->getParams())
+          if (auto *archetype = param->getArchetype())
+            ActiveArchetypes.insert(archetype);
     }
     void pushScope(BraceStmt *scope) {
       Scopes.push_back(scope);
@@ -546,7 +550,11 @@ struct ASTNodeBase {};
       // Remove archetypes from this scope from the set of active archetypes.
       if (auto genericParams
             = getImmediateGenericParams(Scopes.back().get<DeclContext*>())) {
-        for (auto archetype : genericParams->getAllArchetypes()) {
+        for (auto *param : genericParams->getParams()) {
+          auto *archetype = param->getArchetype();
+          if (archetype == nullptr)
+            continue;
+
           if (!ActiveArchetypes.erase(archetype)) {
             llvm::errs() << "archetype " << archetype
                          << " not introduced by scope?\n";

lib/SIL/SILVerifier.cpp

@@ -49,27 +49,27 @@ static llvm::cl::opt<bool> SkipUnreachableMustBeLastErrors(
 // prevent release builds from triggering spurious unused variable warnings.
 #ifndef NDEBUG
 
-/// Returns true if A is an opened existential type, Self, or is equal to an
-/// archetype in F's nested archetype list.
-///
-/// FIXME: Once Self has been removed in favor of opened existential types
-/// everywhere, remove support for self.
+/// Returns true if A is an opened existential type or is equal to an
+/// archetype from F's generic context.
 static bool isArchetypeValidInFunction(ArchetypeType *A, SILFunction *F) {
-  // The only two cases where an archetype is always legal in a function is if
-  // it is self or if it is from an opened existential type. Currently, Self is
-  // being migrated away from in favor of opened existential types, so we should
-  // remove the special case here for Self when that process is completed.
-  //
-  // *NOTE* Associated types of self are not valid here.
-  if (!A->getOpenedExistentialType().isNull() || A->getSelfProtocol())
+  if (!A->getOpenedExistentialType().isNull())
     return true;
 
-  // Ok, we have an archetype, make sure it is in the nested archetypes of our
-  // caller.
-  for (auto Iter : F->getContextGenericParams()->getAllNestedArchetypes())
-    if (A->isEqual(&*Iter))
-      return true;
-  return A->getIsRecursive();
+  // Find the primary archetype.
+  A = A->getPrimary();
+
+  // Ok, we have a primary archetype, make sure it is in the nested generic
+  // parameters of our caller.
+  for (auto *params = F->getContextGenericParams();
+       params != nullptr;
+       params = params->getOuterParameters()) {
+
+    for (auto param : params->getParams())
+      if (param->getArchetype()->isEqual(A))
+        return true;
+  }
+
+  return false;
 }
 
 namespace {

lib/Sema/TypeCheckGeneric.cpp

@@ -815,7 +815,8 @@ void TypeChecker::finalizeGenericParamList(ArchetypeBuilder &builder,
 
 #ifndef NDEBUG
   // Record archetype contexts.
-  for (auto archetype : genericParams->getAllArchetypes()) {
+  for (auto *param : genericParams->getParams()) {
+    auto *archetype = param->getArchetype();
     if (Context.ArchetypeContexts.count(archetype) == 0)
       Context.ArchetypeContexts[archetype] = dc;
   }