rename _Copyable to Copyable and make it available

Author: kavon

include/swift/AST/DiagnosticsParse.def

@@ -1824,6 +1824,8 @@ ERROR(unexpected_class_constraint,none,
        "'class' constraint can only appear on protocol declarations", ())
 NOTE(suggest_anyobject,none,
      "did you mean to write an 'AnyObject' constraint?", ())
+ERROR(suppress_illegal_here,none,
+      "cannot suppress conformances here", ())
 ERROR(expected_generics_type_restriction,none,
       "expected a class type or protocol-constrained type restricting %0",
       (Identifier))

include/swift/AST/KnownProtocols.def

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

lib/Sema/TypeCheckProtocol.cpp

@@ -4623,7 +4623,7 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
   if (type->isPureMoveOnly()) {
     // describe the failure reason as it not conforming to Copyable
     auto *copyable = ctx.getProtocol(KnownProtocolKind::Copyable);
-    assert(copyable && "missing _Copyable protocol!");
+    assert(copyable && "missing Copyable protocol!");
     return CheckTypeWitnessResult(copyable->getDeclaredInterfaceType());
   }
 

stdlib/public/core/CompilerProtocols.swift

@@ -972,3 +972,19 @@ public protocol _ExpressibleByFileReferenceLiteral {
 /// then Array would no longer be a _DestructorSafeContainer.
 public protocol _DestructorSafeContainer {
 }
+
+/// This marker protocol describes the category of types that support implicit
+/// copying. By default, all types in Swift implicitly support copying and thus
+/// conformance to `Copyable` is implicitly synthesized. To suppress the
+/// implicit conformance synthesis, write `~Copyable` on the type declaration:
+///
+///     struct FileDescriptor: ~Copyable { /* ... */ }
+///
+/// The reading of this type declaration is "FileDescriptor suppresses implicit
+/// Copyable conformance".
+@_marker public protocol Copyable {}
+
+/// For older compilers interacting with newer stdlibs, define the unavailable
+/// `_Copyable` marker protocol that they expect to find.
+@available(*, unavailable)
+typealias _Copyable = Copyable

stdlib/public/core/Misc.swift

@@ -154,10 +154,3 @@ public func _getTypeByMangledNameInContext(
 public func _unsafePerformance<T>(_ c: () -> T) -> T {
   return c()
 }
-
-/// This marker protocol represents types that support copying.
-/// This type is not yet available for use to express explicit
-/// constraints on generics in your programs. It is currently
-/// only used internally by the compiler.
-@available(*, unavailable)
-@_marker public protocol _Copyable {}

test/Concurrency/async_overload_filtering.swift

@@ -17,7 +17,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/moveonly_constraints.swift

@@ -88,8 +88,8 @@ func testBasic(_ mo: borrowing MO) {
   genericVarArg(5)
   genericVarArg(mo) // expected-error {{move-only type 'MO' cannot be used with generics yet}}
 
-  takeGeneric( (mo, 5) ) // expected-error {{global function 'takeGeneric' requires that 'MO' conform to '_Copyable'}}
-  takeGenericSendable((mo, mo)) // expected-error 2{{global function 'takeGenericSendable' requires that 'MO' conform to '_Copyable'}}
+  takeGeneric( (mo, 5) ) // expected-error {{global function 'takeGeneric' requires that 'MO' conform to 'Copyable'}}
+  takeGenericSendable((mo, mo)) // expected-error 2{{global function 'takeGenericSendable' requires that 'MO' conform to 'Copyable'}}
 
   let singleton : (MO) = (mo)
   takeGeneric(singleton) // expected-error {{move-only type 'MO' cannot be used with generics yet}}
@@ -150,7 +150,7 @@ func checkCasting(_ b: any Box, _ mo: borrowing MO, _ a: Any) {
 
   let _: Sendable = (MO(), MO()) // expected-error {{move-only type '(MO, MO)' cannot be used with generics yet}}
   let _: Sendable = MO() // expected-error {{move-only type 'MO' cannot be used with generics yet}}
-  let _: _Copyable = mo // expected-error {{'_Copyable' is unavailable}}
+  let _: Copyable = mo // expected-error {{'Copyable' is unavailable}}
                         // expected-error@-1 {{move-only type 'MO' cannot be used with generics yet}}
   let _: AnyObject = MO() // expected-error {{move-only type 'MO' cannot be used with generics yet}}
   let _: Any = mo // expected-error {{move-only type 'MO' cannot be used with generics yet}}
@@ -251,18 +251,18 @@ 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,30 @@
 // RUN: %target-typecheck-verify-swift
 
-protocol P: _Copyable {} // expected-error {{'_Copyable' is unavailable}}
+protocol P: Copyable {} // expected-error {{'Copyable' is unavailable}}
 struct S: P {}
 
-typealias PleaseLetMeDoIt = _Copyable // expected-error {{'_Copyable' is unavailable}}
-typealias WhatIfIQualify = Swift._Copyable // expected-error {{'_Copyable' is unavailable}}
+typealias PleaseLetMeDoIt = Copyable // expected-error {{'Copyable' is unavailable}}
+typealias WhatIfIQualify = Swift.Copyable // expected-error {{'Copyable' is unavailable}}
 
-class C: _Copyable {} // expected-error {{'_Copyable' is unavailable}}
+class C: Copyable {} // expected-error {{'Copyable' is unavailable}}
 
-@_moveOnly struct MOStruct: _Copyable {}
-// expected-error@-1 {{move-only struct 'MOStruct' cannot conform to '_Copyable'}}
-// expected-error@-2 {{'_Copyable' is unavailable}}
+@_moveOnly struct MOStruct: Copyable {}
+// expected-error@-1 {{move-only struct 'MOStruct' cannot conform to 'Copyable'}}
+// expected-error@-2 {{'Copyable' is unavailable}}
 
 
-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 {} // 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}}
 
-enum RockNRoll<T: _Copyable> { // expected-error {{'_Copyable' is unavailable}}
- case isNoisePollution(_Copyable) // expected-error {{'_Copyable' is unavailable}}
+enum RockNRoll<T: Copyable> { // expected-error {{'Copyable' is unavailable}}
+ case isNoisePollution(Copyable) // expected-error {{'Copyable' is unavailable}}
  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) {}
 

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) }
 }