Make FIFOQueue, ActorQueue, and tests pass strict concurrency checking

Author: dfed

AsyncQueue.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name     = 'AsyncQueue'
-  s.version  = '0.2.0'
+  s.version  = '0.3.0'
   s.license  = 'MIT'
   s.summary  = 'A queue that enables ordered sending of events from synchronous to asynchronous code.'
   s.homepage = 'https://github.com/dfed/swift-async-queue'

Package.swift

@@ -22,6 +22,11 @@ let package = Package(
             dependencies: []),
         .testTarget(
             name: "AsyncQueueTests",
-            dependencies: ["AsyncQueue"]),
+            dependencies: ["AsyncQueue"],
+            swiftSettings: [
+                // TODO: Adopt `enableUpcomingFeature` once available.
+                // https://github.com/apple/swift-evolution/blob/main/proposals/0362-piecemeal-future-features.md
+                .unsafeFlags(["-Xfrontend", "-strict-concurrency=complete"])
+            ]),
     ]
 )

README.md

@@ -90,7 +90,7 @@ FIFO execution has a key downside: the queue must wait for all previously enqueu
 Use an `ActorQueue` to send ordered asynchronous tasks to an `actor`’s isolated context from nonisolated or synchronous contexts. Tasks sent to an actor queue are guaranteed to begin executing in the order in which they are enqueued. However, unlike a `FIFOQueue`, execution order is guaranteed only until the first [suspension point](https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html#ID639) within the enqueued task. An `ActorQueue` executes tasks within the its adopted actor’s isolated context, resulting in `ActorQueue` task execution having the same properties as `actor` code execution: code between suspension points is executed atomically, and tasks sent to a single `ActorQueue` can await results from the queue without deadlocking.
 
 An instance of an `ActorQueue` is designed to be utilized by a single `actor` instance: tasks sent to an `ActorQueue` utilize the isolated context of the queue‘s adopted `actor` to serialize tasks. As such, there are a few requirements that must be met when dealing with an `ActorQueue`:
-1. The lifecycle of any `ActorQueue` should not exceed the lifecycle of its `actor`. It is strongly recommended that an `ActorQueue` be a `let` constant on the adopted `actor`. Enqueuing a task to an `ActorQueue` isntance after its adopted `actor` has been deallocated will result in a crash.
+1. The lifecycle of any `ActorQueue` should not exceed the lifecycle of its `actor`. It is strongly recommended that an `ActorQueue` be a `private let` constant on the adopted `actor`. Enqueuing a task to an `ActorQueue` isntance after its adopted `actor` has been deallocated will result in a crash.
 2. An `actor` utilizing an `ActorQueue` should set the adopted execution context of the queue to `self` within the `actor`’s `init`. Failing to set an adopted execution context prior to enqueuing work on an `ActorQueue` will result in a crash.
 
 An `ActorQueue` can easily enqueue tasks that execute on an actor’s isolated context from a nonisolated context in order:

Sources/AsyncQueue/ActorQueue.swift

@@ -50,8 +50,9 @@
 /// }
 /// ```
 ///
+/// - Warning: The `ActorQueue`'s conformance to `@unchecked Sendable` is safe if and only if `adoptExecutionContext(of:)` is called only from the adopted actor's `init` method.
 /// - Precondition: The lifecycle of an `ActorQueue` must not exceed that of the adopted actor.
-public final class ActorQueue<ActorType: Actor> {
+public final class ActorQueue<ActorType: Actor>: @unchecked Sendable {
 
     // MARK: Initialization
 
@@ -150,7 +151,6 @@ public final class ActorQueue<ActorType: Actor> {
         let executionContext: ActorType
         let task: @Sendable (isolated ActorType) async -> Void
     }
-
 }
 
 extension Actor {

Sources/AsyncQueue/FIFOQueue.swift

@@ -85,7 +85,7 @@ public final class FIFOQueue: Sendable {
     ///   - isolatedActor: The actor within which the task is isolated.
     ///   - task: The task to enqueue.
     /// - Returns: The value returned from the enqueued task.
-    public func enqueueAndWait<ActorType: Actor, T>(on isolatedActor: isolated ActorType, _ task: @escaping @Sendable (isolated ActorType) async -> T) async -> T {
+    public func enqueueAndWait<ActorType: Actor, T: Sendable>(on isolatedActor: isolated ActorType, _ task: @escaping @Sendable (isolated ActorType) async -> T) async -> T {
         await withUnsafeContinuation { continuation in
             taskStreamContinuation.yield {
                 continuation.resume(returning: await task(isolatedActor))
@@ -115,7 +115,7 @@ public final class FIFOQueue: Sendable {
     ///   - isolatedActor: The actor within which the task is isolated.
     ///   - task: The task to enqueue.
     /// - Returns: The value returned from the enqueued task.
-    public func enqueueAndWait<ActorType: Actor, T>(on isolatedActor: isolated ActorType, _ task: @escaping @Sendable (isolated ActorType) async throws -> T) async throws -> T {
+    public func enqueueAndWait<ActorType: Actor, T: Sendable>(on isolatedActor: isolated ActorType, _ task: @escaping @Sendable (isolated ActorType) async throws -> T) async throws -> T {
         try await withUnsafeThrowingContinuation { continuation in
             taskStreamContinuation.yield {
                 do {

Tests/AsyncQueueTests/ActorQueueTests.swift

@@ -65,17 +65,17 @@ final class ActorQueueTests: XCTestCase {
 
     func test_enqueue_taskParameterIsAdoptedActor() async {
         let semaphore = Semaphore()
-        systemUnderTest.enqueue { counter in
-            XCTAssertTrue(counter === self.counter)
+        systemUnderTest.enqueue { [storedCounter = counter] counter in
+            XCTAssertTrue(counter === storedCounter)
             await semaphore.signal()
         }
 
         await semaphore.wait()
     }
 
     func test_enqueueAndWait_taskParameterIsAdoptedActor() async {
-        await systemUnderTest.enqueueAndWait { counter in
-            XCTAssertTrue(counter === self.counter)
+        await systemUnderTest.enqueueAndWait { [storedCounter = counter] counter in
+            XCTAssertTrue(counter === storedCounter)
         }
     }