AST: Clean up findGenericParameterReferences()

Author: slavapestov

include/swift/AST/Decl.h

@@ -3337,14 +3337,7 @@ class ValueDecl : public Decl {
 
   /// Find references to 'Self' in the type signature of this declaration in the
   /// context of the given existential base type.
-  ///
-  /// \param treatNonResultCovariantSelfAsInvariant When set, covariant 'Self'
-  /// references that are not in covariant result type position are considered
-  /// invariant. This position is the uncurried interface type of a declaration,
-  /// stripped of any optionality. For example, this is true for 'Self' in
-  /// 'func foo(Int) -> () -> Self?'.
-  GenericParameterReferenceInfo findExistentialSelfReferences(
-      Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
+  GenericParameterReferenceInfo findExistentialSelfReferences(Type baseTy) const;
 };
 
 /// This is a common base class for declarations which declare a type.
@@ -9533,7 +9526,6 @@ class MacroExpansionDecl : public Decl, public FreestandingMacroExpansion {
 GenericParameterReferenceInfo
 findGenericParameterReferences(const ValueDecl *value, CanGenericSignature sig,
                                GenericTypeParamType *genericParam,
-                               bool treatNonResultCovarianceAsInvariant,
                                std::optional<unsigned> skipParamIndex);
 
 inline void

lib/AST/Decl.cpp

@@ -4825,8 +4825,8 @@ GenericParameterReferenceInfo::operator|=(const GenericParameterReferenceInfo &o
 
 /// Forward declaration.
 static GenericParameterReferenceInfo
-findGenericParameterReferences(CanGenericSignature, GenericTypeParamType *,
-                               Type, TypePosition, bool, bool);
+findGenericParameterReferencesRec(CanGenericSignature, GenericTypeParamType *,
+                                  Type, TypePosition, bool);
 
 /// Determine whether a function type with the given result type may have
 /// a covariant generic parameter type result. This is true if the result type
@@ -4848,8 +4848,7 @@ static bool canResultTypeHaveCovariantGenericParameterResult(Type resultTy) {
 static GenericParameterReferenceInfo findGenericParameterReferencesInFunction(
     CanGenericSignature genericSig, GenericTypeParamType *genericParam,
     const AnyFunctionType *fnType, TypePosition position,
-    bool treatNonResultCovarianceAsInvariant, bool canBeCovariantResult,
-    std::optional<unsigned> skipParamIndex) {
+    bool canBeCovariantResult, std::optional<unsigned> skipParamIndex) {
   // If there are no type parameters, we're done.
   if (!isa<GenericFunctionType>(fnType) && !fnType->hasTypeParameter())
     return GenericParameterReferenceInfo();
@@ -4864,10 +4863,9 @@ static GenericParameterReferenceInfo findGenericParameterReferencesInFunction(
     const auto &param = params[paramIdx];
     // inout types are invariant.
     if (param.isInOut()) {
-      inputInfo |= ::findGenericParameterReferences(
+      inputInfo |= ::findGenericParameterReferencesRec(
           genericSig, genericParam, param.getPlainType(),
-          TypePosition::Invariant, treatNonResultCovarianceAsInvariant,
-          /*canBeCovariantResult=*/false);
+          TypePosition::Invariant, /*canBeCovariantResult=*/false);
       continue;
     }
 
@@ -4878,19 +4876,19 @@ static GenericParameterReferenceInfo findGenericParameterReferencesInFunction(
     if (skipParamIndex && paramIdx < *skipParamIndex)
       paramPos = TypePosition::Invariant;
 
-    inputInfo |= ::findGenericParameterReferences(
+    inputInfo |= ::findGenericParameterReferencesRec(
         genericSig, genericParam, param.getParameterType(), paramPos,
-        treatNonResultCovarianceAsInvariant, /*canBeCovariantResult=*/false);
+        /*canBeCovariantResult=*/false);
   }
 
   canBeCovariantResult =
       // &= does not short-circuit.
       canBeCovariantResult &&
       canResultTypeHaveCovariantGenericParameterResult(fnType->getResult());
 
-  const auto resultInfo = ::findGenericParameterReferences(
-      genericSig, genericParam, fnType->getResult(), position,
-      treatNonResultCovarianceAsInvariant, canBeCovariantResult);
+  const auto resultInfo = ::findGenericParameterReferencesRec(
+      genericSig, genericParam, fnType->getResult(),
+      position, canBeCovariantResult);
 
   return inputInfo |= resultInfo;
 }
@@ -4900,12 +4898,11 @@ static GenericParameterReferenceInfo findGenericParameterReferencesInFunction(
 ///
 /// \param position The current position in terms of variance.
 static GenericParameterReferenceInfo
-findGenericParameterReferences(CanGenericSignature genericSig,
-                               GenericTypeParamType *genericParam,
-                               Type type,
-                               TypePosition position,
-                               bool treatNonResultCovarianceAsInvariant,
-                               bool canBeCovariantResult) {
+findGenericParameterReferencesRec(CanGenericSignature genericSig,
+                                  GenericTypeParamType *genericParam,
+                                  Type type,
+                                  TypePosition position,
+                                  bool canBeCovariantResult) {
   // If there are no type parameters, we're done.
   if (!type->hasTypeParameter())
     return GenericParameterReferenceInfo();
@@ -4914,9 +4911,8 @@ findGenericParameterReferences(CanGenericSignature genericSig,
   if (auto tuple = type->getAs<TupleType>()) {
     auto info = GenericParameterReferenceInfo();
     for (auto &elt : tuple->getElements()) {
-      info |= findGenericParameterReferences(
+      info |= findGenericParameterReferencesRec(
           genericSig, genericParam, elt.getType(), position,
-          treatNonResultCovarianceAsInvariant,
           /*canBeCovariantResult=*/false);
     }
 
@@ -4927,69 +4923,61 @@ findGenericParameterReferences(CanGenericSignature genericSig,
   // the parameter type.
   if (auto funcTy = type->getAs<AnyFunctionType>()) {
     return findGenericParameterReferencesInFunction(
-        genericSig, genericParam, funcTy, position,
-        treatNonResultCovarianceAsInvariant, canBeCovariantResult,
+        genericSig, genericParam, funcTy,
+        position, canBeCovariantResult,
         /*skipParamIndex=*/std::nullopt);
   }
 
   // Metatypes preserve variance.
   if (auto metaTy = type->getAs<MetatypeType>()) {
-    return findGenericParameterReferences(genericSig, genericParam,
-                                          metaTy->getInstanceType(), position,
-                                          treatNonResultCovarianceAsInvariant,
-                                          canBeCovariantResult);
+    return findGenericParameterReferencesRec(genericSig, genericParam,
+                                             metaTy->getInstanceType(),
+                                             position, canBeCovariantResult);
   }
 
   // Optionals preserve variance.
   if (auto optType = type->getOptionalObjectType()) {
-    return findGenericParameterReferences(
-        genericSig, genericParam, optType, position,
-        treatNonResultCovarianceAsInvariant, canBeCovariantResult);
+    return findGenericParameterReferencesRec(
+        genericSig, genericParam, optType, position, canBeCovariantResult);
   }
 
   // DynamicSelfType preserves variance.
   if (auto selfType = type->getAs<DynamicSelfType>()) {
-    return findGenericParameterReferences(genericSig, genericParam,
-                                          selfType->getSelfType(), position,
-                                          treatNonResultCovarianceAsInvariant,
-                                          /*canBeCovariantResult=*/false);
+    return findGenericParameterReferencesRec(genericSig, genericParam,
+                                             selfType->getSelfType(), position,
+                                             /*canBeCovariantResult=*/false);
   }
 
   if (auto *const nominal = type->getAs<NominalOrBoundGenericNominalType>()) {
     auto info = GenericParameterReferenceInfo();
 
     // Don't forget to look in the parent.
     if (const auto parent = nominal->getParent()) {
-      info |= findGenericParameterReferences(
+      info |= findGenericParameterReferencesRec(
           genericSig, genericParam, parent, position,
-          treatNonResultCovarianceAsInvariant,
           /*canBeCovariantResult=*/false);
     }
 
     // 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 |= findGenericParameterReferences(
+        info |= findGenericParameterReferencesRec(
             genericSig, genericParam, bgt->getGenericArgs().front(),
-            position, treatNonResultCovarianceAsInvariant,
-            /*canBeCovariantResult=*/false);
+            position, /*canBeCovariantResult=*/false);
       } else if (bgt->isDictionary()) {
         // Swift.Dictionary preserves variance in its 'Element' type.
-        info |= findGenericParameterReferences(
+        info |= findGenericParameterReferencesRec(
             genericSig, genericParam, bgt->getGenericArgs().front(),
-            TypePosition::Invariant, treatNonResultCovarianceAsInvariant,
-            /*canBeCovariantResult=*/false);
-        info |= findGenericParameterReferences(
+            TypePosition::Invariant, /*canBeCovariantResult=*/false);
+        info |= findGenericParameterReferencesRec(
             genericSig, genericParam, bgt->getGenericArgs().back(),
-            position, treatNonResultCovarianceAsInvariant,
-            /*canBeCovariantResult=*/false);
+            position, /*canBeCovariantResult=*/false);
       } else {
         for (const auto &paramType : bgt->getGenericArgs()) {
-          info |= findGenericParameterReferences(
-              genericSig, genericParam, paramType, TypePosition::Invariant,
-              treatNonResultCovarianceAsInvariant,
-              /*canBeCovariantResult=*/false);
+          info |= findGenericParameterReferencesRec(
+              genericSig, genericParam, paramType,
+              TypePosition::Invariant, /*canBeCovariantResult=*/false);
         }
       }
     }
@@ -5012,40 +5000,37 @@ findGenericParameterReferences(CanGenericSignature genericSig,
         continue;
 
       case RequirementKind::SameType:
-        info |= findGenericParameterReferences(
+        info |= findGenericParameterReferencesRec(
             genericSig, genericParam, req.getFirstType(),
-            TypePosition::Invariant, treatNonResultCovarianceAsInvariant,
-            /*canBeCovariantResult=*/false);
+            TypePosition::Invariant, /*canBeCovariantResult=*/false);
 
         LLVM_FALLTHROUGH;
 
       case RequirementKind::Superclass:
-        info |= findGenericParameterReferences(
+        info |= findGenericParameterReferencesRec(
             genericSig, genericParam, req.getSecondType(),
-            TypePosition::Invariant, treatNonResultCovarianceAsInvariant,
-            /*canBeCovariantResult=*/false);
+            TypePosition::Invariant, /*canBeCovariantResult=*/false);
         break;
       }
     }
 
     return info;
   }
 
-  // Protocol compositions preserve variance.
   if (auto *existential = type->getAs<ExistentialType>())
     type = existential->getConstraintType();
+
+  // Protocol compositions are invariant.
   if (auto *comp = type->getAs<ProtocolCompositionType>()) {
-    // 'Self' may be referenced only in an explicit superclass component.
-    for (const auto member : comp->getMembers()) {
-      if (member->getClassOrBoundGenericClass()) {
-        return findGenericParameterReferences(
-            genericSig, genericParam, member, position,
-            treatNonResultCovarianceAsInvariant,
-            /*canBeCovariantResult=*/false);
-      }
+    auto info = GenericParameterReferenceInfo();
+
+    for (auto member : comp->getMembers()) {
+      info |= findGenericParameterReferencesRec(
+          genericSig, genericParam, member,
+          TypePosition::Invariant, /*canBeCovariantResult=*/false);
     }
 
-    return GenericParameterReferenceInfo();
+    return info;
   }
 
   if (!type->isTypeParameter()) {
@@ -5059,13 +5044,8 @@ findGenericParameterReferences(CanGenericSignature genericSig,
 
   // A direct reference to 'Self'.
   if (selfTy->isEqual(type)) {
-    if (position == TypePosition::Covariant) {
-      if (canBeCovariantResult) {
-        return GenericParameterReferenceInfo::forCovariantResult();
-      } else if (treatNonResultCovarianceAsInvariant) {
-        position = TypePosition::Invariant;
-      }
-    }
+    if (position == TypePosition::Covariant && canBeCovariantResult)
+      return GenericParameterReferenceInfo::forCovariantResult();
 
     return GenericParameterReferenceInfo::forSelfRef(position);
   }
@@ -5077,9 +5057,9 @@ findGenericParameterReferences(CanGenericSignature genericSig,
   }
 
   if (const auto concreteTy = genericSig->getConcreteType(type)) {
-    return findGenericParameterReferences(
-        genericSig, genericParam, concreteTy, position,
-        treatNonResultCovarianceAsInvariant, canBeCovariantResult);
+    return findGenericParameterReferencesRec(
+        genericSig, genericParam, concreteTy,
+        position, canBeCovariantResult);
   }
 
   // A reference to an associated type rooted on 'Self'.
@@ -5090,9 +5070,8 @@ GenericParameterReferenceInfo
 swift::findGenericParameterReferences(const ValueDecl *value,
                                       CanGenericSignature sig,
                                       GenericTypeParamType *genericParam,
-                                      bool treatNonResultCovarianceAsInvariant,
                                       std::optional<unsigned> skipParamIndex) {
-  assert(isa<TypeDecl>(value) == false);
+  assert(!isa<TypeDecl>(value));
   assert(sig->getGenericParamOrdinal(genericParam) <
          sig.getGenericParams().size());
 
@@ -5102,25 +5081,25 @@ swift::findGenericParameterReferences(const ValueDecl *value,
   if (type->hasError())
     return GenericParameterReferenceInfo();
 
+  // For functions and subscripts, take skipParamIndex into account.
   if (isa<AbstractFunctionDecl>(value) || isa<SubscriptDecl>(value)) {
-    // For a method, skip the 'self' parameter.
+    // And for a method, skip the 'self' parameter.
     if (value->hasCurriedSelf())
       type = type->castTo<AnyFunctionType>()->getResult();
 
     return ::findGenericParameterReferencesInFunction(
         sig, genericParam, type->castTo<AnyFunctionType>(),
-        TypePosition::Covariant, treatNonResultCovarianceAsInvariant,
-        /*canBeCovariantResult=*/true, skipParamIndex);
+        TypePosition::Covariant, /*canBeCovariantResult=*/true,
+        skipParamIndex);
   }
 
-  return ::findGenericParameterReferences(sig, genericParam, type,
-                                          TypePosition::Covariant,
-                                          treatNonResultCovarianceAsInvariant,
-                                          /*canBeCovariantResult=*/true);
+  return ::findGenericParameterReferencesRec(sig, genericParam, type,
+                                             TypePosition::Covariant,
+                                             /*canBeCovariantResult=*/true);
 }
 
 GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
-    Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const {
+    Type baseTy) const {
   assert(baseTy->isExistentialType());
   assert(!baseTy->hasTypeParameter());
 
@@ -5139,9 +5118,7 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
       GenericSignature());
 
   auto genericParam = sig.getGenericParams().front();
-  return findGenericParameterReferences(this, sig, genericParam,
-                                        treatNonResultCovariantSelfAsInvariant,
-                                        std::nullopt);
+  return findGenericParameterReferences(this, sig, genericParam, std::nullopt);
 }
 
 TypeDecl::CanBeInvertible::Result

lib/Sema/CSSimplify.cpp

@@ -1608,7 +1608,6 @@ shouldOpenExistentialCallArgument(ValueDecl *callee, unsigned paramIdx,
   // because it won't match anywhere else.
   auto referenceInfo = findGenericParameterReferences(
       callee, genericSig, genericParam,
-      /*treatNonResultCovarianceAsInvariant=*/false,
       /*skipParamIdx=*/paramIdx);
   if (referenceInfo.selfRef > TypePosition::Covariant ||
       referenceInfo.assocTypeRef > TypePosition::Covariant)

lib/Sema/ConstraintSystem.cpp

@@ -7548,9 +7548,7 @@ bool ConstraintSystem::isMemberAvailableOnExistential(
   // 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,
-      /*treatNonResultCovariantSelfAsInvariant=*/false);
+  const auto info = member->findExistentialSelfReferences(baseTy);
   if (info.selfRef > TypePosition::Covariant ||
       info.assocTypeRef > TypePosition::Covariant) {
     return false;

lib/Sema/TypeCheckDecl.cpp

@@ -734,8 +734,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(),
-          /*treatNonResultCovariantSelfAsInvariant=*/false);
+          decl->getDeclaredInterfaceType());
       if (info.selfRef > TypePosition::Covariant || info.assocTypeRef) {
         return true;
       }

lib/Sema/TypeCheckProtocol.cpp

@@ -1133,8 +1133,7 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
         // the default witness for 'Collection.Iterator', which is defined
         // as 'IndexingIterator<Self>'.
         const auto selfRefInfo = req->findExistentialSelfReferences(
-            proto->getDeclaredInterfaceType(),
-            /*treatNonResultCovariantSelfAsInvariant=*/true);
+            proto->getDeclaredInterfaceType());
         if (!selfRefInfo.assocTypeRef) {
           covariantSelf = classDecl;
         }
@@ -4037,10 +4036,11 @@ 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(),
-      /*treatNonResultCovariantSelfAsInvariant=*/true);
+      Proto->getDeclaredInterfaceType());
 
-  if (selfRefInfo.selfRef == TypePosition::Invariant) {
+  if (selfRefInfo.selfRef == TypePosition::Invariant ||
+      (selfRefInfo.selfRef == TypePosition::Covariant &&
+       !selfRefInfo.hasCovariantSelfResult)) {
     // References to Self in a position where subclasses cannot do
     // the right thing. Complain if the adoptee is a non-final
     // class.