[NoncopyableGenerics] additional test coverage

Author: kavon

test/Generics/inverse_protocols.swift

@@ -21,7 +21,7 @@ struct File: ~Copyable, Eq {
 }
 
 func check<T: ~Copyable>(_ a: T, _ b: borrowing T) -> Bool where T: Eq {
-// expected-error@-1 {{noncopyable parameter must specify its ownership}}
+// expected-error@-1 {{parameter of noncopyable type 'T' must specify ownership}}
 // expected-note@-2 {{add 'borrowing' for an immutable reference}}
 // expected-note@-3 {{add 'inout' for a mutable reference}}
 // expected-note@-4 {{add 'consuming' to take the value from the caller}}

test/Generics/inverse_protocols_errors.swift

@@ -10,7 +10,7 @@ protocol NCProto: ~Copyable, RegularProto {
 
 protocol Hello: ~Copyable {
   func greet(_ s: Self)
-  // expected-error@-1 {{noncopyable parameter must specify its ownership}}
+  // expected-error@-1 {{parameter of noncopyable type 'Self' must specify ownership}}
   // expected-note@-2 {{add 'borrowing' for an immutable reference}}
   // expected-note@-3 {{add 'inout' for a mutable reference}}
   // expected-note@-4 {{add 'consuming' to take the value from the caller}}
@@ -28,15 +28,15 @@ struct NCThinger<T: ~Copyable>: ~Copyable, Hello {
   deinit {}
 
   func greet(_ f: Self) {}
-  // expected-error@-1 {{noncopyable parameter must specify its ownership}}
+  // expected-error@-1 {{parameter of noncopyable type 'NCThinger<T>' must specify ownership}}
   // expected-note@-2 {{add 'borrowing' for an immutable reference}}
   // expected-note@-3 {{add 'inout' for a mutable reference}}
   // expected-note@-4 {{add 'consuming' to take the value from the caller}}
 
   func salute(_ s: borrowing Self) {}
 
   func setThinger(_ t: T) {}
-  // expected-error@-1 {{noncopyable parameter must specify its ownership}}
+  // expected-error@-1 {{parameter of noncopyable type 'T' must specify ownership}}
   // expected-note@-2 {{add 'borrowing' for an immutable reference}}
   // expected-note@-3 {{add 'inout' for a mutable reference}}
   // expected-note@-4 {{add 'consuming' to take the value from the caller}}

test/Generics/inverse_signatures.swift

@@ -10,6 +10,42 @@ func genericFn<T>(_ t: T) {}
 // CHECK: Generic signature: <T>
 func withInverse<T: ~Copyable>(_ t: borrowing T) {}
 
+// CHECK-LABEL: .where1@
+// CHECK: Generic signature: <T>
+func where1<T>(_ t: borrowing T) where T: ~Copyable {}
+
+// CHECK-LABEL: .where2@
+// CHECK: Generic signature: <T where T : NoCopyP>
+func where2<T>(_ t: borrowing T) where T: NoCopyP, T: ~Copyable {}
+
+// CHECK-LABEL: .where3@
+// CHECK: Generic signature: <T where T : CopyP>
+func where3<T>(_ t: T) where T: CopyP, T: ~Copyable {}
+
+// CHECK-LABEL: .where4@
+// CHECK: Generic signature: <T where T : Equatable>
+func where4<T>(_ t: borrowing T) where T: Equatable, T: ~Copyable {}
+
+// CHECK-LABEL: .compose1@
+// CHECK: Generic signature: <T where T : NoCopyP>
+func compose1<T: NoCopyP & ~Copyable>(_ t: borrowing T) {}
+
+// CHECK-LABEL: .compose2@
+// CHECK: Generic signature: <T where T : CopyP>
+func compose2<T: CopyP & ~Copyable>(_ t: T) {}
+
+// CHECK-LABEL: .compose3@
+// CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : CopyP>
+func compose3(_ t: some CopyP & ~Copyable) {}
+
+// CHECK-LABEL: .compose4@
+// CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : NoCopyP>
+func compose4(_ t: inout some NoCopyP & ~Copyable) {}
+
+// CHECK-LABEL: .f1@
+// CHECK: Generic signature: <T where T : Copyable, T : NoCopyP>
+func f1<T: NoCopyP>(_ t: T) {}
+
 // CHECK-LABEL: .withSome@
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Copyable>
 func withSome(_ t: some Any) {}
@@ -24,7 +60,7 @@ func withSomeProto(_ t: some NoCopyP) {}
 
 // CHECK-LABEL: .withInverseSome@
 // CHECK: Canonical generic signature: <τ_0_0>
-func withInverseSome(_ t: some ~Copyable) {}
+func withInverseSome(_ t: borrowing some ~Copyable) {}
 
 // CHECK-LABEL: .S1@
 // CHECK: Generic signature: <T where T : Copyable>
@@ -44,7 +80,7 @@ class C1_IC<T: ~Copyable, U> {}
 
 // CHECK-LABEL: .C1_CI@
 // CHECK: Generic signature: <T, U where T : Copyable>
-class C1_CI<T, U: ~Copyable> {}
+class C1_CI<T, U> where U: ~Copyable {}
 
 // CHECK-LABEL: .C1_II@
 // CHECK: Generic signature: <T, U>
@@ -54,9 +90,25 @@ class C1_II<T: ~Copyable, U: ~Copyable> {}
 // CHECK: Requirement signature: <Self>
 protocol NoCopyP: ~Copyable {}
 
-// CHECK-LABEL: .P1@
+// CHECK-LABEL: .NoCopyP2@
+// CHECK: Requirement signature: <Self where Self : NoCopyP>
+protocol NoCopyP2 where Self: ~Copyable & NoCopyP {}
+
+// CHECK-LABEL: .CopyP@
 // CHECK: Requirement signature: <Self where Self : Copyable>
-protocol P1 {}
+protocol CopyP {}
+
+// CHECK-LABEL: .CopyP2@
+// CHECK: Requirement signature: <Self where Self : CopyP>
+protocol CopyP2: CopyP, ~Copyable {}  // expected-warning {{protocol 'CopyP2' should be declared to refine 'Copyable' due to a same-type constraint on 'Self'}}
+
+// CHECK-LABEL: .CopyP2_Fixed@
+// CHECK: Requirement signature: <Self where Self : CopyP>
+protocol CopyP2_Fixed: CopyP {}
+
+// CHECK-LABEL: .CopyInheritsNC@
+// CHECK: Requirement signature: <Self where Self : Copyable, Self : NoCopyP>
+protocol CopyInheritsNC: NoCopyP {}
 
 // CHECK-LABEL: .P2@
 // CHECK: <Self where Self : Copyable, Self.[P2]A : Copyable>
@@ -73,3 +125,17 @@ protocol P2_CI { associatedtype A: ~Copyable }
 // CHECK-LABEL: .P2_II@
 // CHECK: Requirement signature: <Self>
 protocol P2_II: ~Copyable { associatedtype A: ~Copyable }
+
+// CHECK-LABEL: .Cond@
+// CHECK: Generic signature: <T>
+// CHECK-NEXT: Canonical generic signature: <τ_0_0>
+struct Cond<T: ~Copyable>: ~Copyable {}
+
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=Cond
+// CHECK: Generic signature: <T where T : Copyable>
+// CHECK-NEXT: Canonical generic signature: <τ_0_0 where τ_0_0 : Copyable>
+
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=Cond
+// CHECK:       (normal_conformance type="Cond<T>" protocol="Copyable"
+// CHECK-NEXT:       (requirement "T" conforms_to "Copyable"))
+extension Cond: Copyable where T: Copyable {}

test/Parse/inverses.swift

@@ -19,14 +19,13 @@ func more() {
 
 struct S4: ~(Copyable & Equatable) {} // expected-error {{type 'Copyable & Equatable' is not invertible}}
 
-func blah<T>(_ t: T) where T: ~Copyable,
-                           T: ~Hashable {}  // expected-error@:31 {{type 'Hashable' is not invertible}}
+func blah<T>(_ t: borrowing T) where T: ~Copyable,
+                                     T: ~Hashable {}  // expected-error@:41 {{type 'Hashable' is not invertible}}
 
 func foo<T: ~Copyable>(x: borrowing T) {}
 
 struct Buurap<T: ~Copyable> {}
 
-// expected-warning@+1 {{protocol 'Foo' should be declared to refine 'Copyable' due to a same-type constraint on 'Self'}}
 protocol Foo: ~Copyable  // expected-note {{previous inverse constraint here}}
          where Self: ~Copyable { // expected-error {{duplicate inverse constraint}}
 
@@ -53,16 +52,21 @@ extension S: ~Copyable {}
 struct S: ~U, // expected-error {{type 'U' is not invertible}}
           ~Copyable {}
 
-func greenBay<each T: ~Copyable>(_ r: repeat each T) {}
+func greenBay<each T: ~Copyable>(_ r: repeat each T) {} // expected-error{{cannot apply inverse '~Copyable' to type 'each T' in conformance requirement}}
 
 typealias Clone = Copyable
 func dup<D: ~Clone>(_ d: D) {}
-// expected-error@-1 {{noncopyable parameter must specify its ownership}}
+// expected-error@-1 {{parameter of noncopyable type 'D' must specify ownership}}
 // expected-note@-2 {{add 'borrowing'}}
 // expected-note@-3 {{add 'inout'}}
 // expected-note@-4 {{add 'consuming'}}
 
+// expected-error@+2 {{parameter of noncopyable type 'some ~Copyable' must specify ownership}}
+// expected-error@+1 {{parameter of noncopyable type 'some ~Clone' must specify ownership}}
 func superb(_ thing: some ~Copyable, thing2: some ~Clone) {}
+// expected-note@-1 2{{add 'borrowing'}}
+// expected-note@-2 2{{add 'inout'}}
+// expected-note@-3 2{{add 'consuming'}}
 
 func ownership1(_ t: borrowing any ~Equatable) {} // expected-error {{type 'Equatable' is not invertible}}