RequirementMachine: Narrower definition of Rule::isProtocolRefinementRule()

With this change the RequirementMachine's minimization behavior with
protocol refinement rules matches the GenericSignatureBuilder.

See swiftlang#37466 for a full explanation
of what's going on here.

Author: slavapestov

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -67,12 +67,28 @@ bool Rule::isIdentityConformanceRule() const {
 /// If this is a rule of the form [P].[Q] => [P] where [P] and [Q] are
 /// protocol symbols, return true, otherwise return false.
 bool Rule::isProtocolRefinementRule() const {
-  return (LHS.size() == 2 &&
-          RHS.size() == 1 &&
-          LHS[0] == RHS[0] &&
-          LHS[0].getKind() == Symbol::Kind::Protocol &&
-          LHS[1].getKind() == Symbol::Kind::Protocol &&
-          LHS[0] != LHS[1]);
+  if (LHS.size() == 2 &&
+      RHS.size() == 1 &&
+      LHS[0] == RHS[0] &&
+      LHS[0].getKind() == Symbol::Kind::Protocol &&
+      LHS[1].getKind() == Symbol::Kind::Protocol &&
+      LHS[0] != LHS[1]) {
+
+    // A protocol refinement rule only if it comes from a directly-stated
+    // inheritance clause entry. It can only become redundant if it is
+    // written in terms of other protocol refinement rules; otherwise, it
+    // must appear in the protocol's requirement signature.
+    //
+    // See RewriteSystem::isValidRefinementPath().
+    auto *proto = LHS[0].getProtocol();
+    auto *otherProto = LHS[1].getProtocol();
+
+    auto inherited = proto->getInheritedProtocols();
+    return (std::find(inherited.begin(), inherited.end(), otherProto)
+            != inherited.end());
+  }
+
+  return false;
 }
 
 /// Returns the length of the left hand side.

test/Generics/redundant_protocol_refinement.swift

@@ -1,12 +1,23 @@
 // RUN: %target-typecheck-verify-swift
-// RUN: %target-swift-frontend -typecheck -debug-generic-signatures %s 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures -requirement-machine-protocol-signatures=verify %s 2>&1 | %FileCheck %s
 
 protocol Base {}
+
+// CHECK-LABEL: redundant_protocol_refinement.(file).Base@
+// CHECK-LABEL: Requirement signature: <Self>
+
 protocol Middle : Base {}
+
+// CHECK-LABEL: redundant_protocol_refinement.(file).Middle@
+// CHECK-LABEL: Requirement signature: <Self where Self : Base>
+
 protocol Derived : Middle, Base {}
 // expected-note@-1 {{conformance constraint 'Self' : 'Base' implied here}}
 // expected-warning@-2 {{redundant conformance constraint 'Self' : 'Base'}}
 
+// CHECK-LABEL: redundant_protocol_refinement.(file).Derived@
+// CHECK-LABEL: Requirement signature: <Self where Self : Middle>
+
 protocol P1 {}
 
 protocol P2 {
@@ -15,10 +26,14 @@ protocol P2 {
 
 // no warning here
 protocol Good: P2, P1 where Assoc == Self {}
+
+// CHECK-LABEL: redundant_protocol_refinement.(file).Good@
 // CHECK-LABEL: Requirement signature: <Self where Self : P1, Self : P2, Self == Self.Assoc>
 
 // missing refinement of 'P1'
 protocol Bad: P2 where Assoc == Self {}
 // expected-warning@-1 {{protocol 'Bad' should be declared to refine 'P1' due to a same-type constraint on 'Self'}}
 // expected-note@-2 {{conformance constraint 'Self' : 'P1' implied here}}
+
+// CHECK-LABEL: redundant_protocol_refinement.(file).Bad@
 // CHECK-LABEL: Requirement signature: <Self where Self : P2, Self == Self.Assoc>