Add Lock property wrapper

Author: insidegui

Sources/BuddyFoundation/Foundation/Lock.swift

@@ -0,0 +1,24 @@
+import Foundation
+import os
+
+/// A property wrapper that uses a lock to protect its value from concurrent reads/writes.
+///
+/// - warning: This is not appropriate for atomic operations. Use it for protecting class properties that might be accessed from multiple actors or queues.
+@available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *)
+@propertyWrapper public struct Lock<T: Sendable>: Sendable {
+
+    private let _value: OSAllocatedUnfairLock<T>
+
+    public var wrappedValue: T {
+        get {
+            _value.withLock { $0 }
+        }
+        nonmutating set {
+            _value.withLock { $0 = newValue }
+        }
+    }
+
+    public init(wrappedValue: T) {
+        self._value = OSAllocatedUnfairLock(initialState: wrappedValue)
+    }
+}

Tests/BuddyFoundationTests/LockTests.swift

@@ -0,0 +1,37 @@
+import Foundation
+import Testing
+@testable import BuddyFoundation
+
+@Suite("Lock Tests")
+struct LockTests {
+    /// No expectations here other than it shouldn't crash.
+    @Test func testConcurrentReadWriteProtected() async {
+        let container = TestContainer()
+
+        let maxCount = 10000
+        let taskCount = 4
+
+        await withTaskGroup { group in
+            func runLoop() async {
+                for i in 1...maxCount {
+                    container.value.insert(i)
+                    await Task.yield()
+                    container.value2.insert(i)
+                }
+            }
+
+            for _ in 0..<taskCount {
+                group.addTask {
+                    await runLoop()
+                }
+            }
+
+            await group.waitForAll()
+        }
+    }
+}
+
+private final class TestContainer: @unchecked Sendable {
+    @Lock var value: Set<Int> = []
+    @Lock var value2: Set<Int> = []
+}