RequirementMachine: Diagnose redundant concrete conformance requirements

A conformance requirement on a concrete type parameter is redundant if the
concrete type conforms to the protocol.

The replacement path for the conformance rule is based on a concrete
conformance rule introduced by the property map. Since the concrete
conformance rule is not associated with a requirement ID, this would
normally muffle the redundancy warning, because we don't want to
suggest removing a rule that depends on a non-redundant, non-explicit
rule.

However, concrete conformance rules don't actually appear in the
minimal signature, so skip them when computing the set of non-redundant,
non-explicit rules to ensure that the original conformance requirement
is still diagnosed as redundant.

Author: slavapestov

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -661,6 +661,15 @@ void RewriteSystem::computeRedundantRequirementDiagnostics(
     if (!isInMinimizationDomain(rule.getLHS().getRootProtocol()))
       continue;
 
+    // Concrete conformance rules do not map to requirements in the minimized
+    // signature; we don't consider them to be 'non-explicit non-redundant',
+    // so that a conformance rule (T.[P] => T) expressed in terms of a concrete
+    // conformance (T.[concrete: C : P] => T) is still diagnosed as redundant.
+    if (auto optSymbol = rule.isPropertyRule()) {
+      if (optSymbol->getKind() == Symbol::Kind::ConcreteConformance)
+        continue;
+    }
+
     auto requirementID = rule.getRequirementID();
 
     if (!requirementID.hasValue()) {

test/Generics/redundant_concrete_conformance.swift

@@ -0,0 +1,16 @@
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on
+
+protocol P1 {}
+protocol P2 : P1 {}
+
+protocol P3 {
+  associatedtype A where A == S
+}
+
+struct S : P2 {}
+
+func f1<T : P3>(_: T) where T.A : P1 {}
+// expected-warning@-1 {{redundant conformance constraint 'T.A' : 'P1'}}
+
+func f2<T : P3>(_: T) where T.A : P2 {}
+// expected-warning@-1 {{redundant conformance constraint 'T.A' : 'P2'}}

test/Generics/superclass_constraint.swift

@@ -1,5 +1,5 @@
-// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
-// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify > %t.dump 2>&1
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on
+// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on > %t.dump 2>&1
 // RUN: %FileCheck %s < %t.dump
 
 class A {
@@ -12,13 +12,10 @@ class B : A {
 
 class Other { }
 
-func f1<T : A>(_: T) where T : Other {} // expected-error{{type 'T' cannot be a subclass of both 'Other' and 'A'}}
-// expected-note@-1{{constraint conflicts with 'T' : 'A'}}
+func f1<T : A>(_: T) where T : Other {} // expected-error{{no type for 'T' can satisfy both 'T : Other' and 'T : A'}}
 
 func f2<T : A>(_: T) where T : B {}
 // expected-warning@-1{{redundant superclass constraint 'T' : 'A'}}
-// expected-note@-2{{superclass constraint 'T' : 'A' implied here}}
-
 
 class GA<T> {}
 class GB<T> : GA<T> {}
@@ -31,19 +28,16 @@ func f5<T, U : GA<T>>(_: T, _: U) {}
 func f6<U : GA<T>, T : P>(_: T, _: U) {}
 func f7<U, T>(_: T, _: U) where U : GA<T>, T : P {}
 
-func f8<T : GA<A>>(_: T) where T : GA<B> {} // expected-error{{type 'T' cannot be a subclass of both 'GA<B>' and 'GA<A>'}}
-// expected-note@-1{{constraint conflicts with 'T' : 'GA<A>'}}
+func f8<T : GA<A>>(_: T) where T : GA<B> {} // expected-error{{no type for 'T' can satisfy both 'T : GA<B>' and 'T : GA<A>'}}
 
 func f9<T : GA<A>>(_: T) where T : GB<A> {}
 // expected-warning@-1{{redundant superclass constraint 'T' : 'GA<A>'}}
-// expected-note@-2{{superclass constraint 'T' : 'GA<A>' implied here}}
 
 func f10<T : GB<A>>(_: T) where T : GA<A> {}
 // expected-warning@-1{{redundant superclass constraint 'T' : 'GA<A>'}}
-// expected-note@-2{{superclass constraint 'T' : 'GA<A>' implied here}}
 
-func f11<T : GA<T>>(_: T) { } // expected-error{{superclass constraint 'T' : 'GA<T>' is recursive}}
-func f12<T : GA<U>, U : GB<T>>(_: T, _: U) { } // expected-error{{superclass constraint 'U' : 'GB<T>' is recursive}} // expected-error{{superclass constraint 'T' : 'GA<U>' is recursive}}
+func f11<T : GA<T>>(_: T) { }
+func f12<T : GA<U>, U : GB<T>>(_: T, _: U) { }
 func f13<T : U, U : GA<T>>(_: T, _: U) { } // expected-error{{type 'T' constrained to non-protocol, non-class type 'U'}}
 
 // rdar://problem/24730536
@@ -68,16 +62,16 @@ class S : P2 {
 // CHECK-LABEL: .superclassConformance1(t:)@
 // CHECK-NEXT: Generic signature: <T where T : C>
 func superclassConformance1<T>(t: T)
-  where T : C, // expected-note{{conformance constraint 'T' : 'P3' implied here}}
-        T : P3 {} // expected-warning{{redundant conformance constraint 'T' : 'P3'}}
+  where T : C,
+        T : P3 {} // expected-warning{{redundant conformance constraint 'C' : 'P3'}}
 
 
 
 // CHECK-LABEL: .superclassConformance2(t:)@
 // CHECK-NEXT: Generic signature: <T where T : C>
 func superclassConformance2<T>(t: T)
-  where T : C, // expected-note{{conformance constraint 'T' : 'P3' implied here}}
-   T : P3 {} // expected-warning{{redundant conformance constraint 'T' : 'P3'}}
+  where T : C,
+   T : P3 {} // expected-warning{{redundant conformance constraint 'C' : 'P3'}}
 
 protocol P4 { }
 
@@ -87,32 +81,28 @@ class C2 : C, P4 { }
 // CHECK-NEXT: Generic signature: <T where T : C2>
 func superclassConformance3<T>(t: T) where T : C, T : P4, T : C2 {}
 // expected-warning@-1{{redundant superclass constraint 'T' : 'C'}}
-// expected-note@-2{{superclass constraint 'T' : 'C' implied here}}
-// expected-warning@-3{{redundant conformance constraint 'T' : 'P4'}}
-// expected-note@-4{{conformance constraint 'T' : 'P4' implied here}}
+// expected-warning@-2{{redundant conformance constraint 'T' : 'P4'}}
 
 protocol P5: A { }
 
-protocol P6: A, Other { } // expected-error {{type 'Self' cannot be a subclass of both 'Other' and 'A'}}
+protocol P6: A, Other { } // expected-error {{no type for 'Self' can satisfy both 'Self : Other' and 'Self : A'}}
 // expected-error@-1{{multiple inheritance from classes 'A' and 'Other'}}
-// expected-note@-2 {{constraint conflicts with 'Self' : 'A'}}
 
 func takeA(_: A) { }
 func takeP5<T: P5>(_ t: T) {
 	takeA(t) // okay
 }
 
 protocol P7 {
-	associatedtype Assoc: A, Other 
-	// expected-note@-1{{constraint conflicts with 'Self.Assoc' : 'A'}}
-	// expected-error@-2{{'Self.Assoc' cannot be a subclass of both 'Other' and 'A'}}
+// expected-error@-1{{no type for 'Self.Assoc' can satisfy both 'Self.Assoc : Other' and 'Self.Assoc : A'}}
+	associatedtype Assoc: A, Other
 }
 
 // CHECK-LABEL: .superclassConformance4@
 // CHECK-NEXT: Generic signature: <T, U where T : P3, U : P3, T.[P3]T : C, T.[P3]T == U.[P3]T>
 func superclassConformance4<T: P3, U: P3>(_: T, _: U)
-  where T.T: C, // expected-note{{superclass constraint 'U.T' : 'C' implied here}}
-        U.T: C, // expected-warning{{redundant superclass constraint 'U.T' : 'C'}}
+  where T.T: C, // expected-warning{{redundant superclass constraint 'T.T' : 'C'}}
+        U.T: C,
         T.T == U.T { }
 
 // Lookup of superclass associated types from inheritance clause
@@ -181,8 +171,7 @@ protocol Rump : Tail {
 class Horse<T>: Rump { }
 
 func hasRedundantConformanceConstraint<X : Horse<T>, T>(_: X) where X : Rump {}
-// expected-warning@-1 {{redundant conformance constraint 'X' : 'Rump'}}
-// expected-note@-2 {{conformance constraint 'X' : 'Rump' implied here}}
+// expected-warning@-1 {{redundant conformance constraint 'Horse<T>' : 'Rump'}}
 
 // SR-5862
 protocol X {

validation-test/compiler_crashers_2_fixed/0145-sr7097.swift

@@ -1,6 +1,6 @@
-// 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-swift-frontend -primary-file %s -emit-ir -o - -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
+// RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=on
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures %s -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -primary-file %s -emit-ir -o - -requirement-machine-inferred-signatures=on
 
 protocol P1 { }
 
@@ -13,7 +13,6 @@ protocol P2 {
 protocol P3 : P2 { }
 
 struct S0<M: P3> where M.Assoc: P1 { } // expected-warning{{redundant conformance constraint 'M.Assoc' : 'P1'}}
-// expected-note@-1{{conformance constraint 'M.Assoc' : 'P1' implied here}}
 
 struct ConformsToP1: P1 { }