Stop passing -warn-redundant-requirements in tests

Author: slavapestov

test/AutoDiff/SILGen/differentiability_witness_generic_signature.swift

@@ -1,5 +1,5 @@
-// RUN: %target-swift-emit-silgen -verify -module-name main %s -warn-redundant-requirements | %FileCheck %s
-// RUN: %target-swift-emit-sil -verify -module-name main %s -warn-redundant-requirements
+// RUN: %target-swift-emit-silgen -verify -module-name main %s | %FileCheck %s
+// RUN: %target-swift-emit-sil -verify -module-name main %s
 
 // NOTE: SILParser crashes for SILGen round-trip
 // (https://github.com/apple/swift/issues/54370).
@@ -85,7 +85,7 @@ extension AllConcrete where T == Float {
   // Derivative generic signature: `<T where T == Float>` (explicit `where` clause)
   //    Witness generic signature: none
   @_silgen_name("allconcrete_where_gensig")
-  @differentiable(reverse where T == Float) // expected-warning {{redundant same-type constraint 'T' == 'Float'}}
+  @differentiable(reverse where T == Float)
   func whereClauseGenericSignature() -> AllConcrete {
     return self
   }
@@ -159,7 +159,7 @@ extension NotAllConcrete where T == Float {
   // Derivative generic signature: `<T, U where T == Float>` (explicit `where` clause)
   //    Witness generic signature: `<T, U where T == Float>` (not all concrete)
   @_silgen_name("notallconcrete_where_gensig")
-  @differentiable(reverse where T == Float) // expected-warning {{redundant same-type constraint 'T' == 'Float'}}
+  @differentiable(reverse where T == Float)
   func whereClauseGenericSignature() -> NotAllConcrete {
     return self
   }

test/AutoDiff/SILOptimizer/generics.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-emit-sil -verify %s -warn-redundant-requirements | %FileCheck %s -check-prefix=CHECK-SIL
+// RUN: %target-swift-emit-sil -verify %s | %FileCheck %s -check-prefix=CHECK-SIL
 
 import _Differentiation
 
@@ -51,14 +51,12 @@ func foo<T>(_ x: Wrapper<T>) {
 
 // Test case where associated derivative function's requirements are met.
 extension Wrapper where Scalar : Numeric {
-  @differentiable(reverse, wrt: self where Scalar : Differentiable & FloatingPoint) // expected-warning {{redundant conformance constraint 'Scalar' : 'Differentiable'}}
-  // expected-warning@-1 {{redundant conformance constraint 'Scalar' : 'Numeric'}}
+  @differentiable(reverse, wrt: self where Scalar : Differentiable & FloatingPoint) 
   func mean() -> Wrapper {
     return self
   }
 
-  @differentiable(reverse, wrt: self where Scalar : Differentiable & FloatingPoint) // expected-warning {{redundant conformance constraint 'Scalar' : 'Differentiable'}}
-  // expected-warning@-1 {{redundant conformance constraint 'Scalar' : 'Numeric'}}
+  @differentiable(reverse, wrt: self where Scalar : Differentiable & FloatingPoint)
   func variance() -> Wrapper {
     return mean() // ok
   }
@@ -219,7 +217,7 @@ let _: @differentiable(reverse) (Float, Float) -> TF_546<Float> = { r, i in
 struct TF_652<Scalar> {}
 extension TF_652 : Differentiable where Scalar : FloatingPoint {}
 
-@differentiable(reverse, wrt: x where Scalar: FloatingPoint) // expected-warning {{redundant conformance constraint 'Scalar' : 'Numeric'}}
+@differentiable(reverse, wrt: x where Scalar: FloatingPoint)
 func test<Scalar: Numeric>(x: TF_652<Scalar>) -> TF_652<Scalar> {
   for _ in 0..<10 {
     let _ = x
@@ -295,7 +293,7 @@ struct TF_697_Sequential<Layer1: TF_697_Module, Layer2: TF_697_Layer>: TF_697_Mo
         layer2.callLayer(layer1.callModule(input))
     }
 }
-extension TF_697_Sequential: TF_697_Layer where Layer1: TF_697_Layer { // expected-warning {{redundant conformance constraint 'Layer1' : 'TF_697_Module'}}
+extension TF_697_Sequential: TF_697_Layer where Layer1: TF_697_Layer {
     @differentiable(reverse)
     func callLayer(_ input: Layer1.Input) -> Layer2.Output {
         layer2.callLayer(layer1.callLayer(input))

test/Compatibility/anyobject_class.swift

@@ -1,5 +1,5 @@
-// RUN: %target-typecheck-verify-swift -swift-version 4 -warn-redundant-requirements
+// RUN: %target-typecheck-verify-swift -swift-version 4
 // RUN: not %target-swift-frontend -typecheck -swift-version 5
 
 protocol P : class, AnyObject { } // expected-warning{{redundant inheritance from 'AnyObject' and Swift 3 'class' keyword}}{{14-21=}}
-// expected-warning@-1{{redundant constraint 'Self' : 'AnyObject'}}
+

test/Constraints/generic_super_constraint.swift

@@ -1,16 +1,14 @@
-// RUN: %target-typecheck-verify-swift %s -warn-redundant-requirements
+// RUN: %target-typecheck-verify-swift %s
 
 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
 }
 
-// FIXME: There is no explicit same-type requirement written.
-// expected-warning@+1{{same-type requirement makes generic parameter 'T' non-generic}}
 func bar<T, U>(_ x: U, y: T) -> (Derived, Int) where U: Base<T>, U: Derived {
+// expected-warning@-1 {{same-type requirement makes generic parameter 'T' non-generic}}
   return (x, y)
 }
 

test/Constraints/same_types.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -warn-redundant-requirements
+// RUN: %target-typecheck-verify-swift
 // RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
 
 protocol Fooable {
@@ -57,7 +57,6 @@ func test2a<T: Fooable, U: Fooable>(_ t: T, u: U) -> (X, X)
 // CHECK-NEXT: Generic signature: <T, U where T : Fooable, U : Fooable, T.[Fooable]Foo == X, U.[Fooable]Foo == X>
 func test3<T: Fooable, U: Fooable>(_ t: T, u: U) -> (X, X)
   where T.Foo == X, U.Foo == X, T.Foo == U.Foo {
-	// expected-warning@-1{{redundant same-type constraint 'T.Foo' == 'X'}}
   return (t.foo, u.foo)
 }
 
@@ -101,7 +100,6 @@ func test6<T: Barrable>(_ t: T) -> (Y, X) where T.Bar == Y {
 // CHECK-LABEL: same_types.(file).test7@
 // CHECK-NEXT: Generic signature: <T where T : Barrable, T.[Barrable]Bar == Y>
 func test7<T: Barrable>(_ t: T) -> (Y, X) where T.Bar == Y, T.Bar.Foo == X {
-	// expected-warning@-1{{redundant same-type constraint 'Y.Foo' (aka 'X') == 'X'}}
   return (t.bar, t.bar.foo)
 }
 
@@ -143,7 +141,7 @@ func fail6<T>(_ t: T) -> Int where T == Int { // expected-warning{{same-type req
 // CHECK-NEXT: Generic signature: <T, U where T : Barrable, U : Barrable, T.[Barrable]Bar == Y, U.[Barrable]Bar == Y>
 func test8<T: Barrable, U: Barrable>(_ t: T, u: U) -> (Y, Y, X, X)
   where T.Bar == Y,
-        U.Bar.Foo == X, T.Bar == U.Bar { // expected-warning{{redundant same-type constraint 'U.Bar.Foo' == 'X'}}
+        U.Bar.Foo == X, T.Bar == U.Bar {
   return (t.bar, u.bar, t.bar.foo, u.bar.foo)
 }
 
@@ -152,14 +150,14 @@ func test8<T: Barrable, U: Barrable>(_ t: T, u: U) -> (Y, Y, X, X)
 func test8a<T: Barrable, U: Barrable>(_ t: T, u: U) -> (Y, Y, X, X)
   where
   T.Bar == Y,
-  U.Bar.Foo == X, U.Bar == T.Bar { // expected-warning{{redundant same-type constraint 'U.Bar.Foo' == 'X'}}
+  U.Bar.Foo == X, U.Bar == T.Bar {
   return (t.bar, u.bar, t.bar.foo, u.bar.foo)
 }
 
 // CHECK-LABEL: same_types.(file).test8b(_:u:)@
 // CHECK-NEXT: Generic signature: <T, U where T : Barrable, U : Barrable, T.[Barrable]Bar == Y, U.[Barrable]Bar == Y>
 func test8b<T: Barrable, U: Barrable>(_ t: T, u: U)
-  where U.Bar.Foo == X, // expected-warning{{redundant same-type constraint 'U.Bar.Foo' == 'X'}}
+  where U.Bar.Foo == X,
         T.Bar == Y,
         T.Bar == U.Bar {
 }
@@ -205,7 +203,6 @@ struct S2<T : P> where T.A == T.B {
   // CHECK-LABEL: same_types.(file).S2.foo(x:y:)@
   // CHECK-NEXT: <T, X, Y where T : P, X == Y, Y == T.[P]A, T.[P]A == T.[P]B>
   func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.B {  // expected-warning{{same-type requirement makes generic parameters 'Y' and 'X' equivalent}}
-  // expected-warning@-1 {{redundant same-type constraint 'X' == 'T.A'}}
     print(X.self)
     print(Y.self)
     print(x)
@@ -278,7 +275,6 @@ func structuralSameType3<T, U, V, W>(_: T, _: U, _: V, _: W)
   where X1<T, U> == X1<V, W> { }
 // expected-warning@-2{{same-type requirement makes generic parameters 'V' and 'T' equivalent}}
 // expected-warning@-3{{same-type requirement makes generic parameters 'W' and 'U' equivalent}}
-// expected-warning@-3{{redundant same-type constraint 'X1<T, U>' == 'X1<V, W>'}}
 
 protocol P2 {
   associatedtype Assoc1
@@ -337,7 +333,6 @@ func test9<T: P6, U: P6>(_ t: T, u: U) // expected-error{{no type for 'T.Bar.Foo
 func testMetatypeSameType<T, U>(_ t: T, _ u: U)
   where T.Type == U.Type { }
 // expected-warning@-2{{same-type requirement makes generic parameters 'U' and 'T' equivalent}}
-// expected-warning@-2{{redundant same-type constraint 'T.Type' == 'U.Type'}}
 
 // CHECK-LABEL: same_types.(file).testSameTypeCommutativity1@
 // CHECK-NEXT: Generic signature: <U, T where U == T.Type>

test/Generics/associated_type_typo.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -warn-redundant-requirements
+// RUN: %target-typecheck-verify-swift
 
 // RUN: not %target-swift-frontend -typecheck -debug-generic-signatures %s > %t.dump 2>&1 
 // RUN: %FileCheck -check-prefix CHECK-GENERIC %s < %t.dump
@@ -62,9 +62,10 @@ protocol Pattern {
 
   // FIXME: This works for all of the wrong reasons, but it is correct that
   // it works.
-  // FIXME(rqm-diagnostics): Bogus warning here.
+  // CHECK-GENERIC-LABEL: .matched(atStartOf:)@
+  // CHECK-GENERIC-NEXT: Generic signature: <Self, C where Self : Pattern, C : Sequence, C : Indexable, Self.[Pattern]Element == C.[Sequence]Element, C.[Sequence]Element == C.[_Indexable1]Slice.[Sequence]Element, C.[_Indexable1]Slice : Sequence>
   func matched<C: Indexable>(atStartOf c: C)
-  where Element_<C> == Element // expected-warning {{redundant same-type constraint 'Element_<C>' (aka 'C.Iterator.Element') == 'Self.Element'}}
+  where Element_<C> == Element
   , Element_<C.Slice> == Element
 }
 

test/Generics/associated_type_where_clause.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -swift-version 4 -warn-redundant-requirements
+// RUN: %target-typecheck-verify-swift -swift-version 4
 
 func needsSameType<T>(_: T.Type, _: T.Type) {}
 
@@ -134,7 +134,6 @@ struct X { }
 protocol P {
 	associatedtype P1 where P1 == X
 	associatedtype P2 where P2 == P1, P2 == X
-	// expected-warning@-1{{redundant same-type constraint 'Self.P2' == 'X'}}
 }
 
 // Lookup of same-named associated types aren't ambiguous in this context.

test/Generics/canonicalization.swift

@@ -1,4 +1,5 @@
-// RUN: %target-typecheck-verify-swift -warn-redundant-requirements
+// RUN: %target-typecheck-verify-swift
+// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
 
 // rdar://problem/23149063
 protocol P0 { }
@@ -11,8 +12,11 @@ protocol Q : P {
   associatedtype A
 }
 
+// CHECK-LABEL: .f(t:)@
+// CHECK-NEXT: Generic signature: <T where T : Q, T.[P]A : P0>
 func f<T>(t: T) where T : P, T : Q, T.A : P0 { } // expected-note{{'f(t:)' previously declared here}}
-// expected-warning@-1{{redundant conformance constraint 'T' : 'P'}}
 
+// CHECK-LABEL: .f(t:)@
+// CHECK-NEXT: Generic signature: <T where T : Q, T.[P]A : P0>
 func f<T>(t: T) where T : Q, T : P, T.A : P0 { } // expected-error{{invalid redeclaration of 'f(t:)'}}
-// expected-warning@-1{{redundant conformance constraint 'T' : 'P'}}
+

test/Generics/concrete_conformances_in_protocol.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -warn-redundant-requirements
+// RUN: %target-typecheck-verify-swift
 // RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
 
 protocol P {
@@ -13,7 +13,6 @@ struct S : P {
 
 protocol R0 {
   associatedtype A where A : P, A == S
-  // expected-warning@-1 {{redundant conformance constraint 'S' : 'P'}}
 }
 
 ////
@@ -26,15 +25,13 @@ struct G<T> : P {}
 protocol R1 {
   associatedtype A
   associatedtype B where B : P, B == G<A>
-  // expected-warning@-1 {{redundant conformance constraint 'G<Self.A>' : 'P'}}
 }
 
 // CHECK-LABEL: concrete_conformances_in_protocol.(file).R2@
 // CHECK-LABEL: Requirement signature: <Self where Self.[R2]A == G<Self.[R2]B>>
 
 protocol R2 {
   associatedtype A where A : P, A == G<B>
-  // expected-warning@-1 {{redundant conformance constraint 'G<Self.B>' : 'P'}}
   associatedtype B
 }
 
@@ -52,15 +49,13 @@ struct GG<T : P> : PP {}
 protocol RR3 {
   associatedtype A : P
   associatedtype B where B : PP, B == GG<A>
-  // expected-warning@-1 {{redundant conformance constraint 'GG<Self.A>' : 'PP'}}
 }
 
 // CHECK-LABEL: concrete_conformances_in_protocol.(file).RR4@
 // CHECK-LABEL: Requirement signature: <Self where Self.[RR4]A == GG<Self.[RR4]B>, Self.[RR4]B : P>
 
 protocol RR4 {
   associatedtype A where A : PP, A == GG<B>
-  // expected-warning@-1 {{redundant conformance constraint 'GG<Self.B>' : 'PP'}}
   associatedtype B : P
 }
 
@@ -70,15 +65,13 @@ protocol RR4 {
 protocol RR5 {
   associatedtype A : PP
   associatedtype B where B : PP, B == GG<A.T>
-  // expected-warning@-1 {{redundant conformance constraint 'GG<Self.A.T>' : 'PP'}}
 }
 
 // CHECK-LABEL: concrete_conformances_in_protocol.(file).RR6@
 // CHECK-LABEL: Requirement signature: <Self where Self.[RR6]A == GG<Self.[RR6]B.[PP]T>, Self.[RR6]B : PP>
 
 protocol RR6 {
   associatedtype A where A : PP, A == GG<B.T>
-  // expected-warning@-1 {{redundant conformance constraint 'GG<Self.B.T>' : 'PP'}}
   associatedtype B : PP
 }
 
@@ -95,7 +88,6 @@ struct GGG<U : P1> : P1 {
 
 protocol P2 {
   associatedtype T : P1 where T == GGG<U>
-  // expected-warning@-1 {{redundant conformance constraint 'GGG<Self.U>' : 'P1'}}
   associatedtype U : P1
 }
 

test/Generics/concrete_contraction_unrelated_typealias.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -typecheck -verify %s -debug-generic-signatures -warn-redundant-requirements 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck -verify %s -debug-generic-signatures 2>&1 | %FileCheck %s
 
 // Another GenericSignatureBuilder oddity, reduced from RxSwift.
 //
@@ -25,10 +25,10 @@ class GenericDelegateProxy<P : AnyObject, D> {
 
   // CHECK-LABEL: .GenericDelegateProxy.init(_:)@
   // CHECK-NEXT: <P, D, Proxy where P == Proxy.[DelegateProxyType]Parent, D == Proxy.[DelegateProxyType]Delegate, Proxy : GenericDelegateProxy<P, D>, Proxy : DelegateProxyType>
-  init<Proxy: DelegateProxyType>(_: Proxy.Type) // expected-warning {{redundant constraint 'P' : 'AnyObject'}}
+  init<Proxy: DelegateProxyType>(_: Proxy.Type)
     where Proxy: GenericDelegateProxy<P, D>,
-          Proxy.Parent == P, // expected-warning {{redundant same-type constraint 'GenericDelegateProxy<P, D>.Parent' (aka 'P') == 'P'}}
-          Proxy.Delegate == D {} // expected-warning {{redundant same-type constraint 'GenericDelegateProxy<P, D>.Delegate' (aka 'D') == 'D'}}
+          Proxy.Parent == P,
+          Proxy.Delegate == D {}
 }
 
 class SomeClass {}