Merge pull request #75966 from slavapestov/more-removal-of-root

Remove some usages of ArchetypeType::getRoot()

Author: slavapestov

include/swift/AST/Types.h

@@ -752,9 +752,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
     return getRecursiveProperties().hasParameterizedExistential();
   }
 
-  /// Determine whether the type involves the given opened existential
-  /// archetype.
-  bool hasOpenedExistentialWithRoot(const OpenedArchetypeType *root) const;
+  /// Determine whether the type involves a local archetype from the given
+  /// environment.
+  bool hasLocalArchetypeFromEnvironment(GenericEnvironment *env) const;
 
   /// Determine whether the type involves an opaque type.
   bool hasOpaqueArchetype() const {

include/swift/Sema/ConstraintSystem.h

@@ -5972,8 +5972,8 @@ Type typeEraseOpenedExistentialReference(Type type, Type existentialBaseType,
 /// Given a type that includes opened existential archetypes derived from
 /// the given generic environment, replace the archetypes with their upper
 /// bounds.
-Type typeEraseOpenedArchetypesWithRoot(Type type,
-                                       const OpenedArchetypeType *root);
+Type typeEraseOpenedArchetypesFromEnvironment(Type type,
+                                              GenericEnvironment *env);
 
 /// Returns true if a reference to a member on a given base type will apply
 /// its curried self parameter, assuming it has one.

lib/AST/Type.cpp

@@ -520,19 +520,14 @@ bool TypeBase::isSpecialized() {
   return false;
 }
 
-bool TypeBase::hasOpenedExistentialWithRoot(
-    const OpenedArchetypeType *root) const {
-  assert(root->isRoot() && "Expected a root archetype");
-
-  if (!hasOpenedExistential())
+bool TypeBase::hasLocalArchetypeFromEnvironment(
+    GenericEnvironment *env) const {
+  if (!hasLocalArchetype())
     return false;
 
   return getCanonicalType().findIf([&](Type type) -> bool {
-    auto *opened = dyn_cast<OpenedArchetypeType>(type.getPointer());
-    if (!opened)
-      return false;
-
-    return opened->getRoot() == root;
+    auto *local = dyn_cast<LocalArchetypeType>(type.getPointer());
+    return local && local->getGenericEnvironment() == env;
   });
 }
 

lib/AST/TypeSubstitution.cpp

@@ -1123,14 +1123,8 @@ static bool canSubstituteTypeInto(Type ty, const DeclContext *dc,
                                   bool isContextWholeModule) {
   TypeDecl *typeDecl = ty->getAnyNominal();
   if (!typeDecl) {
-    // The referenced type might be a different opaque result type.
-
-    // First, unwrap any nested associated types to get the root archetype.
-    if (auto nestedTy = ty->getAs<ArchetypeType>())
-      ty = nestedTy->getRoot();
-
-    // If the root archetype is an opaque result type, check that its
-    // descriptor is accessible.
+    // If the referenced type is a different opaque result type,
+    // check that its descriptor is accessible.
     if (auto opaqueTy = ty->getAs<OpaqueTypeArchetypeType>())
       typeDecl = opaqueTy->getDecl();
   }

lib/IDE/CompletionLookup.cpp

@@ -259,19 +259,13 @@ void CompletionLookup::foundFunction(const AnyFunctionType *AFT) {
 
 bool CompletionLookup::canBeUsedAsRequirementFirstType(Type selfTy,
                                                        TypeAliasDecl *TAD) {
-  auto T = TAD->getDeclaredInterfaceType();
-  auto subMap = selfTy->getMemberSubstitutionMap(TAD);
-  T = T.subst(subMap)->getCanonicalType();
-
-  ArchetypeType *archeTy = T->getAs<ArchetypeType>();
-  if (!archeTy)
+  if (TAD->isGeneric())
     return false;
-  archeTy = archeTy->getRoot();
 
-  // For protocol, the 'archeTy' should match with the 'baseTy' which is the
-  // dynamic 'Self' type of the protocol. For nominal decls, 'archTy' should
-  // be one of the generic params in 'selfTy'. Search 'archeTy' in 'baseTy'.
-  return selfTy.findIf([&](Type T) { return archeTy->isEqual(T); });
+  auto T = TAD->getDeclaredInterfaceType();
+  auto subMap = selfTy->getContextSubstitutionMap(TAD->getDeclContext());
+
+  return T.subst(subMap)->is<ArchetypeType>();
 }
 
 CompletionLookup::CompletionLookup(CodeCompletionResultSink &Sink,

lib/IRGen/GenType.cpp

@@ -1981,11 +1981,8 @@ ArchetypeType *TypeConverter::getExemplarArchetype(ArchetypeType *t) {
 
   assert(isa<PrimaryArchetypeType>(t) || isa<PackArchetypeType>(t));
 
-  // Get the root archetype.
-  auto root = t->getRoot();
-
   // Retrieve the generic environment of the archetype.
-  auto genericEnv = root->getGenericEnvironment();
+  auto genericEnv = t->getGenericEnvironment();
 
   // Dig out the canonical generic environment.
   auto genericSig = genericEnv->getGenericSignature();
@@ -2815,11 +2812,10 @@ void IRGenFunction::setDynamicSelfMetadata(CanType selfClass,
 
 #ifndef NDEBUG
 bool TypeConverter::isExemplarArchetype(ArchetypeType *arch) const {
-  auto primary = arch->getRoot();
-  if (!isa<PrimaryArchetypeType>(primary) &&
-      !isa<PackArchetypeType>(primary))
+  if (!isa<PrimaryArchetypeType>(arch) &&
+      !isa<PackArchetypeType>(arch))
     return true;
-  auto genericEnv = primary->getGenericEnvironment();
+  auto genericEnv = arch->getGenericEnvironment();
 
   // Dig out the canonical generic environment.
   auto genericSig = genericEnv->getGenericSignature();

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -947,7 +947,9 @@ static bool canReplaceCopiedArg(FullApplySite Apply, SILValue Arg,
 static bool applyInvolvesOpenedArchetypeWithRoot(FullApplySite Apply,
                                                  OpenedArchetypeType *RootOA,
                                                  unsigned SkipArgIdx) {
-  if (Apply.getType().getASTType()->hasOpenedExistentialWithRoot(RootOA)) {
+  auto *env = RootOA->getGenericEnvironment();
+
+  if (Apply.getType().getASTType()->hasLocalArchetypeFromEnvironment(env)) {
     return true;
   }
 
@@ -958,7 +960,7 @@ static bool applyInvolvesOpenedArchetypeWithRoot(FullApplySite Apply,
     if (Apply.getArgument(Idx)
             ->getType()
             .getASTType()
-            ->hasOpenedExistentialWithRoot(RootOA)) {
+            ->hasLocalArchetypeFromEnvironment(env)) {
       return true;
     }
   }

lib/Sema/CSApply.cpp

@@ -956,9 +956,12 @@ namespace {
       // If we had a return type of 'Self', erase it.
       Type resultTy;
       resultTy = cs.getType(result);
-      if (resultTy->hasOpenedExistentialWithRoot(record.Archetype)) {
-        Type erasedTy = constraints::typeEraseOpenedArchetypesWithRoot(
-            resultTy, record.Archetype);
+
+      auto *env = record.Archetype->getGenericEnvironment();
+
+      if (resultTy->hasLocalArchetypeFromEnvironment(env)) {
+        Type erasedTy = constraints::typeEraseOpenedArchetypesFromEnvironment(
+            resultTy, env);
         auto range = result->getSourceRange();
         result = coerceToType(result, erasedTy, locator);
         // FIXME: Implement missing tuple-to-tuple conversion
@@ -1668,8 +1671,8 @@ namespace {
         } else {
           // Erase opened existentials from the type of the thunk; we're
           // going to open the existential inside the thunk's body.
-          containerTy = constraints::typeEraseOpenedArchetypesWithRoot(
-              containerTy, knownOpened->second);
+          containerTy = constraints::typeEraseOpenedArchetypesFromEnvironment(
+              containerTy, knownOpened->second->getGenericEnvironment());
           selfTy = containerTy;
         }
       }
@@ -1732,8 +1735,8 @@ namespace {
           // If the base was an opened existential, erase the opened
           // existential.
           if (openedExistential) {
-            refType = constraints::typeEraseOpenedArchetypesWithRoot(
-                refType, baseTy->castTo<OpenedArchetypeType>());
+            refType = constraints::typeEraseOpenedArchetypesFromEnvironment(
+                refType, baseTy->castTo<OpenedArchetypeType>()->getGenericEnvironment());
           }
 
           return refType;
@@ -1958,8 +1961,8 @@ namespace {
               getConstraintSystem().getConstraintLocator(memberLocator));
           if (knownOpened != solution.OpenedExistentialTypes.end()) {
             curryThunkTy =
-                constraints::typeEraseOpenedArchetypesWithRoot(
-                  curryThunkTy, knownOpened->second)
+                constraints::typeEraseOpenedArchetypesFromEnvironment(
+                  curryThunkTy, knownOpened->second->getGenericEnvironment())
                     ->castTo<FunctionType>();
           }
         }

lib/Sema/ConstraintSystem.cpp

@@ -2449,15 +2449,14 @@ Type constraints::typeEraseOpenedExistentialReference(
       /*force=*/false);
 }
 
-Type constraints::typeEraseOpenedArchetypesWithRoot(
-    Type type, const OpenedArchetypeType *root) {
-  assert(root->isRoot() && "Expected a root archetype");
+Type constraints::typeEraseOpenedArchetypesFromEnvironment(
+    Type type, GenericEnvironment *env) {
+  assert(env->getKind() == GenericEnvironment::Kind::OpenedExistential);
 
-  auto *env = root->getGenericEnvironment();
   auto sig = env->getGenericSignature();
 
   return typeEraseExistentialSelfReferences(
-      type, root->getExistentialType(), TypePosition::Covariant, sig,
+      type, env->getOpenedExistentialType(), TypePosition::Covariant, sig,
       /*containsFn=*/[](Type t) {
         return t->hasOpenedExistential();
       },

lib/Sema/TypeCheckConstraints.cpp

@@ -1007,10 +1007,9 @@ static Type replaceArchetypesWithTypeVariables(ConstraintSystem &cs,
         return found->second;
 
       if (auto archetypeType = dyn_cast<ArchetypeType>(origType)) {
-        auto root = archetypeType->getRoot();
-        // For other nested types, fail here so the default logic in subst()
+        // For nested types, fail here so the default logic in subst()
         // for nested types applies.
-        if (root != archetypeType)
+        if (!archetypeType->getInterfaceType()->is<GenericTypeParamType>())
           return Type();
 
         auto locator = cs.getConstraintLocator({});