Add ArchetypeType::isRoot() and use it instead of implicit "root" checks

Author: DougGregor

include/swift/AST/Types.h

@@ -5464,7 +5464,10 @@ class ArchetypeType : public SubstitutableType,
 
   /// Return the root archetype parent of this archetype.
   ArchetypeType *getRoot() const;
-  
+
+  /// Determine whether this is a root archetype within the environment.
+  bool isRoot() const;
+
   /// Get the generic environment this archetype lives in.
   GenericEnvironment *getGenericEnvironment() const { return Environment; }
 

lib/AST/ASTVerifier.cpp

@@ -618,13 +618,7 @@ class Verifier : public ASTWalker {
           }
 
           // Get the archetype's generic signature.
-          GenericEnvironment *archetypeEnv;
-          if (auto seq = dyn_cast<SequenceArchetypeType>(root)) {
-            archetypeEnv = seq->getGenericEnvironment();
-          } else {
-            auto rootPrimary = cast<PrimaryArchetypeType>(root);
-            archetypeEnv = rootPrimary->getGenericEnvironment();
-          }
+          GenericEnvironment *archetypeEnv = root->getGenericEnvironment();
           auto archetypeSig = archetypeEnv->getGenericSignature();
 
           auto genericCtx = Generics.back();

lib/AST/SubstitutionMap.cpp

@@ -249,6 +249,10 @@ Type SubstitutionMap::lookupSubstitution(CanSubstitutableType type) const {
   // If we have an archetype, map out of the context so we can compute a
   // conformance access path.
   if (auto archetype = dyn_cast<ArchetypeType>(type)) {
+    // Only consider root archetypes.
+    if (!archetype->isRoot())
+      return Type();
+
     if (!isa<PrimaryArchetypeType>(archetype) &&
         !isa<SequenceArchetypeType>(archetype))
       return Type();

lib/AST/Type.cpp

@@ -3225,6 +3225,10 @@ ArchetypeType *ArchetypeType::getRoot() const {
       Type(gp))->castTo<ArchetypeType>();
 }
 
+bool ArchetypeType::isRoot() const {
+  return getInterfaceType()->is<GenericTypeParamType>();
+}
+
 Type ArchetypeType::getExistentialType() const {
   // Opened types hold this directly.
   if (auto opened = dyn_cast<OpenedArchetypeType>(this))
@@ -4247,21 +4251,19 @@ static Type substType(Type derivedType,
     if (isa<GenericTypeParamType>(substOrig))
       return ErrorType::get(type);
 
-    if (isa<PrimaryArchetypeType>(substOrig))
-      return ErrorType::get(type);
-
-    if (isa<SequenceArchetypeType>(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.
-    if (isa<OpenedArchetypeType>(substOrig))
+    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);
+
     // For nested archetypes, we can substitute the parent.
-    auto nestedArchetype = cast<ArchetypeType>(substOrig);
-    auto parent = nestedArchetype->getParent();
+    auto parent = origArchetype->getParent();
     assert(parent && "Not a nested archetype");
 
     // Substitute into the parent type.
@@ -4273,7 +4275,7 @@ static Type substType(Type derivedType,
       return Type(type);
 
     // Get the associated type reference from a child archetype.
-    AssociatedTypeDecl *assocType = nestedArchetype->getInterfaceType()
+    AssociatedTypeDecl *assocType = origArchetype->getInterfaceType()
         ->castTo<DependentMemberType>()->getAssocType();
 
     return getMemberForBaseType(lookupConformances, parent, substParent,

lib/IRGen/LocalTypeData.cpp

@@ -336,6 +336,8 @@ static void maybeEmitDebugInfoForLocalTypeData(IRGenFunction &IGF,
   auto type = dyn_cast<ArchetypeType>(key.Type);
   if (!type)
     return;
+  if (!type->isRoot())
+    return;
   if (!isa<PrimaryArchetypeType>(type) && !isa<SequenceArchetypeType>(type))
     return;
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -89,9 +89,9 @@ static bool isArchetypeValidInFunction(ArchetypeType *A, const SILFunction *F) {
   auto root = A->getRoot();
   if (!isa<PrimaryArchetypeType>(root) && !isa<SequenceArchetypeType>(root))
     return true;
-  if (isa<OpenedArchetypeType>(A->getRoot()))
+  if (isa<OpenedArchetypeType>(root))
     return true;
-  if (isa<OpaqueTypeArchetypeType>(A->getRoot()))
+  if (isa<OpaqueTypeArchetypeType>(root))
     return true;
 
   // Ok, we have a primary archetype, make sure it is in the nested generic