spawnDetached to detach, non-suspending group.spawn, spawnUnlessCancelled

Author: ktoso

stdlib/public/Concurrency/Task.swift

@@ -105,7 +105,7 @@ extension Task {
   /// ### Priority inheritance
   /// Child tasks automatically inherit their parent task's priority.
   ///
-  /// Detached tasks (created by `spawnDetached`) DO NOT inherit task priority,
+  /// Detached tasks (created by `detach`) DO NOT inherit task priority,
   /// as they are "detached" from their parent tasks after all.
   ///
   /// ### Priority elevation
@@ -150,7 +150,7 @@ extension Task {
   /// i.e. the task will run regardless of the handle still being present or not.
   /// Dropping a handle however means losing the ability to await on the task's result
   /// and losing the ability to cancel it.
-  public struct Handle<Success, Failure: Error> {
+  public struct Handle<Success, Failure: Error>: Sendable {
     internal let _task: Builtin.NativeObject
 
     internal init(_ task: Builtin.NativeObject) {
@@ -395,7 +395,7 @@ extension Task {
 ///     throw the error the operation has thrown when awaited on.
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 @discardableResult
-public func spawnDetached<T>(
+public func detach<T>(
   priority: Task.Priority = .default,
   operation: __owned @Sendable @escaping () async -> T
 ) -> Task.Handle<T, Never> {
@@ -447,7 +447,7 @@ public func spawnDetached<T>(
 ///     tasks result or `cancel` it. If the operation fails the handle will
 ///     throw the error the operation has thrown when awaited on.
 @discardableResult
-public func spawnDetached<T, Failure>(
+public func detach<T, Failure>(
   priority: Task.Priority = .default,
   operation: __owned @Sendable @escaping () async throws -> T
 ) -> Task.Handle<T, Failure> {
@@ -472,7 +472,7 @@ public func spawnDetached<T, Failure>(
 // TODO: remove this?
 public func _runAsyncHandler(operation: @escaping () async -> ()) {
   typealias ConcurrentFunctionType = @Sendable () async -> ()
-  spawnDetached(
+  detach(
     operation: unsafeBitCast(operation, to: ConcurrentFunctionType.self)
   )
 }
@@ -629,7 +629,7 @@ public func _asyncMainDrainQueue() -> Never
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 public func _runAsyncMain(_ asyncFun: @escaping () async throws -> ()) {
 #if os(Windows)
-  spawnDetached {
+  detach {
     do {
       try await asyncFun()
       exit(0)
@@ -647,7 +647,7 @@ public func _runAsyncMain(_ asyncFun: @escaping () async throws -> ()) {
     }
   }
 
-  spawnDetached {
+  detach {
     await _doMain(asyncFun)
     exit(0)
   }
@@ -705,12 +705,12 @@ func _taskIsCancelled(_ task: Builtin.NativeObject) -> Bool
 @_alwaysEmitIntoClient
 @usableFromInline
 internal func _runTaskForBridgedAsyncMethod(_ body: @escaping () async -> Void) {
-  // TODO: We can probably do better than spawnDetached
+  // TODO: We can probably do better than detach
   // if we're already running on behalf of a task,
   // if the receiver of the method invocation is itself an Actor, or in other
   // situations.
 #if compiler(>=5.5) && $Sendable
-  spawnDetached { await body() }
+  detach { await body() }
 #endif
 }
 

stdlib/public/Concurrency/TaskGroup.swift

@@ -61,10 +61,8 @@ import Swift
 /// - if the body returns normally:
 ///   - the group will await any not yet complete tasks,
 ///   - once the `withTaskGroup` returns the group is guaranteed to be empty.
-/// - if the body throws:
-///   - all tasks remaining in the group will be automatically cancelled.
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-public func withTaskGroup<ChildTaskResult, GroupResult>(
+public func withTaskGroup<ChildTaskResult: Sendable, GroupResult>(
   of childTaskResultType: ChildTaskResult.Type,
   returning returnType: GroupResult.Type = GroupResult.self,
   body: (inout TaskGroup<ChildTaskResult>) async -> GroupResult
@@ -144,7 +142,7 @@ public func withTaskGroup<ChildTaskResult, GroupResult>(
 ///   - once the `withTaskGroup` returns the group is guaranteed to be empty.
 /// - if the body throws:
 ///   - all tasks remaining in the group will be automatically cancelled.
-public func withThrowingTaskGroup<ChildTaskResult, GroupResult>(
+public func withThrowingTaskGroup<ChildTaskResult: Sendable, GroupResult>(
   of childTaskResultType: ChildTaskResult.Type,
   returning returnType: GroupResult.Type = GroupResult.self,
   body: (inout ThrowingTaskGroup<ChildTaskResult, Error>) async throws -> GroupResult
@@ -191,7 +189,7 @@ public func withThrowingTaskGroup<ChildTaskResult, GroupResult>(
 /// A task group serves as storage for dynamically spawned tasks.
 ///
 /// It is created by the `withTaskGroup` function.
-public struct TaskGroup<ChildTaskResult> {
+public struct TaskGroup<ChildTaskResult: Sendable> {
 
   private let _task: Builtin.NativeObject
   /// Group task into which child tasks offer their results,
@@ -225,13 +223,13 @@ public struct TaskGroup<ChildTaskResult> {
   @discardableResult
   public mutating func spawn(
     overridingPriority priorityOverride: Task.Priority? = nil,
-    operation: @Sendable @escaping () async -> ChildTaskResult
-  ) async -> Bool {
+    operation: __owned @Sendable @escaping () async -> ChildTaskResult
+  ) -> Self.Spawned {
     let canAdd = _taskGroupAddPendingTask(group: _group)
 
     guard canAdd else {
       // the group is cancelled and is not accepting any new work
-      return false
+      return Spawned(handle: nil)
     }
 
     // Set up the job flags for a new task.
@@ -252,7 +250,22 @@ public struct TaskGroup<ChildTaskResult> {
     // Enqueue the resulting job.
     _enqueueJobGlobal(Builtin.convertTaskToJob(childTask))
 
-    return true
+    return Spawned(handle: Task.Handle(childTask))
+  }
+
+  public struct Spawned: Sendable {
+    /// Returns `true` if the task was successfully spawned in the task group,
+    /// `false` otherwise which means that the group was already cancelled and
+    /// refused to accept spawn a new child task.
+    public var successfully: Bool { handle != nil }
+
+    /// Task handle for the spawned task group child task,
+    /// or `nil` if it was not spawned successfully.
+    public let handle: Task.Handle<ChildTaskResult, Never>?
+
+    init(handle: Task.Handle<ChildTaskResult, Never>?) {
+      self.handle = handle
+    }
   }
 
   /// Wait for the a child task that was added to the group to complete,
@@ -296,8 +309,8 @@ public struct TaskGroup<ChildTaskResult> {
   /// Order of values returned by next() is *completion order*, and not
   /// submission order. I.e. if tasks are added to the group one after another:
   ///
-  ///     await group.spawn { 1 }
-  ///     await group.spawn { 2 }
+  ///     group.spawn { 1 }
+  ///     group.spawn { 2 }
   ///
   ///     print(await group.next())
   ///     /// Prints "1" OR "2"
@@ -388,7 +401,7 @@ public struct TaskGroup<ChildTaskResult> {
 /// child tasks.
 ///
 /// It is created by the `withTaskGroup` function.
-public struct ThrowingTaskGroup<ChildTaskResult, Failure: Error> {
+public struct ThrowingTaskGroup<ChildTaskResult: Sendable, Failure: Error> {
 
   private let _task: Builtin.NativeObject
   /// Group task into which child tasks offer their results,
@@ -423,12 +436,12 @@ public struct ThrowingTaskGroup<ChildTaskResult, Failure: Error> {
   public mutating func spawn(
     overridingPriority priorityOverride: Task.Priority? = nil,
     operation: __owned @Sendable @escaping () async throws -> ChildTaskResult
-  ) async -> Bool {
+  ) -> Self.Spawned {
     let canAdd = _taskGroupAddPendingTask(group: _group)
 
     guard canAdd else {
       // the group is cancelled and is not accepting any new work
-      return false
+      return Spawned(handle: nil)
     }
 
     // Set up the job flags for a new task.
@@ -449,7 +462,22 @@ public struct ThrowingTaskGroup<ChildTaskResult, Failure: Error> {
     // Enqueue the resulting job.
     _enqueueJobGlobal(Builtin.convertTaskToJob(childTask))
 
-    return true
+    return Spawned(handle: Task.Handle(childTask))
+  }
+
+  public struct Spawned: Sendable  {
+    /// Returns `true` if the task was successfully spawned in the task group,
+    /// `false` otherwise which means that the group was already cancelled and
+    /// refused to accept spawn a new child task.
+    public var successfully: Bool { handle != nil }
+
+    /// Task handle for the spawned task group child task,
+    /// or `nil` if it was not spawned successfully.
+    public let handle: Task.Handle<ChildTaskResult, Error>?
+
+    init(handle: Task.Handle<ChildTaskResult, Error>?) {
+      self.handle = handle
+    }
   }
 
   /// Wait for the a child task that was added to the group to complete,
@@ -493,8 +521,8 @@ public struct ThrowingTaskGroup<ChildTaskResult, Failure: Error> {
   /// Order of values returned by next() is *completion order*, and not
   /// submission order. I.e. if tasks are added to the group one after another:
   ///
-  ///     await group.spawn { 1 }
-  ///     await group.spawn { 2 }
+  ///     group.spawn { 1 }
+  ///     group.spawn { 2 }
   ///
   ///     print(await group.next())
   ///     /// Prints "1" OR "2"
@@ -519,6 +547,29 @@ public struct ThrowingTaskGroup<ChildTaskResult, Failure: Error> {
     return try await _taskGroupWaitNext(group: _group)
   }
 
+  /// - SeeAlso: `next()`
+  public mutating func nextResult() async throws -> Result<ChildTaskResult, Failure>? {
+    #if NDEBUG
+    let callingTask = Builtin.getCurrentAsyncTask() // can't inline into the assert sadly
+    assert(unsafeBitCast(callingTask, to: size_t.self) ==
+      unsafeBitCast(_task, to: size_t.self),
+      """
+      group.next() invoked from task other than the task which created the group! \
+      This means the group must have illegally escaped the withTaskGroup{} scope.
+      """)
+    #endif
+
+    do {
+      guard let success: ChildTaskResult = try await _taskGroupWaitNext(group: _group) else {
+        return nil
+      }
+
+      return .success(success)
+    } catch {
+      return .failure(error as! Failure) // as!-safe, because we are only allowed to throw Failure (Error)
+    }
+  }
+
   /// Query whether the group has any remaining tasks.
   ///
   /// Task groups are always empty upon entry to the `withTaskGroup` body, and
@@ -650,6 +701,7 @@ extension ThrowingTaskGroup: AsyncSequence {
 
     /// - SeeAlso: `ThrowingTaskGroup.next()` for a detailed discussion its semantics.
     public mutating func next() async throws -> Element? {
+      guard !finished else { return nil }
       do {
         guard let element = try await group.next() else {
           finished = true

test/Concurrency/Runtime/actor_counters.swift

@@ -52,7 +52,7 @@ func runTest(numCounters: Int, numWorkers: Int, numIterations: Int) async {
   var workers: [Task.Handle<Void, Error>] = []
   for i in 0..<numWorkers {
     workers.append(
-      spawnDetached { [counters] in
+      detach { [counters] in
         await Task.sleep(UInt64.random(in: 0..<100) * 1_000_000)
         await worker(identity: i, counters: counters, numIterations: numIterations)
       }

test/Concurrency/Runtime/async_task_cancellation_early.swift

@@ -10,9 +10,9 @@
 import Dispatch
 
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-func test_spawnDetached_cancel_child_early() async {
-  print(#function) // CHECK: test_spawnDetached_cancel_child_early
-  let h: Task.Handle<Bool, Error> = spawnDetached {
+func test_detach_cancel_child_early() async {
+  print(#function) // CHECK: test_detach_cancel_child_early
+  let h: Task.Handle<Bool, Error> = detach {
     async let childCancelled: Bool = { () -> Bool in
       await Task.sleep(2_000_000_000)
       return Task.isCancelled
@@ -37,6 +37,6 @@ func test_spawnDetached_cancel_child_early() async {
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 @main struct Main {
   static func main() async {
-    await test_spawnDetached_cancel_child_early()
+    await test_detach_cancel_child_early()
   }
 }

test/Concurrency/Runtime/async_task_cancellation_while_running.swift

@@ -10,8 +10,8 @@
 import Dispatch
 
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-func test_spawnDetached_cancel_while_child_running() async {
-  let h: Task.Handle<Bool, Error> = spawnDetached {
+func test_detach_cancel_while_child_running() async {
+  let h: Task.Handle<Bool, Error> = detach {
     async let childCancelled: Bool = { () -> Bool in
       await Task.sleep(3_000_000_000)
       return Task.isCancelled
@@ -36,6 +36,6 @@ func test_spawnDetached_cancel_while_child_running() async {
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 @main struct Main {
   static func main() async {
-    await test_spawnDetached_cancel_while_child_running()
+    await test_detach_cancel_while_child_running()
   }
 }

test/Concurrency/Runtime/async_task_equals_hashCode.swift

@@ -11,12 +11,12 @@
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 func simple() async {
   print("\(#function) -----------------------")
-  let one = await Task.current()
-  let two = await Task.current()
+  let one = Task.current!
+  let two = Task.current!
   print("same equal: \(one == two)") // CHECK: same equal: true
   print("hashes equal: \(one.hashValue == two.hashValue)") // CHECK: hashes equal: true
 
-  async let x = Task.current()
+  async let x = Task.current
   let three = await x
 
   print("parent/child equal: \(three == two)") // CHECK: parent/child equal: false
@@ -26,12 +26,12 @@ func simple() async {
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 func unsafe() async {
   print("\(#function) -----------------------")
-  let one = Task.unsafeCurrent!
-  let two = Task.unsafeCurrent!
+  let one = withUnsafeCurrentTask { $0! }
+  let two = withUnsafeCurrentTask { $0! }
   print("unsafe same equal: \(one == two)") // CHECK: same equal: true
   print("unsafe hashes equal: \(one.hashValue == two.hashValue)") // CHECK: hashes equal: true
 
-  async let x = Task.unsafeCurrent!
+  async let x = withUnsafeCurrentTask { $0! }
   let three = await x
 
   print("unsafe parent/child equal: \(three == two)") // CHECK: parent/child equal: false
@@ -44,8 +44,8 @@ func unsafe() async {
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 func unsafeSync() {
   print("\(#function) -----------------------")
-  let one = Task.unsafeCurrent!
-  let two = Task.unsafeCurrent!
+  let one = withUnsafeCurrentTask { $0! }
+  let two = withUnsafeCurrentTask { $0! }
   print("unsafe same equal: \(one == two)") // CHECK: same equal: true
   print("unsafe hashes equal: \(one.hashValue == two.hashValue)") // CHECK: hashes equal: true
 }

test/Concurrency/Runtime/async_task_handle_cancellation.swift

@@ -12,7 +12,7 @@
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 @main struct Main {
   static func main() async {
-    let handle = spawnDetached {
+    let handle = detach {
       while (!Task.isCancelled) { // no need for await here, yay
         print("waiting")
       }

test/Concurrency/Runtime/async_task_locals_groups.swift

@@ -51,7 +51,7 @@ func groups() async {
 
   // no value in parent, value in child
   let x1: Int = try! await withTaskGroup(of: Int.self) { group in
-    await group.spawn {
+    group.spawn {
       printTaskLocal(\.number) // CHECK: NumberKey: 0 {{.*}}
       // inside the child task, set a value
       await Task.withLocal(\.number, boundTo: 1) {
@@ -71,7 +71,7 @@ func groups() async {
 
     let x2: Int = try! await withTaskGroup(of: Int.self) { group in
       printTaskLocal(\.number) // CHECK: NumberKey: 2 {{.*}}
-      await group.spawn {
+      group.spawn {
         printTaskLocal(\.number) // CHECK: NumberKey: 2 {{.*}}
 
         async let childInsideGroupChild: () = printTaskLocal(\.number)

test/Concurrency/Runtime/async_task_locals_inherit_never.swift

@@ -68,14 +68,15 @@ func test_async_group() async {
   await Task.withLocal(\.string, boundTo: "top") {
     printTaskLocal(\.string) // CHECK: StringKey: top {{.*}}
 
-    try! await withTaskGroup(of: Void.self) { group -> Void? in
+    await withTaskGroup(of: Int.self, returning: Void.self) { group in
       printTaskLocal(\.string) // CHECK: StringKey: top {{.*}}
 
-      await group.spawn {
+      group.spawn {
         printTaskLocal(\.string) // CHECK: StringKey: <undefined> {{.*}}
+        return 0
       }
 
-      return try! await group.next()
+      _ = await group.next()
     }
   }
 }