[RequirementMachine] Suppress redundancy warnings when an explicit, redundant

rule has a non-explicit, non-redundant rule in its rewrite path.

This fixes bogus redundancy diagnostics in cases where the canonical form
of a redundant rule is not explicit in source, e.g.

protocol Swappable2 {
  associatedtype A
  associatedtype B
  associatedtype Swapped : Swappable2
    where Swapped.B == A,
          Swapped.Swapped == Self
}

in the above case, the canonical rule for `Swapped.B == A` is the rule
[Swappable2:Swapped].[Swappable2:A] => [Swappable2:B], which is not
explicit.

Author: hborla

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -725,13 +725,25 @@ RewriteSystem::getRedundantRequirements() {
   // The resulting set of redundant requirements.
   std::vector<RequirementError> redundantRequirements;
 
+  // Map redundant rule IDs to their rewrite path for easy access
+  // in the `isRedundantRule` lambda.
+  llvm::SmallDenseMap<unsigned, RewritePath> redundantRules;
+  for (auto &pair : RedundantRules)
+    redundantRules[pair.first] = pair.second;
+
   // Collect all rule IDs for each unique requirement ID.
   llvm::SmallDenseMap<unsigned, llvm::SmallDenseSet<unsigned, 2>>
       rulesPerRequirement;
 
+  // Collect non-explicit requirements that are not redundant.
+  llvm::SmallDenseSet<unsigned, 2> impliedRequirements;
+
   for (unsigned ruleID : indices(getRules())) {
     auto &rule = getRules()[ruleID];
 
+    if (!rule.isExplicit() && !rule.isPermanent() && !rule.isRedundant())
+      impliedRequirements.insert(ruleID);
+
     if (!rule.isExplicit())
       continue;
 
@@ -744,6 +756,30 @@ RewriteSystem::getRedundantRequirements() {
 
   auto isRedundantRule = [&](unsigned ruleID) {
     auto &rule = getRules()[ruleID];
+
+    // If this rule is replaced using a non-explicit,
+    // non-redundant rule, it's not redundant.
+    auto rewritePath = redundantRules[ruleID];
+    for (auto step : rewritePath) {
+      switch (step.Kind) {
+      case RewriteStep::Rule: {
+        if (impliedRequirements.count(step.getRuleID()))
+          return false;
+
+        break;
+      }
+
+      case RewriteStep::LeftConcreteProjection:
+      case RewriteStep::Decompose:
+      case RewriteStep::PrefixSubstitutions:
+      case RewriteStep::Shift:
+      case RewriteStep::Relation:
+      case RewriteStep::DecomposeConcrete:
+      case RewriteStep::RightConcreteProjection:
+        break;
+      }
+    }
+
     return rule.isRedundant();
   };
 

test/Constraints/generic_super_constraint.swift

@@ -3,6 +3,7 @@
 class Base<T> { }
 class Derived: Base<Int> { }
 
+// expected-warning@+1 {{redundant superclass constraint 'T' : 'Base<Int>'}}
 func foo<T>(_ x: T) -> Derived where T: Base<Int>, T: Derived {
   return x
 }

test/Generics/requirement_machine_diagnostics.swift

@@ -152,7 +152,8 @@ protocol P7 : P6 {
   associatedtype AssocP7: P6
 }
 
-extension P7 where AssocP6.Element : P6, // expected-warning{{redundant conformance constraint 'Self.AssocP6.Element' : 'P6'}}
+// FIXME: diagnose redundant requirement 'AssocP6.Element : P6'
+extension P7 where AssocP6.Element : P6,
         AssocP7.AssocP6.Element : P6,
         AssocP6.Element == AssocP7.AssocP6.Element {
   func nestedSameType1() { }

test/Generics/sr10752.swift

@@ -9,6 +9,6 @@ protocol P {
 // CHECK: sr10752.(file).Q@
 // CHECK-NEXT: Requirement signature: <Self where Self.[Q]A == Self.[Q]C.[P]A, Self.[Q]C : P>
 protocol Q {
-  associatedtype A : P
+  associatedtype A : P // expected-warning {{redundant conformance constraint 'Self.A' : 'P'}}
   associatedtype C : P where A == C.A
 }

test/Generics/sr12120.swift

@@ -6,8 +6,8 @@ protocol Swappable1 {
   associatedtype A
   associatedtype B
   associatedtype Swapped : Swappable1
-    where Swapped.B == A,
-          Swapped.A == B, // FIXME: Diagnose redundancy
+    where Swapped.B == A, // expected-warning {{redundant same-type constraint 'Self.Swapped.B' == 'Self.A'}}
+          Swapped.A == B,
           Swapped.Swapped == Self
 }
 

test/Generics/sr14485.swift

@@ -3,6 +3,8 @@
 // CHECK: sr14485.(file).P@
 // CHECK-NEXT: Requirement signature: <Self where Self.[P]Input == Self.[P]Output.[Numeric]Magnitude, Self.[P]Output : FixedWidthInteger, Self.[P]Output : SignedInteger>
 protocol P {
+  // expected-warning@+2 {{redundant conformance constraint 'Self.Input' : 'FixedWidthInteger'}}
+  // expected-warning@+1 {{redundant conformance constraint 'Self.Input' : 'UnsignedInteger'}}
   associatedtype Input: FixedWidthInteger & UnsignedInteger & BinaryInteger
   associatedtype Output: FixedWidthInteger & SignedInteger & BinaryInteger
     where Output.Magnitude == Input

test/decl/protocol/req/associated_type_ambiguity.swift

@@ -11,14 +11,14 @@ protocol P2 {
 
 // CHECK: ExtensionDecl line={{.*}} base=P1
 // CHECK-NEXT: Generic signature: <Self where Self : P1, Self : P2>
-extension P1 where Self : P2, T == Int {
+extension P1 where Self : P2, T == Int { // expected-warning {{redundant same-type constraint 'Self.T' == 'Int'}}
   func takeT11(_: T) {}
   func takeT12(_: Self.T) {}
 }
 
 // CHECK: ExtensionDecl line={{.*}} base=P1
 // CHECK-NEXT: Generic signature: <Self where Self : P1, Self : P2>
-extension P1 where Self : P2, Self.T == Int {
+extension P1 where Self : P2, Self.T == Int { // expected-warning {{redundant same-type constraint 'Self.T' == 'Int'}}
   func takeT21(_: T) {}
   func takeT22(_: Self.T) {}
 }