GSB: Canonicalize subject type in isValidDerivationPath()

Generally we say that a conformance requirement in a generic signature
is redundant if there is some other way to derive this conformance by
starting from another conformance requirement in the same signature,
and possibly following one or more conformance requirements on nested
types defined in protocols.

The notion of a 'valid derivation path' comes into play when you have
something like this:

    protocol P {
      associatedtype A
    }

    protocol Q {
      associatedtype B : P
    }

    <T where T : P, T.A : P, T.A.B == T>

Here, we don't want to conclude that (T : P) can be derived from
(T.A : P)(Self.B : P), because if we drop (T : P) from the signature,
we end up with

    <T where T.A : P, T.A.B == T>

Now in order to recover the witness table for T : P, we need to start
from T.A : P, which requires the type metadata for T.A, which can
only be recovered from the witness table for T : P, etc. We're stuck.

What we want to do is say that T : P is not redundant, because we
cannot derive it from T.A : P, because T.A depends on T : P.

However, this check was also too strict. Consider this example:

    protocol P {
      associatedtype T where T == Self
    }

    protocol Q : P {}

    <T where T : P, T.T : Q>

The naive algorithm would conclude that T : P is redundant because
it can be derived as (T.T : Q)(Self.T == Self). However, the valid
derivation path check would fail since T.T is derived from (T : P).

The problem is that since T.T is equivalent to T via (Self.T == T),
we would end up with this minimized signature:

    <T where T : P, T : Q>

The derivation path check should canonicalize the type first.

I'm still not 100% convinced this logic is correct, but at least,
we have another test case and maybe it's _more_ correct now.

Fixes part of rdar://problem/80503090.

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -5701,6 +5701,11 @@ GenericSignatureBuilder::isValidRequirementDerivationPath(
 
     auto otherSubjectType = otherReq.getSubjectType();
 
+    auto *equivClass = resolveEquivalenceClass(otherSubjectType,
+                                         ArchetypeResolutionKind::AlreadyKnown);
+    assert(equivClass &&
+           "Explicit requirement names an unknown equivalence class?");
+
     // If our requirement is based on a path involving some other
     // redundant requirement, see if we can derive the redundant
     // requirement using requirements we haven't visited yet.
@@ -5720,11 +5725,6 @@ GenericSignatureBuilder::isValidRequirementDerivationPath(
       if (!otherSource->isDerivedNonRootRequirement())
         return None;
 
-      auto *equivClass = resolveEquivalenceClass(otherSubjectType,
-                                           ArchetypeResolutionKind::AlreadyKnown);
-      assert(equivClass &&
-             "Explicit requirement names an unknown equivalence class?");
-
       switch (otherReq.getKind()) {
       case RequirementKind::Conformance: {
         auto *proto = otherReq.getRHS().get<ProtocolDecl *>();
@@ -5804,20 +5804,22 @@ GenericSignatureBuilder::isValidRequirementDerivationPath(
       }
     }
 
-    if (auto *depMemType = otherSubjectType->getAs<DependentMemberType>()) {
+    auto anchor = equivClass->getAnchor(*this, { });
+
+    if (auto *depMemType = anchor->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,
+      auto *baseEquivClass = resolveEquivalenceClass(baseType,
                                            ArchetypeResolutionKind::AlreadyKnown);
-      assert(equivClass &&
+      assert(baseEquivClass &&
              "Explicit requirement names an unknown equivalence class?");
 
-      auto found = equivClass->conformsTo.find(proto);
-      assert(found != equivClass->conformsTo.end());
+      auto found = baseEquivClass->conformsTo.find(proto);
+      assert(found != baseEquivClass->conformsTo.end());
 
       bool foundValidDerivation = false;
       for (const auto &constraint : found->second) {

test/Generics/rdar80503090.swift

@@ -0,0 +1,19 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures %s 2>&1 | %FileCheck %s
+
+protocol P {
+  associatedtype T where T == Self
+}
+
+protocol Q : P {}
+
+extension P {
+  func missing() {}
+}
+
+extension P where T : Q {
+  // CHECK-LABEL: Generic signature: <Self where Self : Q>
+  func test() {
+    missing()
+  }
+}