RequirementMachine: Prefer to eliminate concrete type requirements over superclass requirements again

If you have something like this:

    protocol P {
      associatedtype A : Q where Self == Self.A.B
    }

    protocol Q {
      associatedtype B
    }

    class C : P {
      typealias A = D
    }

    class D : P {
      typealias B = C
    }

The GSB would minimize the generic signature <T where T : P, T : C>
to <T where T == C>, because of the same-type requirement in
protocol P.

However in reality, the conformance 'C : P' is unsound, because it
is no longer covariant. I added a warning in commit d831eff74879cb.

Because the upcoming 'concrete contraction' pass eliminates 'T : P'
before homotopy reduction gets a chance to run, I'm changing the
Requirement Machine to produce a different minimization from the
GSB. This is technically an ABI break, but it should not impact any
real code in practice. If it does, I'll need to come up with a
different workaround in concrete contraction.

Author: slavapestov

lib/AST/RequirementMachine/Symbol.h

@@ -120,18 +120,13 @@ class Symbol final {
     /// term's type satisfies the layout constraint.
     Layout,
 
-    /// When appearing at the end of a term, denotes that the term
-    /// is exactly equal to the concrete type.
-    ConcreteType,
-
     /// When appearing at the end of a term, denotes that the term
     /// is a subclass of the superclass constraint.
-    ///
-    /// Note that this orders after ConcreteType, to ensure compatibility
-    /// with the GenericSignatureBuilder on pathological generic signatures
-    /// where a type is subject to both a superclass and concrete type
-    /// requirement that imply each other.
     Superclass,
+
+    /// When appearing at the end of a term, denotes that the term
+    /// is exactly equal to the concrete type.
+    ConcreteType,
   };
 
   static const unsigned NumKinds = 8;

test/Generics/non_final_class_conforms_same_type_requirement_on_self.swift

@@ -1,5 +1,5 @@
-// RUN: %target-typecheck-verify-swift
-// RUN: not %target-swift-frontend -typecheck -debug-generic-signatures -requirement-machine-inferred-signatures=verify %s 2>&1 | %FileCheck %s
+// RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=on
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures -requirement-machine-inferred-signatures=on %s 2>&1 | %FileCheck %s
 
 public protocol P {
   associatedtype A : Q where A.B == Self
@@ -21,20 +21,26 @@ public class D : Q {
   public typealias B = C
 }
 
-// Both <T : P & C> and <T : C & P> minimize to <T where T == C>:
+// This is fine, because FinalC is final.
+public final class FinalC : P {
+  public typealias A = FinalD
+}
+
+public class FinalD : Q {
+  public typealias B = FinalC
+}
+
+// With the GSB, both <T : P & C> and <T : C & P> minimized to <T where T == C>:
 // - T : P and T : C imply that T.A == C.A == D;
 // - T : P also implies that T.A.B == T, via A.B == Self in P;
 // - Since T.A == D, T.A.B == D.B, therefore Self == D.B.
 // - D.B is a typealias for C, so really Self == C.
+//
+// The Requirement Machine leaves it as <T : C>. Technically this is an ABI break,
+// but the entire construction is unsound unless C is final.
+
+// CHECK-LABEL: Generic signature: <T where T : C>
+public func takesBoth1<T>(_: T) where T : P, T : C {}
 
-// CHECK-LABEL: Generic signature: <T where T == C>
-public func takesBoth1<T : P & C>(_: T) {}
-// expected-warning@-1 {{redundant conformance constraint 'T' : 'P'}}
-// expected-note@-2 {{conformance constraint 'T' : 'P' implied here}}
-// expected-error@-3 {{same-type requirement makes generic parameter 'T' non-generic}}
-
-// CHECK-LABEL: Generic signature: <U where U == C>
-public func takesBoth2<U : C & P>(_: U) {}
-// expected-warning@-1 {{redundant conformance constraint 'U' : 'P'}}
-// expected-note@-2 {{conformance constraint 'U' : 'P' implied here}}
-// expected-error@-3 {{same-type requirement makes generic parameter 'U' non-generic}}
+// CHECK-LABEL: Generic signature: <U where U : C>
+public func takesBoth2<U>(_: U) where U : C, U : P {}

test/Generics/rdar80503090.swift

@@ -22,7 +22,7 @@ class C : P {}
 // expected-warning@-1 {{non-final class 'C' cannot safely conform to protocol 'P', which requires that 'Self' is exactly equal to 'Self.T'; this is an error in Swift 6}}
 
 extension P where T : C {
-  // CHECK-LABEL: Generic signature: <Self where Self == C>
+  // CHECK-LABEL: Generic signature: <Self where Self : C>
   func test() {
     missing()
   }