Decouple detection of «Self ==» constraints from SelfReferenceKind

Author: AnthonyLatsis

include/swift/AST/Decl.h

@@ -3747,56 +3747,48 @@ class ClassDecl final : public NominalTypeDecl {
 struct SelfReferenceKind {
   bool result;
   bool parameter;
-  bool requirement;
   bool other;
 
   /// The type does not refer to 'Self' at all.
   static SelfReferenceKind None() {
-    return SelfReferenceKind(false, false, false, false);
+    return SelfReferenceKind(false, false, false);
   }
 
   /// The type refers to 'Self', but only as the type of a property or
   /// the result type of a method/subscript.
   static SelfReferenceKind Result() {
-    return SelfReferenceKind(true, false, false, false);
+    return SelfReferenceKind(true, false, false);
   }
 
   /// The type refers to 'Self', but only as the parameter type
   /// of a method/subscript.
   static SelfReferenceKind Parameter() {
-    return SelfReferenceKind(false, true, false, false);
-  }
-
-  /// The type refers to 'Self' within a same-type requiement.
-  static SelfReferenceKind Requirement() {
-    return SelfReferenceKind(false, false, true, false);
+    return SelfReferenceKind(false, true, false);
   }
 
   /// The type refers to 'Self' in a position that is invariant.
   static SelfReferenceKind Other() {
-    return SelfReferenceKind(false, false, false, true);
+    return SelfReferenceKind(false, false, true);
   }
 
   SelfReferenceKind flip() const {
-    return SelfReferenceKind(parameter, result, requirement, other);
+    return SelfReferenceKind(parameter, result, other);
   }
 
   SelfReferenceKind operator|=(SelfReferenceKind kind) {
     result |= kind.result;
-    requirement |= kind.requirement;
     parameter |= kind.parameter;
     other |= kind.other;
     return *this;
   }
 
   operator bool() const {
-    return result || parameter || requirement || other;
+    return result || parameter || other;
   }
 
 private:
-  SelfReferenceKind(bool result, bool parameter, bool requirement, bool other)
-    : result(result), parameter(parameter), requirement(requirement),
-      other(other) { }
+  SelfReferenceKind(bool result, bool parameter, bool other)
+    : result(result), parameter(parameter), other(other) { }
 };
 
 /// The set of known protocols for which derived conformances are supported.

lib/AST/Decl.cpp

@@ -4778,25 +4778,6 @@ findProtocolSelfReferences(const ProtocolDecl *proto, Type type,
   return SelfReferenceKind::None();
 }
 
-/// Find Self references in a generic signature's same-type requirements.
-static SelfReferenceKind
-findProtocolSelfReferences(const ProtocolDecl *protocol,
-                           GenericSignature genericSig){
-  if (!genericSig) return SelfReferenceKind::None();
-
-  auto selfTy = protocol->getSelfInterfaceType();
-  for (const auto &req : genericSig->getRequirements()) {
-    if (req.getKind() != RequirementKind::SameType)
-      continue;
-
-    if (req.getFirstType()->isEqual(selfTy) ||
-        req.getSecondType()->isEqual(selfTy))
-      return SelfReferenceKind::Requirement();
-  }
-
-  return SelfReferenceKind::None();
-}
-
 /// Find Self references within the given requirement.
 SelfReferenceKind
 ProtocolDecl::findProtocolSelfReferences(const ValueDecl *value,
@@ -4836,27 +4817,11 @@ ProtocolDecl::findProtocolSelfReferences(const ValueDecl *value,
         return SelfReferenceKind::Other();
     }
 
-    // Check the requirements of a generic function.
-    if (func->isGeneric()) {
-      if (auto result =
-            ::findProtocolSelfReferences(this, func->getGenericSignature()))
-        return result;
-    }
-
     return ::findProtocolSelfReferences(this, type,
                                         skipAssocTypes);
   } else {
     assert(isa<AbstractStorageDecl>(value));
 
-    if (auto *const subscript = dyn_cast<SubscriptDecl>(value)) {
-      // Check the requirements of a generic subscript.
-      if (subscript->isGeneric()) {
-        if (auto result = ::findProtocolSelfReferences(
-                this, subscript->getGenericSignature()))
-          return result;
-      }
-    }
-
     return ::findProtocolSelfReferences(this, type,
                                         skipAssocTypes);
   }

lib/Sema/TypeCheckProtocol.cpp

@@ -3359,6 +3359,30 @@ diagnoseMissingWitnesses(MissingWitnessDiagnosisKind Kind) {
   }
 }
 
+/// Whether the given protocol requirement has a "Self ==" constraint.
+static bool hasSelfSameTypeConstraint(const ValueDecl *req) {
+  const auto *proto = cast<ProtocolDecl>(req->getDeclContext());
+  const auto *genCtx = req->getAsGenericContext();
+  if (!genCtx)
+    return false;
+
+  const auto genericSig = genCtx->getGenericSignature();
+  if (!genericSig)
+    return false;
+
+  const auto selfTy = proto->getSelfInterfaceType();
+  for (const auto &constr : genericSig->getRequirements()) {
+    if (constr.getKind() != RequirementKind::SameType)
+      continue;
+
+    if (constr.getFirstType()->isEqual(selfTy) ||
+        constr.getSecondType()->isEqual(selfTy))
+      return true;
+  }
+
+  return false;
+}
+
 /// Determine the given witness has a same-type constraint constraining the
 /// given 'Self' type, and return the requirement that does.
 ///
@@ -3509,7 +3533,7 @@ void ConformanceChecker::checkNonFinalClassWitness(ValueDecl *requirement,
           });
       }
     }
-  } else if (selfKind.requirement) {
+  } else if (hasSelfSameTypeConstraint(requirement)) {
     if (auto targetPair = getAdopteeSelfSameTypeConstraint(classDecl,
                                                            witness)) {
       // A "Self ==" constraint works incorrectly with subclasses. Complain.