AST: Simplify ValueDecl::findExistentialSelfReferences()

Author: slavapestov

include/swift/AST/Decl.h

@@ -3335,9 +3335,8 @@ class ValueDecl : public Decl {
   /// that this declaration dynamically replaces.
   ValueDecl *getDynamicallyReplacedDecl() const;
 
-  /// Find references to 'Self' in the type signature of this declaration in the
-  /// context of the given existential base type.
-  GenericParameterReferenceInfo findExistentialSelfReferences(Type baseTy) const;
+  /// Find references to 'Self' in the type signature of this declaration.
+  GenericParameterReferenceInfo findExistentialSelfReferences() const;
 };
 
 /// This is a common base class for declarations which declare a type.

lib/AST/Decl.cpp

@@ -5125,7 +5125,8 @@ swift::findGenericParameterReferences(const ValueDecl *value,
                                       GenericTypeParamType *origParam,
                                       GenericTypeParamType *openedParam,
                                       std::optional<unsigned> skipParamIndex) {
-  assert(!isa<TypeDecl>(value));
+  if (isa<TypeDecl>(value))
+    return GenericParameterReferenceInfo();
 
   auto type = value->getInterfaceType();
 
@@ -5150,26 +5151,13 @@ swift::findGenericParameterReferences(const ValueDecl *value,
                                              /*canBeCovariantResult=*/true);
 }
 
-GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
-    Type baseTy) const {
-  assert(baseTy->isExistentialType());
-  assert(!baseTy->hasTypeParameter());
-
-  // Type declarations don't really have type signatures.
-  if (isa<TypeDecl>(this))
-    return GenericParameterReferenceInfo();
-
-  // Skip invalid declarations.
-  if (getInterfaceType()->hasError())
-    return GenericParameterReferenceInfo();
+GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences() const {
+  auto *dc = getDeclContext();
+  ASSERT(dc->getSelfProtocolDecl());
 
-  // Note: a non-null GenericSignature would violate the invariant that
-  // the protocol 'Self' type referenced from the requirement's interface
-  // type is the same as the existential 'Self' type.
-  auto sig = getASTContext().getOpenedExistentialSignature(baseTy,
-      GenericSignature());
+  auto sig = dc->getGenericSignatureOfContext().getCanonicalSignature();
+  auto genericParam = dc->getSelfInterfaceType()->castTo<GenericTypeParamType>();
 
-  auto genericParam = sig.getGenericParams().front();
   return findGenericParameterReferences(this, sig, genericParam, genericParam,
                                         std::nullopt);
 }

lib/Sema/ConstraintSystem.cpp

@@ -7544,11 +7544,20 @@ bool ConstraintSystem::isMemberAvailableOnExistential(
 
   // If the type of the member references 'Self' or a 'Self'-rooted associated
   // type in non-covariant position, we cannot reference the member.
-  //
-  // N.B. We pass the module context because this check does not care about the
-  // the actual signature of the opened archetype in context, rather it cares
-  // about whether you can "hold" `baseTy.member` properly in the abstract.
-  const auto info = member->findExistentialSelfReferences(baseTy);
+  assert(baseTy->isExistentialType());
+  assert(!baseTy->hasTypeParameter());
+
+  // Note: a non-null GenericSignature would violate the invariant that
+  // the protocol 'Self' type referenced from the requirement's interface
+  // type is the same as the existential 'Self' type.
+  auto sig = getASTContext().getOpenedExistentialSignature(baseTy,
+      GenericSignature());
+
+  auto genericParam = sig.getGenericParams().front();
+  auto info = findGenericParameterReferences(
+      member, sig, genericParam, genericParam,
+      std::nullopt);
+
   if (info.selfRef > TypePosition::Covariant ||
       info.assocTypeRef > TypePosition::Covariant) {
     return false;

lib/Sema/TypeCheckDecl.cpp

@@ -733,8 +733,7 @@ bool HasSelfOrAssociatedTypeRequirementsRequest::evaluate(
 
     // For value members, look at their type signatures.
     if (auto valueMember = dyn_cast<ValueDecl>(member)) {
-      const auto info = valueMember->findExistentialSelfReferences(
-          decl->getDeclaredInterfaceType());
+      const auto info = valueMember->findExistentialSelfReferences();
       if (info.selfRef > TypePosition::Covariant || info.assocTypeRef) {
         return true;
       }

lib/Sema/TypeCheckProtocol.cpp

@@ -1132,8 +1132,7 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
         // defining a non-final class conforming to 'Collection' which uses
         // the default witness for 'Collection.Iterator', which is defined
         // as 'IndexingIterator<Self>'.
-        const auto selfRefInfo = req->findExistentialSelfReferences(
-            proto->getDeclaredInterfaceType());
+        const auto selfRefInfo = req->findExistentialSelfReferences();
         if (!selfRefInfo.assocTypeRef) {
           covariantSelf = classDecl;
         }
@@ -4035,8 +4034,7 @@ void ConformanceChecker::checkNonFinalClassWitness(ValueDecl *requirement,
 
   // Check whether this requirement uses Self in a way that might
   // prevent conformance from succeeding.
-  const auto selfRefInfo = requirement->findExistentialSelfReferences(
-      Proto->getDeclaredInterfaceType());
+  const auto selfRefInfo = requirement->findExistentialSelfReferences();
 
   if (selfRefInfo.selfRef == TypePosition::Invariant ||
       (selfRefInfo.selfRef == TypePosition::Covariant &&