AST, Sema: Use the opened archetype's generic signature to determine existential member availability

Author: AnthonyLatsis

include/swift/AST/Decl.h

@@ -2674,14 +2674,15 @@ class ValueDecl : public Decl {
   /// that this declaration dynamically replaces.
   ValueDecl *getDynamicallyReplacedDecl() const;
 
-  /// Report 'Self' references within the type of this protocol member.
+  /// Report 'Self' references within the type of this declaration as a
+  /// member of the given existential base type.
   ///
   /// \param treatNonResultCovariantSelfAsInvariant If true, 'Self' or 'Self?'
   /// is considered covariant only when it appears as the immediate type of a
-  /// property, or the uncurried result type of a method/subscript.
-  SelfReferenceInfo
-  findProtocolSelfReferences(const ProtocolDecl *proto,
-                             bool treatNonResultCovariantSelfAsInvariant) const;
+  /// property, or the uncurried result type of a method/subscript, e.g.
+  /// '() -> () -> Self'.
+  SelfReferenceInfo findExistentialSelfReferences(
+      Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
 };
 
 /// This is a common base class for declarations which declare a type.

include/swift/AST/GenericSignature.h

@@ -390,6 +390,8 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
 
   bool isCanonicalTypeInContext(Type type) const;
 
+  /// Determine whether the given type parameter is defined under this generic
+  /// signature.
   bool isValidTypeInContext(Type type) const;
 
   /// Retrieve the conformance access path used to extract the conformance of
@@ -428,6 +430,13 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// generic parameter types by their sugared form.
   Type getSugaredType(Type type) const;
 
+  /// Given a type parameter, compute the most specific supertype (upper bound)
+  /// that is not dependent on other type parameters.
+  ///
+  /// \note If the upper bound is a protocol or protocol composition,
+  /// will return an instance of \c ExistentialType.
+  Type getNonDependentUpperBounds(Type type) const;
+
   static void Profile(llvm::FoldingSetNodeID &ID,
                       TypeArrayView<GenericTypeParamType> genericParams,
                       ArrayRef<Requirement> requirements);

include/swift/AST/Types.h

@@ -513,13 +513,13 @@ class alignas(1 << TypeAlignInBits) TypeBase
   TypeBase *getWithoutSyntaxSugar();
 
   /// getASTContext - Return the ASTContext that this type belongs to.
-  ASTContext &getASTContext();
-  
+  ASTContext &getASTContext() const;
+
   /// isEqual - Return true if these two types are equal, ignoring sugar.
   ///
   /// To compare sugar, check for pointer equality of the underlying TypeBase *
   /// values, obtained by calling getPointer().
-  bool isEqual(Type Other);
+  bool isEqual(Type Other) const;
 
   /// getDesugaredType - If this type is a sugared type, remove all levels of
   /// sugar until we get down to a non-sugar type.
@@ -621,7 +621,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   /// Determine whether the type involves the given opened existential
   /// archetype.
-  bool hasOpenedExistential(OpenedArchetypeType *opened);
+  bool hasOpenedExistential(const OpenedArchetypeType *opened);
 
   /// Determine whether the type involves an opaque type.
   bool hasOpaqueArchetype() const {
@@ -641,9 +641,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// within this type.
   void getOpenedExistentials(SmallVectorImpl<OpenedArchetypeType *> &opened);
 
-  /// Erase the given opened existential type by replacing it with its
-  /// existential type throughout the given type.
-  Type eraseOpenedExistential(OpenedArchetypeType *opened);
+  /// 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.
@@ -6287,7 +6287,7 @@ BEGIN_CAN_TYPE_WRAPPER(PackExpansionType, Type)
 END_CAN_TYPE_WRAPPER(PackExpansionType, Type)
 
 /// getASTContext - Return the ASTContext that this type belongs to.
-inline ASTContext &TypeBase::getASTContext() {
+inline ASTContext &TypeBase::getASTContext() const {
   // If this type is canonical, it has the ASTContext in it.
   if (isCanonical())
     return *const_cast<ASTContext*>(Context);

include/swift/Sema/ConstraintSystem.h

@@ -5296,12 +5296,13 @@ class ConstraintSystem {
   /// in (if any) has a result builder applied to its body.
   bool isInResultBuilderContext(ClosureExpr *closure) const;
 
-  /// Determine whether we are allowed to refer to an existential type
-  /// conforming to the given protocol. This is only permitted if the type of
-  /// the member does not contain any associated types, and does not
-  /// contain 'Self' in 'parameter' or 'other' position.
-  bool isAvailableInExistential(const ProtocolDecl *proto,
-                                const ValueDecl *member) const;
+  /// Determine whether referencing the given member on the
+  /// given existential base type is supported. This is the case only if the
+  /// type of the member, spelled in the context of \p baseTy,
+  /// - does not contain any 'Self'-rooted dependent member types, and
+  /// - does not contain 'Self' in non-covariant position.
+  bool isMemberAvailableOnExistential(Type baseTy,
+                                      const ValueDecl *member) const;
 
   SWIFT_DEBUG_DUMP;
   SWIFT_DEBUG_DUMPER(dump(Expr *));

lib/AST/Decl.cpp

@@ -3739,12 +3739,13 @@ SelfReferenceInfo::operator|=(const SelfReferenceInfo &other) {
   return *this;
 }
 
-/// Report references to 'Self' within the given type.
+/// Report references to 'Self' within the given type using the given
+/// existential generic signature.
 ///
 /// \param position The current position in terms of variance.
-static SelfReferenceInfo findProtocolSelfReferences(const ProtocolDecl *proto,
-                                                    Type type,
-                                                    TypePosition position) {
+static SelfReferenceInfo
+findExistentialSelfReferences(CanGenericSignature existentialSig, Type type,
+                              TypePosition position) {
   // If there are no type parameters, we're done.
   if (!type->hasTypeParameter())
     return SelfReferenceInfo();
@@ -3753,7 +3754,8 @@ static SelfReferenceInfo findProtocolSelfReferences(const ProtocolDecl *proto,
   if (auto tuple = type->getAs<TupleType>()) {
     auto info = SelfReferenceInfo();
     for (auto &elt : tuple->getElements()) {
-      info |= findProtocolSelfReferences(proto, elt.getType(), position);
+      info |= findExistentialSelfReferences(existentialSig, elt.getType(),
+                                            position);
     }
 
     // A covariant Self result inside a tuple will not be bona fide.
@@ -3769,19 +3771,19 @@ static SelfReferenceInfo findProtocolSelfReferences(const ProtocolDecl *proto,
     for (auto param : funcTy->getParams()) {
       // inout parameters are invariant.
       if (param.isInOut()) {
-        inputInfo |= findProtocolSelfReferences(proto, param.getPlainType(),
-                                                TypePosition::Invariant);
+        inputInfo |= findExistentialSelfReferences(
+            existentialSig, param.getPlainType(), TypePosition::Invariant);
         continue;
       }
-      inputInfo |= findProtocolSelfReferences(proto, param.getParameterType(),
-                                              position.flipped());
+      inputInfo |= findExistentialSelfReferences(
+          existentialSig, param.getParameterType(), position.flipped());
     }
 
     // A covariant Self result inside a parameter will not be bona fide.
     inputInfo.hasCovariantSelfResult = false;
 
-    auto resultInfo =
-        findProtocolSelfReferences(proto, funcTy->getResult(), position);
+    auto resultInfo = findExistentialSelfReferences(
+        existentialSig, funcTy->getResult(), position);
     if (resultInfo.selfRef == TypePosition::Covariant) {
       resultInfo.hasCovariantSelfResult = true;
     }
@@ -3790,46 +3792,48 @@ static SelfReferenceInfo findProtocolSelfReferences(const ProtocolDecl *proto,
 
   // Metatypes preserve variance.
   if (auto metaTy = type->getAs<MetatypeType>()) {
-    return findProtocolSelfReferences(proto, metaTy->getInstanceType(),
-                                      position);
+    return findExistentialSelfReferences(existentialSig,
+                                         metaTy->getInstanceType(), position);
   }
 
   // Optionals preserve variance.
   if (auto optType = type->getOptionalObjectType()) {
-    return findProtocolSelfReferences(proto, optType, position);
+    return findExistentialSelfReferences(existentialSig, optType, position);
   }
 
   // DynamicSelfType preserves variance.
   // FIXME: This shouldn't ever appear in protocol requirement
   // signatures.
   if (auto selfType = type->getAs<DynamicSelfType>()) {
-    return findProtocolSelfReferences(proto, selfType->getSelfType(), position);
+    return findExistentialSelfReferences(existentialSig,
+                                         selfType->getSelfType(), position);
   }
 
   if (auto *const nominal = type->getAs<NominalOrBoundGenericNominalType>()) {
     auto info = SelfReferenceInfo();
 
     // Don't forget to look in the parent.
     if (const auto parent = nominal->getParent()) {
-      info |= findProtocolSelfReferences(proto, parent, position);
+      info |= findExistentialSelfReferences(existentialSig, parent, position);
     }
 
     // Most bound generic types are invariant.
     if (auto *const bgt = type->getAs<BoundGenericType>()) {
       if (bgt->isArray()) {
-        // Swift.Array preserves variance in its Value type.
-        info |= findProtocolSelfReferences(proto, bgt->getGenericArgs().front(),
-                                           position);
+        // Swift.Array preserves variance in its 'Value' type.
+        info |= findExistentialSelfReferences(
+            existentialSig, bgt->getGenericArgs().front(), position);
       } else if (bgt->isDictionary()) {
-        // Swift.Dictionary preserves variance in its Element type.
-        info |= findProtocolSelfReferences(proto, bgt->getGenericArgs().front(),
-                                           TypePosition::Invariant);
-        info |= findProtocolSelfReferences(proto, bgt->getGenericArgs().back(),
-                                           position);
+        // Swift.Dictionary preserves variance in its 'Element' type.
+        info |= findExistentialSelfReferences(existentialSig,
+                                              bgt->getGenericArgs().front(),
+                                              TypePosition::Invariant);
+        info |= findExistentialSelfReferences(
+            existentialSig, bgt->getGenericArgs().back(), position);
       } else {
         for (auto paramType : bgt->getGenericArgs()) {
-          info |= findProtocolSelfReferences(proto, paramType,
-                                             TypePosition::Invariant);
+          info |= findExistentialSelfReferences(existentialSig, paramType,
+                                                TypePosition::Invariant);
         }
       }
     }
@@ -3849,29 +3853,45 @@ static SelfReferenceInfo findProtocolSelfReferences(const ProtocolDecl *proto,
   if (auto *comp = constraint->getAs<ProtocolCompositionType>()) {
     // 'Self' may be referenced only in a superclass component.
     if (const auto superclass = comp->getSuperclass()) {
-      return findProtocolSelfReferences(proto, superclass, position);
+      return findExistentialSelfReferences(existentialSig, superclass,
+                                           position);
     }
 
     return SelfReferenceInfo();
   }
 
+  if (!type->isTypeParameter()) {
+    return SelfReferenceInfo();
+  }
+
+  const auto selfTy = existentialSig.getGenericParams().front();
+  if (!type->getRootGenericParam()->isEqual(selfTy)) {
+    return SelfReferenceInfo();
+  }
+
   // A direct reference to 'Self'.
-  if (proto->getSelfInterfaceType()->isEqual(type))
+  if (selfTy->isEqual(type)) {
     return SelfReferenceInfo::forSelfRef(position);
+  }
 
-  // A reference to an associated type rooted on 'Self'.
-  if (type->is<DependentMemberType>()) {
-    type = type->getRootGenericParam();
-    if (proto->getSelfInterfaceType()->isEqual(type))
-      return SelfReferenceInfo::forAssocTypeRef(position);
+  // If the type parameter is beyond the domain of the existential generic
+  // signature, ignore it.
+  if (!existentialSig->isValidTypeInContext(type)) {
+    return SelfReferenceInfo();
   }
 
-  return SelfReferenceInfo();
+  if (const auto concreteTy = existentialSig->getConcreteType(type)) {
+    return findExistentialSelfReferences(existentialSig, concreteTy, position);
+  }
+
+  // A reference to an associated type rooted on 'Self'.
+  return SelfReferenceInfo::forAssocTypeRef(position);
 }
 
-SelfReferenceInfo ValueDecl::findProtocolSelfReferences(
-    const ProtocolDecl *proto,
-    bool treatNonResultCovariantSelfAsInvariant) const {
+SelfReferenceInfo ValueDecl::findExistentialSelfReferences(
+    Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const {
+  assert(baseTy->isExistentialType());
+
   // Types never refer to 'Self'.
   if (isa<TypeDecl>(this))
     return SelfReferenceInfo();
@@ -3882,6 +3902,8 @@ SelfReferenceInfo ValueDecl::findProtocolSelfReferences(
   if (type->hasError())
     return SelfReferenceInfo();
 
+  const auto sig = getASTContext().getOpenedArchetypeSignature(baseTy);
+
   if (isa<AbstractFunctionDecl>(this) || isa<SubscriptDecl>(this)) {
     // For a method, skip the 'self' parameter.
     if (isa<AbstractFunctionDecl>(this))
@@ -3891,12 +3913,12 @@ SelfReferenceInfo ValueDecl::findProtocolSelfReferences(
     for (auto param : type->castTo<AnyFunctionType>()->getParams()) {
       // inout parameters are invariant.
       if (param.isInOut()) {
-        inputInfo |= ::findProtocolSelfReferences(proto, param.getPlainType(),
-                                                  TypePosition::Invariant);
+        inputInfo |= ::findExistentialSelfReferences(sig, param.getPlainType(),
+                                                     TypePosition::Invariant);
         continue;
       }
-      inputInfo |= ::findProtocolSelfReferences(proto, param.getParameterType(),
-                                                TypePosition::Contravariant);
+      inputInfo |= ::findExistentialSelfReferences(
+          sig, param.getParameterType(), TypePosition::Contravariant);
     }
 
     // A covariant Self result inside a parameter will not be bona fide.
@@ -3913,8 +3935,8 @@ SelfReferenceInfo ValueDecl::findProtocolSelfReferences(
       inputInfo.selfRef = TypePosition::Invariant;
     }
 
-    auto resultInfo = ::findProtocolSelfReferences(
-        proto, type->castTo<AnyFunctionType>()->getResult(),
+    auto resultInfo = ::findExistentialSelfReferences(
+        sig, type->castTo<AnyFunctionType>()->getResult(),
         TypePosition::Covariant);
     if (resultInfo.selfRef == TypePosition::Covariant) {
       resultInfo.hasCovariantSelfResult = true;
@@ -3925,7 +3947,7 @@ SelfReferenceInfo ValueDecl::findProtocolSelfReferences(
     assert(isa<VarDecl>(this));
 
     auto info =
-        ::findProtocolSelfReferences(proto, type, TypePosition::Covariant);
+        ::findExistentialSelfReferences(sig, type, TypePosition::Covariant);
     if (info.selfRef == TypePosition::Covariant) {
       info.hasCovariantSelfResult = true;
     }

lib/AST/GenericEnvironment.cpp

@@ -290,8 +290,11 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
     switch (getKind()) {
     case Kind::Normal:
     case Kind::OpenedExistential:
-      return mapTypeIntoContext(type, conformanceLookupFn);
-
+      if (type->hasTypeParameter()) {
+        return mapTypeIntoContext(type, conformanceLookupFn);
+      } else {
+        return type;
+      }
     case Kind::Opaque:
       return maybeApplyOpaqueTypeSubstitutions(type);
     }

lib/AST/GenericSignature.cpp

@@ -542,6 +542,37 @@ unsigned GenericSignatureImpl::getGenericParamOrdinal(
   return GenericParamKey(param).findIndexIn(getGenericParams());
 }
 
+Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
+  assert(type->isTypeParameter());
+
+  llvm::SmallVector<Type, 2> types;
+  if (Type superclass = getSuperclassBound(type)) {
+    // If the class contains a type parameter, try looking for a non-dependent
+    // superclass.
+    while (superclass && superclass->hasTypeParameter()) {
+      superclass = superclass->getSuperclass();
+    }
+
+    if (superclass)
+      types.push_back(superclass);
+  }
+  for (const auto &elt : getRequiredProtocols(type)) {
+    types.push_back(elt->getDeclaredInterfaceType());
+  }
+
+  const auto layout = getLayoutConstraint(type);
+  const auto boundsTy = ProtocolCompositionType::get(
+      getASTContext(), types,
+      /*HasExplicitAnyObject=*/layout &&
+          layout->getKind() == LayoutConstraintKind::Class);
+
+  if (boundsTy->isExistentialType()) {
+    return ExistentialType::get(boundsTy);
+  }
+
+  return boundsTy;
+}
+
 void GenericSignature::Profile(llvm::FoldingSetNodeID &id) const {
   return GenericSignature::Profile(id, getPointer()->getGenericParams(),
                                      getPointer()->getRequirements());