Rename AtomicValue to AtomicRepresentable

Author: Azoy

stdlib/public/Synchronization/Atomic.swift

@@ -17,7 +17,7 @@ import Builtin
 @frozen
 @_rawLayout(like: Value.AtomicRepresentation)
 @_staticExclusiveOnly
-public struct Atomic<Value: AtomicValue>: ~Copyable {
+public struct Atomic<Value: AtomicRepresentable>: ~Copyable {
   @available(SwiftStdlib 5.11, *)
   @_alwaysEmitIntoClient
   @_transparent

stdlib/public/Synchronization/AtomicBool.swift

@@ -13,11 +13,11 @@
 import Builtin
 
 //===----------------------------------------------------------------------===//
-// Bool AtomicValue conformance
+// Bool AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension Bool: AtomicValue {
+extension Bool: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)

stdlib/public/Synchronization/AtomicFloats.swift

@@ -11,13 +11,13 @@
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
-// Float16 AtomicValue conformance
+// Float16 AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 #if !((os(macOS) || targetEnvironment(macCatalyst)) && arch(x86_64))
 
 @available(SwiftStdlib 5.11, *)
-extension Float16: AtomicValue {
+extension Float16: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -65,11 +65,11 @@ extension Float16: AtomicValue {
 #endif
 
 //===----------------------------------------------------------------------===//
-// Float AtomicValue conformance
+// Float AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension Float: AtomicValue {
+extension Float: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -115,13 +115,13 @@ extension Float: AtomicValue {
 }
 
 //===----------------------------------------------------------------------===//
-// Double AtomicValue conformance
+// Double AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || _pointerBitWidth(_64)
 
 @available(SwiftStdlib 5.11, *)
-extension Double: AtomicValue {
+extension Double: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)

stdlib/public/Synchronization/AtomicIntegers.swift.gyb

@@ -17,15 +17,15 @@ import Builtin
 % for (intType, intStorage, builtinInt) in intTypes:
 
 //===----------------------------------------------------------------------===//
-// ${intType} AtomicValue conformance
+// ${intType} AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 % if intType == "Int64" or intType == "UInt64":
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || _pointerBitWidth(_64)
 % end
 
 @available(SwiftStdlib 5.11, *)
-extension ${intType}: AtomicValue {
+extension ${intType}: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
 %   if intType == "Int" or intType == "UInt":

stdlib/public/Synchronization/AtomicOptional.swift

@@ -11,11 +11,10 @@
 //===----------------------------------------------------------------------===//
 
 /// An atomic value that also supports atomic operations when wrapped
-/// in an `Optional`. Atomic optional wrappable types come with a
-/// standalone atomic representation for their optional-wrapped
-/// variants.
+/// in an `Optional`. Atomic optional representable types come with a standalone
+/// atomic representation for their optional-wrapped variants.
 @available(SwiftStdlib 5.11, *)
-public protocol AtomicOptionalWrappable: AtomicValue {
+public protocol AtomicOptionalRepresentable: AtomicRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -52,14 +51,14 @@ public protocol AtomicOptionalWrappable: AtomicValue {
 }
 
 //===----------------------------------------------------------------------===//
-// RawRepresentable AtomicOptionalWrappable conformance
+// RawRepresentable AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
 extension RawRepresentable
 where
-  Self: AtomicOptionalWrappable,
-  RawValue: AtomicOptionalWrappable
+  Self: AtomicOptionalRepresentable,
+  RawValue: AtomicOptionalRepresentable
 {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
@@ -118,11 +117,11 @@ where
 }
 
 //===----------------------------------------------------------------------===//
-// Optional AtomicValue conformance
+// Optional AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension Optional: AtomicValue where Wrapped: AtomicOptionalWrappable {
+extension Optional: AtomicRepresentable where Wrapped: AtomicOptionalRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)

stdlib/public/Synchronization/AtomicPointers.swift

@@ -11,11 +11,11 @@
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
-// UnsafePointer AtomicValue and AtomicOptionalWrappable conformance
+// UnsafePointer AtomicRepresentable and AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafePointer: AtomicValue {
+extension UnsafePointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -65,7 +65,7 @@ extension UnsafePointer: AtomicValue {
 }
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafePointer: AtomicOptionalWrappable {
+extension UnsafePointer: AtomicOptionalRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -117,11 +117,11 @@ extension UnsafePointer: AtomicOptionalWrappable {
 }
 
 //===----------------------------------------------------------------------===//
-// UnsafeMutablePointer AtomicOptionalWrappable conformance
+// UnsafeMutablePointer AtomicRepresentable and AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeMutablePointer: AtomicValue {
+extension UnsafeMutablePointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -171,7 +171,7 @@ extension UnsafeMutablePointer: AtomicValue {
 }
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeMutablePointer: AtomicOptionalWrappable {
+extension UnsafeMutablePointer: AtomicOptionalRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -223,11 +223,11 @@ extension UnsafeMutablePointer: AtomicOptionalWrappable {
 }
 
 //===----------------------------------------------------------------------===//
-// UnsafeRawPointer AtomicOptionalWrappable conformance
+// UnsafeRawPointer AtomicRepresentable and AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeRawPointer: AtomicValue {
+extension UnsafeRawPointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -277,7 +277,7 @@ extension UnsafeRawPointer: AtomicValue {
 }
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeRawPointer: AtomicOptionalWrappable {
+extension UnsafeRawPointer: AtomicOptionalRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -329,11 +329,11 @@ extension UnsafeRawPointer: AtomicOptionalWrappable {
 }
 
 //===----------------------------------------------------------------------===//
-// UnsafeMutableRawPointer AtomicOptionalWrappable conformance
+// UnsafeMutableRawPointer AtomicRepresentable and AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeMutableRawPointer: AtomicValue {
+extension UnsafeMutableRawPointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -383,7 +383,7 @@ extension UnsafeMutableRawPointer: AtomicValue {
 }
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeMutableRawPointer: AtomicOptionalWrappable {
+extension UnsafeMutableRawPointer: AtomicOptionalRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -435,11 +435,11 @@ extension UnsafeMutableRawPointer: AtomicOptionalWrappable {
 }
 
 //===----------------------------------------------------------------------===//
-// Unmanaged AtomicOptionalWrappable conformance
+// Unmanaged AtomicRepresentable and AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension Unmanaged: AtomicValue {
+extension Unmanaged: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -489,7 +489,7 @@ extension Unmanaged: AtomicValue {
 }
 
 @available(SwiftStdlib 5.11, *)
-extension Unmanaged: AtomicOptionalWrappable {
+extension Unmanaged: AtomicOptionalRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -549,11 +549,11 @@ extension Unmanaged: AtomicOptionalWrappable {
 }
 
 //===----------------------------------------------------------------------===//
-// OpaquePointer AtomicOptionalWrappable conformance
+// OpaquePointer AtomicRepresentable and AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension OpaquePointer: AtomicValue {
+extension OpaquePointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -603,7 +603,7 @@ extension OpaquePointer: AtomicValue {
 }
 
 @available(SwiftStdlib 5.11, *)
-extension OpaquePointer: AtomicOptionalWrappable {
+extension OpaquePointer: AtomicOptionalRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -655,11 +655,11 @@ extension OpaquePointer: AtomicOptionalWrappable {
 }
 
 //===----------------------------------------------------------------------===//
-// ObjectIdentifier AtomicOptionalWrappable conformance
+// ObjectIdentifier AtomicRepresentable and AtomicOptionalRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 5.11, *)
-extension ObjectIdentifier: AtomicValue {
+extension ObjectIdentifier: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -711,7 +711,7 @@ extension ObjectIdentifier: AtomicValue {
 }
 
 @available(SwiftStdlib 5.11, *)
-extension ObjectIdentifier: AtomicOptionalWrappable {
+extension ObjectIdentifier: AtomicOptionalRepresentable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -767,13 +767,13 @@ extension ObjectIdentifier: AtomicOptionalWrappable {
 }
 
 //===----------------------------------------------------------------------===//
-// UnsafeBufferPointer AtomicValue conformance
+// UnsafeBufferPointer AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || (_pointerBitWidth(_64) && _hasAtomicBitWidth(_128))
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeBufferPointer: AtomicValue {
+extension UnsafeBufferPointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -833,13 +833,13 @@ extension UnsafeBufferPointer: AtomicValue {
 #endif
 
 //===----------------------------------------------------------------------===//
-// UnsafeMutableBufferPointer AtomicValue conformance
+// UnsafeMutableBufferPointer AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || (_pointerBitWidth(_64) && _hasAtomicBitWidth(_128))
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeMutableBufferPointer: AtomicValue {
+extension UnsafeMutableBufferPointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -899,13 +899,13 @@ extension UnsafeMutableBufferPointer: AtomicValue {
 #endif
 
 //===----------------------------------------------------------------------===//
-// UnsafeRawBufferPointer AtomicValue conformance
+// UnsafeRawBufferPointer AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || (_pointerBitWidth(_64) && _hasAtomicBitWidth(_128))
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeRawBufferPointer: AtomicValue {
+extension UnsafeRawBufferPointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)
@@ -965,13 +965,13 @@ extension UnsafeRawBufferPointer: AtomicValue {
 #endif
 
 //===----------------------------------------------------------------------===//
-// UnsafeMutableRawBufferPointer AtomicValue conformance
+// UnsafeMutableRawBufferPointer AtomicRepresentable conformance
 //===----------------------------------------------------------------------===//
 
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || (_pointerBitWidth(_64) && _hasAtomicBitWidth(_128))
 
 @available(SwiftStdlib 5.11, *)
-extension UnsafeMutableRawBufferPointer: AtomicValue {
+extension UnsafeMutableRawBufferPointer: AtomicRepresentable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 5.11, *)