Add a DeclContext Parameter to Opened Archetype Construction

This ensures that opened archetypes always inherit any outer generic parameters from the context in which they reside. This matters because class bounds may bind generic parameters from these outer contexts, and without the outer context you can wind up with ill-formed generic environments like

<τ_0_0, where τ_0_0 : C<T>, τ_0_0 : P>

Where T is otherwise unbound because there is no entry for it among the generic parameters of the environment's associated generic signature.

Author: CodaFi

include/swift/AST/ASTContext.h

@@ -1298,8 +1298,6 @@ class ASTContext final {
   CanGenericSignature getSingleGenericParameterSignature() const;
 
   /// Retrieve a generic signature with a single type parameter conforming
-  /// to the given protocol or composition type, like <T: type>.
-  CanGenericSignature getOpenedArchetypeSignature(Type type);
   /// to the given protocol or composition type, like <T: P>.
   ///
   /// The opened archetype may have a different set of conformances from the
@@ -1309,6 +1307,8 @@ class ASTContext final {
   /// particular, the opened archetype signature does not have requirements for
   /// conformances inherited from superclass constraints while existential
   /// values do.
+  CanGenericSignature getOpenedArchetypeSignature(Type type,
+                                                  const DeclContext *useDC);
 
   GenericSignature getOverrideGenericSignature(const ValueDecl *base,
                                                const ValueDecl *derived);

include/swift/AST/Decl.h

@@ -2693,7 +2693,8 @@ class ValueDecl : public Decl {
   /// property, or the uncurried result type of a method/subscript, e.g.
   /// '() -> () -> Self'.
   GenericParameterReferenceInfo findExistentialSelfReferences(
-      Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
+      Type baseTy, const DeclContext *useDC,
+      bool treatNonResultCovariantSelfAsInvariant) const;
 };
 
 /// This is a common base class for declarations which declare a type.

include/swift/AST/GenericEnvironment.h

@@ -157,7 +157,14 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   GenericEnvironment *getIncomplete(GenericSignature signature);
 
   /// Create a new generic environment for an opened existential.
-  static GenericEnvironment *forOpenedExistential(Type existential, UUID uuid);
+  ///
+  /// \param existential The subject existential type
+  /// \param useDC The decl 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);
+  static GenericEnvironment *
+  forOpenedExistential(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

@@ -507,7 +507,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Canonical protocol composition types are minimized only to a certain
   /// degree to preserve ABI compatibility. This routine enables performing
   /// slower, but stricter minimization at need (e.g. redeclaration checking).
-  CanType getMinimalCanonicalType() const;
+  CanType getMinimalCanonicalType(const DeclContext *useDC) const;
 
   /// Reconstitute type sugar, e.g., for array types, dictionary
   /// types, optionals, etc.
@@ -648,7 +648,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   /// Replace opened archetypes with the given root with their most
   /// specific non-dependent upper bounds throughout this type.
-  Type typeEraseOpenedArchetypesWithRoot(const OpenedArchetypeType *root) const;
+  Type typeEraseOpenedArchetypesWithRoot(const OpenedArchetypeType *root,
+                                         const DeclContext *useDC) const;
 
   /// Given a declaration context, returns a function type with the 'self'
   /// type curried as the input if the declaration context describes a type.
@@ -763,7 +764,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
   bool isClassExistentialType();
 
   /// Opens an existential instance or meta-type and returns the opened type.
-  Type openAnyExistentialType(OpenedArchetypeType *&opened);
+  Type openAnyExistentialType(OpenedArchetypeType *&opened,
+                              const DeclContext *useDC);
 
   /// Break an existential down into a set of constraints.
   ExistentialLayout getExistentialLayout();
@@ -5189,7 +5191,7 @@ class ProtocolCompositionType final : public TypeBase,
   /// Canonical protocol composition types are minimized only to a certain
   /// degree to preserve ABI compatibility. This routine enables performing
   /// slower, but stricter minimization at need (e.g. redeclaration checking).
-  CanType getMinimalCanonicalType() const;
+  CanType getMinimalCanonicalType(const DeclContext *useDC) const;
 
   /// Retrieve the set of members composed to create this type.
   ///
@@ -5752,8 +5754,9 @@ class OpenedArchetypeType final : public ArchetypeType,
   ///
   /// \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, Optional<UUID> knownID = None);
+  static CanTypeWrapper<OpenedArchetypeType> get(CanType existential,
+                                                 const DeclContext *useDC,
+                                                 Optional<UUID> knownID = None);
 
   /// Get or create an archetype that represents the opened type
   /// of an existential value.
@@ -5763,21 +5766,24 @@ class OpenedArchetypeType final : public ArchetypeType,
   ///
   /// \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, Optional<UUID> knownID = None);
+  static CanTypeWrapper<OpenedArchetypeType> get(CanType existential,
+                                                 Type interfaceType,
+                                                 const DeclContext *useDC,
+                                                 Optional<UUID> knownID = None);
 
   /// Create a new archetype that represents the opened type
   /// of an existential value.
   ///
   /// \param existential The existential type or existential metatype to open.
   /// \param interfaceType The interface type represented by this archetype.
-  static CanType getAny(CanType existential, Type interfaceType);
+  static CanType getAny(CanType existential, Type interfaceType,
+                        const DeclContext *useDC);
 
   /// Create a new archetype that represents the opened type
   /// of an existential value.
   ///
   /// \param existential The existential type or existential metatype to open.
-  static CanType getAny(CanType existential);
+  static CanType getAny(CanType existential, const DeclContext *useDC);
 
   /// Retrieve the ID number of this opened existential.
   UUID getOpenedExistentialID() const;

include/swift/SIL/SILCloner.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_SIL_SILCLONER_H
 #define SWIFT_SIL_SILCLONER_H
 
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/DebugUtils.h"
@@ -251,10 +252,13 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
   void remapRootOpenedType(CanOpenedArchetypeType archetypeTy) {
     assert(archetypeTy->isRoot());
 
+    auto sig = archetypeTy->getGenericEnvironment()->getGenericSignature();
     auto existentialTy = archetypeTy->getExistentialType()->getCanonicalType();
-    auto replacementTy = OpenedArchetypeType::get(
-        getOpASTType(existentialTy),
-        archetypeTy->getInterfaceType());
+    auto env = GenericEnvironment::forOpenedExistential(
+        getOpASTType(existentialTy), sig, UUID::fromTime());
+    auto replacementTy =
+        env->mapTypeIntoContext(archetypeTy->getInterfaceType())
+            ->template castTo<OpenedArchetypeType>();
     registerOpenedExistentialRemapping(archetypeTy, replacementTy);
   }
 

include/swift/Sema/ConstraintSystem.h

@@ -5585,7 +5585,8 @@ Expr *getArgumentLabelTargetExpr(Expr *fn);
 /// the given type variable, type-erase occurences of that opened type
 /// variable and anything that depends on it to their non-dependent bounds.
 Type typeEraseOpenedExistentialReference(Type type, Type existentialBaseType,
-                                         TypeVariableType *openedTypeVar);
+                                         TypeVariableType *openedTypeVar,
+                                         const DeclContext *useDC);
 
 /// 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/ASTContext.cpp

@@ -328,7 +328,8 @@ struct ASTContext::Implementation {
   CanGenericSignature SingleGenericParameterSignature;
 
   /// The existential signature <T : P> for each P.
-  llvm::DenseMap<CanType, CanGenericSignature> ExistentialSignatures;
+  llvm::DenseMap<std::pair<CanType, const DeclContext *>, CanGenericSignature>
+      ExistentialSignatures;
 
   /// Overridden declarations.
   llvm::DenseMap<const ValueDecl *, ArrayRef<ValueDecl *>> Overrides;
@@ -4421,6 +4422,12 @@ CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::getNew(
     GenericEnvironment *environment, Type interfaceType,
     ArrayRef<ProtocolDecl *> conformsTo, Type superclass,
     LayoutConstraint layout) {
+  // FIXME: It'd be great if all of our callers could submit interface types.
+  // But the constraint solver submits archetypes when trying to issue checks
+  // against members of existential types. For now, we'll work around them by
+  // forcing an interface type.
+  //  assert((!superclass || !superclass->hasArchetype())
+  //         && "superclass must be interface type");
   auto arena = AllocationArena::Permanent;
   ASTContext &ctx = interfaceType->getASTContext();
   void *mem = ctx.Allocate(
@@ -4434,16 +4441,21 @@ CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::getNew(
       environment, interfaceType, conformsTo, superclass, layout));
 }
 
-CanTypeWrapper<OpenedArchetypeType> OpenedArchetypeType::get(
-    CanType existential, Optional<UUID> knownID) {
+CanTypeWrapper<OpenedArchetypeType>
+OpenedArchetypeType::get(CanType existential, const DeclContext *useDC,
+                         Optional<UUID> knownID) {
   Type interfaceType = GenericTypeParamType::get(
-      /*isTypeSequence=*/false, 0, 0, existential->getASTContext());
-  return get(existential, interfaceType, knownID);
+      /*isTypeSequence=*/false,
+      /*depth*/ useDC->getGenericContextDepth() + 1, /*index*/ 0,
+      existential->getASTContext());
+  return get(existential, interfaceType, useDC, knownID);
 }
 
 CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
                                                 Type interfaceType,
+                                                const DeclContext *useDC,
                                                 Optional<UUID> knownID) {
+  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
   // means that simplifying an opened archetype in the constraint
@@ -4475,8 +4487,8 @@ CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
   }
 
   /// Create a generic environment for this opened archetype.
-  auto genericEnv = GenericEnvironment::forOpenedExistential(
-      existential, *knownID);
+  auto genericEnv =
+      GenericEnvironment::forOpenedExistential(existential, useDC, *knownID);
   openedExistentialEnvironments[*knownID] = genericEnv;
 
   // Map the interface type into that environment.
@@ -4485,22 +4497,24 @@ CanOpenedArchetypeType OpenedArchetypeType::get(CanType existential,
   return CanOpenedArchetypeType(result);
 }
 
-
-CanType OpenedArchetypeType::getAny(CanType existential, Type interfaceType) {
+CanType OpenedArchetypeType::getAny(CanType existential, Type interfaceType,
+                                    const DeclContext *useDC) {
   if (auto metatypeTy = existential->getAs<ExistentialMetatypeType>()) {
     auto instanceTy =
         metatypeTy->getExistentialInstanceType()->getCanonicalType();
     return CanMetatypeType::get(
-        OpenedArchetypeType::getAny(instanceTy, interfaceType));
+        OpenedArchetypeType::getAny(instanceTy, interfaceType, useDC));
   }
   assert(existential->isExistentialType());
-  return OpenedArchetypeType::get(existential, interfaceType);
+  return OpenedArchetypeType::get(existential, interfaceType, useDC);
 }
 
-CanType OpenedArchetypeType::getAny(CanType existential) {
+CanType OpenedArchetypeType::getAny(CanType existential,
+                                    const DeclContext *useDC) {
   Type interfaceType = GenericTypeParamType::get(
-      /*isTypeSequence=*/false, 0, 0, existential->getASTContext());
-  return getAny(existential, interfaceType);
+      /*isTypeSequence=*/false, useDC->getGenericContextDepth() + 1, 0,
+      existential->getASTContext());
+  return getAny(existential, interfaceType, useDC);
 }
 
 void SubstitutionMap::Storage::Profile(
@@ -4655,12 +4669,23 @@ GenericEnvironment *GenericEnvironment::getIncomplete(
 }
 
 /// Create a new generic environment for an opened archetype.
-GenericEnvironment *GenericEnvironment::forOpenedExistential(
-    Type existential, UUID uuid) {
+GenericEnvironment *
+GenericEnvironment::forOpenedExistential(Type existential,
+                                         const DeclContext *useDC, UUID uuid) {
   auto &ctx = existential->getASTContext();
-  auto signature = ctx.getOpenedArchetypeSignature(existential);
+  auto signature = ctx.getOpenedArchetypeSignature(existential, useDC);
+
+  SubstitutionMap subs;
+  if (auto *useEnvironment = useDC->getGenericEnvironmentOfContext()) {
+    subs = useEnvironment->getForwardingSubstitutionMap();
+  }
+  return GenericEnvironment::forOpenedExistential(existential, signature, uuid);
+}
 
+GenericEnvironment *GenericEnvironment::forOpenedExistential(
+    Type existential, GenericSignature signature, UUID uuid) {
   // Allocate and construct the new environment.
+  auto &ctx = existential->getASTContext();
   unsigned numGenericParams = signature.getGenericParams().size();
   size_t bytes = totalSizeToAlloc<OpaqueTypeDecl *, SubstitutionMap,
                                   OpenedGenericEnvironmentData, Type>(
@@ -5166,38 +5191,47 @@ CanGenericSignature ASTContext::getSingleGenericParameterSignature() const {
   return canonicalSig;
 }
 
-CanGenericSignature ASTContext::getOpenedArchetypeSignature(Type type) {
+CanGenericSignature
+ASTContext::getOpenedArchetypeSignature(Type type, const DeclContext *useDC) {
   assert(type->isExistentialType());
+  assert(useDC && "Must have a working declaration context!");
+
   if (auto existential = type->getAs<ExistentialType>())
     type = existential->getConstraintType();
 
   const CanType constraint = type->getCanonicalType();
   assert(!constraint->hasTypeParameter() && "This only works with archetypes");
 
   // The opened archetype signature for a protocol type is identical
-  // to the protocol's own canonical generic signature.
-  if (const auto protoTy = dyn_cast<ProtocolType>(constraint)) {
-    return protoTy->getDecl()->getGenericSignature().getCanonicalSignature();
+  // to the protocol's own canonical generic signature if there aren't any
+  // outer generic parameters to worry about.
+  if (!useDC->isGenericContext()) {
+    if (const auto protoTy = dyn_cast<ProtocolType>(constraint)) {
+      return protoTy->getDecl()->getGenericSignature().getCanonicalSignature();
+    }
   }
 
-  auto found = getImpl().ExistentialSignatures.find(constraint);
+  // 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});
   if (found != getImpl().ExistentialSignatures.end())
     return found->second;
 
+  auto depth = useDC->getGenericContextDepth() + 1;
   auto genericParam =
       GenericTypeParamType::get(/*type sequence*/ false,
-                                /*depth*/ 0, /*index*/ 0, *this);
+                                /*depth*/ depth, /*index*/ 0, *this);
   Requirement requirement(RequirementKind::Conformance, genericParam,
                           constraint);
-  auto genericSig = buildGenericSignature(*this,
-                                          GenericSignature(),
-                                          {genericParam},
-                                          {requirement});
+  auto genericSig = buildGenericSignature(
+      *this, useDC->getGenericSignatureOfContext().getCanonicalSignature(),
+      {genericParam}, {requirement});
 
   CanGenericSignature canGenericSig(genericSig);
 
   auto result = getImpl().ExistentialSignatures.insert(
-    std::make_pair(constraint, canGenericSig));
+      std::make_pair(std::make_pair(constraint, useDC), canGenericSig));
   assert(result.second);
   (void) result;
 

lib/AST/Decl.cpp

@@ -2926,7 +2926,7 @@ CanType ValueDecl::getOverloadSignatureType() const {
                                     /*topLevelFunction=*/true, isMethod,
                                     /*isInitializer=*/isa<ConstructorDecl>(afd),
                                     getNumCurryLevels())
-        ->getCanonicalType();
+        ->getMinimalCanonicalType(afd);
   }
 
   if (isa<AbstractStorageDecl>(this)) {
@@ -2942,22 +2942,22 @@ CanType ValueDecl::getOverloadSignatureType() const {
                                    /*topLevelFunction=*/true,
                                    /*isMethod=*/false,
                                    /*isInitializer=*/false, getNumCurryLevels())
-              ->getCanonicalType();
+              ->getMinimalCanonicalType(getDeclContext());
     }
 
     // We want to curry the default signature type with the 'self' type of the
     // given context (if any) in order to ensure the overload signature type
     // is unique across different contexts, such as between a protocol extension
     // and struct decl.
     return defaultSignatureType->addCurriedSelfType(getDeclContext())
-        ->getCanonicalType();
+        ->getMinimalCanonicalType(getDeclContext());
   }
 
   if (isa<EnumElementDecl>(this)) {
     auto mappedType = mapSignatureFunctionType(
         getASTContext(), getInterfaceType(), /*topLevelFunction=*/false,
         /*isMethod=*/false, /*isInitializer=*/false, getNumCurryLevels());
-    return mappedType->getCanonicalType();
+    return mappedType->getMinimalCanonicalType(getDeclContext());
   }
 
   // Note: If you add more cases to this function, you should update the
@@ -4085,7 +4085,8 @@ GenericParameterReferenceInfo swift::findGenericParameterReferences(
 }
 
 GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
-    Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const {
+    Type baseTy, const DeclContext *useDC,
+    bool treatNonResultCovariantSelfAsInvariant) const {
   assert(baseTy->isExistentialType());
 
   // Types never refer to 'Self'.
@@ -4098,7 +4099,8 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
   if (type->hasError())
     return GenericParameterReferenceInfo();
 
-  const auto sig = getASTContext().getOpenedArchetypeSignature(baseTy);
+  const auto sig =
+      getASTContext().getOpenedArchetypeSignature(baseTy, useDC);
   auto genericParam = sig.getGenericParams().front();
   return findGenericParameterReferences(
       this, sig, genericParam, treatNonResultCovariantSelfAsInvariant, None);