full compatibility with OSAllocatedUnfairLock

Author: swhitty

.github/workflows/build.yml

@@ -6,13 +6,15 @@ on:
   workflow_dispatch:
 
 jobs:
-  xcode_15_2:
+  xcode_16:
     runs-on: macos-14
-    env:
-      DEVELOPER_DIR: /Applications/Xcode_15.2.app/Contents/Developer
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+      - name: 🔍 Xcode Select
+        run: |
+          XCODE_PATH=`mdfind "kMDItemCFBundleIdentifier == 'com.apple.dt.Xcode' && kMDItemVersion = '16.*'" -onlyin /Applications | head -1`
+          echo "DEVELOPER_DIR=$XCODE_PATH/Contents/Developer" >> $GITHUB_ENV
       - name: Version
         run: swift --version
       - name: Build
@@ -27,10 +29,10 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./coverage_report.lcov
 
-  xcode_14_3_1:
-    runs-on: macos-13
+  xcode_15_4:
+    runs-on: macos-14
     env:
-      DEVELOPER_DIR: /Applications/Xcode_14.3.1.app/Contents/Developer
+      DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -41,9 +43,10 @@ jobs:
       - name: Test
         run: swift test
 
-  linux_swift_5_10:
-    runs-on: ubuntu-latest
-    container: swift:5.8
+  xcode_15_2:
+    runs-on: macos-14
+    env:
+      DEVELOPER_DIR: /Applications/Xcode_15.2.app/Contents/Developer
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -52,11 +55,11 @@ jobs:
       - name: Build
         run: swift build --build-tests
       - name: Test
-        run: swift test --skip-build
+        run: swift test
 
-  linux_swift_5_9:
+  linux_swift_6_0:
     runs-on: ubuntu-latest
-    container: swift:5.8
+    container: swiftlang/swift:nightly-6.0-jammy
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -67,9 +70,9 @@ jobs:
       - name: Test
         run: swift test --skip-build
 
-  linux_swift_5_8:
+  linux_swift_5_10:
     runs-on: ubuntu-latest
-    container: swift:5.8
+    container: swift:5.10
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -80,9 +83,9 @@ jobs:
       - name: Test
         run: swift test --skip-build
 
-  linux_swift_5_7:
+  linux_swift_5_9:
     runs-on: ubuntu-latest
-    container: swift:5.7
+    container: swift:5.9
     steps:
       - name: Checkout
         uses: actions/checkout@v4

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.7
+// swift-tools-version:6.0
 
 import PackageDescription
 
@@ -16,12 +16,23 @@ let package = Package(
     targets: [
         .target(
             name: "AllocatedLock",
-            path: "Sources"
+            path: "Sources",
+            swiftSettings: .upcomingFeatures
         ),
         .testTarget(
             name: "AllocatedLockTests",
             dependencies: ["AllocatedLock"],
-            path: "Tests"
+            path: "Tests",
+            swiftSettings: .upcomingFeatures
         )
     ]
 )
+
+extension Array where Element == SwiftSetting {
+
+    static var upcomingFeatures: [SwiftSetting] {
+        [
+            .swiftLanguageMode(.v6)
+        ]
+    }
+}

[email protected] renamed to [email protected]

@@ -1,4 +1,4 @@
-// swift-tools-version:5.8
+// swift-tools-version:5.9
 
 import PackageDescription
 

Sources/AllocatedLock.swift

@@ -29,14 +29,17 @@
 //  SOFTWARE.
 //
 
-// Backports the Swift interface around os_unfair_lock_t available in recent Darwin platforms
-//
+// Backports the Swift interface around OSAllocatedUnfairLock available in recent Darwin platforms
 public struct AllocatedLock<State>: @unchecked Sendable {
 
     @usableFromInline
     let storage: Storage
 
-    public init(initialState: State) {
+    public init(uncheckedState initialState: State) {
+        self.storage = Storage(initialState: initialState)
+    }
+
+    public init(initialState: State) where State: Sendable {
         self.storage = Storage(initialState: initialState)
     }
 
@@ -46,6 +49,28 @@ public struct AllocatedLock<State>: @unchecked Sendable {
         defer { storage.unlock() }
         return try body(&storage.state)
     }
+
+    @inlinable
+    public func withLockIfAvailable<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R? where R: Sendable {
+        guard storage.tryLock() else { return nil }
+        defer { storage.unlock() }
+        return try body(&storage.state)
+    }
+
+    @inlinable
+    public func withLockIfAvailableUnchecked<R>(_ body: (inout State) throws -> R) rethrows -> R? {
+        guard storage.tryLock() else { return nil }
+        defer { storage.unlock() }
+        return try body(&storage.state)
+    }
+
+    @inlinable
+    public func withLockUnchecked<R>(_ body: (inout State) throws -> R) rethrows -> R {
+        storage.lock()
+        defer { storage.unlock() }
+        return try body(&storage.state)
+    }
+
 }
 
 public extension AllocatedLock where State == Void {
@@ -59,6 +84,11 @@ public extension AllocatedLock where State == Void {
         storage.lock()
     }
 
+    @inlinable @available(*, noasync)
+    func lockIfAvailable() -> Bool {
+        storage.tryLock()
+    }
+
     @inlinable @available(*, noasync)
     func unlock() {
         storage.unlock()
@@ -70,6 +100,27 @@ public extension AllocatedLock where State == Void {
         defer { storage.unlock() }
         return try body()
     }
+
+    @inlinable
+    func withLockIfAvailable<R>(_ body: @Sendable () throws -> R) rethrows -> R? where R: Sendable {
+        guard storage.tryLock() else { return nil }
+        defer { storage.unlock() }
+        return try body()
+    }
+
+    @inlinable
+    func withLockIfAvailableUnchecked<R>(_ body: () throws -> R) rethrows -> R? {
+        guard storage.tryLock() else { return nil }
+        defer { storage.unlock() }
+        return try body()
+    }
+
+    @inlinable
+    func withLockUnchecked<R>(_ body: () throws -> R) rethrows -> R {
+        storage.lock()
+        defer { storage.unlock() }
+        return try body()
+    }
 }
 
 #if canImport(Darwin)
@@ -78,6 +129,7 @@ import struct os.os_unfair_lock_t
 import struct os.os_unfair_lock
 import func os.os_unfair_lock_lock
 import func os.os_unfair_lock_unlock
+import func os.os_unfair_lock_trylock
 
 extension AllocatedLock {
     @usableFromInline
@@ -103,6 +155,11 @@ extension AllocatedLock {
             os_unfair_lock_unlock(_lock)
         }
 
+        @usableFromInline
+        func tryLock() -> Bool {
+            os_unfair_lock_trylock(_lock)
+        }
+
         deinit {
             self._lock.deinitialize(count: 1)
             self._lock.deallocate()
@@ -143,6 +200,11 @@ extension AllocatedLock {
             precondition(err == 0, "pthread_mutex_unlock error: \(err)")
         }
 
+        @usableFromInline
+        func tryLock() -> Bool {
+            pthread_mutex_trylock(&_lock) == 0
+        }
+
         deinit {
             let err = pthread_mutex_destroy(self._lock)
             precondition(err == 0, "pthread_mutex_destroy error: \(err)")
@@ -179,6 +241,17 @@ extension AllocatedLock {
         func unlock() {
             ReleaseSRWLockExclusive(_lock)
         }
+
+        @usableFromInline
+        func tryLock() -> Bool {
+            TryAcquireSRWLockExclusive(_lock)
+        }
+
+        @usableFromInline
+        func tryLock() -> Bool {
+            os_unfair_lock_trylock(_lock)
+        }
+
     }
 }
 

Tests/AllocatedLockTests.swift

@@ -29,7 +29,7 @@
 //  SOFTWARE.
 //
 
-import AllocatedLock
+@testable import AllocatedLock
 import XCTest
 
 final class AllocatedLockTests: XCTestCase {
@@ -84,10 +84,112 @@ final class AllocatedLockTests: XCTestCase {
         }
         XCTAssertEqual(results, [true, false])
     }
+
+    func testTryLock() {
+        let lock = AllocatedLock()
+        let value = lock.withLock { true }
+        XCTAssertTrue(value)
+    }
+
+    func testIfAvailable() {
+        let lock = AllocatedLock(uncheckedState: 5)
+        XCTAssertEqual(
+            lock.withLock { _ in "fish" },
+            "fish"
+        )
+
+        lock.unsafeLock()
+        XCTAssertEqual(
+            lock.withLockIfAvailable { _ in "fish" },
+            String?.none
+        )
+
+        lock.unsafeUnlock()
+        XCTAssertEqual(
+            lock.withLockIfAvailable { _ in "fish" },
+            "fish"
+        )
+    }
+
+    func testIfAvailableUnchecked() {
+        let lock = AllocatedLock(uncheckedState: NonSendable("fish"))
+        XCTAssertEqual(
+            lock.withLockUnchecked { $0 }.name,
+            "fish"
+        )
+
+        lock.unsafeLock()
+        XCTAssertNil(
+            lock.withLockIfAvailableUnchecked { $0 }?.name
+        )
+
+        lock.unsafeUnlock()
+        XCTAssertEqual(
+            lock.withLockIfAvailableUnchecked { $0 }?.name,
+            "fish"
+        )
+    }
+
+    func testVoidIfAvailable() {
+        let lock = AllocatedLock()
+        XCTAssertEqual(
+            lock.withLock { "fish" },
+            "fish"
+        )
+
+        lock.unsafeLock()
+        XCTAssertEqual(
+            lock.withLockIfAvailable { "fish" },
+            String?.none
+        )
+
+        lock.unsafeUnlock()
+        XCTAssertEqual(
+            lock.withLockIfAvailable { "fish" },
+            "fish"
+        )
+    }
+
+    func testVoidIfAvailableUnchecked() {
+        let lock = AllocatedLock()
+        XCTAssertEqual(
+            lock.withLockUnchecked { NonSendable("fish") }.name,
+            "fish"
+        )
+
+        lock.lock()
+        XCTAssertNil(
+            lock.withLockIfAvailableUnchecked { NonSendable("fish") }
+        )
+
+        lock.unlock()
+        XCTAssertEqual(
+            lock.withLockIfAvailableUnchecked { NonSendable("chips") }?.name,
+            "chips"
+        )
+    }
+
+    func testVoidLock() {
+        let lock = AllocatedLock()
+        lock.lock()
+        XCTAssertFalse(lock.lockIfAvailable())
+        lock.unlock()
+        XCTAssertTrue(lock.lockIfAvailable())
+        lock.unlock()
+    }
+}
+
+public final class NonSendable {
+
+    let name: String
+
+    init(_ name: String) {
+        self.name = name
+    }
 }
 
 // sidestep warning: unavailable from asynchronous contexts
-extension AllocatedLock where State == Void {
-    func unsafeLock() { lock() }
-    func unsafeUnlock() { unlock() }
+extension AllocatedLock {
+    func unsafeLock() { storage.lock() }
+    func unsafeUnlock() { storage.unlock() }
 }