Address review comments; get() must throw, formatting

Author: ktoso

stdlib/public/Concurrency/Task.swift

@@ -37,7 +37,7 @@ extension Task {
   /// it is always able to return the current `Task` in which we are currently
   /// running.
   public static func current() async -> Task {
-    fatalError("\(#function) not implemented yet.")
+    fatalError("\(#function) not implemented yet.") // TODO: needs a built-in function
   }
 }
 
@@ -100,13 +100,16 @@ extension Task {
   /// Dropping a handle however means losing the ability to await on the task's result
   /// and losing the ability to cancel it.
   public final class Handle<Success, Failure: Error> {
-      /// Wait for the task to complete, returning (or throwing) its result.
-      ///
-      /// ### Priority
-      /// If the task has not completed yet, its priority will be elevated to the
-      /// priority of the current task. Note that this may not be as effective as
-      /// creating the task with the "right" priority to in the first place.
-      public func get() async throws -> Success {
+    /// Wait for the task to complete, returning (or throwing) its result.
+    ///
+    /// ### Priority
+    /// If the task has not completed yet, its priority will be elevated to the
+    /// priority of the current task. Note that this may not be as effective as
+    /// creating the task with the "right" priority to in the first place.
+    ///
+    /// ### Cancellation
+    /// If the awaited on task gets cancelled the `get()` will throw a cancellation error.
+    public func get() async throws -> Success {
       fatalError("\(#function) not implemented yet.")
     }
 
@@ -124,18 +127,6 @@ extension Task {
   }
 }
 
-extension Task.Handle where Failure == Never {
-  /// Wait for the task to complete, returning its result.
-  ///
-  /// ### Priority
-  /// If the task has not completed yet, its priority will be elevated to the
-  /// priority of the current task. Note that this may not be as effective as
-  /// creating the task with the "right" priority to in the first place.
-  public func get() async -> Success {
-  fatalError("\(#function) not implemented yet.")
-}
-}
-
 // ==== Detached Tasks ---------------------------------------------------------
 
 extension Task {

test/Concurrency/async_tasks.swift

@@ -6,15 +6,6 @@ func someAsyncFunc() async -> String { "" }
 struct MyError: Error {}
 func someThrowingAsyncFunc() async throws -> String { throw MyError() }
 
-// non-async function with "weird shape" representing some API that has not adopted
-// swift concurrency yet, but we want to call it from an async function and make it
-// play nice with the rest of the system.
-func someManyCallbacksFunction(
-  calledSometimes: () -> (),
-  otherwiseThisIsCalled: () -> (),
-  calledOnError: (Error) -> ()
-) { }
-
 func test_unsafeContinuations() async {
   // the closure should not allow async operations;
   // after all: if you have async code, just call it directly, without the unsafe continuation
@@ -42,12 +33,12 @@ func test_unsafeThrowingContinuations() async {
 
 // ==== Detached Tasks ---------------------------------------------------------
 
-func test_detached() async {
+func test_detached() async throws {
   let handle = Task.runDetached() {
     await someAsyncFunc() // able to call async functions
   }
 
-  let result: String = await handle.get()
+  let result: String = await try handle.get()
   _ = result
 }