[stdilb] introduce Copyable protocol

This replaces the old, unavailable `_Copyable`.

Author: kavon

include/swift/AST/KnownProtocols.def

@@ -126,7 +126,7 @@ PROTOCOL(AsyncIteratorProtocol)
 
 PROTOCOL(FloatingPoint)
 
-PROTOCOL_(Copyable)
+PROTOCOL(Copyable)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral, "BooleanLiteralType", true)

stdlib/public/core/Misc.swift

@@ -164,4 +164,7 @@ public func _unsafePerformance<T>(_ c: () -> T) -> T {
 /// constraints on generics in your programs. It is currently
 /// only used internally by the compiler.
 @available(*, unavailable)
-@_marker public protocol _Copyable {}
+@_marker public protocol _Copyable {} // FIXME: rdar://115793371 (delete _Copyable from stdlib)
+
+
+@_marker public protocol Copyable {}

test/Concurrency/async_overload_filtering.swift

@@ -18,7 +18,7 @@ func filter_async(_: String) -> Void {}
 var a: String? = nil
 
 // CHECK: attempting disjunction choice $T0 bound to decl async_overload_filtering.(file).filter_async(fn2:)
-// CHECK-NEXT: added constraint: {{.*}} conforms to _Copyable
+// CHECK-NEXT: added constraint: {{.*}} conforms to Copyable
 // CHECK-NEXT: overload set choice binding $T0 := {{.*}}
 // CHECK-NEXT: (considering: ({{.*}}) -> {{.*}} applicable fn {{.*}}
 // CHECK: increasing 'sync-in-asynchronous' score by 1

test/Constraints/copyable_requirement.swift

@@ -108,7 +108,7 @@ func checkBasicBoxes() {
   _ = rb.get()
   _ = rb.val
 
-  let vb2: ValBox<MO> = .init(MO())  // expected-error {{type 'MO' does not conform to protocol '_Copyable'}}
+  let vb2: ValBox<MO> = .init(MO())  // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
 }
 
 func checkExistential() {
@@ -126,15 +126,15 @@ func checkExistential() {
 }
 
 func checkMethodCalls() {
-  let tg: NotStoredGenerically<MO> = NotStoredGenerically() // expected-error {{type 'MO' does not conform to protocol '_Copyable'}}
+  let tg: NotStoredGenerically<MO> = NotStoredGenerically() // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
   tg.take(MO())
   tg.give()
 
   let _ = Maybe.just(MO()) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'Maybe'}}
 
-  let _: Maybe<MO> = .none // expected-error {{type 'MO' does not conform to protocol '_Copyable'}}
-  let _ = Maybe<MO>.just(MO()) // expected-error {{type 'MO' does not conform to protocol '_Copyable'}}
-  let _: Maybe<MO> = .just(MO()) // expected-error {{type 'MO' does not conform to protocol '_Copyable'}}
+  let _: Maybe<MO> = .none // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
+  let _ = Maybe<MO>.just(MO()) // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
+  let _: Maybe<MO> = .just(MO()) // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
 
   takeMaybe(.just(MO())) // expected-error {{noncopyable type 'MO' cannot be substituted for copyable generic parameter 'T' in 'takeMaybe'}}
   takeMaybe(true ? .none : .just(MO()))
@@ -144,7 +144,7 @@ func checkMethodCalls() {
 func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
   // casting dynamically is allowed, but should always fail since you can't
   // construct such a type.
-  let box = b as! ValBox<MO> // expected-error {{type 'MO' does not conform to protocol '_Copyable'}}
+  let box = b as! ValBox<MO> // expected-error {{type 'MO' does not conform to protocol 'Copyable'}}
   let dup = box
 
   let _: MO = dup.get()
@@ -157,8 +157,7 @@ func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
 
   let _: Sendable = (MO(), MO()) // expected-error {{noncopyable type '(MO, MO)' cannot be erased to copyable existential type 'any Sendable'}}
   let _: Sendable = MO() // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'any Sendable'}}
-  let _: _Copyable = mo // expected-error {{'_Copyable' is unavailable}}
-                        // expected-error@-1 {{noncopyable type 'MO' cannot be erased to copyable existential type 'any _Copyable'}}
+  let _: Copyable = mo // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'any Copyable'}}
   let _: AnyObject = MO() // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'AnyObject'}}
   let _: Any = mo // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'Any'}}
 
@@ -262,19 +261,19 @@ protocol HasType<Ty> {
 }
 
 class SomeGuy: HasType { // expected-error {{type 'SomeGuy' does not conform to protocol 'HasType'}}
-  typealias Ty = MO // expected-note {{possibly intended match 'SomeGuy.Ty' (aka 'MO') does not conform to '_Copyable'}}
+  typealias Ty = MO // expected-note {{possibly intended match 'SomeGuy.Ty' (aka 'MO') does not conform to 'Copyable'}}
 }
 
 struct AnotherGuy: HasType { // expected-error {{type 'AnotherGuy' does not conform to protocol 'HasType'}}
-  @_moveOnly struct Ty {} // expected-note {{possibly intended match 'AnotherGuy.Ty' does not conform to '_Copyable'}}
+  @_moveOnly struct Ty {} // expected-note {{possibly intended match 'AnotherGuy.Ty' does not conform to 'Copyable'}}
 }
 
 protocol Gives: HasType {
   func give() -> Ty
 }
 
 struct GenerousGuy: Gives { // expected-error {{type 'GenerousGuy' does not conform to protocol 'HasType'}}
-  typealias Ty = MO // expected-note {{possibly intended match 'GenerousGuy.Ty' (aka 'MO') does not conform to '_Copyable'}}
+  typealias Ty = MO // expected-note {{possibly intended match 'GenerousGuy.Ty' (aka 'MO') does not conform to 'Copyable'}}
   func give() -> Ty {}
 }
 

test/Constraints/moveonly_constraints.swift

@@ -160,8 +160,7 @@ func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
 
   let _: Sendable = (MO(), MO()) // expected-error {{noncopyable type '(MO, MO)' cannot be erased to copyable existential type 'any Sendable'}}
   let _: Sendable = MO() // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'any Sendable'}}
-  let _: _Copyable = mo // expected-error {{'_Copyable' is unavailable}}
-                        // expected-error@-1 {{noncopyable type 'MO' cannot be erased to copyable existential type 'any _Copyable'}}
+  let _: Copyable = mo // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'any Copyable'}}
   let _: AnyObject = MO() // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'AnyObject'}}
   let _: Any = mo // expected-error {{noncopyable type 'MO' cannot be erased to copyable existential type 'Any'}}
 
@@ -260,19 +259,19 @@ protocol HasType<Ty> {
 }
 
 class SomeGuy: HasType { // expected-error {{type 'SomeGuy' does not conform to protocol 'HasType'}}
-  typealias Ty = MO // expected-note {{possibly intended match 'SomeGuy.Ty' (aka 'MO') does not conform to '_Copyable'}}
+  typealias Ty = MO // expected-note {{possibly intended match 'SomeGuy.Ty' (aka 'MO') does not conform to 'Copyable'}}
 }
 
 struct AnotherGuy: HasType { // expected-error {{type 'AnotherGuy' does not conform to protocol 'HasType'}}
-  @_moveOnly struct Ty {} // expected-note {{possibly intended match 'AnotherGuy.Ty' does not conform to '_Copyable'}}
+  @_moveOnly struct Ty {} // expected-note {{possibly intended match 'AnotherGuy.Ty' does not conform to 'Copyable'}}
 }
 
 protocol Gives: HasType {
   func give() -> Ty
 }
 
 struct GenerousGuy: Gives { // expected-error {{type 'GenerousGuy' does not conform to protocol 'HasType'}}
-  typealias Ty = MO // expected-note {{possibly intended match 'GenerousGuy.Ty' (aka 'MO') does not conform to '_Copyable'}}
+  typealias Ty = MO // expected-note {{possibly intended match 'GenerousGuy.Ty' (aka 'MO') does not conform to 'Copyable'}}
   func give() -> Ty {}
 }
 

test/ModuleInterface/copyable.swift

@@ -1,6 +1,6 @@
 // RUN: %empty-directory(%t)
 
-// This test checks that conformances to _Copyable do not appear in swiftinterface files
+// This test checks that conformances to Copyable do not appear in swiftinterface files
 
 // Generate the parseable interface of the current file via the merge-modules step
 // RUN: %target-build-swift -emit-module -o %t/Test.swiftmodule -emit-module-interface-path %t/TestMerge.swiftinterface -module-name Test %s -enable-library-evolution -swift-version 5

test/SILGen/unmanaged_ownership.swift

@@ -1,7 +1,7 @@
 
 // RUN: %target-swift-emit-silgen -parse-stdlib -module-name Swift %s | %FileCheck %s
 
-@_marker protocol _Copyable {}
+@_marker protocol Copyable {}
 
 class C {}
 

test/SILOptimizer/nonescaping_partial_apply_gauntlet.swift

@@ -5,7 +5,7 @@
 // RUN: %target-swift-frontend -emit-sil -parse-stdlib -module-name Swift %s
 // RUN: %target-swift-frontend -emit-sil -O -parse-stdlib -module-name Swift %s
 
-@_marker protocol _Copyable {}
+@_marker protocol Copyable {}
 precedencegroup CastingPrecedence {}
 precedencegroup AssignmentPrecedence {}
 

test/SILOptimizer/opaque_values_Onone_stdlib.swift

@@ -10,7 +10,7 @@ precedencegroup AssignmentPrecedence { assignment: true }
 precedencegroup CastingPrecedence {}
 
 public protocol _ObjectiveCBridgeable {}
-@_marker public protocol _Copyable {}
+@_marker public protocol Copyable {}
 
 public protocol _ExpressibleByBuiltinBooleanLiteral {
   init(_builtinBooleanLiteral value: Builtin.Int1)

test/Sema/copyable.swift

@@ -1,30 +1,28 @@
 // RUN: %target-typecheck-verify-swift
 
-protocol P: _Copyable {} // expected-error {{'_Copyable' is unavailable}}
+protocol P: Copyable {} 
 struct S: P {}
 
-typealias PleaseLetMeDoIt = _Copyable // expected-error {{'_Copyable' is unavailable}}
-typealias WhatIfIQualify = Swift._Copyable // expected-error {{'_Copyable' is unavailable}}
+typealias PleaseLetMeDoIt = Copyable 
+typealias WhatIfIQualify = Swift.Copyable 
 
-class C: _Copyable {} // expected-error {{'_Copyable' is unavailable}}
+class C: Copyable {} 
 
-@_moveOnly struct MOStruct: _Copyable {}
-// expected-error@-1 {{noncopyable struct 'MOStruct' cannot conform to '_Copyable'}}
-// expected-error@-2 {{'_Copyable' is unavailable}}
+@_moveOnly struct MOStruct: Copyable {} // expected-error {{noncopyable struct 'MOStruct' cannot conform to 'Copyable'}}
 
 
-func whatever<T>(_ t: T) where T: _Copyable {} // expected-error {{'_Copyable' is unavailable}}
-func vatever<T: _Copyable>(_ t: T) {} // expected-error {{'_Copyable' is unavailable}}
-func buttever(_ t: any _Copyable) {} // expected-error {{'_Copyable' is unavailable}}
-func zuttever(_ t: some _Copyable) {} // expected-error 2{{'_Copyable' is unavailable}}
+func whatever<T>(_ t: T) where T: Copyable {} 
+func vatever<T: Copyable>(_ t: T) {} 
+func buttever(_ t: any Copyable) {}
+func zuttever(_ t: some Copyable) {}
 
-enum RockNRoll<T: _Copyable> { // expected-error {{'_Copyable' is unavailable}}
- case isNoisePollution(_Copyable) // expected-error {{'_Copyable' is unavailable}}
+enum RockNRoll<T: Copyable> { 
+ case isNoisePollution(Copyable) 
  case isMusic(T)
 }
 
 enum namespace {
-  typealias _Copyable = Int
+  typealias Copyable = Int
 
-  func _Copyable() -> _Copyable { return 0 }
+  func Copyable() -> Copyable { return 0 }
 }

test/Sema/copyable_constraint.swift

@@ -5,7 +5,7 @@
 // FIXME: Now demonstrate that plain -parse-stdlib, such as in some arbitrary test, doesn't get the Copyable constraint :(
 // RUN: not %target-swift-frontend -typecheck -verify -parse-stdlib %s
 
-@_marker public protocol _Copyable {}
+@_marker public protocol Copyable {}
 
 func nextTime<T>(_ t: T) {} // expected-note {{generic parameter 'T' has an implicit Copyable requirement}}
 

test/Sema/moveonly_sendable.swift

@@ -131,7 +131,7 @@ protocol GiveSendable<T> {
 
 // make sure witnessing associatedtypes is still prevented, even though we meet the explicit constraint.
 class Bad: GiveSendable { // expected-error {{type 'Bad' does not conform to protocol 'GiveSendable'}}
-  typealias T = FileDescriptor // expected-note {{possibly intended match 'Bad.T' (aka 'FileDescriptor') does not conform to '_Copyable'}}
+  typealias T = FileDescriptor // expected-note {{possibly intended match 'Bad.T' (aka 'FileDescriptor') does not conform to 'Copyable'}}
   func give() -> FileDescriptor { return FileDescriptor(id: -1) }
 }