AST: Use new form of getOpenedExistentialSignature() in GenericEnvironment::forOpenedExistential()

Author: slavapestov

include/swift/SIL/SILCloner.h

@@ -245,8 +245,8 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
   /// Register a re-mapping for local archetypes such as opened existentials.
   void registerLocalArchetypeRemapping(GenericEnvironment *From,
                                        GenericEnvironment *To) {
-    ASSERT(From->getGenericSignature()->getMaxDepth()
-           == To->getGenericSignature()->getMaxDepth());
+    ASSERT(From->getGenericSignature().getPointer()
+           == To->getGenericSignature().getPointer());
 
     auto result = Functor.LocalArchetypeSubs.insert(std::make_pair(From, To));
     assert(result.second);
@@ -380,14 +380,14 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
 
   void remapRootOpenedType(CanOpenedArchetypeType archetypeTy) {
     auto *origEnv = archetypeTy->getGenericEnvironment();
+
+    auto genericSig = origEnv->getGenericSignature();
+    auto existentialTy = origEnv->getOpenedExistentialType();
     auto subMap = origEnv->getOuterSubstitutions();
-    ASSERT(!subMap && "Transform the substitution map!");
-    auto origExistentialTy = origEnv->getOpenedExistentialType()
-        ->getCanonicalType();
 
-    auto substExistentialTy = getOpASTType(origExistentialTy);
     auto *newEnv = GenericEnvironment::forOpenedExistential(
-        substExistentialTy, UUID::fromTime());
+        genericSig, existentialTy, getOpSubstitutionMap(subMap),
+        UUID::fromTime());
 
     registerLocalArchetypeRemapping(origEnv, newEnv);
   }

lib/AST/ASTContext.cpp

@@ -5342,22 +5342,21 @@ CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::getNew(
 
 CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
                                                 std::optional<UUID> knownID) {
-  assert(existential->isExistentialType());
-  assert(!existential->hasTypeParameter());
-
-  auto interfaceType = OpenedArchetypeType::getSelfInterfaceTypeFromContext(
-      GenericSignature(), existential->getASTContext());
+  auto &ctx = existential->getASTContext();
+  auto existentialSig = ctx.getOpenedExistentialSignature(existential);
 
   if (!knownID)
     knownID = UUID::fromTime();
 
   auto *genericEnv = GenericEnvironment::forOpenedExistential(
-      existential, *knownID);
+      existentialSig.OpenedSig,
+      existentialSig.Shape,
+      existentialSig.Generalization,
+      *knownID);
 
-  // Map the interface type into that environment.
-  auto result = genericEnv->mapTypeIntoContext(interfaceType)
-      ->castTo<OpenedArchetypeType>();
-  return CanOpenedArchetypeType(result);
+  return cast<OpenedArchetypeType>(
+    genericEnv->mapTypeIntoContext(existentialSig.SelfType)
+      ->getCanonicalType());
 }
 
 Type OpenedArchetypeType::getAny(Type existential) {
@@ -5547,8 +5546,10 @@ GenericEnvironment *GenericEnvironment::forOpaqueType(
 GenericEnvironment *
 GenericEnvironment::forOpenedExistential(Type existential, UUID uuid) {
   auto &ctx = existential->getASTContext();
-  auto signature = ctx.getOpenedExistentialSignature(existential, GenericSignature());
-  return forOpenedExistential(signature, existential, SubstitutionMap(), uuid);
+  auto existentialSig = ctx.getOpenedExistentialSignature(existential);
+  return forOpenedExistential(existentialSig.OpenedSig,
+                              existentialSig.Shape,
+                              existentialSig.Generalization, uuid);
 }
 
 /// Create a new generic environment for an opened archetype.
@@ -6175,26 +6176,24 @@ OpenedExistentialSignature
 ASTContext::getOpenedExistentialSignature(Type type) {
   assert(type->isExistentialType());
 
-  if (auto existential = type->getAs<ExistentialType>())
-    type = existential->getConstraintType();
-
-  const CanType constraint = type->getCanonicalType();
+  auto canType = type->getCanonicalType();
 
   // The constraint type might contain type variables.
-  auto properties = constraint->getRecursiveProperties();
+  auto properties = canType->getRecursiveProperties();
   auto arena = getArena(properties);
 
   // Check the cache.
   const auto &sigs = getImpl().getArena(arena).ExistentialSignatures;
-  auto found = sigs.find(constraint);
+  auto found = sigs.find(canType);
   if (found != sigs.end())
     return found->second;
 
   OpenedExistentialSignature existentialSig;
 
   // Generalize the existential type, to move type variables and primary
   // archetypes into the substitution map.
-  auto gen = ExistentialTypeGeneralization::get(constraint);
+  auto gen = ExistentialTypeGeneralization::get(canType);
+
   existentialSig.Shape = gen.Shape->getCanonicalType();
   existentialSig.Generalization = gen.Generalization;
 
@@ -6212,7 +6211,7 @@ ASTContext::getOpenedExistentialSignature(Type type) {
 
   // Cache the result.
   auto result = getImpl().getArena(arena).ExistentialSignatures.insert(
-      std::make_pair(constraint, existentialSig));
+      std::make_pair(canType, existentialSig));
   ASSERT(result.second);
 
   return existentialSig;

lib/AST/GenericEnvironment.cpp

@@ -295,9 +295,9 @@ Type
 GenericEnvironment::maybeApplyOuterContextSubstitutions(Type type) const {
   switch (getKind()) {
   case Kind::Primary:
-  case Kind::OpenedExistential:
     return type;
 
+  case Kind::OpenedExistential:
   case Kind::OpenedElement:
   case Kind::Opaque: {
     OuterSubstitutions replacer{
@@ -358,25 +358,8 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
   auto genericSig = getGenericSignature();
   auto requirements = genericSig->getLocalRequirements(depType);
 
-  /// Substitute a type for the purpose of requirements.
-  auto substForRequirements = [&](Type type) {
-    switch (getKind()) {
-    case Kind::Primary:
-    case Kind::OpenedExistential:
-      if (type->hasTypeParameter()) {
-        return mapTypeIntoContext(type, LookUpConformanceInModule());
-      } else {
-        return type;
-      }
-    case Kind::OpenedElement:
-    case Kind::Opaque:
-      return maybeApplyOuterContextSubstitutions(type);
-    }
-  };
-
-  if (requirements.concreteType) {
-    return substForRequirements(requirements.concreteType);
-  }
+  if (requirements.concreteType)
+    return mapTypeIntoContext(requirements.concreteType);
 
   assert(requirements.anchor && "No anchor or concrete type?");
 
@@ -404,7 +387,7 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
   // Substitute into the superclass.
   Type superclass = requirements.superclass;
   if (superclass && superclass->hasTypeParameter()) {
-    superclass = substForRequirements(superclass);
+    superclass = mapTypeIntoContext(superclass);
     if (superclass->is<ErrorType>())
       superclass = Type();
   }
@@ -428,14 +411,10 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
     break;
 
   case Kind::Opaque: {
-    assert(!rootGP->isParameterPack());
-
     // If the anchor type isn't rooted in a generic parameter that
     // represents an opaque declaration, then apply the outer substitutions.
     // It would be incorrect to build an opaque type archetype here.
-    unsigned opaqueDepth =
-        getOpaqueTypeDecl()->getOpaqueGenericParams().front()->getDepth();
-    if (rootGP->getDepth() < opaqueDepth) {
+    if (rootGP->getDepth() < genericSig->getMaxDepth()) {
       result = maybeApplyOuterContextSubstitutions(requirements.anchor);
       break;
     }
@@ -447,7 +426,10 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
   }
 
   case Kind::OpenedExistential: {
-    assert(!rootGP->isParameterPack());
+    if (rootGP->getDepth() < genericSig->getMaxDepth()) {
+      result = maybeApplyOuterContextSubstitutions(requirements.anchor);
+      break;
+    }
 
     // FIXME: The existential layout's protocols might differ from the
     // canonicalized set of protocols determined by the generic signature.
@@ -475,10 +457,7 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
   }
 
   case Kind::OpenedElement: {
-    auto packElements = getGenericSignature().getInnermostGenericParams();
-    auto elementDepth = packElements.front()->getDepth();
-
-    if (rootGP->getDepth() < elementDepth) {
+    if (rootGP->getDepth() < genericSig->getMaxDepth()) {
       result = maybeApplyOuterContextSubstitutions(requirements.anchor);
       break;
     }
@@ -536,9 +515,7 @@ Type GenericEnvironment::mapTypeIntoContext(
   Type result = type.subst(QueryInterfaceTypeSubstitutions(this),
                            lookupConformance,
                            SubstFlags::PreservePackExpansionLevel);
-  assert((!result->hasTypeParameter() || result->hasError() ||
-          getKind() == Kind::Opaque) &&
-         "not fully substituted");
+  ASSERT(getKind() != Kind::Primary || !result->hasTypeParameter());
   return result;
 
 }

lib/AST/LocalArchetypeRequirementCollector.cpp

@@ -137,8 +137,9 @@ GenericSignature swift::buildGenericSignatureWithCapturedEnvironments(
       break;
 
     case GenericEnvironment::Kind::OpenedExistential: {
-      auto existentialTy = genericEnv->getOpenedExistentialType()
-          ->mapTypeOutOfContext();
+      auto existentialTy = genericEnv->maybeApplyOuterContextSubstitutions(
+          genericEnv->getOpenedExistentialType())
+              ->mapTypeOutOfContext();
       collector.addOpenedExistential(existentialTy);
       continue;
     }

lib/AST/Type.cpp

@@ -3389,7 +3389,8 @@ Type ArchetypeType::getExistentialType() const {
   // Opened types hold this directly.
   if (auto *opened = dyn_cast<OpenedArchetypeType>(this)) {
     if (opened->isRoot()) {
-      return genericEnv->getOpenedExistentialType();
+      return genericEnv->maybeApplyOuterContextSubstitutions(
+          genericEnv->getOpenedExistentialType());
     }
   }
 
@@ -3398,10 +3399,7 @@ Type ArchetypeType::getExistentialType() const {
   auto genericSig = genericEnv->getGenericSignature();
 
   auto existentialType = genericSig->getExistentialType(interfaceType);
-  if (existentialType->hasTypeParameter())
-    existentialType = genericEnv->mapTypeIntoContext(existentialType);
-
-  return existentialType;
+  return genericEnv->maybeApplyOuterContextSubstitutions(existentialType);
 }
 
 bool ArchetypeType::requiresClass() const {

lib/Sema/TypeCheckType.cpp

@@ -2854,18 +2854,21 @@ TypeResolver::resolveOpenedExistentialArchetype(
 
     archetypeType = ErrorType::get(interfaceType->getASTContext());
   } {
-    // The constraint type is written with respect to the surrounding
-    // generic environment.
-    constraintType = GenericEnvironment::mapTypeIntoContext(
-        resolution.getGenericSignature().getGenericEnvironment(),
-        constraintType);
-
     // The opened existential type is formed by mapping the interface type
     // into a new opened generic environment.
     auto *env = GenericEnvironment::forOpenedExistential(
         constraintType->getCanonicalType(),
         openedAttr->getUUID());
-    return env->mapTypeIntoContext(interfaceType);
+
+    // Rewrite the interface type into one with the correct depth.
+    interfaceType = Type(interfaceType).subst(
+        [&](SubstitutableType *type) -> Type {
+          return env->getGenericSignature().getGenericParams().back();
+        },
+        MakeAbstractConformanceForGenericType());
+
+    archetypeType = env->mapTypeIntoContext(interfaceType);
+    ASSERT(archetypeType->is<OpenedArchetypeType>());
   }
 
   return archetypeType;