NCGenerics: update a number of tests

These tests were not updated in the transition to
`REQUIRES: noncopyable_generics` and thus running them with a
correctly-built stdlib that has the Copyable requirements.

Author: kavon

test/Generics/inverse_copyable_requirement.swift

@@ -231,22 +231,22 @@ func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
 // FIXME: rdar://115752211 (deal with existing Swift modules that lack Copyable requirements)
 // the stdlib right now is not yet being compiled with NoncopyableGenerics
 func checkStdlibTypes(_ mo: borrowing MO) {
-  _ = "\(mo)" // MISSING-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'appendInterpolation'}}
-  let _: String = String(describing: mo) // MISSING-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'Subject' in 'init(describing:)'}}
+  _ = "\(mo)" // expected-error {{no exact matches in call to instance method 'appendInterpolation'}}
+  let _: String = String(describing: mo) // expected-error {{no exact matches in call to initializer}}
 
   let _: [MO] = // MISSING-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
       [MO(), MO()]
   let _: [MO] = // MISSING-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
       []
-  let _: [String: MO] = // MISSING-error {{noncopyable type 'MO' cannot be used with generic type 'Dictionary<Key, Value>' yet}}
+  let _: [String: MO] = // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
       ["hello" : MO()]  // expected-error{{type '(String, MO)' containing noncopyable element is not supported}}
 
-  _ = [MO()] // MISSING-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'Element' in 'Array'}}
+  _ = [MO()] // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'Element' in 'Array'}}
 
-  let _: Array<MO> = .init() // MISSING-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
-  _ = [MO]() // MISSING-error {{noncopyable type 'MO' cannot be used with generic type 'Array<Element>' yet}}
+  let _: Array<MO> = .init() // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
+  _ = [MO]() // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'Element' in 'Array'}}
 
-  let _: String = "hello \(mo)" // MISSING-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'appendInterpolation'}}
+  let _: String = "hello \(mo)" // expected-error {{no exact matches in call to instance method 'appendInterpolation'}}
 }
 
 func copyableExistentials(_ a: Any, _ e1: Error, _ e2: any Error, _ ah: AnyHashable) {

test/Generics/inverse_signatures.swift

@@ -27,8 +27,8 @@ func where1<T>(_ t: borrowing T) where T: ~Copyable {}
 func where2<T>(_ t: borrowing T) where T: NoCopyP, T: ~Copyable {}
 
 // CHECK-LABEL: .where3@
-// CHECK: Generic signature: <T where T : Equatable, T : Escapable>
-func where3<T>(_ t: borrowing T) where T: Equatable, T: ~Copyable {}
+// CHECK: Generic signature: <T where T : Escapable, T : Empty>
+func where3<T>(_ t: borrowing T) where T: Empty, T: ~Copyable {}
 
 // CHECK-LABEL: .where4@
 // CHECK: Generic signature: <T where T : Copyable>
@@ -39,8 +39,8 @@ func where4<T>(_ t: borrowing T) where T: ~Escapable {}
 func where5<T>(_ t: borrowing T) where T: Empty, T: ~Escapable {}
 
 // CHECK-LABEL: .where6@
-// CHECK: Generic signature: <T where T : Equatable, T : Escapable>
-func where6<T>(_ t: borrowing T) where T: Equatable, T: ~Copyable {}
+// CHECK: Generic signature: <T where T : Escapable, T : Empty>
+func where6<T>(_ t: borrowing T) where T: Empty, T: ~Copyable {}
 
 // CHECK-LABEL: .compose1@
 // CHECK: Generic signature: <T where T : NoCopyP>
@@ -58,9 +58,9 @@ func f1<T: NoCopyP>(_ t: T) {}
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Copyable, τ_0_0 : Escapable>
 func withSome(_ t: some Any) {}
 
-// CHECK-LABEL: .withSomeEquatable@
-// CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Copyable, τ_0_0 : Equatable, τ_0_0 : Escapable>
-func withSomeEquatable(_ t: some Equatable) {}
+// CHECK-LABEL: .withSomeEmpty@
+// CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Copyable, τ_0_0 : Escapable, τ_0_0 : Empty>
+func withSomeEmpty(_ t: some Empty) {}
 
 // CHECK-LABEL: .withSomeProto@
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Copyable, τ_0_0 : NoCopyP>
@@ -193,8 +193,10 @@ extension Cond: Copyable where T: Copyable {}
 // CHECK-NEXT: Canonical generic signature: <τ_0_0>
 struct ImplicitCond<T: ~Escapable & ~Copyable> {}
 
+// FIXME: At the moment, Sendable in the stdlib requires Escapable.
 // CHECK-LABEL: StructDecl name=ImplicitCond
-// CHECK-NEXT:    (normal_conformance type="ImplicitCond<T>" protocol="Sendable")
+// CHECK-NEXT:    (normal_conformance type="ImplicitCond<T>" protocol="Sendable"
+// CHECK-NEXT:      (assoc_conformance type="Self" proto="Escapable"
 
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=ImplicitCond
 // CHECK: Generic signature: <T>

test/Parse/inverses.swift

@@ -17,7 +17,7 @@ func more() {
   let _: ~AnyObject // expected-error {{type 'AnyObject' is not invertible}}
 }
 
-struct S4: ~(Copyable & Equatable) {} // expected-error {{type 'Copyable & Equatable' is not invertible}}
+struct S4: ~(Copyable & Equatable) {} // expected-error {{type 'Equatable' is not invertible}}
 
 func blah<T>(_ t: borrowing T) where T: ~Copyable,
                                      T: ~Hashable {}  // expected-error@:41 {{type 'Hashable' is not invertible}}
@@ -103,5 +103,5 @@ typealias Z4 = ~Rope<Int> // expected-error {{type 'Rope<Int>' is not invertible
 typealias Z5 = (~Int) -> Void // expected-error {{type 'Int' is not invertible}}
 typealias Z6 = ~() -> () // expected-error {{single argument function types require parentheses}}
                          // expected-error@-1 {{type '()' is not invertible}}
-typealias Z7 = ~(Copyable & Hashable) // expected-error {{type 'Copyable & Hashable' is not invertible}}
+typealias Z7 = ~(Copyable & Hashable) // expected-error {{type 'Hashable' is not invertible}}
 typealias Z8 = ~Copyable & Hashable

test/Parse/inverses_legacy_ifdef.swift

@@ -1,9 +1,6 @@
 // RUN: %swift-frontend -typecheck %s
-// RUN: %swift-frontend -typecheck %s -DHAVE_NCGENERICS -enable-experimental-feature NoncopyableGenerics
 // RUN: %swift-frontend -typecheck %s -verify -DHAVE_NCGENERICS
 
-// REQUIRES: noncopyable_generics
-
 /// This test checks that you can write ~Copyable in places that were illegal
 /// in Swift 5.9, as long as those illegal appearances are guarded within
 /// a disabled #if block.

test/SILOptimizer/moveonly_computed_property.swift

@@ -3,9 +3,6 @@
 
 // REQUIRES: noncopyable_generics
 
-// SIL verification failed: 'MoveOnly' types can only be copied in Raw SIL?!
-// REQUIRES: rdar118135397
-
 // Applying a computed property to a move-only field in a class should occur
 // entirely within a formal access to the class property. rdar://105794506
 

test/Serialization/Inputs/ncgenerics.swift

@@ -31,10 +31,5 @@ public protocol Either<Left, Right>: ~Copyable {
     associatedtype Left: ~Copyable
     associatedtype Right: ~Copyable
 }
-
-#else
-public enum Maybe<Wrapped> {
-    case just(Wrapped)
-    case none
-}
 #endif
+

test/Serialization/noncopyable_generics.swift

@@ -38,15 +38,20 @@ struct NC: ~Copyable {}
 struct RegularStruct {}
 
 func isItCopyable<T: Copyable>(_ t: T) {}
-// expected-note@-1 2{{generic parameter 'T' has an implicit Copyable requirement}}
+// expected-note@-1 {{generic parameter 'T' has an implicit Copyable requirement}}
 
 func check() {
     var tr = TestRequirements()
     advance(by: 12, &tr)
 
     isItCopyable(TestRequirements())
     isItCopyable(RegularStruct())
-    isItCopyable(NC()) // expected-error 2{{noncopyable type 'NC' cannot be substituted for copyable generic parameter 'T' in 'isItCopyable'}}
+    isItCopyable(NC()) // expected-error {{noncopyable type 'NC' cannot be substituted for copyable generic parameter 'T' in 'isItCopyable'}}
 
-    let x: Maybe<NC> = .none // expected-error {{noncopyable type 'NC' cannot be used with generic type 'Maybe<Wrapped>' yet}}
+    let x: Maybe<NC> = .none
+}
+
+struct Witness: Either {
+    typealias Left = Maybe<RegularStruct>
+    typealias Right = Maybe<NC>
 }