swift-mutex update

Author: swhitty

Sources/Mutex.swift

@@ -29,14 +29,14 @@
 //  SOFTWARE.
 //
 
-// Backports the Swift 6.0 Mutex API
-@usableFromInline
-package struct Mutex<Value>: @unchecked Sendable {
-    let storage: Storage
-}
-
 #if compiler(>=6)
-package extension Mutex {
+
+#if !canImport(WinSDK)
+
+// Backports the Swift 6 type Mutex<Value> to all Darwin platforms
+@usableFromInline
+struct Mutex<Value: ~Copyable>: ~Copyable {
+    let storage: Storage<Value>
 
     @usableFromInline
     init(_ initialValue: consuming sending Value) {
@@ -53,40 +53,49 @@ package extension Mutex {
     }
 
     @usableFromInline
-    borrowing func withLockIfAvailable<Result, E>(
+    borrowing func withLockIfAvailable<Result, E: Error>(
         _ body: (inout sending Value) throws(E) -> sending Result
-    ) throws(E) -> sending Result? where E: Error {
+    ) throws(E) -> sending Result? {
         guard storage.tryLock() else { return nil }
         defer { storage.unlock() }
         return try body(&storage.value)
     }
 }
+
+extension Mutex: @unchecked Sendable where Value: ~Copyable { }
+
 #else
-package extension Mutex {
+
+// Windows doesn't support ~Copyable yet
+
+@usableFromInline
+struct Mutex<Value>: @unchecked Sendable {
+    let storage: Storage<Value>
 
     @usableFromInline
-    init(_ initialValue: Value) {
+    init(_ initialValue: consuming sending Value) {
         self.storage = Storage(initialValue)
     }
 
     @usableFromInline
-    borrowing func withLock<Result>(
-        _ body: (inout Value) throws -> Result
-    ) rethrows -> Result {
+    borrowing func withLock<Result, E: Error>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result {
         storage.lock()
         defer { storage.unlock() }
         return try body(&storage.value)
     }
 
     @usableFromInline
-    borrowing func withLockIfAvailable<Result>(
-        _ body: (inout Value) throws -> Result
-    ) rethrows -> Result? {
+    borrowing func withLockIfAvailable<Result, E: Error>(
+        _ body: (inout sending Value) throws(E) -> sending Result
+    ) throws(E) -> sending Result? {
         guard storage.tryLock() else { return nil }
         defer { storage.unlock() }
         return try body(&storage.value)
     }
 }
+
 #endif
 
 #if canImport(Darwin)
@@ -97,81 +106,76 @@ import func os.os_unfair_lock_lock
 import func os.os_unfair_lock_unlock
 import func os.os_unfair_lock_trylock
 
-extension Mutex {
+final class Storage<Value: ~Copyable> {
+    private let _lock: os_unfair_lock_t
+    var value: Value
 
-    final class Storage {
-        private let _lock: os_unfair_lock_t
-
-        var value: Value
-
-        init(_ initialValue: Value) {
-            self._lock = .allocate(capacity: 1)
-            self._lock.initialize(to: os_unfair_lock())
-            self.value = initialValue
-        }
+    init(_ initialValue: consuming Value) {
+        self._lock = .allocate(capacity: 1)
+        self._lock.initialize(to: os_unfair_lock())
+        self.value = initialValue
+    }
 
-        func lock() {
-            os_unfair_lock_lock(_lock)
-        }
+    func lock() {
+        os_unfair_lock_lock(_lock)
+    }
 
-        func unlock() {
-            os_unfair_lock_unlock(_lock)
-        }
+    func unlock() {
+        os_unfair_lock_unlock(_lock)
+    }
 
-        func tryLock() -> Bool {
-            os_unfair_lock_trylock(_lock)
-        }
+    func tryLock() -> Bool {
+        os_unfair_lock_trylock(_lock)
+    }
 
-        deinit {
-            self._lock.deinitialize(count: 1)
-            self._lock.deallocate()
-        }
+    deinit {
+        self._lock.deinitialize(count: 1)
+        self._lock.deallocate()
     }
 }
 
-#elseif canImport(Glibc) || canImport(Musl)
+#elseif canImport(Glibc) || canImport(Musl) || canImport(Bionic)
 
 #if canImport(Musl)
 import Musl
+#elseif canImport(Bionic)
+import Android
 #else
 import Glibc
 #endif
 
-extension Mutex {
-
-    final class Storage {
-        private let _lock: UnsafeMutablePointer<pthread_mutex_t>
+final class Storage<Value: ~Copyable> {
+    private let _lock: UnsafeMutablePointer<pthread_mutex_t>
 
-        var value: Value
+    var value: Value
 
-        init(_ initialValue: Value) {
-            var attr = pthread_mutexattr_t()
-            pthread_mutexattr_init(&attr)
-            self._lock = .allocate(capacity: 1)
-            let err = pthread_mutex_init(self._lock, &attr)
-            precondition(err == 0, "pthread_mutex_init error: \(err)")
-            self.value = initialValue
-        }
+    init(_ initialValue: consuming Value) {
+        var attr = pthread_mutexattr_t()
+        pthread_mutexattr_init(&attr)
+        self._lock = .allocate(capacity: 1)
+        let err = pthread_mutex_init(self._lock, &attr)
+        precondition(err == 0, "pthread_mutex_init error: \(err)")
+        self.value = initialValue
+    }
 
-        func lock() {
-            let err = pthread_mutex_lock(_lock)
-            precondition(err == 0, "pthread_mutex_lock error: \(err)")
-        }
+    func lock() {
+        let err = pthread_mutex_lock(_lock)
+        precondition(err == 0, "pthread_mutex_lock error: \(err)")
+    }
 
-        func unlock() {
-            let err = pthread_mutex_unlock(_lock)
-            precondition(err == 0, "pthread_mutex_unlock error: \(err)")
-        }
+    func unlock() {
+        let err = pthread_mutex_unlock(_lock)
+        precondition(err == 0, "pthread_mutex_unlock error: \(err)")
+    }
 
-        func tryLock() -> Bool {
-            pthread_mutex_trylock(_lock) == 0
-        }
+    func tryLock() -> Bool {
+        pthread_mutex_trylock(_lock) == 0
+    }
 
-        deinit {
-            let err = pthread_mutex_destroy(self._lock)
-            precondition(err == 0, "pthread_mutex_destroy error: \(err)")
-            self._lock.deallocate()
-        }
+    deinit {
+        let err = pthread_mutex_destroy(self._lock)
+        precondition(err == 0, "pthread_mutex_destroy error: \(err)")
+        self._lock.deallocate()
     }
 }
 
@@ -180,31 +184,30 @@ extension Mutex {
 import ucrt
 import WinSDK
 
-extension Mutex {
-
-    final class Storage {
-        private let _lock: UnsafeMutablePointer<SRWLOCK>
+final class Storage<Value> {
+    private let _lock: UnsafeMutablePointer<SRWLOCK>
 
-        var value: Value
+    var value: Value
 
-        init(_ initialValue: Value) {
-            self._lock = .allocate(capacity: 1)
-            InitializeSRWLock(self._lock)
-            self.value = initialValue
-        }
+    init(_ initialValue: Value) {
+        self._lock = .allocate(capacity: 1)
+        InitializeSRWLock(self._lock)
+        self.value = initialValue
+    }
 
-        func lock() {
-            AcquireSRWLockExclusive(_lock)
-        }
+    func lock() {
+        AcquireSRWLockExclusive(_lock)
+    }
 
-        func unlock() {
-            ReleaseSRWLockExclusive(_lock)
-        }
+    func unlock() {
+        ReleaseSRWLockExclusive(_lock)
+    }
 
-        func tryLock() -> Bool {
-            TryAcquireSRWLockExclusive(_lock) != 0
-        }
+    func tryLock() -> Bool {
+        TryAcquireSRWLockExclusive(_lock) != 0
     }
 }
 
 #endif
+
+#endif