AST: Move TypeBase::typeEraseOpenedArchetypesWithRoot() into ConstraintSystem.cpp

Author: slavapestov

include/swift/AST/Types.h

@@ -757,10 +757,6 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Retrieve the set of type parameter packs that occur within this type.
   void walkPackReferences(llvm::function_ref<bool (Type)> fn);
 
-  /// Replace opened archetypes with the given root with their most
-  /// specific non-dependent upper bounds throughout this type.
-  Type typeEraseOpenedArchetypesWithRoot(const OpenedArchetypeType *root) const;
-
   /// Given a declaration context, returns a function type with the 'self'
   /// type curried as the input if the declaration context describes a type.
   /// Otherwise, returns the type itself.

include/swift/Sema/ConstraintSystem.h

@@ -5776,12 +5776,19 @@ llvm::Optional<MatchCallArgumentResult> matchCallArguments(
 Expr *getArgumentLabelTargetExpr(Expr *fn);
 
 /// Given a type that includes an existential type that has been opened to
-/// the given type variable, type-erase occurrences of that opened type
-/// variable and anything that depends on it to their non-dependent bounds.
+/// the given type variable, replace the opened type variable and its member
+/// types with their upper bounds.
 Type typeEraseOpenedExistentialReference(Type type, Type existentialBaseType,
                                          TypeVariableType *openedTypeVar,
                                          TypePosition outermostPosition);
 
+
+/// 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);
+
 /// 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

@@ -606,87 +606,6 @@ void TypeBase::getRootOpenedExistentials(
   });
 }
 
-Type TypeBase::typeEraseOpenedArchetypesWithRoot(
-    const OpenedArchetypeType *root) const {
-  assert(root->isRoot() && "Expected a root archetype");
-
-  Type type = Type(const_cast<TypeBase *>(this));
-  if (!hasOpenedExistential())
-    return type;
-
-  auto *env = root->getGenericEnvironment();
-  auto sig = env->getGenericSignature();
-
-  unsigned metatypeDepth = 0;
-
-  std::function<Type(Type)> transformFn;
-  transformFn = [&](Type type) -> Type {
-    return type.transformRec([&](TypeBase *ty) -> llvm::Optional<Type> {
-      // Don't recurse into children unless we have to.
-      if (!ty->hasOpenedExistential())
-        return Type(ty);
-
-      if (isa<MetatypeType>(ty)) {
-        const auto instanceTy = ty->getMetatypeInstanceType();
-        ++metatypeDepth;
-        const auto erasedTy = transformFn(instanceTy);
-        --metatypeDepth;
-
-        if (instanceTy.getPointer() == erasedTy.getPointer()) {
-          return Type(ty);
-        }
-
-        return Type(ExistentialMetatypeType::get(erasedTy));
-      }
-
-      // Opaque types whose substitutions involve this type parameter are
-      // erased to their upper bound.
-      if (auto opaque = dyn_cast<OpaqueTypeArchetypeType>(ty)) {
-        for (auto replacementType :
-                 opaque->getSubstitutions().getReplacementTypes()) {
-          if (replacementType->hasOpenedExistentialWithRoot(root)) {
-            return opaque->getExistentialType();
-          }
-        }
-      }
-
-      if (auto lvalue = dyn_cast<LValueType>(type)) {
-        auto objTy = lvalue->getObjectType();
-        auto erased = transformFn(objTy);
-        if (erased.getPointer() == objTy.getPointer())
-          return Type(lvalue);
-
-        return erased;
-      }
-
-      auto *const archetype = dyn_cast<OpenedArchetypeType>(ty);
-      if (!archetype) {
-        // Recurse.
-        return llvm::None;
-      }
-
-      if (archetype->getGenericEnvironment() != env)
-        return Type(ty);
-
-      Type erasedTy;
-      if (root->isEqual(archetype)) {
-        erasedTy = root->getExistentialType();
-      } else {
-        erasedTy = sig->getUpperBound(archetype->getInterfaceType());
-      }
-
-      if (metatypeDepth) {
-        if (const auto existential = erasedTy->getAs<ExistentialType>())
-          return existential->getConstraintType();
-      }
-
-      return erasedTy;
-    });
-  };
-
-  return transformFn(type);
-}
-
 Type TypeBase::addCurriedSelfType(const DeclContext *dc) {
   if (!dc->isTypeContext())
     return this;

lib/Sema/CSApply.cpp

@@ -880,8 +880,8 @@ namespace {
       Type resultTy;
       resultTy = cs.getType(result);
       if (resultTy->hasOpenedExistentialWithRoot(record.Archetype)) {
-        Type erasedTy = resultTy->typeEraseOpenedArchetypesWithRoot(
-            record.Archetype);
+        Type erasedTy = constraints::typeEraseOpenedArchetypesWithRoot(
+            resultTy, record.Archetype);
         auto range = result->getSourceRange();
         result = coerceToType(result, erasedTy, locator);
         // FIXME: Implement missing tuple-to-tuple conversion
@@ -1590,8 +1590,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 = containerTy->typeEraseOpenedArchetypesWithRoot(
-              knownOpened->second);
+          containerTy = constraints::typeEraseOpenedArchetypesWithRoot(
+              containerTy, knownOpened->second);
           selfTy = containerTy;
         }
       }
@@ -1673,8 +1673,8 @@ namespace {
           // If the base was an opened existential, erase the opened
           // existential.
           if (openedExistential) {
-            refType = refType->typeEraseOpenedArchetypesWithRoot(
-                baseTy->castTo<OpenedArchetypeType>());
+            refType = constraints::typeEraseOpenedArchetypesWithRoot(
+                refType, baseTy->castTo<OpenedArchetypeType>());
           }
 
           return refType;
@@ -1884,8 +1884,8 @@ namespace {
               getConstraintSystem().getConstraintLocator(memberLocator));
           if (knownOpened != solution.OpenedExistentialTypes.end()) {
             curryThunkTy =
-                curryThunkTy
-                    ->typeEraseOpenedArchetypesWithRoot(knownOpened->second)
+                constraints::typeEraseOpenedArchetypesWithRoot(
+                  curryThunkTy, knownOpened->second)
                     ->castTo<FunctionType>();
           }
         }

lib/Sema/ConstraintSystem.cpp

@@ -2266,6 +2266,86 @@ Type constraints::typeEraseOpenedExistentialReference(
   });
 }
 
+Type constraints::typeEraseOpenedArchetypesWithRoot(
+    Type type, const OpenedArchetypeType *root) {
+  assert(root->isRoot() && "Expected a root archetype");
+
+  if (!type->hasOpenedExistential())
+    return type;
+
+  auto *env = root->getGenericEnvironment();
+  auto sig = env->getGenericSignature();
+
+  unsigned metatypeDepth = 0;
+
+  std::function<Type(Type)> transformFn;
+  transformFn = [&](Type type) -> Type {
+    return type.transformRec([&](TypeBase *ty) -> llvm::Optional<Type> {
+      // Don't recurse into children unless we have to.
+      if (!ty->hasOpenedExistential())
+        return Type(ty);
+
+      if (isa<MetatypeType>(ty)) {
+        const auto instanceTy = ty->getMetatypeInstanceType();
+        ++metatypeDepth;
+        const auto erasedTy = transformFn(instanceTy);
+        --metatypeDepth;
+
+        if (instanceTy.getPointer() == erasedTy.getPointer()) {
+          return Type(ty);
+        }
+
+        return Type(ExistentialMetatypeType::get(erasedTy));
+      }
+
+      // Opaque types whose substitutions involve this type parameter are
+      // erased to their upper bound.
+      if (auto opaque = dyn_cast<OpaqueTypeArchetypeType>(ty)) {
+        for (auto replacementType :
+                 opaque->getSubstitutions().getReplacementTypes()) {
+          if (replacementType->hasOpenedExistentialWithRoot(root)) {
+            return opaque->getExistentialType();
+          }
+        }
+      }
+
+      if (auto lvalue = dyn_cast<LValueType>(type)) {
+        auto objTy = lvalue->getObjectType();
+        auto erased = transformFn(objTy);
+        if (erased.getPointer() == objTy.getPointer())
+          return Type(lvalue);
+
+        return erased;
+      }
+
+      auto *const archetype = dyn_cast<OpenedArchetypeType>(ty);
+      if (!archetype) {
+        // Recurse.
+        return llvm::None;
+      }
+
+      if (archetype->getGenericEnvironment() != env)
+        return Type(ty);
+
+      Type erasedTy;
+      if (root->isEqual(archetype)) {
+        erasedTy = root->getExistentialType();
+      } else {
+        erasedTy = sig->getUpperBound(archetype->getInterfaceType());
+      }
+
+      if (metatypeDepth) {
+        if (const auto existential = erasedTy->getAs<ExistentialType>())
+          return existential->getConstraintType();
+      }
+
+      return erasedTy;
+    });
+  };
+
+  return transformFn(type);
+}
+
 Type ConstraintSystem::getMemberReferenceTypeFromOpenedType(
     Type &openedType, Type baseObjTy, ValueDecl *value, DeclContext *outerDC,
     ConstraintLocator *locator, bool hasAppliedSelf,