Add a weakCompareExchange variant that only takes a single ordering

Package.swift

@@ -50,12 +50,13 @@ let package = Package(
       dependencies: ["_AtomicsShims"],
       exclude: [
         "CMakeLists.txt",
-        "Builtins.swift.gyb",
-        "HighLevelTypes.swift.gyb",
-        "PointerConformances.swift.gyb",
-        "IntegerConformances.swift.gyb",
         "AtomicBool.swift.gyb",
         "AtomicLazyReference.swift.gyb",
+        "HighLevelTypes.swift.gyb",
+        "IntegerConformances.swift.gyb",
+        "PointerConformances.swift.gyb",
+        "Primitives.native.swift.gyb",
+        "Primitives.shims.swift.gyb",
       ],
       cSettings: _cSettings,
       swiftSettings: _swiftSettings

Sources/Atomics/AtomicMemoryOrderings.swift

@@ -289,6 +289,24 @@ extension AtomicUpdateOrdering: CustomStringConvertible {
   }
 }
 
+extension AtomicLoadOrdering {
+  @_semantics("constant_evaluable")
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  static func _failureOrdering(
+    for ordering: AtomicUpdateOrdering
+  ) -> AtomicLoadOrdering {
+    switch ordering {
+    case .relaxed: return .relaxed
+    case .acquiring: return .acquiring
+    case .releasing: return .relaxed
+    case .acquiringAndReleasing: return .acquiring
+    case .sequentiallyConsistent: return .sequentiallyConsistent
+    default: fatalError("Unsupported ordering")
+    }
+  }
+}
+
 /// Establishes a memory ordering without associating it with a
 /// particular atomic operation.
 ///

Sources/Atomics/AtomicStrongReference.swift

@@ -12,6 +12,8 @@
 
 #if ATOMICS_NATIVE_BUILTINS
 import Swift
+#else
+import _AtomicsShims
 #endif
 
 /// A class type that supports atomic strong references.

Sources/Atomics/AtomicValue.swift

@@ -176,6 +176,43 @@ public protocol AtomicStorage {
     failureOrdering: AtomicLoadOrdering
   ) -> (exchanged: Bool, original: Value)
 
+  /// Perform an atomic weak compare and exchange operation on the value
+  /// referenced by `pointer`, applying the specified memory orderings.
+  /// This compare-exchange variant is allowed to spuriously fail; it
+  /// is designed to be called in a loop until it indicates a successful
+  /// exchange has happened.
+  ///
+  /// This operation performs the following algorithm as a single atomic
+  /// transaction:
+  ///
+  /// ```
+  /// atomic(self) { currentValue in
+  ///   let original = currentValue
+  ///   guard original == expected else { return (false, original) }
+  ///   currentValue = desired
+  ///   return (true, original)
+  /// }
+  /// ```
+  ///
+  /// (In this weak form, transient conditions may cause the `original ==
+  /// expected` check to sometimes return false when the two values are in fact
+  /// the same.)
+  ///
+  /// - Parameter expected: The expected current value.
+  /// - Parameter desired: The desired new value.
+  /// - Parameter pointer: A memory location previously initialized with a value
+  ///   returned by `prepareAtomicRepresentation(for:)`.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
+  ///   the exchange was successful, and `original` is the original value.
+  @_semantics("atomics.requires_constant_orderings")
+  static func atomicWeakCompareExchange(
+    expected: Value,
+    desired: __owned Value,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> (exchanged: Bool, original: Value)
+
   /// Perform an atomic weak compare and exchange operation on the value
   /// referenced by `pointer`, applying the specified success/failure memory
   /// orderings. This compare-exchange variant is allowed to spuriously fail; it
@@ -221,3 +258,37 @@ public protocol AtomicStorage {
     failureOrdering: AtomicLoadOrdering
   ) -> (exchanged: Bool, original: Value)
 }
+
+extension AtomicStorage {
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func atomicCompareExchange(
+    expected: Value,
+    desired: __owned Value,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> (exchanged: Bool, original: Value) {
+    atomicCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: pointer,
+      successOrdering: ordering,
+      failureOrdering: ._failureOrdering(for: ordering))
+  }
+
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public static func atomicWeakCompareExchange(
+    expected: Value,
+    desired: __owned Value,
+    at pointer: UnsafeMutablePointer<Self>,
+    ordering: AtomicUpdateOrdering
+  ) -> (exchanged: Bool, original: Value) {
+    atomicWeakCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: pointer,
+      successOrdering: ordering,
+      failureOrdering: ._failureOrdering(for: ordering))
+  }
+}

Sources/Atomics/HighLevelTypes.swift.gyb

@@ -247,6 +247,46 @@ extension ${type} {
       failureOrdering: failureOrdering)
   }
 
+  /// Perform an atomic weak compare and exchange operation on the current
+  /// value, applying the memory ordering. This compare-exchange variant is
+  /// allowed to spuriously fail; it is designed to be called in a loop until
+  /// it indicates a successful exchange has happened.
+  ///
+  /// This operation performs the following algorithm as a single atomic
+  /// transaction:
+  ///
+  /// ```
+  /// atomic(self) { currentValue in
+  ///   let original = currentValue
+  ///   guard original == expected else { return (false, original) }
+  ///   currentValue = desired
+  ///   return (true, original)
+  /// }
+  /// ```
+  ///
+  /// (In this weak form, transient conditions may cause the `original ==
+  /// expected` check to sometimes return false when the two values are in fact
+  /// the same.)
+  ///
+  /// - Parameter expected: The expected current value.
+  /// - Parameter desired: The desired new value.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
+  ///   the exchange was successful, and `original` is the original value.
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public func weakCompareExchange(
+    expected: Value,
+    desired: __owned Value,
+    ordering: AtomicUpdateOrdering
+  ) -> (exchanged: Bool, original: Value) {
+    _Storage.atomicWeakCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: _ptr,
+      ordering: ordering)
+  }
+
   /// Perform an atomic weak compare and exchange operation on the current
   /// value, applying the specified success/failure memory orderings. This
   /// compare-exchange variant is allowed to spuriously fail; it is designed to

Sources/Atomics/autogenerated/HighLevelTypes.swift

@@ -248,6 +248,46 @@ extension UnsafeAtomic {
       failureOrdering: failureOrdering)
   }
 
+  /// Perform an atomic weak compare and exchange operation on the current
+  /// value, applying the memory ordering. This compare-exchange variant is
+  /// allowed to spuriously fail; it is designed to be called in a loop until
+  /// it indicates a successful exchange has happened.
+  ///
+  /// This operation performs the following algorithm as a single atomic
+  /// transaction:
+  ///
+  /// ```
+  /// atomic(self) { currentValue in
+  ///   let original = currentValue
+  ///   guard original == expected else { return (false, original) }
+  ///   currentValue = desired
+  ///   return (true, original)
+  /// }
+  /// ```
+  ///
+  /// (In this weak form, transient conditions may cause the `original ==
+  /// expected` check to sometimes return false when the two values are in fact
+  /// the same.)
+  ///
+  /// - Parameter expected: The expected current value.
+  /// - Parameter desired: The desired new value.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
+  ///   the exchange was successful, and `original` is the original value.
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public func weakCompareExchange(
+    expected: Value,
+    desired: __owned Value,
+    ordering: AtomicUpdateOrdering
+  ) -> (exchanged: Bool, original: Value) {
+    _Storage.atomicWeakCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: _ptr,
+      ordering: ordering)
+  }
+
   /// Perform an atomic weak compare and exchange operation on the current
   /// value, applying the specified success/failure memory orderings. This
   /// compare-exchange variant is allowed to spuriously fail; it is designed to
@@ -654,6 +694,46 @@ extension ManagedAtomic {
       failureOrdering: failureOrdering)
   }
 
+  /// Perform an atomic weak compare and exchange operation on the current
+  /// value, applying the memory ordering. This compare-exchange variant is
+  /// allowed to spuriously fail; it is designed to be called in a loop until
+  /// it indicates a successful exchange has happened.
+  ///
+  /// This operation performs the following algorithm as a single atomic
+  /// transaction:
+  ///
+  /// ```
+  /// atomic(self) { currentValue in
+  ///   let original = currentValue
+  ///   guard original == expected else { return (false, original) }
+  ///   currentValue = desired
+  ///   return (true, original)
+  /// }
+  /// ```
+  ///
+  /// (In this weak form, transient conditions may cause the `original ==
+  /// expected` check to sometimes return false when the two values are in fact
+  /// the same.)
+  ///
+  /// - Parameter expected: The expected current value.
+  /// - Parameter desired: The desired new value.
+  /// - Parameter ordering: The memory ordering to apply on this operation.
+  /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
+  ///   the exchange was successful, and `original` is the original value.
+  @_semantics("atomics.requires_constant_orderings")
+  @_transparent @_alwaysEmitIntoClient
+  public func weakCompareExchange(
+    expected: Value,
+    desired: __owned Value,
+    ordering: AtomicUpdateOrdering
+  ) -> (exchanged: Bool, original: Value) {
+    _Storage.atomicWeakCompareExchange(
+      expected: expected,
+      desired: desired,
+      at: _ptr,
+      ordering: ordering)
+  }
+
   /// Perform an atomic weak compare and exchange operation on the current
   /// value, applying the specified success/failure memory orderings. This
   /// compare-exchange variant is allowed to spuriously fail; it is designed to

Tests/AtomicsTests/Basics/BasicTests.gyb-template

@@ -125,36 +125,37 @@ class BasicAtomic${label}Tests: XCTestCase {
 
 % end
 
-% for (order, _, _, _, _) in updateOrderings:
-  func test_compareExchange_${order}() {
+% for operation in ["compareExchange", "weakCompareExchange"]:
+%   for (order, _, _, _, _) in updateOrderings:
+  func test_${operation}_${order}() {
     let v: UnsafeAtomic<${type}> = .create(${a})
     defer { v.destroy() }
 
-    var (exchanged, original): (Bool, ${type}) = v.compareExchange(
+    var (exchanged, original): (Bool, ${type}) = v.${operation}(
       expected: ${a},
       desired: ${b},
       ordering: .${order})
     XCTAssertTrue(exchanged)
     XCTAssertEqual(original, ${a})
     XCTAssertEqual(v.load(ordering: .relaxed), ${b})
 
-    (exchanged, original) = v.compareExchange(
+    (exchanged, original) = v.${operation}(
       expected: ${a},
       desired: ${b},
       ordering: .${order})
     XCTAssertFalse(exchanged)
     XCTAssertEqual(original, ${b})
     XCTAssertEqual(v.load(ordering: .relaxed), ${b})
 
-    (exchanged, original) = v.compareExchange(
+    (exchanged, original) = v.${operation}(
       expected: ${b},
       desired: ${a},
       ordering: .${order})
     XCTAssertTrue(exchanged)
     XCTAssertEqual(original, ${b})
     XCTAssertEqual(v.load(ordering: .relaxed), ${a})
 
-    (exchanged, original) = v.compareExchange(
+    (exchanged, original) = v.${operation}(
       expected: ${b},
       desired: ${a},
       ordering: .${order})
@@ -163,6 +164,7 @@ class BasicAtomic${label}Tests: XCTestCase {
     XCTAssertEqual(v.load(ordering: .relaxed), ${a})
   }
 
+%   end
 % end
 
 % for operation in ["compareExchange", "weakCompareExchange"]: