GSB: Replace 'self derived' check with a more sound notion of well-foundedness

Consider this example:

    protocol P1 {
      associatedtype A : P2
    }

    protocol P2 {
      associatedtype A
    }

    func foo<T : P2>(_: T) where T.A : P1, T.A.A == T {}

We cannot drop 'T : P2', even though it can be derived from
T.A.A == T and Self.A : P2 in protocol P1, because we actually
need the conformance T : P2 in order to recover the concrete
type for T.A.

This was handled via a hack which would ensure that the
conformance path (T.A : P1)(Self.A : P2) was not a candidate
derivation for T : P2, because T : P2 is one of the conformances
used to construct the subject type T.A in the conformance path.

This hack did not generalize to "cycles" of length greater than 1
however:

    func foo<T : P2, U : P2>(_: T, _: U)
      where T.A : P1, T.A.A == U, U.A : P1, U.A.A == T {}

We used to drop both T : P2 and U : P2, because each one had a
conformance path (U.A : P1)(Self.A : P2) and (T.A : P1)(Self.A : P2),
respectively; however, once we drop T : P2 and U : P2, these two
paths become invalid for the same reason that the concrete type
for T.A and U.A can no longer be recovered.

The correct fix is to recursively visit the subject type of each
base requirement when evaluating a conformance path, and not
consider any requirement whose subject type's parent type cannot
be recovered. This proceeds recursively.

In the worst case, this algorithm is exponential in the number of
conformance requirements, but it is not always exponential, and
a generic signature is not going to have a large number of
conformance requirements anyway (hopefully). Also, the old logic
in getMinimalConformanceSource() wasn't cheap either.

Perhaps some clever minimization can speed this up too, but I'm
going to focus on correctness first, before looking at performance
here.

Fixes rdar://problem/74890907.

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -5931,6 +5931,42 @@ GenericSignatureBuilder::isValidRequirementDerivationPath(
     // invalid once redundant requirements are dropped.
     if (isRedundantExplicitRequirement(otherReq))
       return None;
+
+    SWIFT_DEFER {
+      visited.erase(otherReq);
+    };
+    visited.insert(otherReq);
+
+    auto otherSubjectType = otherReq.getSubjectType();
+    if (auto *depMemType = otherSubjectType->getAs<DependentMemberType>()) {
+      // If 'req' is based on some other conformance requirement
+      // `T.[P.]A : Q', we want to make sure that we have a
+      // non-redundant derivation for 'T : P'.
+      auto baseType = depMemType->getBase();
+      auto *proto = depMemType->getAssocType()->getProtocol();
+
+      auto *equivClass = resolveEquivalenceClass(baseType,
+                                           ArchetypeResolutionKind::AlreadyKnown);
+      assert(equivClass &&
+             "Explicit requirement names an unknown equivalence class?");
+
+      auto found = equivClass->conformsTo.find(proto);
+      assert(found != equivClass->conformsTo.end());
+
+      bool foundValidDerivation = false;
+      for (const auto &constraint : found->second) {
+        if (isValidRequirementDerivationPath(
+                visited, RequirementKind::Conformance,
+                constraint.source, proto,
+                requirementSignatureSelfProto)) {
+          foundValidDerivation = true;
+          break;
+        }
+      }
+
+      if (!foundValidDerivation)
+        return None;
+    }
   }
 
   return result.front();
@@ -6024,15 +6060,6 @@ void GenericSignatureBuilder::computeRedundantRequirements(
           req, found->second,
           requirementSignatureSelfProto,
           [&](const Constraint<ProtocolDecl *> &constraint) {
-            // FIXME: Remove this.
-            auto minimalSource =
-              constraint.source->getMinimalConformanceSource(
-                  *this,
-                  constraint.getSubjectDependentType({ }),
-                  proto);
-            if (minimalSource != constraint.source)
-              return true;
-
             return false;
           });
 

test/Generics/rdar74890907.swift

@@ -0,0 +1,21 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures %s 2>&1 | %FileCheck %s
+
+protocol P1 {
+  associatedtype A : P2
+}
+
+protocol P2 {
+  associatedtype A
+}
+
+// CHECK: Generic signature: <T, U where T : P2, T == U.A.A, U == T.A.A, T.A : P1, U.A : P1>
+func testTU<T : P2, U : P2>(_: T, _: U) where T.A : P1, T.A.A == U, U.A : P1, U.A.A == T {}
+// expected-warning@-1 {{redundant conformance constraint 'U' : 'P2'}}
+// expected-note@-2 {{conformance constraint 'U' : 'P2' implied here}}
+
+// CHECK: Generic signature: <T, U where T == U.A.A, U : P2, U == T.A.A, T.A : P1, U.A : P1>
+func testU<T, U : P2>(_: T, _: U) where T.A : P1, T.A.A == U, U.A : P1, U.A.A == T {}
+
+// CHECK: Generic signature: <T, U where T : P2, T == U.A.A, U == T.A.A, T.A : P1, U.A : P1>
+func testT<T : P2, U>(_: T, _: U) where T.A : P1, T.A.A == U, U.A : P1, U.A.A == T {}