Sema: typeEraseOpenedArchetypesWithRoot() => typeEraseOpenedArchetypesFromEnvironment()

Author: slavapestov

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/Sema/CSApply.cpp

@@ -960,8 +960,8 @@ namespace {
       auto *env = record.Archetype->getGenericEnvironment();
 
       if (resultTy->hasLocalArchetypeFromEnvironment(env)) {
-        Type erasedTy = constraints::typeEraseOpenedArchetypesWithRoot(
-            resultTy, record.Archetype);
+        Type erasedTy = constraints::typeEraseOpenedArchetypesFromEnvironment(
+            resultTy, env);
         auto range = result->getSourceRange();
         result = coerceToType(result, erasedTy, locator);
         // FIXME: Implement missing tuple-to-tuple conversion
@@ -1671,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;
         }
       }
@@ -1735,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;
@@ -1961,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/TypeCheckEffects.cpp

@@ -810,17 +810,17 @@ static Type typeEraseOpenedArchetypes(Type type) {
   if (!type || !type->hasOpenedExistential())
     return type;
 
-  const OpenedArchetypeType *root = nullptr;
+  GenericEnvironment *env = nullptr;
   type.visit([&](Type type) {
     if (auto opened = dyn_cast<OpenedArchetypeType>(type.getPointer())) {
-      root = opened->getRoot();
+      env = opened->getGenericEnvironment();
     }
   });
 
-  if (!root)
+  if (!env)
     return type;
 
-  return constraints::typeEraseOpenedArchetypesWithRoot(type, root);
+  return constraints::typeEraseOpenedArchetypesFromEnvironment(type, env);
 }
 
 /// A type expressing the result of classifying whether a call or function