RequirementMachine: Update tests for protocol typealiases

Author: slavapestov

test/Generics/Inputs/protocol_typealias_other.swift

@@ -0,0 +1,9 @@
+public protocol P1 {
+  typealias X = Y.Z
+  associatedtype Y : P2
+}
+
+public protocol P2 {
+  associatedtype Z
+  typealias C = Array<Z>
+}

test/Generics/protocol_type_aliases.swift

@@ -1,5 +1,8 @@
-// RUN: %target-typecheck-verify-swift
-// RUN: %target-typecheck-verify-swift -debug-generic-signatures > %t.dump 2>&1
+// FIXME: Once the Requirement Machine can emit diagnostics, run this test with
+// it enabled unconditionally.
+
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=off
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on > %t.dump 2>&1
 // RUN: %FileCheck %s < %t.dump
 
 
@@ -54,6 +57,9 @@ protocol Q3_1: P3, P3_1 {} // expected-error{{generic signature requires types '
 
 // Subprotocols can force associated types in their parents to be concrete, and
 // this should be understood for types constrained by the subprotocols.
+
+// CHECK-LABEL: .Q4@
+// CHECK: Requirement signature: <Self where Self : P, Self.[P]A == Int>
 protocol Q4: P {
     typealias A = Int // expected-warning{{typealias overriding associated type 'A' from protocol 'P'}}
 }
@@ -70,22 +76,21 @@ func getP_X<T: P>(_: T.Type) -> T.X.Type { return T.X.self }
 func checkQ4_A<T: Q4>(x: T.Type) { sameType(getP_A(x), Int.self) }
 func checkQ4_X<T: Q4>(x: T.Type) { sameType(getP_X(x), Int.self) }
 
-// FIXME: these do not work, seemingly mainly due to the 'recursive decl validation'
-// FIXME in GenericSignatureBuilder.cpp.
-/*
 func checkQ5_A<T: Q5>(x: T.Type) { sameType(getP_A(x), Int.self) }
 func checkQ5_X<T: Q5>(x: T.Type) { sameType(getP_X(x), Int.self) }
-*/
 
 
-// Typealiases happen to allow imposing same type requirements between parent
-// protocols
+
+// Typealiases allow imposing same type requirements between parent protocols
 protocol P6_1 {
     associatedtype A // expected-note{{'A' declared here}}
 }
 protocol P6_2 {
     associatedtype B
 }
+
+// CHECK-LABEL: .Q6@
+// CHECK-NEXT: Requirement signature: <Self where Self : P6_1, Self : P6_2, Self.[P6_1]A == Self.[P6_2]B>
 protocol Q6: P6_1, P6_2 {
     typealias A = B // expected-warning{{typealias overriding associated type}}
 }
@@ -101,7 +106,10 @@ protocol P7 {
   typealias A = Int
 }
 
+// CHECK-LABEL: .P7a@
+// CHECK: Requirement signature: <Self where Self : P7>
 protocol P7a : P7 {
   associatedtype A   // expected-warning{{associated type 'A' is redundant with type 'A' declared in inherited protocol 'P7'}}
 }
 
+func testP7A<T : P7a>(_: T, a: T.A) -> Int { return a }

test/Generics/protocol_typealias_concrete_unification.swift

@@ -0,0 +1,12 @@
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=on
+
+protocol P1 {
+  typealias T = Array<U>
+  associatedtype U
+}
+
+protocol P2 {
+  typealias T = Array<Int>
+}
+
+func foo<T : P1 & P2>(_: T, u: T.U) -> Int { return u }

test/Generics/protocol_typealias_redeclaration.swift

@@ -0,0 +1,8 @@
+// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on 2>&1 | %FileCheck %s
+
+// CHECK-LABEL: .P@
+// CHECK-NEXT: Requirement signature: <Self>
+protocol P {
+  typealias T = Int
+  associatedtype T
+}

test/Generics/protocol_typealias_same_type_requirement.swift

@@ -41,5 +41,7 @@ protocol P7 {
 }
 
 // CHECK-LABEL: protocol_typealias_same_type_requirement.(file).P8@
-// CHECK-LABEL: Requirement signature: <Self where Self : P6, Self : P7, Self.[P7]X == Int>
+// CHECK-LABEL: Requirement signature: <Self where Self : P6, Self : P7>
 protocol P8 : P6, P7 {}
+
+func testP8<T : P8>(_: T, x: T.X) -> Int { return x }

test/Generics/protocol_typealias_serialization.swift

@@ -0,0 +1,13 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module %S/Inputs/protocol_typealias_other.swift -emit-module-path %t/protocol_typealias_other.swiftmodule -module-name protocol_typealias_other -requirement-machine-protocol-signatures=on
+// RUN: %target-swift-frontend -typecheck %s -I %t -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
+
+import protocol_typealias_other
+
+// CHECK-LABEL: .useP1@
+// CHECK-NEXT: <T where T : P1, T.[P1]Y.[P2]Z == Int>
+func useP1<T : P1>(_: T) where T.X == Int {}
+
+// CHECK-LABEL: .useP2@
+// CHECK-NEXT: <T where T : P2, T.[P2]Z == Int>
+func useP2<T : P2>(_: T) where T.C == Array<Int> {}

test/decl/protocol/req/associated_type_ambiguity.swift

@@ -1,8 +1,5 @@
 // RUN: %target-typecheck-verify-swift
-
-// References to associated type from 'where' clause should be
-// ambiguous when there's a typealias with the same name in another
-// unrelated protocol.
+// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on -requirement-machine-protocol-signatures=on 2>&1 | %FileCheck %s
 
 protocol P1 {
   typealias T = Int // expected-note 3{{found this candidate}}
@@ -12,35 +9,44 @@ protocol P2 {
   associatedtype T // expected-note 3{{found this candidate}}
 }
 
+// CHECK: ExtensionDecl line={{.*}} base=P1
+// CHECK-NEXT: Generic signature: <Self where Self : P1, Self : P2>
 extension P1 where Self : P2, T == Int { // expected-error {{'T' is ambiguous for type lookup in this context}}
   func takeT11(_: T) {} // expected-error {{'T' is ambiguous for type lookup in this context}}
   func takeT12(_: Self.T) {}
 }
 
-extension P1 where Self : P2 {
-  // FIXME: This doesn't make sense -- either both should
-  // succeed, or both should be ambiguous.
-  func takeT21(_: T) {} // expected-error {{'T' is ambiguous for type lookup in this context}}
+// CHECK: ExtensionDecl line={{.*}} base=P1
+// CHECK-NEXT: Generic signature: <Self where Self : P1, Self : P2>
+extension P1 where Self : P2, Self.T == Int {
+  func takeT21(_: T) {}
   func takeT22(_: Self.T) {}
 }
 
+extension P1 where Self : P2 {
+  func takeT31(_: T) {} // expected-error {{'T' is ambiguous for type lookup in this context}}
+  func takeT32(_: Self.T) {}
+}
+
 // Same as above, but now we have two visible associated types with the same
 // name.
 protocol P3 {
   associatedtype T
 }
 
+// CHECK: ExtensionDecl line={{.*}} base=P2
+// CHECK-NEXT: Generic signature: <Self where Self : P2, Self : P3, Self.[P2]T == Int>
 extension P2 where Self : P3, T == Int {
-  func takeT31(_: T) {}
-  func takeT32(_: Self.T) {}
+  func takeT41(_: T) {}
+  func takeT52(_: Self.T) {}
 }
 
 extension P2 where Self : P3 {
-  func takeT41(_: T) {}
-  func takeT42(_: Self.T) {}
+  func takeT61(_: T) {}
+  func takeT62(_: Self.T) {}
 }
 
 protocol P4 : P2, P3 {
-  func takeT51(_: T)
-  func takeT52(_: Self.T)
+  func takeT71(_: T)
+  func takeT72(_: Self.T)
 }

validation-test/Sema/type_checker_crashers_fixed/sr13856.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
 
 protocol OptionalType {
   associatedtype Wrapped

validation-test/compiler_crashers_2_fixed/0142-rdar36549499.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend %s -emit-ir -o /dev/null
+// RUN: %target-swift-frontend %s -emit-ir -o /dev/null -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
 protocol S {
   associatedtype I: IteratorProtocol
   typealias E = I.Element