Convert DeclContext Parameters to their Associated Generic Signatures Instead

Author: CodaFi

include/swift/AST/ASTContext.h

@@ -1308,7 +1308,7 @@ class ASTContext final {
   /// conformances inherited from superclass constraints while existential
   /// values do.
   CanGenericSignature getOpenedArchetypeSignature(Type type,
-                                                  const DeclContext *useDC);
+                                                  GenericSignature parentSig);
 
   GenericSignature getOverrideGenericSignature(const ValueDecl *base,
                                                const ValueDecl *derived);

include/swift/AST/GenericEnvironment.h

@@ -158,13 +158,28 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
   /// Create a new generic environment for an opened existential.
   ///
+  /// This function uses the provided parent signature to construct a new
+  /// signature suitable for use with an opened archetype. If you have an
+  /// existing generic signature from e.g. deserialization use
+  /// \c GenericEnvironment::forOpenedArchetypeSignature instead.
+  ///
   /// \param existential The subject existential type
-  /// \param useDC The decl context where this existential type is being opened
+  /// \param parentSig The signature of the context where this existential type is being opened
   /// \param uuid The unique identifier for this opened existential
   static GenericEnvironment *
-  forOpenedExistential(Type existential, const DeclContext *useDC, UUID uuid);
+  forOpenedExistential(Type existential, GenericSignature parentSig, UUID uuid);
+
+  /// Create a new generic environment for an opened existential.
+  ///
+  /// It is unlikely you want to use this function.
+  /// Call \c GenericEnvironment::forOpenedExistential instead.
+  ///
+  /// \param existential The subject existential type
+  /// \param signature The signature of the opened archetype
+  /// \param uuid The unique identifier for this opened existential
   static GenericEnvironment *
-  forOpenedExistential(Type existential, GenericSignature signature, UUID uuid);
+  forOpenedArchetypeSignature(Type existential,
+                              GenericSignature signature, UUID uuid);
 
   /// Create a new generic environment for an opaque type with the given set of
   /// outer substitutions.

include/swift/AST/Types.h

@@ -765,7 +765,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   /// Opens an existential instance or meta-type and returns the opened type.
   Type openAnyExistentialType(OpenedArchetypeType *&opened,
-                              const DeclContext *useDC);
+                              GenericSignature parentSig);
 
   /// Break an existential down into a set of constraints.
   ExistentialLayout getExistentialLayout();
@@ -5748,51 +5748,67 @@ class OpenedArchetypeType final : public ArchetypeType,
 
 public:
   /// Compute the parameter that serves as the \c Self type for an opened
-  /// archetype from the given declaration context.
+  /// archetype from the given outer generic signature.
   ///
-  /// For protocol extensions, this type is the context's \c Self type. For
-  /// all other contexts, this type is a generic parameter one level deeper
+  /// This type is a generic parameter one level deeper
   /// than the deepest generic context depth.
-  static Type getSelfInterfaceTypeFromContext(const DeclContext *useDC);
+  static Type getSelfInterfaceTypeFromContext(GenericSignature parentSig,
+                                              ASTContext &ctx);
 
 public:
   /// Get or create an archetype that represents the opened type
   /// of an existential value.
   ///
   /// \param existential The existential type to open.
+  /// \param parentSig The generic signature of the context opening
+  /// this existential.
   ///
   /// \param knownID When non-empty, the known ID of the archetype. When empty,
   /// a fresh archetype with a unique ID will be opened.
   static CanTypeWrapper<OpenedArchetypeType> get(CanType existential,
-                                                 const DeclContext *useDC,
+                                                 GenericSignature parentSig,
                                                  Optional<UUID> knownID = None);
 
   /// Get or create an archetype that represents the opened type
   /// of an existential value.
   ///
   /// \param existential The existential type to open.
   /// \param interfaceType The interface type represented by this archetype.
+  /// \param parentSig The generic signature of the context opening
+  /// this existential.
   ///
   /// \param knownID When non-empty, the known ID of the archetype. When empty,
   /// a fresh archetype with a unique ID will be opened.
   static CanTypeWrapper<OpenedArchetypeType> get(CanType existential,
                                                  Type interfaceType,
-                                                 const DeclContext *useDC,
+                                                 GenericSignature parentSig,
                                                  Optional<UUID> knownID = None);
 
   /// Create a new archetype that represents the opened type
   /// of an existential value.
   ///
+  /// Use this function when you are unsure of whether the
+  /// \c existential type is a metatype or an instance type. This function
+  /// will unwrap any existential metatype containers.
+  ///
   /// \param existential The existential type or existential metatype to open.
   /// \param interfaceType The interface type represented by this archetype.
+  /// \param parentSig The generic signature of the context opening
+  /// this existential.
   static CanType getAny(CanType existential, Type interfaceType,
-                        const DeclContext *useDC);
+                        GenericSignature parentSig);
 
   /// Create a new archetype that represents the opened type
   /// of an existential value.
   ///
+  /// Use this function when you are unsure of whether the
+  /// \c existential type is a metatype or an instance type. This function
+  /// will unwrap any existential metatype containers.
+  ///
   /// \param existential The existential type or existential metatype to open.
-  static CanType getAny(CanType existential, const DeclContext *useDC);
+  /// \param parentSig The generic signature of the context opening
+  /// this existential.
+  static CanType getAny(CanType existential, GenericSignature parentSig);
 
   /// Retrieve the ID number of this opened existential.
   UUID getOpenedExistentialID() const;

include/swift/SIL/SILCloner.h

@@ -254,7 +254,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
 
     auto sig = archetypeTy->getGenericEnvironment()->getGenericSignature();
     auto existentialTy = archetypeTy->getExistentialType()->getCanonicalType();
-    auto env = GenericEnvironment::forOpenedExistential(
+    auto env = GenericEnvironment::forOpenedArchetypeSignature(
         getOpASTType(existentialTy), sig, UUID::fromTime());
     auto replacementTy =
         env->mapTypeIntoContext(archetypeTy->getInterfaceType())

include/swift/SIL/SILFunction.h

@@ -1049,6 +1049,10 @@ class SILFunction
     GenericEnv = env;
   }
 
+  /// Retrieve the generic signature from the generic environment of this
+  /// function, if any. Else returns the null \c GenericSignature.
+  GenericSignature getGenericSignature() const;
+
   /// Map the given type, which is based on an interface SILFunctionType and may
   /// therefore be dependent, to a type based on the context archetypes of this
   /// SILFunction.

lib/AST/ASTContext.cpp

@@ -328,7 +328,7 @@ struct ASTContext::Implementation {
   CanGenericSignature SingleGenericParameterSignature;
 
   /// The existential signature <T : P> for each P.
-  llvm::DenseMap<std::pair<CanType, const DeclContext *>, CanGenericSignature>
+  llvm::DenseMap<std::pair<CanType, const GenericSignatureImpl *>, CanGenericSignature>
       ExistentialSignatures;
 
   /// Overridden declarations.
@@ -4441,17 +4441,18 @@ CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::getNew(
 }
 
 CanTypeWrapper<OpenedArchetypeType>
-OpenedArchetypeType::get(CanType existential, const DeclContext *useDC,
+OpenedArchetypeType::get(CanType existential, GenericSignature parentSig,
                          Optional<UUID> knownID) {
-  return get(existential,
-             OpenedArchetypeType::getSelfInterfaceTypeFromContext(useDC),
-             useDC, knownID);
+  assert(existential->isExistentialType());
+  auto interfaceType = OpenedArchetypeType::getSelfInterfaceTypeFromContext(parentSig, existential->getASTContext());
+  return get(existential, interfaceType, parentSig, knownID);
 }
 
 CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
                                                 Type interfaceType,
-                                                const DeclContext *useDC,
+                                                GenericSignature parentSig,
                                                 Optional<UUID> knownID) {
+  assert(existential->isExistentialType());
   assert(!interfaceType->hasArchetype() && "must be interface type");
   // FIXME: Opened archetypes can't be transformed because the
   // the identity of the archetype has to be preserved. This
@@ -4485,7 +4486,7 @@ CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
 
   /// Create a generic environment for this opened archetype.
   auto genericEnv =
-      GenericEnvironment::forOpenedExistential(existential, useDC, *knownID);
+      GenericEnvironment::forOpenedExistential(existential, parentSig, *knownID);
   openedExistentialEnvironments[*knownID] = genericEnv;
 
   // Map the interface type into that environment.
@@ -4495,22 +4496,22 @@ CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
 }
 
 CanType OpenedArchetypeType::getAny(CanType existential, Type interfaceType,
-                                    const DeclContext *useDC) {
+                                    GenericSignature parentSig) {
+  assert(existential->isAnyExistentialType());
   if (auto metatypeTy = existential->getAs<ExistentialMetatypeType>()) {
     auto instanceTy =
         metatypeTy->getExistentialInstanceType()->getCanonicalType();
     return CanMetatypeType::get(
-        OpenedArchetypeType::getAny(instanceTy, interfaceType, useDC));
+        OpenedArchetypeType::getAny(instanceTy, interfaceType, parentSig));
   }
   assert(existential->isExistentialType());
-  return OpenedArchetypeType::get(existential, interfaceType, useDC);
+  return OpenedArchetypeType::get(existential, interfaceType, parentSig);
 }
 
 CanType OpenedArchetypeType::getAny(CanType existential,
-                                    const DeclContext *useDC) {
-  return getAny(existential,
-                OpenedArchetypeType::getSelfInterfaceTypeFromContext(useDC),
-                useDC);
+                                    GenericSignature parentSig) {
+  auto interfaceTy = OpenedArchetypeType::getSelfInterfaceTypeFromContext(parentSig, existential->getASTContext());
+  return getAny(existential, interfaceTy, parentSig);
 }
 
 void SubstitutionMap::Storage::Profile(
@@ -4666,19 +4667,14 @@ GenericEnvironment *GenericEnvironment::getIncomplete(
 
 /// Create a new generic environment for an opened archetype.
 GenericEnvironment *
-GenericEnvironment::forOpenedExistential(Type existential,
-                                         const DeclContext *useDC, UUID uuid) {
+GenericEnvironment::forOpenedExistential(
+    Type existential, GenericSignature parentSig, UUID uuid) {
   auto &ctx = existential->getASTContext();
-  auto signature = ctx.getOpenedArchetypeSignature(existential, useDC);
-
-  SubstitutionMap subs;
-  if (auto *useEnvironment = useDC->getGenericEnvironmentOfContext()) {
-    subs = useEnvironment->getForwardingSubstitutionMap();
-  }
-  return GenericEnvironment::forOpenedExistential(existential, signature, uuid);
+  auto signature = ctx.getOpenedArchetypeSignature(existential, parentSig);
+  return GenericEnvironment::forOpenedArchetypeSignature(existential, signature, uuid);
 }
 
-GenericEnvironment *GenericEnvironment::forOpenedExistential(
+GenericEnvironment *GenericEnvironment::forOpenedArchetypeSignature(
     Type existential, GenericSignature signature, UUID uuid) {
   // Allocate and construct the new environment.
   auto &ctx = existential->getASTContext();
@@ -5187,22 +5183,19 @@ CanGenericSignature ASTContext::getSingleGenericParameterSignature() const {
   return canonicalSig;
 }
 
-Type OpenedArchetypeType::getSelfInterfaceTypeFromContext(const DeclContext *useDC) {
-  auto typeContext = useDC->getInnermostTypeContext();
-  if (typeContext && typeContext->getSelfProtocolDecl()) {
-    return typeContext->getProtocolSelfType();
-  } else {
-    return GenericTypeParamType::get(
-        /*isTypeSequence=*/false,
-        /*depth*/ useDC->getGenericContextDepth() + 1, /*index*/ 0,
-        useDC->getASTContext());
-  }
+Type OpenedArchetypeType::getSelfInterfaceTypeFromContext(GenericSignature parentSig,
+                                                          ASTContext &ctx) {
+  unsigned depth = 0;
+  if (!parentSig.getGenericParams().empty())
+    depth = parentSig.getGenericParams().back()->getDepth() + 1;
+  return GenericTypeParamType::get(/*isTypeSequence=*/ false,
+                                   /*depth=*/ depth, /*index=*/ 0,
+                                   ctx);
 }
 
 CanGenericSignature
-ASTContext::getOpenedArchetypeSignature(Type type, const DeclContext *useDC) {
+ASTContext::getOpenedArchetypeSignature(Type type, GenericSignature parentSig) {
   assert(type->isExistentialType());
-  assert(useDC && "Must have a working declaration context!");
 
   if (auto existential = type->getAs<ExistentialType>())
     type = existential->getConstraintType();
@@ -5213,7 +5206,7 @@ ASTContext::getOpenedArchetypeSignature(Type type, const DeclContext *useDC) {
   // The opened archetype signature for a protocol type is identical
   // to the protocol's own canonical generic signature if there aren't any
   // outer generic parameters to worry about.
-  if (!useDC->isGenericContext()) {
+  if (parentSig.isNull()) {
     if (const auto protoTy = dyn_cast<ProtocolType>(constraint)) {
       return protoTy->getDecl()->getGenericSignature().getCanonicalSignature();
     }
@@ -5222,31 +5215,23 @@ ASTContext::getOpenedArchetypeSignature(Type type, const DeclContext *useDC) {
   // Otherwise we need to build a generic signature that captures any outer
   // generic parameters. This ensures that we keep e.g. generic superclass
   // existentials contained in a well-formed generic context.
-  auto found = getImpl().ExistentialSignatures.find({constraint, useDC});
+  auto canParentSig = parentSig.getCanonicalSignature();
+  auto found = getImpl().ExistentialSignatures.find({constraint, canParentSig.getPointer()});
   if (found != getImpl().ExistentialSignatures.end())
     return found->second;
 
-  GenericSignature outerSignature;
-  auto *typeContext = useDC->getInnermostTypeContext();
-  if (typeContext && typeContext->getSelfProtocolDecl()) {
-    outerSignature = GenericSignature();
-  } else {
-    outerSignature = useDC->getGenericSignatureOfContext();
-  }
-
-  auto genericParam = OpenedArchetypeType::getSelfInterfaceTypeFromContext(useDC)
-                        ->getCanonicalType()->getAs<GenericTypeParamType>();
-
+  auto genericParam = OpenedArchetypeType::getSelfInterfaceTypeFromContext(canParentSig, type->getASTContext())
+    ->castTo<GenericTypeParamType>();
   Requirement requirement(RequirementKind::Conformance, genericParam,
                           constraint);
   auto genericSig = buildGenericSignature(
-      *this, outerSignature.getCanonicalSignature(),
+      *this, canParentSig,
       {genericParam}, {requirement});
 
   CanGenericSignature canGenericSig(genericSig);
 
   auto result = getImpl().ExistentialSignatures.insert(
-      std::make_pair(std::make_pair(constraint, useDC), canGenericSig));
+      std::make_pair(std::make_pair(constraint, canParentSig.getPointer()), canGenericSig));
   assert(result.second);
   (void) result;
 

lib/AST/Decl.cpp

@@ -4100,7 +4100,8 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
     return GenericParameterReferenceInfo();
 
   const auto sig =
-      getASTContext().getOpenedArchetypeSignature(baseTy, useDC);
+      getASTContext().getOpenedArchetypeSignature(baseTy,
+                                                  useDC->getGenericSignatureOfContext());
   auto genericParam = sig.getGenericParams().front();
   return findGenericParameterReferences(
       this, sig, genericParam, treatNonResultCovariantSelfAsInvariant, None);

lib/AST/GenericSignature.cpp

@@ -472,7 +472,7 @@ bool GenericSignatureImpl::isValidTypeInContext(Type type) const {
 
 ArrayRef<CanTypeWrapper<GenericTypeParamType>>
 CanGenericSignature::getGenericParams() const {
-  auto params = getPointer()->getGenericParams().getOriginalArray();
+  auto params = this->GenericSignature::getGenericParams().getOriginalArray();
   auto base = static_cast<const CanTypeWrapper<GenericTypeParamType>*>(
                                                               params.data());
   return {base, params.size()};

lib/AST/Type.cpp

@@ -480,7 +480,7 @@ Type TypeBase::typeEraseOpenedArchetypesWithRoot(
     return type;
 
   const auto sig = root->getASTContext().getOpenedArchetypeSignature(
-      root->getExistentialType(), useDC);
+      root->getExistentialType(), useDC->getGenericSignatureOfContext());
 
   unsigned metatypeDepth = 0;
 
@@ -4008,7 +4008,8 @@ CanType ProtocolCompositionType::getMinimalCanonicalType(
 
   // Use generic signature minimization: the requirements of the signature will
   // represent the minimal composition.
-  const auto Sig = Ctx.getOpenedArchetypeSignature(CanTy, useDC);
+  auto sig = useDC->getGenericSignatureOfContext();
+  const auto Sig = Ctx.getOpenedArchetypeSignature(CanTy, sig);
   const auto &Reqs = Sig.getRequirements();
   if (Reqs.size() == 1) {
     return Reqs.front().getSecondType()->getCanonicalType();
@@ -4017,7 +4018,7 @@ CanType ProtocolCompositionType::getMinimalCanonicalType(
   Type superclass;
   llvm::SmallVector<Type, 2> MinimalMembers;
   bool MinimalHasExplicitAnyObject = false;
-  auto ifaceTy = OpenedArchetypeType::getSelfInterfaceTypeFromContext(useDC);
+  auto ifaceTy = Sig.getGenericParams().back();
   for (const auto &Req : Reqs) {
     if (!Req.getFirstType()->isEqual(ifaceTy)) {
       continue;
@@ -5994,17 +5995,19 @@ SILBoxType::SILBoxType(ASTContext &C,
 }
 
 Type TypeBase::openAnyExistentialType(OpenedArchetypeType *&opened,
-                                      const DeclContext *useDC) {
+                                      GenericSignature parentSig) {
   assert(isAnyExistentialType());
   if (auto metaty = getAs<ExistentialMetatypeType>()) {
     opened = OpenedArchetypeType::get(
-        metaty->getExistentialInstanceType()->getCanonicalType(), useDC);
+        metaty->getExistentialInstanceType()->getCanonicalType(),
+        parentSig.getCanonicalSignature());
     if (metaty->hasRepresentation())
       return MetatypeType::get(opened, metaty->getRepresentation());
     else
       return MetatypeType::get(opened);
   }
-  opened = OpenedArchetypeType::get(getCanonicalType(), useDC);
+  opened = OpenedArchetypeType::get(getCanonicalType(),
+                                    parentSig.getCanonicalSignature());
   return opened;
 }