feat: Implement DispatchSemaphore using Swift Concurrency.

Author: scottmarchant

Sources/DispatchAsync/AsyncSemaphore.swift

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// Provides a semaphore implantation in `async` context, with a safe wait method. Provides easy safer replacement
+/// for DispatchSemaphore usage.
+@available(macOS 10.15, *)
+actor AsyncSemaphore {
+    private var value: Int
+    private var waiters: Array<CheckedContinuation<Void, Never>> = []
+
+    init(value: Int = 1) {
+        self.value = value
+    }
+
+    func wait() async {
+        value -= 1
+        if value >= 0 { return }
+        await withCheckedContinuation {
+            waiters.append($0)
+        }
+    }
+
+    func signal() {
+        self.value += 1
+
+        guard !waiters.isEmpty else { return }
+        let first = waiters.removeFirst()
+        first.resume()
+    }
+}
+
+@available(macOS 10.15, *)
+extension AsyncSemaphore {
+    func withLock<T: Sendable>(_ closure: () async throws -> T) async rethrows -> T {
+        await wait()
+        defer { signal() }
+        return try await closure()
+    }
+
+    func withLockVoid(_ closure: () async throws -> Void) async rethrows {
+        await wait()
+        defer { signal() }
+        try await closure()
+    }
+}

Sources/DispatchAsync/DispatchSemaphore.swift

@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// This implementation assumes the single-threaded
+// environment that swift wasm executables typically run in.
+//
+// It is not appropriate for true multi-threaded environments.
+//
+// For safety, this class is only defined for WASI platforms.
+//
+//
+#if os(WASI)
+
+/// DispatchSemaphore is not safe to use for most wasm executables.
+///
+/// Most wasm executables are single-threaded. Calling DispatchSemaphore.wait
+/// when it's value is 0 or lower would be likely cause a frozen main thread,
+/// because that would block the calling thread. And there is usually
+/// only one thread in the wasm world (right now).
+///
+/// For now, we guard against that case with both compile-time deprecation
+/// pointing to the much safer ``AsyncSemaphore``, and also at run-time with
+/// assertions.
+///
+/// ``AsyncSemaphore`` provides full functionality, but only exposes
+/// Swift Concurrency api's with a safe async wait function.
+@available(
+    *,
+     deprecated,
+     renamed: "AsyncSemaphore",
+     message: "DispatchSemaphore.wait is dangerous because of it's thread-blocking nature. Use AsyncSemaphore and Swift Concurrency instead."
+)
+@available(macOS 10.15, *)
+public class DispatchSemaphore: @unchecked Sendable {
+    public var value: Int
+
+    public init(value: Int) {
+        self.value = value
+    }
+
+    @discardableResult
+    public func signal() -> Int {
+        MainActor.assertIsolated()
+        value += 1
+        return value
+    }
+
+    public func wait() {
+        // NOTE: wasm is currently mostly single threaded.
+        // And we don't have a Thread.sleep API yet.
+        // So
+        MainActor.assertIsolated()
+        assert(value > 0, "DispatchSemaphore is currently only designed for single-threaded use.")
+        value -= 1
+    }
+}
+
+#else
+
+@available(macOS 10.15, *)
+typealias DispatchSemaphore = AsyncSemaphore
+
+#endif // #if os(WASI)