implemented

Author: ktoso

stdlib/public/Concurrency/TaskGroup.cpp

@@ -414,9 +414,6 @@ class TaskGroupImpl: public TaskGroupTaskStatusRecord {
 
   /// Returns *assumed* new status, including the just performed +1.
   GroupStatus statusMarkWaitingAssumeAcquire() {
-//    fprintf(stderr, "[%s:%d](%s) statusMarkWaitingAssumeAcquire, load....\n", __FILE_NAME__, __LINE__, __FUNCTION__);
-//    fprintf(stderr, "[%s:%d](%s) statusMarkWaitingAssumeAcquire = %s\n", __FILE_NAME__, __LINE__, __FUNCTION__,
-//            statusLoadRelaxed().to_string(this).c_str());
     auto old = status.fetch_or(GroupStatus::waiting, std::memory_order_acquire);
     return GroupStatus{old | GroupStatus::waiting};
   }

stdlib/public/Concurrency/TaskGroup.swift

@@ -670,6 +670,8 @@ public struct ThrowingTaskGroup<ChildTaskResult: Sendable, Failure: Error> {
   }
 
   /// Wait for all of the group's remaining tasks to complete.
+  ///
+  /// - Throws: only during
   @_alwaysEmitIntoClient
   public mutating func waitForAll() async throws {
     try await self.awaitAllRemainingTasks()

test/Concurrency/Runtime/async_taskgroup_throw_rethrow.swift

@@ -8,38 +8,120 @@
 // REQUIRES: concurrency_runtime
 // UNSUPPORTED: back_deployment_runtime
 
-struct Boom: Error {}
-struct IgnoredBoom: Error {}
+struct Boom: Error {
+  let id: String
+
+  init(file: String = #fileID, line: UInt = #line) {
+    self.id = "\(file):\(line)"
+  }
+  init(id: String) {
+    self.id = id
+  }
+}
 
+struct IgnoredBoom: Error {}
 func echo(_ i: Int) async -> Int { i }
-func boom() async throws -> Int { throw Boom() }
+
+func test_taskGroup_throws_rethrows() async {
+  print("==== \(#function) ------") // CHECK_LABEL: test_taskGroup_throws_rethrows
+  do {
+    let got = try await withThrowingTaskGroup(of: Int.self, returning: Int.self) { group in
+      group.addTask { await echo(1) }
+      group.addTask { await echo(2) }
+      group.addTask { throw Boom() }
+
+      do {
+        while let r = try await group.next() {
+          print("next: \(r)")
+        }
+      } catch {
+        // CHECK: error caught and rethrown in group: Boom(
+        print("error caught and rethrown in group: \(error)")
+        throw error
+      }
+
+      print("should have thrown")
+      return 0
+    }
+
+    print("Expected error to be thrown, but got: \(got)")
+  } catch {
+    // CHECK: rethrown: Boom(
+    print("rethrown: \(error)")
+  }
+}
+
+func test_taskGroup_noThrow_ifNotAwaitedThrowingTask() async {
+  print("==== \(#function) ------") // CHECK_LABEL: test_taskGroup_noThrow_ifNotAwaitedThrowingTask
+  let got = await withThrowingTaskGroup(of: Int.self, returning: Int.self) { group in
+    group.addTask { await echo(1) }
+    guard let r = try! await group.next() else {
+      return 0
+    }
+
+    group.addTask { throw Boom() }
+    // don't consume this task, so we're not throwing here
+
+    return r
+  }
+
+  print("Expected no error to be thrown, got: \(got)") // CHECK: Expected no error to be thrown, got: 1
+}
 
 func test_taskGroup_discardResults_automaticallyRethrows() async {
-  print("==== \(#function) ------")
+  print("==== \(#function) ------") // CHECK_LABEL: test_taskGroup_discardResults_automaticallyRethrows
   do {
     let got = try await withThrowingTaskGroup(of: Int.self, returning: Int.self,
                                               discardResults: true) { group in
       group.addTask { await echo(1) }
-      group.addTask { try await boom() }
+      group.addTask { throw Boom() }
       // add a throwing task, but don't consume it explicitly
       // since we're in discard results mode, all will be awaited and the first error it thrown
-
       return 13
     }
 
     print("Expected error to be thrown, but got: \(got)")
   } catch {
-    // CHECK: rethrown: Boom()
+    // CHECK: rethrown: Boom(
     print("rethrown: \(error)")
   }
 }
 
+func test_taskGroup_discardResults_automaticallyRethrowsOnlyFirst() async {
+  print("==== \(#function) ------") // CHECK_LABEL: test_taskGroup_discardResults_automaticallyRethrowsOnlyFirst
+  do {
+    let got = try await withThrowingTaskGroup(of: Int.self, returning: Int.self,
+                                              discardResults: true) { group in
+      group.addTask { await echo(1) }
+      group.addTask { throw Boom(id: "first") }
+      // add a throwing task, but don't consume it explicitly
+      // since we're in discard results mode, all will be awaited and the first error it thrown
+
+      do {
+        try await group.waitForAll()
+      } catch {
+        // CHECK: caught: Boom(id: "first")
+        print("caught: \(error)")
+      }
+
+      group.addTask { throw Boom(id: "second") }
+
+      return 4
+    }
+
+    print("Expected error to be thrown, but got: \(got)")
+  } catch {
+    // CHECK: rethrown: Boom(id: "second")
+    print("rethrown: \(error)")
+  }
+}
 
 @available(SwiftStdlib 5.1, *)
 @main struct Main {
   static func main() async {
-//    await test_taskGroup_throws_rethrows()
-//    await test_taskGroup_noThrow_ifNotAwaitedThrowingTask()
+    await test_taskGroup_throws_rethrows()
+    await test_taskGroup_noThrow_ifNotAwaitedThrowingTask()
     await test_taskGroup_discardResults_automaticallyRethrows()
+    await test_taskGroup_discardResults_automaticallyRethrowsOnlyFirst()
   }
 }