refactor: Update ifdefs and @_spi guards to allow development against traditional iOS targets, but to elide exact Dispatch api replacements for any current or future target that does not include Dispatch.

Author: scottmarchant

Package.swift

@@ -7,14 +7,18 @@ let package = Package(
     products: [
         .library(
             name: "DispatchAsync",
-            targets: ["DispatchAsync"])
+            targets: ["DispatchAsync"]
+        ),
     ],
     targets: [
         .target(
-            name: "DispatchAsync"),
+            name: "DispatchAsync",
+        ),
         .testTarget(
             name: "DispatchAsyncTests",
-            dependencies: ["DispatchAsync"]
+            dependencies: [
+                "DispatchAsync"
+            ],
         ),
     ]
 )

Sources/DispatchAsync/AsyncSemaphore.swift

@@ -14,16 +14,16 @@
 
 /// Provides a semaphore implantation in `async` context, with a safe wait method. Provides easy safe replacement
 /// for DispatchSemaphore usage.
-@available(macOS 10.15, *)
-actor AsyncSemaphore {
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+public actor AsyncSemaphore {
     private var value: Int
     private var waiters: [CheckedContinuation<Void, Never>] = []
 
-    init(value: Int = 1) {
+    public init(value: Int = 1) {
         self.value = value
     }
 
-    func wait() async {
+    public func wait() async {
         value -= 1
 
         if value >= 0 { return }
@@ -32,7 +32,7 @@ actor AsyncSemaphore {
         }
     }
 
-    func signal() {
+    public func signal() {
         self.value += 1
 
         guard !waiters.isEmpty else { return }
@@ -41,15 +41,15 @@ actor AsyncSemaphore {
     }
 }
 
-@available(macOS 10.15, *)
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
 extension AsyncSemaphore {
-    func withLock<T: Sendable>(_ closure: () async throws -> T) async rethrows -> T {
+    public 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 {
+    public func withLockVoid(_ closure: () async throws -> Void) async rethrows {
         await wait()
         defer { signal() }
         try await closure()

Sources/DispatchAsync/PackageConstants.swift renamed to Sources/DispatchAsync/DispatchAsync.swift

@@ -12,6 +12,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-package let kNanosecondsPerSecond: UInt64 = 1_000_000_000
-package let kNanosecondsPerMillisecond: UInt64 = 1_000_000
-package let kNanoSecondsPerMicrosecond: UInt64 = 1_000
+/// Top level namespace for functionality provided in DispatchAsync.
+///
+/// Used to avoid namespacing conflicts with `Dispatch` and `Foundation`
+///
+/// Platforms other than WASI shouldn't consume this library for now
+/// except for testing and development purposes.
+///
+/// TODO: SM: Add github permalink to this, after it is merged.
+#if !os(WASI)
+@_spi(DispatchAsync)
+#endif
+public enum DispatchAsync {}

Sources/DispatchAsync/DispatchGroup.swift

@@ -12,118 +12,138 @@
 //
 //===----------------------------------------------------------------------===//
 
-// MARK: - Public Interface for Non-Async Usage -
-
-/// `DispatchGroup` is a drop-in replacement for the `DispatchGroup` implemented
-/// in Grand Central Dispatch. However, this class uses Swift Concurrency, instead of low-level threading API's.
-///
-/// The primary goal of this implementation is to enable WASM support for Dispatch.
-///
-/// Refer to documentation for the original [DispatchGroup](https://developer.apple.com/documentation/dispatch/dispatchgroup)
-/// for more details,
-@available(macOS 10.15, *)
-public class DispatchGroup: @unchecked Sendable {
-    private let group = _AsyncGroup()
-    private let queue = FIFOQueue()
-
-    public func enter() {
-        queue.enqueue { [weak self] in
-            guard let self else { return }
-            await group.enter()
+// NOTE: The following typealias mirrors Dispatch API's, but only for
+// specific compilation conditions where Dispatch is not available.
+// It is designed to safely elide away if and when Dispatch is introduced
+// in the required Dispatch support becomes available.
+#if os(WASI) && !canImport(Dispatch)
+/// Drop-in replacement for ``Dispatch.DispatchGroup``, implemented using pure swift.
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+public typealias DispatchGroup = DispatchAsync.DispatchGroup
+#endif
+
+extension DispatchAsync {
+    // MARK: - Public Interface for Non-Async Usage -
+
+    /// Drop-in replacement for ``Dispatch.DispatchGroup``, implemented using pure swift.
+    ///
+    /// The primary goal of this implementation is to enable WASM support for Dispatch.
+    ///
+    /// Refer to documentation for the original [DispatchGroup](https://developer.apple.com/documentation/dispatch/dispatchgroup)
+    /// for more details,
+    #if !os(WASI)
+    @_spi(DispatchAsync)
+    #endif
+    @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+    public class DispatchGroup: @unchecked Sendable {
+        private let group = _AsyncGroup()
+        private let queue = DispatchAsync.FIFOQueue()
+
+        public func enter() {
+            queue.enqueue { [weak self] in
+                guard let self else { return }
+                await group.enter()
+            }
         }
-    }
 
-    public func leave() {
-        queue.enqueue { [weak self] in
-            guard let self else { return }
-            await group.leave()
+        public func leave() {
+            queue.enqueue { [weak self] in
+                guard let self else { return }
+                await group.leave()
+            }
         }
-    }
 
-    public func notify(queue notificationQueue: DispatchQueue, execute work: @escaping @Sendable @convention(block) () -> Void) {
-        queue.enqueue { [weak self] in
-            guard let self else { return }
-            await group.notify {
-                await withCheckedContinuation { continuation in
-                    notificationQueue.async {
-                        work()
-                        continuation.resume()
+        public func notify(
+            queue notificationQueue: DispatchAsync.DispatchQueue,
+            execute work: @escaping @Sendable @convention(block) () -> Void
+        ) {
+            queue.enqueue { [weak self] in
+                guard let self else { return }
+                await group.notify {
+                    await withCheckedContinuation { continuation in
+                        notificationQueue.async {
+                            work()
+                            continuation.resume()
+                        }
                     }
                 }
             }
         }
-    }
 
-    func wait() async {
-        await withCheckedContinuation { continuation in
-            queue.enqueue { [weak self] in
-                guard let self else { return }
-                // NOTE: We use a task for the wait, because
-                // otherwise the queue won't execute any more
-                // tasks until the wait finishes, which is not the
-                // behavior we want here. We want to enqueue the wait
-                // in FIFO call order, but then we want to allow the wait
-                // to be non-blocking for the queue until the last leave
-                // is called on the group.
-                Task {
-                    await group.wait()
-                    continuation.resume()
+        func wait() async {
+            await withCheckedContinuation { continuation in
+                queue.enqueue { [weak self] in
+                    guard let self else { return }
+                    // NOTE: We use a task for the wait, because
+                    // otherwise the queue won't execute any more
+                    // tasks until the wait finishes, which is not the
+                    // behavior we want here. We want to enqueue the wait
+                    // in FIFO call order, but then we want to allow the wait
+                    // to be non-blocking for the queue until the last leave
+                    // is called on the group.
+                    Task {
+                        await group.wait()
+                        continuation.resume()
+                    }
                 }
             }
         }
+
+        public init() {}
     }
 
-    public init() {}
-}
+    // MARK: - Private Interface for Async Usage -
 
-// MARK: - Private Interface for Async Usage -
+    #if !os(WASI)
+    @_spi(DispatchAsync)
+    #endif
+    @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+    fileprivate actor _AsyncGroup {
+        private var taskCount = 0
+        private var notifyHandlers: [@Sendable () async -> Void] = []
 
-@available(macOS 10.15, *)
-fileprivate actor _AsyncGroup {
-    private var taskCount = 0
-    private var notifyHandlers: [@Sendable () async -> Void] = []
+        func enter() {
+            taskCount += 1
+        }
 
-    func enter() {
-        taskCount += 1
-    }
+        func leave() {
+            defer {
+                checkCompletion()
+            }
+            guard taskCount > 0 else {
+                assertionFailure("leave() called more times than enter()")
+                return
+            }
+            taskCount -= 1
+        }
 
-    func leave() {
-        defer {
+        func notify(handler: @escaping @Sendable () async -> Void) {
+            notifyHandlers.append(handler)
             checkCompletion()
         }
-        guard taskCount > 0 else {
-            assertionFailure("leave() called more times than enter()")
-            return
-        }
-        taskCount -= 1
-    }
 
-    func notify(handler: @escaping @Sendable () async -> Void) {
-        notifyHandlers.append(handler)
-        checkCompletion()
-    }
-
-    func wait() async {
-        if taskCount <= 0 {
-            return
-        }
+        func wait() async {
+            if taskCount <= 0 {
+                return
+            }
 
-        await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
-            notify {
-                continuation.resume()
+            await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
+                notify {
+                    continuation.resume()
+                }
+                checkCompletion()
             }
-            checkCompletion()
         }
-    }
 
-    private func checkCompletion() {
-        if taskCount <= 0, !notifyHandlers.isEmpty {
-            let handlers = notifyHandlers
-            notifyHandlers.removeAll()
+        private func checkCompletion() {
+            if taskCount <= 0, !notifyHandlers.isEmpty {
+                let handlers = notifyHandlers
+                notifyHandlers.removeAll()
 
-            for handler in handlers {
-                Task {
-                    await handler()
+                for handler in handlers {
+                    Task {
+                        await handler()
+                    }
                 }
             }
         }