[BitwiseCopyable] Remove underscore.

Author: nate-chandler

include/swift/AST/DiagnosticsSema.def

@@ -7727,7 +7727,7 @@ ERROR(non_bitwise_copyable_type_cxx_nontrivial,none,
 ERROR(non_bitwise_copyable_c_type_nontrivial,none,
       "type with unrepresentable fields cannot derive conformance to 'BitwiseCopyable'", ())
 NOTE(note_non_bitwise_copyable_c_type_add_attr,none,
-     "annotate the type __attribute__((__swift_attr__(\"_BitwiseCopyable\")))",())
+     "annotate the type __attribute__((__swift_attr__(\"BitwiseCopyable\")))",())
 ERROR(non_bitwise_copyable_type_member,none,
       "%select{stored property %2|associated value %2}1 of "
       "'BitwiseCopyable'-conforming %kind3 has non-bitwise-copyable type %0",

include/swift/AST/KnownProtocols.def

@@ -150,7 +150,7 @@ PROTOCOL(FloatingPoint)
     INVERTIBLE_PROTOCOL_WITH_NAME(Name, #Name)
 #include "swift/ABI/InvertibleProtocols.def"
 
-REPRESSIBLE_PROTOCOL_(BitwiseCopyable)
+REPRESSIBLE_PROTOCOL(BitwiseCopyable)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral, "BooleanLiteralType", true)

lib/ClangImporter/ImportDecl.cpp

@@ -8047,7 +8047,7 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
         continue;
       }
 
-      if (swiftAttr->getAttribute() == "_BitwiseCopyable") {
+      if (swiftAttr->getAttribute() == "BitwiseCopyable") {
         auto *protocol =
             SwiftContext.getProtocol(KnownProtocolKind::BitwiseCopyable);
         auto *nominal = dyn_cast<NominalTypeDecl>(MappedDecl);

lib/SIL/IR/TypeLowering.cpp

@@ -3199,7 +3199,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
           // conforming.
           if (!nominal) {
             llvm::errs()
-                << "Non-nominal type without conformance to _BitwiseCopyable:\n"
+                << "Non-nominal type without conformance to BitwiseCopyable:\n"
                 << ty << "\n"
                 << "within " << substType << "\n"
                 << "of " << origType << "\n";
@@ -3310,7 +3310,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
           return true;
         });
     if (hasNoConformingArchetypeNode) {
-      llvm::errs() << "Non-trivial type with _BitwiseCopyable conformance!?:\n"
+      llvm::errs() << "Non-trivial type with BitwiseCopyable conformance!?:\n"
                    << substType << "\n";
       conformance.print(llvm::errs());
       llvm::errs() << "\n"

stdlib/public/core/CommandLine.swift

@@ -21,14 +21,14 @@ internal func _swift_stdlib_getUnsafeArgvArgc(_: UnsafeMutablePointer<Int32>)
 /// Command-line arguments for the current process.
 #if $BitwiseCopyable && $ConformanceSuppression
 @frozen // namespace
-public enum CommandLine : ~_BitwiseCopyable {
+public enum CommandLine : ~BitwiseCopyable {
 }
 #else
 @frozen // namespace
 public enum CommandLine {
 }
 @available(*, unavailable)
-extension CommandLine : _BitwiseCopyable {}
+extension CommandLine : BitwiseCopyable {}
 #endif
 
 extension CommandLine {

stdlib/public/core/KeyPath.swift

@@ -1857,12 +1857,12 @@ internal struct RawKeyPathComponent {
   }
 }
 
-internal func _pop<T : _BitwiseCopyable>(from: inout UnsafeRawBufferPointer,
+internal func _pop<T : BitwiseCopyable>(from: inout UnsafeRawBufferPointer,
                       as type: T.Type) -> T {
   let buffer = _pop(from: &from, as: type, count: 1)
   return buffer.baseAddress.unsafelyUnwrapped.pointee
 }
-internal func _pop<T : _BitwiseCopyable>(from: inout UnsafeRawBufferPointer,
+internal func _pop<T : BitwiseCopyable>(from: inout UnsafeRawBufferPointer,
                       as: T.Type,
                       count: Int) -> UnsafeBufferPointer<T> {
   from = MemoryLayout<T>._roundingUpBaseToAlignment(from)
@@ -3482,7 +3482,7 @@ internal struct InstantiateKeyPathBuffer: KeyPathPatternVisitor {
     }
     return (baseAddress, misalign)
   }
-  mutating func pushDest<T : _BitwiseCopyable>(_ value: T) {
+  mutating func pushDest<T : BitwiseCopyable>(_ value: T) {
     let size = MemoryLayout<T>.size
     let (baseAddress, misalign) = adjustDestForAlignment(of: T.self)
     _withUnprotectedUnsafeBytes(of: value) {

stdlib/public/core/MemoryLayout.swift

@@ -41,12 +41,12 @@
 ///             alignment: MemoryLayout<Point>.alignment)
 #if $BitwiseCopyable && $ConformanceSuppression
 @frozen // namespace
-public enum MemoryLayout<T: ~Copyable>: ~_BitwiseCopyable, Copyable {}
+public enum MemoryLayout<T: ~Copyable>: ~BitwiseCopyable, Copyable {}
 #else
 @frozen // namespace
 public enum MemoryLayout<T: ~Copyable>: Copyable {}
 @available(*, unavailable)
-extension MemoryLayout: _BitwiseCopyable {}
+extension MemoryLayout: BitwiseCopyable {}
 #endif
 
 extension MemoryLayout where T: ~Copyable {

stdlib/public/core/Misc.swift

@@ -174,7 +174,10 @@ func _rethrowsViaClosure(_ fn: () throws -> ()) rethrows {
 @_marker public protocol Escapable {}
 
 #if $NoncopyableGenerics && $NonescapableTypes
-@_marker public protocol _BitwiseCopyable: ~Escapable { }
+@_marker public protocol BitwiseCopyable: ~Escapable { }
 #else
-@_marker public protocol _BitwiseCopyable { }
+@_marker public protocol BitwiseCopyable { }
 #endif
+
+@available(*, unavailable)
+@_marker public protocol _BitwiseCopyable {}

stdlib/public/core/Optional.swift

@@ -136,7 +136,7 @@ extension Optional: Copyable /* where Wrapped: Copyable */ {}
 
 extension Optional: Sendable where Wrapped: ~Copyable & Sendable { }
 
-extension Optional: _BitwiseCopyable where Wrapped: _BitwiseCopyable { }
+extension Optional: BitwiseCopyable where Wrapped: BitwiseCopyable { }
 
 @_preInverseGenerics
 extension Optional: ExpressibleByNilLiteral where Wrapped: ~Copyable {

stdlib/public/core/Pointer.swift

@@ -30,7 +30,7 @@ public protocol _Pointer:
   Strideable,
   _CustomDebugStringConvertibleOrNone,
   _CustomReflectableOrNone,
-  _BitwiseCopyable
+  BitwiseCopyable
 {
   /// A type that represents the distance between two pointers.
   typealias Distance = Int

stdlib/public/core/SIMDVector.swift

@@ -31,7 +31,7 @@ prefix operator .!
 /// elementwise accesses. Computational operations are defined on the `SIMD`
 /// protocol, which refines this protocol, and on the concrete types that
 /// conform to `SIMD`.
-public protocol SIMDStorage : _BitwiseCopyable {
+public protocol SIMDStorage : BitwiseCopyable {
   /// The type of scalars in the vector space.
   #if $Embedded
   associatedtype Scalar: Hashable
@@ -64,7 +64,7 @@ extension SIMDStorage {
 }
 
 /// A type that can be used as an element in a SIMD vector.
-public protocol SIMDScalar : _BitwiseCopyable {
+public protocol SIMDScalar : BitwiseCopyable {
   associatedtype SIMDMaskScalar: SIMDScalar & FixedWidthInteger & SignedInteger
     where SIMDMaskScalar.SIMDMaskScalar == SIMDMaskScalar
   associatedtype SIMD2Storage: SIMDStorage where SIMD2Storage.Scalar == Self
@@ -81,7 +81,7 @@ public protocol SIMD<Scalar>:
   SIMDStorage,
   Hashable,
   ExpressibleByArrayLiteral,
-  _BitwiseCopyable
+  BitwiseCopyable
 {
   /// The mask type resulting from pointwise comparisons of this vector type.
   associatedtype MaskStorage: SIMD
@@ -97,7 +97,7 @@ public protocol SIMD<Scalar>:
   Hashable,
   CustomStringConvertible,
   ExpressibleByArrayLiteral,
-  _BitwiseCopyable
+  BitwiseCopyable
 {
   /// The mask type resulting from pointwise comparisons of this vector type.
   associatedtype MaskStorage: SIMD

stdlib/public/core/Unicode.swift

@@ -673,7 +673,7 @@ public func transcode<Input, InputEncoding, OutputEncoding>(
 /// A namespace for Unicode utilities.
 #if $BitwiseCopyable && $ConformanceSuppression
 @frozen
-public enum Unicode : ~_BitwiseCopyable {}
+public enum Unicode : ~BitwiseCopyable {}
 #else
 @frozen
 public enum Unicode {}

stdlib/public/core/UnsafeBufferPointerSlice.swift

@@ -381,7 +381,7 @@ extension Slice where Base == UnsafeMutableRawBufferPointer {
 #if $BitwiseCopyable
   @inlinable
   @_alwaysEmitIntoClient
-  public func loadUnaligned<T : _BitwiseCopyable>(
+  public func loadUnaligned<T : BitwiseCopyable>(
     fromByteOffset offset: Int = 0,
     as type: T.Type
   ) -> T {
@@ -620,7 +620,7 @@ extension Slice where Base == UnsafeRawBufferPointer {
 #if $BitwiseCopyable
   @inlinable
   @_alwaysEmitIntoClient
-  public func loadUnaligned<T : _BitwiseCopyable>(
+  public func loadUnaligned<T : BitwiseCopyable>(
     fromByteOffset offset: Int = 0,
     as type: T.Type
   ) -> T {

stdlib/public/core/UnsafeRawBufferPointer.swift.gyb

@@ -440,7 +440,7 @@ extension Unsafe${Mutable}RawBufferPointer {
   ///   memory.
 #if $BitwiseCopyable
   @_alwaysEmitIntoClient
-  public func loadUnaligned<T : _BitwiseCopyable>(
+  public func loadUnaligned<T : BitwiseCopyable>(
     fromByteOffset offset: Int = 0,
     as type: T.Type
   ) -> T {

stdlib/public/core/UnsafeRawPointer.swift

@@ -480,7 +480,7 @@ extension UnsafeRawPointer {
   ///   with the value in the range of memory referenced by this pointer.
   @inlinable
   @_alwaysEmitIntoClient
-  public func loadUnaligned<T: _BitwiseCopyable>(
+  public func loadUnaligned<T: BitwiseCopyable>(
     fromByteOffset offset: Int = 0,
     as type: T.Type
   ) -> T {
@@ -1313,7 +1313,7 @@ extension UnsafeMutableRawPointer {
   ///   with the value in the range of memory referenced by this pointer.
   @inlinable
   @_alwaysEmitIntoClient
-  public func loadUnaligned<T: _BitwiseCopyable>(
+  public func loadUnaligned<T: BitwiseCopyable>(
     fromByteOffset offset: Int = 0,
     as type: T.Type
   ) -> T {
@@ -1400,7 +1400,7 @@ extension UnsafeMutableRawPointer {
   ///   - type: The type of `value`.
   @inlinable
   @_alwaysEmitIntoClient
-  public func storeBytes<T: _BitwiseCopyable>(
+  public func storeBytes<T: BitwiseCopyable>(
     of value: T, toByteOffset offset: Int = 0, as type: T.Type
   ) {
 #if $BuiltinStoreRaw

test/Frontend/bitwise-copyable-flag.swift

@@ -4,5 +4,5 @@
 
 // Verify that the BitwiseCopyable feature flag works both in asserts and noasserts builds.
 
-struct S : _BitwiseCopyable {
+struct S : BitwiseCopyable {
 }

test/IRGen/bitwise-copyable-derived-loadRaw.swift

@@ -4,7 +4,7 @@
 
 // Execute an unaligned load of SIMD16<UInt8> which conforms to a protocol derived from BitwiseCopyable.
 
-public protocol MyBitwiseCopyable : _BitwiseCopyable {}
+public protocol MyBitwiseCopyable : BitwiseCopyable {}
 
 extension SIMD16 : MyBitwiseCopyable where Scalar.SIMD16Storage : MyBitwiseCopyable {}
 extension UInt8.SIMD16Storage : MyBitwiseCopyable {}

test/IRGen/bitwise-copyable-loadRaw.swift

@@ -4,7 +4,7 @@
 
 // Execute an unaligned load of SIMD16<UInt8> which retroactively conforms directly to BitwiseCopyable.
 
-extension SIMD16 : @retroactive _BitwiseCopyable where Scalar.SIMD16Storage : _BitwiseCopyable {}
+extension SIMD16 : @retroactive BitwiseCopyable where Scalar.SIMD16Storage : BitwiseCopyable {}
 
 func doit() {
   let bytes: [UInt8] = Array(repeating: 0, count: 64)

test/IRGen/bitwise_copyable.swift

@@ -12,11 +12,11 @@
 import Foundation
 import Builtin
 
-struct Box<T : _BitwiseCopyable> : _BitwiseCopyable {
+struct Box<T : BitwiseCopyable> : BitwiseCopyable {
   var t: T
 }
 
-struct Boxx<each T : _BitwiseCopyable> {
+struct Boxx<each T : BitwiseCopyable> {
   var ts: (repeat each T)
 }
 

test/IRGen/bitwise_copyable_onone.swift

@@ -7,7 +7,7 @@
 // RUN: %FileCheck %s
 
 
-// CHECK-LABEL: define{{.*}} ptr @"$s22bitwise_copyable_onone1EOy1AQzGAA1PRzs16_BitwiseCopyableAERQlWOh"(
+// CHECK-LABEL: define{{.*}} ptr @"$s22bitwise_copyable_onone1EOy1AQzGAA1PRzs16BitwiseCopyableAERQlWOh"(
 // CHECK-SAME:      ptr %0, 
 // CHECK-SAME:      ptr %I.A, 
 // CHECK-SAME:      ptr %"E<I.A>"
@@ -21,7 +21,7 @@ protocol P {
   associatedtype A
 }
 
-class C<I: P> where I.A: _BitwiseCopyable {
+class C<I: P> where I.A: BitwiseCopyable {
   func takeE(_ event: E<I.A>) {}
   func run(_ e: I.A) {
     takeE(.next(e))

test/IRGen/bitwise_copyable_resilient.swift

@@ -32,22 +32,22 @@ public struct Integer {
 //--- Downstream.swift
 import Library
 
-func take<T: _BitwiseCopyable>(_ t: T) {}
+func take<T: BitwiseCopyable>(_ t: T) {}
 
-struct S_Explicit_With_Oopsional<T> : _BitwiseCopyable {
+struct S_Explicit_With_Oopsional<T> : BitwiseCopyable {
   var o: Oopsional<T> // expected-error{{non_bitwise_copyable_type_member}}
 }
 
 func passOopsional<T>(_ t: Oopsional<T>) { take(t) } // expected-error   {{type_does_not_conform_decl_owner}}
                                                      // expected-note@-7 {{where_requirement_failure_one_subst}}
 
 
-struct S_Explicit_With_Woopsional<T> : _BitwiseCopyable {
+struct S_Explicit_With_Woopsional<T> : BitwiseCopyable {
   var o: Woopsional<T> // expected-error{{non_bitwise_copyable_type_member}}
 }
 
 func passWoopsional<T>(_ t: Woopsional<T>) { take(t) } // expected-error    {{type_does_not_conform_decl_owner}}
                                                        // expected-note@-15 {{where_requirement_failure_one_subst}}
 
-extension Integer : @retroactive _BitwiseCopyable {} // expected-error {{bitwise_copyable_outside_module}}
+extension Integer : @retroactive BitwiseCopyable {} // expected-error {{bitwise_copyable_outside_module}}
 

test/ModuleInterface/bitwise_copyable.swift

@@ -8,4 +8,4 @@
 @_moveOnly
 public struct S_Implicit_Noncopyable {}
 
-// CHECK-NOT: extension Test.S_Implicit_Noncopyable : Swift._BitwiseCopyable {}
+// CHECK-NOT: extension Test.S_Implicit_Noncopyable : Swift.BitwiseCopyable {}