Merge pull request #27 from pbk20191/develop

prepare for xcode 15 and swift 5.9
pbk20191 · Jun 17, 2023 · a1ce051 · a1ce051
2 parents 13e7573 + 34ed4e3
commit a1ce051
Show file tree

Hide file tree

Showing 5 changed files with 97 additions and 77 deletions.
diff --git a/Sources/Tetra/AsyncScope/InvalidTaskScope.swift b/Sources/Tetra/AsyncScope/InvalidTaskScope.swift
@@ -14,7 +14,7 @@ struct InvalidTaskScope: TaskScopeProtocol {
     var isCancelled:Bool { true }
 
     @usableFromInline
-    func launch(operation: @escaping Job) -> Bool {
+    func launch(operation: @escaping PendingWork) -> Bool {
         print("InvalidTaskScope never launch")
         return false
     }

diff --git a/Sources/Tetra/AsyncScope/JobSequence.swift b/Sources/Tetra/AsyncScope/JobSequence.swift
@@ -9,7 +9,7 @@ import Foundation
 
 @usableFromInline
 struct JobSequence: Sendable, AsyncSequence {
-    
+
     @usableFromInline
     func makeAsyncIterator() -> AsyncIterator {
         stream.makeAsyncIterator()
@@ -25,14 +25,9 @@ struct JobSequence: Sendable, AsyncSequence {
     private let continuation:AsyncStream<Element>.Continuation
 
     init() {
-        var reference: AsyncStream<Element>.Continuation? = nil
-        let semaphore = DispatchSemaphore(value: 0)
-        stream = .init{ continuation in
-            reference = continuation
-            semaphore.signal()
-        }
-        semaphore.wait()
-        continuation = reference.unsafelyUnwrapped
+        let (source, ref) = AsyncStream<Element>.makeStream()
+        stream = source
+        continuation = ref
     }
 
     func append(job: __owned @escaping Element) -> Bool {

diff --git a/Sources/Tetra/AsyncScope/StandaloneTaskScope.swift b/Sources/Tetra/AsyncScope/StandaloneTaskScope.swift
@@ -7,7 +7,7 @@
 
 import Foundation
 import os
-
+import _Concurrency
 
 /**
  Wrapper object which act like CoroutineScope in Coroutine.
@@ -94,58 +94,42 @@ public struct StandaloneTaskScope: TaskScopeProtocol {
             }
         }
         task = creator(priority) {
-          // TODO: use withDiscardingTaskGroup
-            await withTaskGroup(of: Void.self) { group in
-                group.addTask(priority: .background) {
-                    let lock = createCheckedStateLock(checkedState: TaskCancellationState.waiting)
-                    await withTaskCancellationHandler {
-                        await withUnsafeContinuation{ continuation in
-
-                            let snapShot = lock.withLock{
-                                let oldValue = $0
-                                switch oldValue {
-                                case .cancelled:
-                                    break
-                                case .suspending:
-                                    assertionFailure("unexpected state")
-                                    fallthrough
-                                case .waiting:
-                                    $0 = .suspending(continuation)
-
-                                }
-                                return oldValue
-                            }
-                            switch snapShot {
-                            case .cancelled:
-                                continuation.resume()
-                            case .waiting:
-                                break
-                            case .suspending(let unsafeContinuation):
-                                unsafeContinuation.resume()
-                            }
-                        }
-                    } onCancel: {
-                        lock.withLock{
-                            $0.take()
-                        }?.resume()
+            if #available(macOS 13.3, iOS 16.4, watchOS 9.4, tvOS 16.4, *) {
+                await withDiscardingTaskGroup { group in
+                    group.addTask(priority: .background) {
+                        await suspendUntilCancelled()
+                    }
+                    for await operation in sequence {
+                        group.addTask(operation: operation)
                     }
                 }
-
-                var childIterator = group.makeAsyncIterator()
-                let stream = AsyncStream<Void> {
-                    await childIterator.next()
-                } onCancel: {
-                    sequence.finish()
-                }
-                // consume finished child Task to be released
-                async let iteratingTask: Void = await {
-                    for await _ in stream { }
-                }()
-
-                for await operation in sequence {
-                    group.addTask(operation: operation)
+            } else {
+                await withTaskGroup(of: Void.self) { group in
+                    group.addTask(priority: .background) {
+                        await suspendUntilCancelled()
+                    }
+
+                    var childIterator = group.makeAsyncIterator()
+                    let stream = AsyncStream<Void> {
+                        await childIterator.next()
+                    } onCancel: {
+                        sequence.finish()
+                    }
+                    // consume finished child Task to be released
+                    async let iteratingTask: Void = await {
+                        for await _ in stream {
+                            print("release")
+                        }
+                    }()
+
+                    for await operation in sequence {
+                        group.addTask(operation: operation)
+                        // await Task.yield()
+                    }
+                    await iteratingTask
+                    // release all the childTask which is not release from `stream` caused by early Task cancellation
+                    //for await _ in group { print("release2") }
                 }
-                await iteratingTask
             }
 
         }
@@ -154,27 +138,65 @@ public struct StandaloneTaskScope: TaskScopeProtocol {
         cancellable = nil
     }
 
-    public func launch(operation: __owned @escaping Job) -> Bool {
+    public func launch(operation: __owned @escaping PendingWork) -> Bool {
         buffer.append(job: operation)
     }
 
 
-    private enum TaskCancellationState: Sendable {
-
-        case waiting
-        case suspending(UnsafeContinuation<Void,Never>)
-        case cancelled
-
-        mutating func take() -> UnsafeContinuation<Void,Never>? {
-            if case let .suspending(continuation) = self {
-                self = .cancelled
-                return continuation
-            } else {
-                self = .cancelled
-                return nil
+
+
+}
+
+private enum TaskCancellationState: Sendable {
+
+    case waiting
+    case suspending(UnsafeContinuation<Void,Never>)
+    case cancelled
+
+    mutating func take() -> UnsafeContinuation<Void,Never>? {
+        if case let .suspending(continuation) = self {
+            self = .cancelled
+            return continuation
+        } else {
+            self = .cancelled
+            return nil
+        }
+    }
+
+}
+
+private func suspendUntilCancelled() async {
+    let lock = createCheckedStateLock(checkedState: TaskCancellationState.waiting)
+    await withTaskCancellationHandler {
+        await withUnsafeContinuation{ continuation in
+
+            let snapShot = lock.withLock{
+                let oldValue = $0
+                switch oldValue {
+                case .cancelled:
+                    break
+                case .suspending:
+                    assertionFailure("unexpected state")
+                    fallthrough
+                case .waiting:
+                    $0 = .suspending(continuation)
+
+                }
+                return oldValue
+            }
+            switch snapShot {
+            case .cancelled:
+                continuation.resume()
+            case .waiting:
+                break
+            case .suspending(let unsafeContinuation):
+                unsafeContinuation.resume()
             }
         }
-
+    } onCancel: {
+        lock.withLock{
+            $0.take()
+        }?.resume()
     }
 }
 
diff --git a/Sources/Tetra/AsyncScope/TaskScopeProtocol.swift b/Sources/Tetra/AsyncScope/TaskScopeProtocol.swift
@@ -9,7 +9,10 @@ import Foundation
 
 public protocol TaskScopeProtocol: Sendable, Hashable {
 
-    typealias Job = @Sendable () async -> Void
+    typealias PendingWork = @Sendable () async -> Void
+
+    @available(*, deprecated, renamed: "PendingJob", message: "Job is deprecated since Swift has own type named Job")
+    typealias Job = PendingWork
 
     /**
      submit the Job to this `TaskScope`. Job will be executed on the next possible opportunity unless it's cancelled.

diff --git a/Sources/Tetra/AsyncScope/ViewBoundTaskScope.swift b/Sources/Tetra/AsyncScope/ViewBoundTaskScope.swift
@@ -12,7 +12,7 @@ public struct ViewBoundTaskScope: TaskScopeProtocol {
 
     @discardableResult
     @inlinable
-    public func launch(operation: @escaping Job) -> Bool {
+    public func launch(operation: @escaping PendingWork) -> Bool {
         switch scope {
         case .invalid:
             return InvalidTaskScope().launch(operation: operation)