Mutex should be ~Copyable

Author: swhitty

.github/workflows/build.yml

@@ -71,7 +71,7 @@ jobs:
 
   linux_swift_6_1:
     runs-on: ubuntu-latest
-    container: swift:6.1
+    container: swift:6.1.2
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -123,7 +123,7 @@ jobs:
 
   linux_swift_6_1_musl:
     runs-on: ubuntu-latest
-    container: swift:6.1
+    container: swift:6.1.2
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -146,7 +146,7 @@ jobs:
       - name: Install Swift
         uses: SwiftyLab/setup-swift@latest
         with:
-          swift-version: "6.1.0"
+          swift-version: "6.1.2"
       - name: Version
         run: swift --version
       - name: Build

Sources/Mutex.swift

@@ -29,82 +29,120 @@
 //  SOFTWARE.
 //
 
+#if compiler(>=6) && !canImport(WinSDK)
+
 // 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: Error>(
         _ 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")
+    ) throws(E) -> sending Result? {
+        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
 
-    init(_ value: T) {
-        self.value = value
+#elseif compiler(>=6) && canImport(WinSDK)
+
+// Windows doesn't support <Value: ~Copyable> yet
+
+public struct Mutex<Value>: @unchecked Sendable, ~Copyable {
+    package let lock = AllocatedLock()
+    private let storage: Storage
+
+    public init(_ initialValue: consuming sending Value) {
+        self.storage = Storage(initialValue)
+    }
+
+    public borrowing func withLock<Result, E: Error>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result {
+        lock.lock()
+        defer { lock.unlock() }
+        return try body(&storage.value)
+    }
+
+    public borrowing func withLockIfAvailable<Result, E: Error>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result? {
+        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
+        }
     }
 }
+
 #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