RequirementMachine: Fix a case where we diagnose requirements made redundant by an inferred requirement

We infer requirements from types appearing in parameter and result types,
like this:

    func foo<T>(_: Set<T>) // 'T : Hashable' inferred from 'Set<T>'

Normally we muffle the warning if the requirement is re-stated redundantly:

    func foo<T>(_: Set<T>) where T : Hashable // no warning

However, in some cases we failed to do this if the requirement was inferred
from a type appearing in a 'where' clause, like this:

    struct G<A, B> {}
    extension G where B : Hashable, A == Set<B> {}

This is because in this case the redundancy was detected by
RewriteSystem::addRule() returning false.

The simplest fix here is to change InferredGenericSignatureRequest
to re-order requirements so that inferred requirements appear last.
This way, if any are redundant, we won't diagnose them since it is
the inferred requirement that is redundant and not the user-written
one.

Fixes rdar://problem/92092635.

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -816,6 +816,15 @@ InferredGenericSignatureRequestRQM::evaluate(
   for (const auto &req : addedRequirements)
     requirements.push_back({req, SourceLoc(), /*wasInferred=*/true});
 
+  // Re-order requirements so that inferred requirements appear last. This
+  // ensures that if an inferred requirement is redundant with some other
+  // requirement, it is the inferred requirement that becomes redundant,
+  // which muffles the redundancy diagnostic.
+  std::stable_partition(requirements.begin(), requirements.end(),
+                        [](const StructuralRequirement &req) {
+                          return !req.inferred;
+                        });
+
   auto &ctx = moduleForInference->getASTContext();
   auto &rewriteCtx = ctx.getRewriteContext();
 

test/Generics/rdar75656022.swift

@@ -1,5 +1,5 @@
-// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
-// RUN: %target-swift-frontend -typecheck -debug-generic-signatures %s -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify 2>&1 | %FileCheck %s
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures %s -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
 
 protocol P1 {
   associatedtype T
@@ -48,8 +48,7 @@ struct OriginalExampleWithWarning<A, B> where A : P2, B : P2, A.T == B.T {
   init<C, D, E>(_: C)
     where C : P1,
           D : P1, // expected-warning {{redundant conformance constraint 'D' : 'P1'}}
-          C.T : P1, // expected-warning {{redundant conformance constraint 'D' : 'P1'}}
-          // expected-note@-1 {{conformance constraint 'D' : 'P1' implied here}}
+          C.T : P1, // expected-warning {{redundant conformance constraint 'C.T' : 'P1'}}
           A == S1<C, C.T.T, S2<C.T>>,
           C.T == D,
           E == D.T { }

test/Generics/rdar77462797.swift

@@ -1,5 +1,5 @@
-// RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=verify
-// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=verify 2>&1 | %FileCheck %s
+// RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=on
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
 
 protocol P {}
 
@@ -21,18 +21,15 @@ struct G<X, Y> where X : Q {
 
   // 'X : Q' is redundant
   func foo3() where X : Q, X == S<Y>, Y : P {}
-  // expected-warning@-1 {{redundant conformance constraint 'X' : 'Q'}}
-  // expected-note@-2 {{conformance constraint 'X' : 'Q' implied here}}
+  // expected-warning@-1 {{redundant conformance constraint 'S<Y>' : 'Q'}}
   // CHECK: Generic signature: <X, Y where X == S<Y>, Y : P>
 
   // 'T.T : P' is redundant
   func foo4<T : Q>(_: T) where X == S<Y>, T.T : P {}
   // expected-warning@-1 {{redundant conformance constraint 'T.T' : 'P'}}
-  // expected-note@-2 {{conformance constraint 'T.T' : 'P' implied here}}
   // CHECK: Generic signature: <X, Y, T where X == S<Y>, Y : P, T : Q>
 }
 
 func foo<X, Y>(_: X, _: Y) where X : Q, X : S<Y>, Y : P {}
-// expected-warning@-1 {{redundant conformance constraint 'X' : 'Q'}}
-// expected-note@-2 {{conformance constraint 'X' : 'Q' implied here}}
+// expected-warning@-1 {{redundant conformance constraint 'S<Y>' : 'Q'}}
 // CHECK: Generic signature: <X, Y where X : S<Y>, Y : P>

test/Generics/redundant_inferred_requirement_order.swift

@@ -0,0 +1,14 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P {}
+
+struct S<T : P> {}
+
+struct G<A, B> {}
+
+extension G where A == S<B>, B : P {}
+
+extension G where B : P, A == S<B> {}
+
+extension G where B : P, A == S<B>, B : P {}
+// expected-warning@-1 {{redundant conformance constraint 'B' : 'P'}}