RequirementMachine: Update remaining tests for requirement machine diagnostics

A handful of cases where we emit a bogus redundancy warning are marked with
'FIXME(rqm-diagnostics)'.

Author: slavapestov

test/AutoDiff/Sema/differentiable_func_type.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -typecheck -verify %s -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
+// RUN: %target-swift-frontend -typecheck -verify %s -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on
 
 import _Differentiation
 
@@ -188,8 +188,6 @@ extension Vector: Differentiable where T: Differentiable {
 // expected-note@+1 2 {{found this candidate}}
 func inferredConformancesGeneric<T, U>(_: @differentiable(reverse) (Vector<T>) -> Vector<U>) {}
 
-// expected-error @+4 {{generic signature requires types 'Vector<T>' and 'Vector<T>.TangentVector' to be the same}}
-// expected-error @+3 {{generic signature requires types 'Vector<U>' and 'Vector<U>.TangentVector' to be the same}}
 // expected-error @+2 {{parameter type 'Vector<T>' does not conform to 'Differentiable' and satisfy 'Vector<T> == Vector<T>.TangentVector', but the enclosing function type is '@differentiable(_linear)'}}
 // expected-error @+1 {{result type 'Vector<U>' does not conform to 'Differentiable' and satisfy 'Vector<U> == Vector<U>.TangentVector', but the enclosing function type is '@differentiable(_linear)'}}
 func inferredConformancesGenericLinear<T, U>(_: @differentiable(_linear) (Vector<T>) -> Vector<U>) {}
@@ -209,8 +207,6 @@ func diff(x: Vector<Float>) -> Vector<Float> {}
 inferredConformancesGeneric(diff) // okay!
 
 func inferredConformancesGenericResult<T, U>() -> @differentiable(reverse) (Vector<T>) -> Vector<U> {}
-// expected-error @+4 {{generic signature requires types 'Vector<T>' and 'Vector<T>.TangentVector' to be the same}}
-// expected-error @+3 {{generic signature requires types 'Vector<U>' and 'Vector<U>.TangentVector' to be the same}}
 // expected-error @+2 {{parameter type 'Vector<T>' does not conform to 'Differentiable' and satisfy 'Vector<T> == Vector<T>.TangentVector', but the enclosing function type is '@differentiable(_linear)'}}
 // expected-error @+1 {{result type 'Vector<U>' does not conform to 'Differentiable' and satisfy 'Vector<U> == Vector<U>.TangentVector', but the enclosing function type is '@differentiable(_linear)'}}
 func inferredConformancesGenericResultLinear<T, U>() -> @differentiable(_linear) (Vector<T>) -> Vector<U> {}

test/Constraints/same_types.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=off
+// RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=on
 // RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
 
 protocol Fooable {
@@ -57,29 +57,26 @@ 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 'U.Foo' == 'X'}}
-	// expected-note@-2{{same-type constraint 'T.Foo' == 'X' written here}}
+	// expected-warning@-1{{redundant same-type constraint 'T.Foo' == 'X'}}
   return (t.foo, u.foo)
 }
 
 // CHECK-LABEL: same_types.(file).fail1(_:u:)@
 // CHECK-NEXT: Generic signature: <T, U where T : Fooable, U : Fooable, T.[Fooable]Foo == U.[Fooable]Foo>
-func fail1<
+func fail1< // expected-error{{no type for 'T.Foo' can satisfy both 'T.Foo == X' and 'T.Foo == Y'}}
   T: Fooable, U: Fooable
 >(_ t: T, u: U) -> (X, Y)
-  where T.Foo == X, U.Foo == Y, T.Foo == U.Foo { // expected-error{{'U.Foo' cannot be equal to both 'Y' and 'X'}}
-  // expected-note@-1{{same-type constraint 'T.Foo' == 'X' written here}}
-  return (t.foo, u.foo) // expected-error{{cannot convert return expression of type '(X, X)' to return type '(X, Y)'}}
+  where T.Foo == X, U.Foo == Y, T.Foo == U.Foo {
+  return (t.foo, u.foo) // expected-error{{cannot convert return expression of type '(T.Foo, T.Foo)' to return type '(X, Y)'}}
 }
 
 // CHECK-LABEL: same_types.(file).fail2(_:u:)@
 // CHECK-NEXT: Generic signature: <T, U where T : Fooable, U : Fooable, T.[Fooable]Foo == U.[Fooable]Foo>
-func fail2<
+func fail2< // expected-error{{no type for 'T.Foo' can satisfy both 'T.Foo == Y' and 'T.Foo == X'}}
   T: Fooable, U: Fooable
 >(_ t: T, u: U) -> (X, Y)
-  where T.Foo == U.Foo, T.Foo == X, U.Foo == Y { // expected-error{{'U.Foo' cannot be equal to both 'Y' and 'X'}}
-  // expected-note@-1{{same-type constraint 'T.Foo' == 'X' written here}}
-  return (t.foo, u.foo) // expected-error{{cannot convert return expression of type '(X, X)' to return type '(X, Y)'}}
+  where T.Foo == U.Foo, T.Foo == X, U.Foo == Y {
+  return (t.foo, u.foo) // expected-error{{cannot convert return expression of type '(T.Foo, T.Foo)' to return type '(X, Y)'}}
 }
 
 func test4<T: Barrable>(_ t: T) -> Y where T.Bar == Y {
@@ -88,8 +85,8 @@ func test4<T: Barrable>(_ t: T) -> Y where T.Bar == Y {
 
 // CHECK-LABEL: same_types.(file).fail3@
 // CHECK-NEXT: Generic signature: <T where T : Barrable>
-func fail3<T: Barrable>(_ t: T) -> X
-  where T.Bar == X { // expected-error {{'X' does not conform to required protocol 'Fooable'}}
+func fail3<T: Barrable>(_ t: T) -> X // expected-error {{no type for 'T.Bar' can satisfy both 'T.Bar == X' and 'T.Bar : Fooable'}}
+  where T.Bar == X {
   return t.bar // expected-error{{cannot convert return expression of type 'T.Bar' }}
 }
 
@@ -104,7 +101,7 @@ 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{{neither type in same-type constraint ('Y.Foo' (aka 'X') or 'X') refers to a generic parameter or associated type}}
+	// expected-warning@-1{{redundant same-type constraint 'Y.Foo' (aka 'X') == 'X'}}
   return (t.bar, t.bar.foo)
 }
 
@@ -121,31 +118,31 @@ func fail4<T: Barrable>(_ t: T) -> (Y, Z)
 // CHECK-NEXT: Generic signature: <T where T : Barrable, T.[Barrable]Bar == Y>
 func fail5<T: Barrable>(_ t: T) -> (Y, Z)
   where
-  T.Bar.Foo == Z, // expected-note{{same-type constraint 'T.Bar.Foo' == 'Z' written here}}
-  T.Bar == Y { // expected-error{{'T.Bar.Foo' cannot be equal to both 'Y.Foo' (aka 'X') and 'Z'}}
+  T.Bar.Foo == Z, // expected-error{{generic signature requires types 'Y.Foo' (aka 'X') and 'Z' to be the same}}
+  T.Bar == Y {
   return (t.bar, t.bar.foo) // expected-error{{cannot convert return expression of type '(Y, X)' to return type '(Y, Z)'}}
 }
 
 // CHECK-LABEL: same_types.(file).test8@
 // CHECK-NEXT: Generic signature: <T where T : Fooable>
-func test8<T: Fooable>(_ t: T)
-  where T.Foo == X, // expected-note{{same-type constraint 'T.Foo' == 'X' written here}}
-  T.Foo == Y {} // expected-error{{'T.Foo' cannot be equal to both 'Y' and 'X'}}
+func test8<T: Fooable>(_ t: T) // expected-error{{no type for 'T.Foo' can satisfy both 'T.Foo == Y' and 'T.Foo == X'}}
+  where T.Foo == X,
+  T.Foo == Y {}
 
 
 func testAssocTypeEquivalence<T: Fooable>(_ fooable: T) -> X.Type
   where T.Foo == X {
   return T.Foo.self
 }
 
-func fail6<T>(_ t: T) -> Int where T == Int { // expected-error{{same-type requirement makes generic parameter 'T' non-generic}}
+func fail6<T>(_ t: T) -> Int where T == Int { // expected-warning{{same-type requirement makes generic parameter 'T' non-generic}}
   return t
 }
 
 // CHECK-LABEL: same_types.(file).test8(_:u:)@
 // 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, // expected-note{{same-type constraint 'U.Bar.Foo' == 'Y.Foo' (aka 'X') implied here}}
+  where T.Bar == Y,
         U.Bar.Foo == X, T.Bar == U.Bar { // expected-warning{{redundant same-type constraint 'U.Bar.Foo' == 'X'}}
   return (t.bar, u.bar, t.bar.foo, u.bar.foo)
 }
@@ -154,7 +151,7 @@ func test8<T: Barrable, U: Barrable>(_ t: T, u: U) -> (Y, Y, X, X)
 // CHECK-NEXT: Generic signature: <T, U where T : Barrable, U : Barrable, T.[Barrable]Bar == Y, U.[Barrable]Bar == Y>
 func test8a<T: Barrable, U: Barrable>(_ t: T, u: U) -> (Y, Y, X, X)
   where
-  T.Bar == Y, // expected-note{{same-type constraint 'U.Bar.Foo' == 'Y.Foo' (aka 'X') implied here}}
+  T.Bar == Y,
   U.Bar.Foo == X, U.Bar == T.Bar { // expected-warning{{redundant same-type constraint 'U.Bar.Foo' == 'X'}}
   return (t.bar, u.bar, t.bar.foo, u.bar.foo)
 }
@@ -163,7 +160,7 @@ func test8a<T: Barrable, U: Barrable>(_ t: T, u: U) -> (Y, Y, X, X)
 // 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'}}
-        T.Bar == Y, // expected-note{{same-type constraint 'U.Bar.Foo' == 'Y.Foo' (aka 'X') implied here}}
+        T.Bar == Y,
         T.Bar == U.Bar {
 }
 
@@ -207,7 +204,8 @@ S1<Q>().foo(x: 1, y: 2)
 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-error{{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
+  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)
@@ -219,7 +217,7 @@ S2<Q>().foo(x: 1, y: 2)
 struct S3<T : P> {
   // CHECK-LABEL: same_types.(file).S3.foo(x:y:)@
   // CHECK-NEXT: <T, X, Y where T : P, X == Y, Y == T.[P]A>
-  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.A {} // expected-error{{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
+  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.A {} // expected-warning{{same-type requirement makes generic parameters 'Y' and 'X' equivalent}}
 }
 S3<Q>().foo(x: 1, y: 2)
 
@@ -262,25 +260,25 @@ protocol P1 {
 // CHECK-NEXT: Generic signature: <A, B, T, U, V, W where A : P1, B : P1, T == V, U == W, A.[P1]Assoc == X1<T, U>, B.[P1]Assoc == X1<T, U>>
 func structuralSameType1<A: P1, B: P1, T, U, V, W>(_: A, _: B, _: T, _: U, _: V, _: W)
   where A.Assoc == X1<T, U>, B.Assoc == X1<V, W>, A.Assoc == B.Assoc { }
-// expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-2{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// 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}}
 
 typealias Tuple2<T, U> = (T, U)
 
 // CHECK-LABEL: same_types.(file).structuralSameType2@
 // CHECK-NEXT: Generic signature: <A, B, T, U, V, W where A : P1, B : P1, T == V, U == W, A.[P1]Assoc == (T, U), B.[P1]Assoc == (T, U)>
 func structuralSameType2<A: P1, B: P1, T, U, V, W>(_: A, _: B, _: T, _: U, _: V, _: W)
   where A.Assoc == Tuple2<T, U>, B.Assoc == Tuple2<V, W>, A.Assoc == B.Assoc { }
-// expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-2{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// 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}}
 
 // CHECK-LABEL: same_types.(file).structuralSameType3@
 // CHECK-NEXT: Generic signature: <T, U, V, W where T == V, U == W>
 func structuralSameType3<T, U, V, W>(_: T, _: U, _: V, _: W)
   where X1<T, U> == X1<V, W> { }
-// expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-2{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
-// expected-warning@-3{{neither type in same-type constraint ('X1<T, U>' or 'X1<V, W>') refers to a generic parameter or associated type}}
+// 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
@@ -289,8 +287,13 @@ protocol P2 {
 
 // CHECK-LABEL: same_types.(file).structuralSameTypeRecursive1@
 // CHECK-NEXT: Generic signature: <T, U>
+
+// expected-error@+2 {{cannot build rewrite system for generic signature; concrete nesting limit exceeded}}
+// expected-note@+1 {{failed rewrite rule is τ_0_0.[P2:Assoc1].[concrete: ((((((((((((((((((((((((((((((τ_0_0.[P2:Assoc1], τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1), τ_0_1)] => τ_0_0.[P2:Assoc1]}}
 func structuralSameTypeRecursive1<T: P2, U>(_: T, _: U)
-  where T.Assoc1 == Tuple2<T.Assoc1, U> // expected-error{{same-type constraint 'T.Assoc1' == '(T.Assoc1, U)' is recursive}}
+  where T.Assoc1 == Tuple2<T.Assoc1, U>
+  // expected-error@-1 {{'Assoc1' is not a member type of type 'T'}}
+  // expected-error@-2 {{'Assoc1' is not a member type of type 'T'}}
 { }
 
 protocol P3 {
@@ -302,7 +305,7 @@ protocol P4 {
 
 // CHECK-LABEL: same_types.(file).test9@
 // CHECK-NEXT: Generic signature: <T where T : P4>
-func test9<T>(_: T) where T.A == X, T: P4, T.A: P3 { } // expected-error{{same-type constraint type 'X' does not conform to required protocol 'P3'}}
+func test9<T>(_: T) where T.A == X, T: P4, T.A: P3 { } // expected-error{{no type for 'T.A' can satisfy both 'T.A == X' and 'T.A : P3'}}
 
 // Same-type constraint conflict through protocol where clauses.
 protocol P5 where Foo1 == Foo2 {
@@ -320,9 +323,9 @@ struct X5b { }
 
 // CHECK-LABEL: same_types.(file).test9(_:u:)@
 // CHECK-NEXT: Generic signature: <T, U where T : P6, U : P6, T.[P6]Bar == U.[P6]Bar>
-func test9<T: P6, U: P6>(_ t: T, u: U)
-  where T.Bar.Foo1 == X5a, // expected-note{{same-type constraint 'T.Bar.Foo1' == 'X5a' written here}}
-        U.Bar.Foo2 == X5b, // expected-error{{'U.Bar.Foo2' cannot be equal to both 'X5b' and 'X5a'}}
+func test9<T: P6, U: P6>(_ t: T, u: U) // expected-error{{no type for 'T.Bar.Foo1' can satisfy both 'T.Bar.Foo1 == X5a' and 'T.Bar.Foo1 == X5b'}}
+  where T.Bar.Foo1 == X5a,
+        U.Bar.Foo2 == X5b,
         T.Bar == U.Bar {
 }
 
@@ -333,14 +336,14 @@ func test9<T: P6, U: P6>(_ t: T, u: U)
 // CHECK-NEXT: Generic signature: <T, U where T == U>
 func testMetatypeSameType<T, U>(_ t: T, _ u: U)
   where T.Type == U.Type { }
-// expected-error@-1{{same-type requirement makes generic parameters 'T' and 'U' equivalent}}
-// expected-warning@-2{{neither type in same-type constraint ('T.Type' or 'U.Type') refers to a generic parameter or associated 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>
 func testSameTypeCommutativity1<U, T>(_ t: T, _ u: U)
   where T.Type == U { } // Equivalent to U == T.Type
-// expected-error@-1{{same-type requirement makes generic parameter 'U' non-generic}}
+// expected-warning@-2{{same-type requirement makes generic parameter 'U' non-generic}}
 
 // CHECK-LABEL: same_types.(file).testSameTypeCommutativity2@
 // CHECK-NEXT: Generic signature: <U, T where T : P1, T.[P1]Assoc == U?>
@@ -356,7 +359,7 @@ func testSameTypeCommutativity3<U, T: P1>(_ t: T, _ u: U)
 // CHECK-NEXT: Generic signature: <U, T where T == (U) -> ()>
 func testSameTypeCommutativity4<U, T>(_ t: T, _ u: U)
   where (U) -> () == T { } // Equivalent to T == (U) -> ()
-// expected-error@-1{{same-type requirement makes generic parameter 'T' non-generic}}
+// expected-warning@-2{{same-type requirement makes generic parameter 'T' non-generic}}
 
 // CHECK-LABEL: same_types.(file).testSameTypeCommutativity5@
 // CHECK-NEXT: Generic signature: <U, T where T : P1, T.[P1]Assoc == P3 & PPP>
@@ -381,8 +384,6 @@ struct Bar<A: P1, B: P1> where A.Assoc == B.Assoc {
   // CHECK-LABEL: same_types.(file).Bar.f(with:)@
   // CHECK-NEXT: Generic signature: <A, B, C where A : P1, B : P1, C : P1, A.[P1]Assoc == B.[P1]Assoc, B.[P1]Assoc == C.[P1]Assoc>
   func f<C: P1>(with other: C) -> Foo<A, B, C> where A.Assoc == C.Assoc {
-    // expected-note@-1 {{previous same-type constraint 'B.Assoc' == 'C.Assoc' inferred from type here}}
-    // expected-warning@-2 {{redundant same-type constraint 'A.Assoc' == 'C.Assoc'}}
     fatalError()
   }
 }

test/Generics/associated_type_typo.swift

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

test/Generics/conditional_requirement_inference_in_protocol.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on
 // RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
 
-// FIXME: The redundant conformance warnings here should not be emitted, since
+// FIXME(rqm-diagnostics): The redundant conformance warnings here should not be emitted, since
 // these requirements participate in conditional requirement inference.
 
 // CHECK-LABEL: conditional_requirement_inference_in_protocol.(file).Good@

test/Generics/deduction.swift

@@ -172,8 +172,7 @@ struct StaticFuncs {
 }
 
 struct StaticFuncsGeneric<U> {
-  // FIXME: Nested generics are very broken
-  // static func chameleon<T>() -> T {}
+  static func chameleon<T>() -> T {}
 }
 
 func chameleon<T>() -> T {}
@@ -182,10 +181,10 @@ func testStatic(_ sf: StaticFuncs, sfi: StaticFuncsGeneric<Int>) {
   var x: Int16
   x = StaticFuncs.chameleon()
   x = sf.chameleon2()
-  // FIXME: Nested generics are very broken
-  // x = sfi.chameleon()
-  // typealias SFI = StaticFuncsGeneric<Int>
-  // x = SFI.chameleon()
+
+  x = sfi.chameleon() // expected-error {{static member 'chameleon' cannot be used on instance of type 'StaticFuncsGeneric<Int>'}}
+  typealias SFI = StaticFuncsGeneric<Int>
+  x = SFI.chameleon()
   _ = x
 }
 

test/Generics/interdependent_protocol_conformance_example_3.swift

@@ -19,7 +19,7 @@ public protocol MultiPoint {
 
   typealias P = Self.C.P
   // expected-warning@-1 {{redundant same-type constraint 'Self.P' == 'Self.C.P'}}
-  // FIXME: This is bogus
+  // FIXME(rqm-diagnostics): This is bogus
 
   associatedtype X: NonEmptyProtocol
     where X.C: NonEmptyProtocol,