[Concurrency] deprecate not implemented Task functions, until they're implemented

Author: ktoso

stdlib/public/Concurrency/Task.swift

@@ -19,7 +19,6 @@ import Glibc
 import CRT
 #endif
 
-
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
@@ -58,9 +57,11 @@ extension Task {
   /// this function was called.
   ///
   /// All functions available on the Task
-  // TODO: once Kavon's async properties land make this computed property
-  public static func current() async -> Task {
-    Task.unsafeCurrent!.task // !-safe, guaranteed to have a Task available.
+  // TODO: once we can have async properties land make this computed property
+  @available(*, deprecated, message: "Please use Builtin.getCurrentAsyncTask() or Task.__unsafeCurrentAsync() until this function becomes implemented.")
+  public static func current(file: StaticString = #file, line: UInt = #line) async -> Task {
+    fatalError("Task.current() is not implemented yet!", file: file, line: line)
+    Task.unsafeCurrent!.task // !-safe, guaranteed to have a Task available within an async function.
   }
 
 }
@@ -75,6 +76,7 @@ extension Task {
   ///
   /// - SeeAlso: `Task.Priority`
   /// - SeeAlso: `Task.priority`
+  @available(*, deprecated, message: "Not implemented yet, until unsafeCurrent is ready. Please use Task.__unsafeCurrentAsync().priority instead.")
   public static var currentPriority: Priority {
     Task.unsafeCurrent?.priority ?? Priority.default
   }
@@ -389,6 +391,8 @@ extension Task {
     startingOn executor: ExecutorRef? = nil,
     operation: @concurrent @escaping () async -> T
   ) -> Handle<T, Never> {
+    assert(executor == nil, "Custom executor support is not implemented yet.") // FIXME
+
     // Set up the job flags for a new task.
     var flags = JobFlags()
     flags.kind = .task
@@ -441,6 +445,8 @@ extension Task {
     startingOn executor: ExecutorRef? = nil,
     operation: @concurrent @escaping () async throws -> T
   ) -> Handle<T, Failure> {
+    assert(executor == nil, "Custom executor support is not implemented yet.") // FIXME
+
     // Set up the job flags for a new task.
     var flags = JobFlags()
     flags.kind = .task
@@ -476,6 +482,7 @@ extension Task {
   /// This is not a perfect cure for starvation;
   /// if the task is the highest-priority task in the system, it might go
   /// immediately back to executing.
+  @available(*, deprecated, message: "Not implemented yet.")
   public static func yield() async {
     fatalError("\(#function) not implemented yet.")
   }
@@ -494,17 +501,18 @@ extension Task {
   /// asynchronous function present in this functions call stack.
   ///
   /// The returned value must not be accessed from tasks other than the current one.
+  @available(*, deprecated, message: "Not implemented yet, use Builtin.getCurrentAsyncTask() or Task.___unsafeCurrentAsync() until this function is implemented.")
   public static var unsafeCurrent: UnsafeCurrentTask? {
     // FIXME: rdar://70546948 implement this once getCurrentAsyncTask can be called from sync funcs
     //    guard let _task = Builtin.getCurrentAsyncTask() else {
     //      return nil
     //    }
     //    return UnsafeCurrentTask(_task)
-    fatalError("\(#function) is not implemented yet, can not (yet) get task from sync function")
+    fatalError("\(#function) is not implemented yet")
   }
 
-  @available(*, deprecated, message: "This should be removed", renamed: "unsafeCurrent()")
-  public static func unsafeCurrentASYNC() async -> UnsafeCurrentTask {
+  @available(*, deprecated, message: "This will be removed, and replaced by unsafeCurrent().", renamed: "unsafeCurrent()")
+  public static func __unsafeCurrentAsync() async -> UnsafeCurrentTask {
     let task = Builtin.getCurrentAsyncTask()
     _swiftRetain(task)
     return UnsafeCurrentTask(task)

test/Concurrency/Runtime/actor_counters.swift

@@ -58,7 +58,7 @@ func runTest(numCounters: Int, numWorkers: Int, numIterations: Int) async {
   }
 
   // Create a bunch of worker threads.
-  var workers: [Task.Handle<Void>] = []
+  var workers: [Task.Handle<Void, Error>] = []
   for i in 0..<numWorkers {
     workers.append(
       Task.runDetached {

test/Concurrency/Runtime/async_task_equals_hashCode.swift

@@ -13,12 +13,12 @@ import Glibc
 
 @main struct Main {
   static func main() async {
-    let one = await Task.unsafeCurrentASYNC().task // FIXME: replace with Task.current
-    let two = await Task.unsafeCurrentASYNC().task // FIXME: replace with Task.current
+    let one = await Task.__unsafeCurrentAsync().task // FIXME: replace with Task.current
+    let two = await Task.__unsafeCurrentAsync().task // FIXME: replace with Task.current
     print(one == two) // CHECK: true
     print("hashes equal: \(one.hashValue == two.hashValue)") // CHECK: hashes equal: true
 
-    async let x = Task.unsafeCurrentASYNC().task // FIXME: replace with Task.current
+    async let x = Task.__unsafeCurrentAsync().task // FIXME: replace with Task.current
 
     let three = await x
     print(three == two) // CHECK: false

test/Concurrency/Runtime/async_task_priority_current.swift

@@ -15,24 +15,24 @@ import CRT
 // FIXME: use `Task.currentPriority` once unsafeCurrent works in all these
 
 func test_detach() async {
-  let a1 = await Task.unsafeCurrentASYNC().task.priority
+  let a1 = await Task.__unsafeCurrentAsync().task.priority
   print("a1: \(a1)") // CHECK: a1: default
 
   // Note: remember to detach using a higher priority, otherwise a lower one
   // might be escalated by the get() and we could see `default` in the detached
   // task.
   await Task.runDetached(priority: .userInitiated) {
-    let a2 = await Task.unsafeCurrentASYNC().task.priority
+    let a2 = await Task.__unsafeCurrentAsync().task.priority
     print("a2: \(a2)") // CHECK: a2: userInitiated
   }.get()
 
-  let a3 = await Task.unsafeCurrentASYNC().task.priority
+  let a3 = await Task.__unsafeCurrentAsync().task.priority
   print("a3: \(a3)") // CHECK: a3: default
 }
 
 func test_multiple_lo_indirectly_escalated() async {
   func loopUntil(priority: Task.Priority) async {
-    while (await Task.unsafeCurrentASYNC().task.priority != priority) {
+    while (await Task.__unsafeCurrentAsync().task.priority != priority) {
       sleep(1)
     }
   }

test/Concurrency/Runtime/async_taskgroup_is_empty.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency -parse-as-library) | %FileCheck %s --dump-input always
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency -parse-as-library) | %FileCheck %s
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 // XFAIL: windows

test/Concurrency/Runtime/async_taskgroup_next_not_invoked_cancelAll.swift

@@ -16,7 +16,7 @@ func test_skipCallingNext_butInvokeCancelAll() async {
       await group.add { () async -> Int in
         sleep(1)
         print("  inside group.add { \(n) }")
-        let cancelled = Task.isCancelled
+        let cancelled = await Task.__unsafeCurrentAsync().isCancelled
         print("  inside group.add { \(n) } (canceled: \(cancelled))")
         return n
       }
@@ -25,7 +25,8 @@ func test_skipCallingNext_butInvokeCancelAll() async {
     group.cancelAll()
 
     // return immediately; the group should wait on the tasks anyway
-    print("return immediately 0 (canceled: \(Task.isCancelled))")
+    let c = await Task.__unsafeCurrentAsync().isCancelled
+    print("return immediately 0 (canceled: \(c))")
     return 0
   }
 

test/Concurrency/Runtime/async_taskgroup_next_not_invoked_without_cancelAll.swift

@@ -15,13 +15,15 @@ func test_skipCallingNext() async {
       print("group.add { \(n) }")
       await group.add { () async -> Int in
         sleep(1)
-        print("  inside group.add { \(n) } (canceled: \(Task.isCancelled))")
+        let c = await Task.__unsafeCurrentAsync().isCancelled
+        print("  inside group.add { \(n) } (canceled: \(c))")
         return n
       }
     }
 
     // return immediately; the group should wait on the tasks anyway
-    print("return immediately 0 (canceled: \(Task.isCancelled))")
+    let c = await Task.__unsafeCurrentAsync().isCancelled
+    print("return immediately 0 (canceled: \(c))")
     return 0
   }
 

test/Concurrency/Runtime/async_taskgroup_throw_recover.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency -parse-as-library) | %FileCheck %s --dump-input always
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency -parse-as-library) | %FileCheck %s
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 // XFAIL: windows
@@ -7,21 +7,12 @@
 
 import Dispatch
 
-struct Boom: Error {
-}
-
-struct IgnoredBoom: Error {
-}
-
-func one()
-
-async -> Int {
-  1
-}
+struct Boom: Error {}
+struct IgnoredBoom: Error {}
 
-func boom()
+func one() async -> Int { 1 }
 
-async throws -> Int {
+func boom() async throws -> Int {
   throw Boom()
 }
 
@@ -40,7 +31,8 @@ func test_taskGroup_throws() async {
         print("error caught in group: \(error)")
 
         await group.add { () async -> Int in
-          print("task 3 (cancelled: \(Task.isCancelled))")
+          let c = await Task.__unsafeCurrentAsync().isCancelled
+          print("task 3 (cancelled: \(c))")
           return 3
         }
 

test/Concurrency/Runtime/async_taskgroup_throw_rethrow.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency -parse-as-library) | %FileCheck %s --dump-input always
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency -parse-as-library) | %FileCheck %s
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 

test/Concurrency/async_cancellation.swift

@@ -7,11 +7,11 @@ enum PictureData {
 }
 
 func test_cancellation_checkCancellation() async throws {
-  try await Task.checkCancellation()
+  try Task.checkCancellation()
 }
 
 func test_cancellation_guard_isCancelled(_ any: Any) async -> PictureData {
-  guard await !Task.isCancelled() else {
+  guard !Task.isCancelled else {
     return PictureData.failedToLoadImagePlaceholder
   }
 
@@ -23,7 +23,7 @@ struct SomeFile {
 }
 
 func test_cancellation_withCancellationHandler(_ anything: Any) async -> PictureData {
-  let handle = Task.runDetached { () -> PictureData in
+  let handle: Task.Handle<PictureData, Error> = Task.runDetached {
     let file = SomeFile()
 
     return try await Task.withCancellationHandler(
@@ -41,25 +41,9 @@ func test_cancellation_loop() async -> Int {
 
   let tasks = [SampleTask(), SampleTask()]
   var processed = 0
-  for t in tasks where await !Task.isCancelled() {
+  for t in tasks where !Task.isCancelled {
     await t.process()
     processed += 1
   }
   return processed
 }
-
-// ==== Deadlines --------------------------------------------------------------
-
-func int() async -> Int { 42 }
-
-func test_cancellation_withDeadline_in() async throws -> Int {
-  await Task.withDeadline(in: .seconds(5), operation: {
-    await int()
-  })
-}
-
-func test_cancellation_withDeadline(specificDeadline: Task.Deadline) async -> Int {
-  await Task.withDeadline(specificDeadline) {
-    await int()
-  }
-}

test/Concurrency/async_tasks.swift

@@ -82,12 +82,12 @@ func test_detached() async throws {
     await someAsyncFunc() // able to call async functions
   }
 
-  let result: String = try await handle.get()
+  let result: String = await handle.get()
   _ = result
 }
 
 func test_detached_throwing() async -> String {
-  let handle: Task.Handle<String> = Task.runDetached() {
+  let handle: Task.Handle<String, Error> = Task.runDetached() {
     try await someThrowingAsyncFunc() // able to call async functions
   }