Mutex should be ~Copyable

Author: swhitty

Sources/Mutex.swift

@@ -29,82 +29,109 @@
 //  SOFTWARE.
 //
 
+#if canImport(Darwin) && compiler(>=6)
+
 // Backports the Swift 6 type Mutex<Value> to all Darwin platforms
 
-// @available(macOS, deprecated: 15.0, message: "use Mutex from Synchronization module included with Swift 6")
-// @available(iOS, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
-// @available(tvOS, deprecated: 18.0, message: "use Mutex from Synchronization module included with Swift 6")
-// @available(watchOS, deprecated: 11.0, message: "use Mutex from Synchronization module included with Swift 6")
-// @available(visionOS, deprecated: 2.0, message: "use Mutex from Synchronization module included with Swift 6")
-public struct Mutex<Value>: Sendable {
-    let lock: AllocatedLock<Value> // Compatible with OSAllocatedUnfairLock iOS 16+
-}
+@available(macOS, introduced: 13.0, deprecated: 15.0, message: "use Mutex from Synchronization module")
+@available(iOS, introduced: 16.0, deprecated: 18.0, message: "use Mutex from Synchronization module")
+@available(tvOS, introduced: 18.0, deprecated: 15.0, message: "use Mutex from Synchronization module")
+@available(watchOS, introduced: 11.0, deprecated: 15.0, message: "use Mutex from Synchronization module")
+@available(visionOS, introduced: 2.0, deprecated: 15.0, message: "use Mutex from Synchronization module")
+public struct Mutex<Value: ~Copyable>: @unchecked Sendable, ~Copyable {
+    package let lock = AllocatedLock()
+    private let storage: Storage
 
-#if compiler(>=6)
-public extension Mutex {
-    init(_ initialValue: consuming sending Value) {
-        self.lock = AllocatedLock(uncheckedState: initialValue)
+    public init(_ initialValue: consuming sending Value) {
+        self.storage = Storage(initialValue)
     }
 
-    borrowing func withLock<Result, E: Error>(
+    public borrowing func withLock<Result, E: Error>(
         _ body: (inout sending Value) throws(E) -> sending Result
     ) throws(E) -> sending Result {
-        do {
-            return try lock.withLockUnchecked { value in
-                nonisolated(unsafe) var copy = value
-                defer { value = copy }
-                return try Transferring(body(&copy))
-            }.value
-        } catch let error as E {
-            throw error
-        } catch {
-            preconditionFailure("cannot occur")
-        }
+        lock.lock()
+        defer { lock.unlock() }
+        return try body(&storage.value)
     }
 
-    borrowing func withLockIfAvailable<Result, E>(
+    public borrowing func withLockIfAvailable<Result, E>(
         _ body: (inout sending Value) throws(E) -> sending Result
     ) throws(E) -> sending Result? where E: Error {
-        do {
-            return try lock.withLockIfAvailableUnchecked { value in
-                nonisolated(unsafe) var copy = value
-                defer { value = copy }
-                return try Transferring(body(&copy))
-            }?.value
-        } catch let error as E {
-            throw error
-        } catch {
-            preconditionFailure("cannot occur")
+        guard lock.lockIfAvailable() else { return nil }
+        defer { lock.unlock() }
+        return try body(&storage.value)
+    }
+
+    private final class Storage {
+        var value: Value
+
+        init(_ initialValue: consuming Value) {
+            self.value = initialValue
         }
     }
 }
-private struct Transferring<T> {
-    nonisolated(unsafe) var value: T
+#elseif compiler(>=6)
+
+// Use Swift 6 Mutex directly
+
+import Synchronization
+typealias Mutext = Synchronization.Mutex
+
+public struct Mutex<Value: ~Copyable>: @unchecked Sendable, ~Copyable {
+    private let inner: Synchronization.Mutex<Value>
+
+    public init(_ initialValue: consuming sending Value) {
+        self.inner = .init(initialValue)
+    }
+
+    public borrowing func withLock<Result, E: Error>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result {
+        inner.withLock(body)
+    }
 
-    init(_ value: T) {
-        self.value = value
+    public borrowing func withLockIfAvailable<Result, E>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result? where E: Error {
+        inner.withLockIfAvailable(body)
     }
 }
+
 #else
-public extension Mutex {
-    init(_ initialValue: consuming Value) {
-        self.lock = AllocatedLock(uncheckedState: initialValue)
+
+// Use Swift 5 compatible version
+
+public struct Mutex<Value>: @unchecked Sendable {
+    let lock = AllocatedLock()
+    private let storage: Storage
+
+    public init(_ initialValue: consuming Value) {
+        self.storage = Storage(initialValue)
     }
 
-    borrowing func withLock<Result>(
+    public borrowing func withLock<Result>(
         _ body: (inout Value) throws -> Result
     ) rethrows -> Result {
-        try lock.withLockUnchecked {
-            return try body(&$0)
-        }
+        lock.lock()
+        defer { lock.unlock() }
+        return try body(&storage.value)
     }
 
-    borrowing func withLockIfAvailable<Result>(
+    public borrowing func withLockIfAvailable<Result>(
         _ body: (inout Value) throws -> Result
     ) rethrows -> Result? {
-        try lock.withLockIfAvailableUnchecked {
-            return try body(&$0)
+        guard lock.lockIfAvailable() else { return nil }
+        defer { lock.unlock() }
+        return try body(&storage.value)
+    }
+
+    private final class Storage {
+        var value: Value
+
+        init(_ initialValue: consuming Value) {
+            self.value = initialValue
         }
     }
 }
+
 #endif