Swift 6.0

Author: swhitty

.github/workflows/build.yml

@@ -6,10 +6,10 @@ on:
   workflow_dispatch:
 
 jobs:
-  xcode_15_2:
+  xcode_15_4:
     runs-on: macos-14
     env:
-      DEVELOPER_DIR: /Applications/Xcode_15.2.app/Contents/Developer
+      DEVELOPER_DIR: /Applications/Xcode_15.4.app/Contents/Developer
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -27,59 +27,6 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./coverage_report.lcov
 
-  xcode_14_3_1:
-    runs-on: macos-13
-    env:
-      DEVELOPER_DIR: /Applications/Xcode_14.3.1.app/Contents/Developer
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Version
-        run: swift --version
-      - name: Build
-        run: swift build --build-tests
-      - name: Test
-        run: swift test --skip-build
-
-  linux_swift_5_7:
-    runs-on: ubuntu-latest
-    container: swift:5.7
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Version
-        run: swift --version
-      - name: Build
-        run: swift build --build-tests
-      - name: Test
-        run: swift test --skip-build
-
-  linux_swift_5_8:
-    runs-on: ubuntu-latest
-    container: swift:5.8
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Version
-        run: swift --version
-      - name: Build
-        run: swift build --build-tests
-      - name: Test
-        run: swift test --skip-build
-
-  linux_swift_5_9:
-    runs-on: ubuntu-latest
-    container: swift:5.9
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Version
-        run: swift --version
-      - name: Build
-        run: swift build --build-tests
-      - name: Test
-        run: swift test --skip-build
-
   linux_swift_5_10:
     runs-on: ubuntu-latest
     container: swift:5.10

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.8
+// swift-tools-version:6.0
 
 import PackageDescription
 
@@ -33,7 +33,8 @@ extension Array where Element == SwiftSetting {
     static var upcomingFeatures: [SwiftSetting] {
         [
             .enableUpcomingFeature("ExistentialAny"),
-            .enableExperimentalFeature("StrictConcurrency")
+            .enableExperimentalFeature("StrictConcurrency"),
+            .swiftLanguageVersion(.v6)
         ]
     }
 }

[email protected] renamed to [email protected]

@@ -1,4 +1,4 @@
-// swift-tools-version:5.7
+// swift-tools-version:5.10
 
 import PackageDescription
 
@@ -16,12 +16,24 @@ let package = Package(
     targets: [
         .target(
             name: "IdentifiableContinuation",
-            path: "Sources"
+            path: "Sources",
+            swiftSettings: .upcomingFeatures
         ),
         .testTarget(
             name: "IdentifiableContinuationTests",
             dependencies: ["IdentifiableContinuation"],
-            path: "Tests"
+            path: "Tests",
+            swiftSettings: .upcomingFeatures
         )
     ]
 )
+
+extension Array where Element == SwiftSetting {
+
+    static var upcomingFeatures: [SwiftSetting] {
+        [
+            .enableUpcomingFeature("ExistentialAny"),
+            .enableExperimentalFeature("StrictConcurrency")
+        ]
+    }
+}

README.md

@@ -1,7 +1,7 @@
 [![Build](https://github.com/swhitty/IdentifiableContinuation/actions/workflows/build.yml/badge.svg)](https://github.com/swhitty/IdentifiableContinuation/actions/workflows/build.yml)
 [![Codecov](https://codecov.io/gh/swhitty/IdentifiableContinuation/graphs/badge.svg)](https://codecov.io/gh/swhitty/IdentifiableContinuation)
 [![Platforms](https://img.shields.io/badge/platforms-iOS%20|%20Mac%20|%20tvOS%20|%20Linux%20|%20Windows-lightgray.svg)](https://github.com/swhitty/IdentifiableContinuation/blob/main/Package.swift)
-[![Swift 5.10](https://img.shields.io/badge/swift-5.7%20–%205.10-red.svg?style=flat)](https://developer.apple.com/swift)
+[![Swift 6.0](https://img.shields.io/badge/swift-5.10%20–%206.0-red.svg?style=flat)](https://developer.apple.com/swift)
 [![License](https://img.shields.io/badge/license-MIT-lightgrey.svg)](https://opensource.org/licenses/MIT)
 [![Twitter](https://img.shields.io/badge/[email protected])](http://twitter.com/simonwhitty)
 
@@ -22,26 +22,35 @@ To install using Swift Package Manager, add this to the `dependencies:` section
 
 # Usage
 
-Usage is similar to existing continuations, but requires an `Actor` to ensure the closure is executed within the actors isolation:
+With Swift 6, usage is similar to existing continuations where the closure is executed syncronously within the current isolation allowing actors to mutate their isolated state.
 
 ```swift
-let val: String = await withIdentifiableContinuation(isolation: self) { 
-    $0.resume(returning: "bar")
+let val: String = await withIdentifiableContinuation { 
+  continuations[$0.id] = $0
 }
 ```
 
-This allows actors to synchronously start continuations and mutate their isolated state _before_ suspension occurs. The `onCancel:` handler is `@Sendable` and can be called at any time _after_ the body has completed. Manually check `Task.isCancelled` before creating the continuation to prevent performing unrequired work.
+An optional cancellation handler is called when the task is cancelled.  The handler is `@Sendable` and can be called at any time _after_ the body has completed.
 
 ```swift
-let val: String = await withIdentifiableContinuation(isolation: self) {
-  // executed within actor isolation so can immediately mutate actor state
+let val: String = await withIdentifiableContinuation { 
   continuations[$0.id] = $0
-} onCancel: { id in
+} onCancel { id in
   // @Sendable closure executed outside of actor isolation requires `await` to mutate actor state
   Task { await self.cancelContinuation(with: id) }
 }
 ```
 
+## Swift 5
+
+ While behaviour is identical, Swift 5 is unable to automatically inherit actor isolation through the new `#isolation` keyword ([SE-420](https://github.com/swiftlang/swift-evolution/blob/main/proposals/0420-inheritance-of-actor-isolation.md)) so an `isolated` reference to the current actor must always be passed.
+
+```swift
+let val: String = await withIdentifiableContinuation(isolation: self) { 
+  continuations[$0.id] = $0
+}
+```
+
 # Credits
 
 IdentifiableContinuation is primarily the work of [Simon Whitty](https://github.com/swhitty).

Sources/IdentifiableContinuation.swift

@@ -29,6 +29,99 @@
 //  SOFTWARE.
 //
 
+#if compiler(>=6.0)
+/// Invokes the passed in closure with an `IdentifableContinuation` for the current task.
+///
+/// The body of the closure executes synchronously on the calling actor. Once it returns the calling task is suspended.
+/// It is possible to immediately resume the task, or escape the continuation in order to complete it afterwards, which
+/// will then resume the suspended task.
+///
+/// You must invoke the continuation's `resume` method exactly once.
+/// - Parameters:
+///   - function: A string identifying the declaration that is the notional
+///     source for the continuation, used to identify the continuation in
+///     runtime diagnostics related to misuse of this continuation.
+///   - body: A closure that takes a `IdentifiableContinuation` parameter.
+///   - handler: Cancellation closure executed when the current Task is cancelled.  Handler is always called _after_ the body closure is compeled.
+/// - Returns: The value continuation is resumed with.
+public func withIdentifiableContinuation<T>(
+  isolation: isolated (any Actor)? = #isolation,
+  function: String = #function,
+  body: (IdentifiableContinuation<T, Never>) -> Void,
+  onCancel handler: @Sendable (IdentifiableContinuation<T, Never>.ID) -> Void
+) async -> T {
+    let id = IdentifiableContinuation<T, Never>.ID()
+    let state = AllocatedLock(initialState: (isStarted: false, isCancelled: false))
+    return await withTaskCancellationHandler {
+        await withCheckedContinuation(function: function) {
+            let continuation = IdentifiableContinuation(id: id, continuation: $0)
+            body(continuation)
+            let sendCancel = state.withLock {
+                $0.isStarted = true
+                return $0.isCancelled
+            }
+            if sendCancel {
+                handler(id)
+            }
+            _ = isolation
+        }
+    } onCancel: {
+        let sendCancel = state.withLock {
+            $0.isCancelled = true
+            return $0.isStarted
+        }
+        if sendCancel {
+            handler(id)
+        }
+    }
+}
+
+/// Invokes the passed in closure with an `IdentifableContinuation` for the current task.
+///
+/// The body of the closure executes synchronously on the calling actor. Once it returns the calling task is suspended.
+/// It is possible to immediately resume the task, or escape the continuation in order to complete it afterwards, which
+/// will then resume the suspended task.
+///
+/// You must invoke the continuation's `resume` method exactly once.
+/// - Parameters:
+///   - function: A string identifying the declaration that is the notional
+///     source for the continuation, used to identify the continuation in
+///     runtime diagnostics related to misuse of this continuation.
+///   - body: A closure that takes a `IdentifiableContinuation` parameter.
+///   - handler: Cancellation closure executed when the current Task is cancelled.  Handler is always called _after_ the body closure is compeled.
+/// - Returns: The value continuation is resumed with.
+public func withIdentifiableThrowingContinuation<T>(
+  isolation: isolated (any Actor)? = #isolation,
+  function: String = #function,
+  body: (IdentifiableContinuation<T, any Error>) -> Void,
+  onCancel handler: @Sendable (IdentifiableContinuation<T, any Error>.ID) -> Void
+) async throws -> T {
+    let id = IdentifiableContinuation<T, any Error>.ID()
+    let state = AllocatedLock(initialState: (isStarted: false, isCancelled: false))
+    return try await withTaskCancellationHandler {
+        try await withCheckedThrowingContinuation(function: function) {
+            let continuation = IdentifiableContinuation(id: id, continuation: $0)
+            body(continuation)
+            let sendCancel = state.withLock {
+                $0.isStarted = true
+                return $0.isCancelled
+            }
+            if sendCancel {
+                handler(id)
+            }
+            _ = isolation
+        }
+    } onCancel: {
+        let sendCancel = state.withLock {
+            $0.isCancelled = true
+            return $0.isStarted
+        }
+        if sendCancel {
+            handler(id)
+        }
+    }
+}
+#else
 /// Invokes the passed in closure with an `IdentifableContinuation` for the current task.
 ///
 /// The body of the closure executes synchronously on the calling actor. Once it returns the calling task is suspended.
@@ -124,6 +217,7 @@ public func withIdentifiableThrowingContinuation<T>(
         }
     }
 }
+#endif
 
 public struct IdentifiableContinuation<T, E>: Sendable, Identifiable where E: Error {
 
@@ -149,17 +243,27 @@ public struct IdentifiableContinuation<T, E>: Sendable, Identifiable where E: Er
 
     private let continuation: CheckedContinuation<T, E>
 
-    public func resume(returning value: T) {
+#if compiler(>=6.0)
+    public func resume(returning value: sending T) {
         continuation.resume(returning: value)
     }
 
-    public func resume(throwing error: E) {
-        continuation.resume(throwing: error)
+    public func resume(with result: sending Result<T, E>) {
+        continuation.resume(with: result)
+    }
+#else
+    public func resume(returning value: T) {
+        continuation.resume(returning: value)
     }
 
     public func resume(with result: Result<T, E>) {
         continuation.resume(with: result)
     }
+#endif
+
+    public func resume(throwing error: E) {
+        continuation.resume(throwing: error)
+    }
 
     public func resume() where T == () {
         continuation.resume()

Tests/IdentifiableContinuationTests.swift

@@ -154,7 +154,7 @@ final class IdentifiableContinuationAsyncTests: XCTestCase {
     }
 }
 
-private actor Waiter<T, E: Error> {
+private actor Waiter<T: Sendable, E: Error> {
     typealias Continuation = IdentifiableContinuation<T, E>
 
     private var waiting = [Continuation.ID: Continuation]()
@@ -166,22 +166,38 @@ private actor Waiter<T, E: Error> {
     func makeTask(delay: TimeInterval = 0, onCancel: T) -> Task<T, Never> where E == Never {
         Task {
             await Task.sleep(seconds: delay)
+#if compiler(>=6.0)
+            return await withIdentifiableContinuation {
+                addContinuation($0)
+            } onCancel: { id in
+                Task { await self.resumeID(id, returning: onCancel) }
+            }
+#else
             return await withIdentifiableContinuation(isolation: self) {
                 addContinuation($0)
             } onCancel: { id in
                 Task { await self.resumeID(id, returning: onCancel) }
             }
+#endif
         }
     }
 
     func makeTask(delay: TimeInterval = 0, onCancel: Result<T, E>) -> Task<T, any Error> where E == any Error {
         Task {
             await Task.sleep(seconds: delay)
+#if compiler(>=6.0)
+            return try await withIdentifiableThrowingContinuation {
+                addContinuation($0)
+            } onCancel: { id in
+                Task { await self.resumeID(id, with: onCancel) }
+            }
+#else
             return try await withIdentifiableThrowingContinuation(isolation: self) {
                 addContinuation($0)
             } onCancel: { id in
                 Task { await self.resumeID(id, with: onCancel) }
             }
+#endif
         }
     }
 
@@ -234,13 +250,22 @@ private extension Actor {
         body:  @Sendable (IdentifiableContinuation<T, Never>) -> Void,
     onCancel handler: @Sendable (IdentifiableContinuation<T, Never>.ID) -> Void = { _ in }
     ) async -> T {
+#if compiler(>=6.0)
+        await withIdentifiableContinuation(body: body, onCancel: handler)
+#else
         await withIdentifiableContinuation(isolation: self, body: body, onCancel: handler)
+#endif
     }
 
     func throwingIdentifiableContinuation<T: Sendable>(
         body:  @Sendable (IdentifiableContinuation<T, any Error>) -> Void,
     onCancel handler: @Sendable (IdentifiableContinuation<T, any Error>.ID) -> Void = { _ in }
     ) async throws -> T {
+#if compiler(>=6.0)
+        try await withIdentifiableThrowingContinuation(body: body, onCancel: handler)
+#else
         try await withIdentifiableThrowingContinuation(isolation: self, body: body, onCancel: handler)
+#endif
+
     }
 }