[concurrency] Use the new builtins.

Author: gottesmm

stdlib/public/Concurrency/Task+PriorityEscalation.swift

@@ -125,8 +125,11 @@ func __withTaskPriorityEscalationHandler0<T, E>(
   onPriorityEscalated handler0: @Sendable (UInt8, UInt8) -> Void,
   isolation: isolated (any Actor)? = #isolation
 ) async throws(E) -> T {
-  let record = unsafe _taskAddPriorityEscalationHandler(handler: handler0)
-  defer { unsafe _taskRemovePriorityEscalationHandler(record: record) }
+  let record =
+    unsafe Builtin.taskAddPriorityEscalationHandler(handler: handler0)
+  defer {
+    unsafe Builtin.taskRemovePriorityEscalationHandler(record: record)
+  }
 
   return try await operation()
 }

stdlib/public/Concurrency/Task.swift

@@ -829,20 +829,6 @@ func _enqueueJobGlobalWithDeadline(_ seconds: Int64, _ nanoseconds: Int64,
                                    _ toleranceSec: Int64, _ toleranceNSec: Int64,
                                    _ clock: Int32, _ task: UnownedJob)
 
-@usableFromInline
-@available(SwiftStdlib 6.2, *)
-@_silgen_name("swift_task_addPriorityEscalationHandler")
-func _taskAddPriorityEscalationHandler(
-  handler: (UInt8, UInt8) -> Void
-) -> UnsafeRawPointer /*EscalationNotificationStatusRecord*/
-
-@usableFromInline
-@available(SwiftStdlib 6.2, *)
-@_silgen_name("swift_task_removePriorityEscalationHandler")
-func _taskRemovePriorityEscalationHandler(
-  record: UnsafeRawPointer /*EscalationNotificationStatusRecord*/
-)
-
 @available(SwiftStdlib 5.1, *)
 @usableFromInline
 @_silgen_name("swift_task_asyncMainDrainQueue")

stdlib/public/Concurrency/TaskCancellation.swift

@@ -84,8 +84,8 @@ public func withTaskCancellationHandler<T>(
 ) async rethrows -> T {
   // unconditionally add the cancellation record to the task.
   // if the task was already cancelled, it will be executed right away.
-  let record = unsafe _taskAddCancellationHandler(handler: handler)
-  defer { unsafe _taskRemoveCancellationHandler(record: record) }
+  let record = unsafe Builtin.taskAddCancellationHandler(handler: handler)
+  defer { unsafe Builtin.taskRemoveCancellationHandler(record: record) }
 
   return try await operation()
 }
@@ -105,8 +105,8 @@ public func _unsafeInheritExecutor_withTaskCancellationHandler<T>(
 ) async rethrows -> T {
   // unconditionally add the cancellation record to the task.
   // if the task was already cancelled, it will be executed right away.
-  let record = unsafe _taskAddCancellationHandler(handler: handler)
-  defer { unsafe _taskRemoveCancellationHandler(record: record) }
+  let record = unsafe Builtin.taskAddCancellationHandler(handler: handler)
+  defer { unsafe Builtin.taskRemoveCancellationHandler(record: record) }
 
   return try await operation()
 }
@@ -163,15 +163,3 @@ public struct CancellationError: Error {
   // no extra information, cancellation is intended to be light-weight
   public init() {}
 }
-
-@usableFromInline
-@available(SwiftStdlib 5.1, *)
-@_silgen_name("swift_task_addCancellationHandler")
-func _taskAddCancellationHandler(handler: () -> Void) -> UnsafeRawPointer /*CancellationNotificationStatusRecord*/
-
-@usableFromInline
-@available(SwiftStdlib 5.1, *)
-@_silgen_name("swift_task_removeCancellationHandler")
-func _taskRemoveCancellationHandler(
-  record: UnsafeRawPointer /*CancellationNotificationStatusRecord*/
-)

stdlib/public/Concurrency/TaskLocal.swift

@@ -235,22 +235,22 @@ public final class TaskLocal<Value: Sendable>: Sendable, CustomStringConvertible
 
   /// Implementation for withValue that consumes valueDuringOperation.
   ///
-  /// Because _taskLocalValuePush and _taskLocalValuePop involve calls to
-  /// swift_task_alloc/swift_task_dealloc respectively unbeknownst to the
-  /// compiler, compiler-emitted calls to swift_task_de/alloc must be avoided
-  /// in a function that calls them.
+  /// Because Builtin.taskLocalValuePush and Builtin.taskLocalValuePop involve
+  /// calls to swift_task_alloc/swift_task_dealloc respectively unbeknownst to
+  /// the compiler, compiler-emitted calls to swift_task_de/alloc must be
+  /// avoided in a function that calls them.
   ///
   /// A copy of valueDuringOperation is required because withValue borrows its
-  /// argument but _taskLocalValuePush consumes its.  Because
+  /// argument but Builtin.taskLocalValuePush consumes its.  Because
   /// valueDuringOperation is of generic type, its size is not generally known,
   /// so such a copy entails a stack allocation and a copy to that allocation.
   /// That stack traffic gets lowered to calls to
   /// swift_task_alloc/swift_task_deallloc.
   ///
-  /// Split the calls _taskLocalValuePush/Pop from the compiler-emitted calls
+  /// Split the calls Builtin.taskLocalValuePush/Pop from the compiler-emitted calls
   /// to swift_task_de/alloc for the copy as follows:
   /// - withValue contains the compiler-emitted calls swift_task_de/alloc.
-  /// - withValueImpl contains the calls to _taskLocalValuePush/Pop
+  /// - withValueImpl contains the calls to Builtin.taskLocalValuePush/Pop
   @inlinable
   @discardableResult
   @available(SwiftStdlib 5.1, *)
@@ -259,8 +259,8 @@ public final class TaskLocal<Value: Sendable>: Sendable, CustomStringConvertible
                                  operation: () async throws -> R,
                                  isolation: isolated (any Actor)?,
                                  file: String = #fileID, line: UInt = #line) async rethrows -> R {
-    _taskLocalValuePush(key: key, value: consume valueDuringOperation)
-    defer { _taskLocalValuePop() }
+    Builtin.taskLocalValuePush(key, consume valueDuringOperation)
+    defer { Builtin.taskLocalValuePop() }
 
     return try await operation()
   }
@@ -275,8 +275,8 @@ public final class TaskLocal<Value: Sendable>: Sendable, CustomStringConvertible
     operation: () async throws -> R,
     file: String = #fileID, line: UInt = #line
   ) async rethrows -> R {
-    _taskLocalValuePush(key: key, value: consume valueDuringOperation)
-    defer { _taskLocalValuePop() }
+    Builtin.taskLocalValuePush(key, consume valueDuringOperation)
+    defer { Builtin.taskLocalValuePop() }
 
     return try await operation()
   }
@@ -299,8 +299,8 @@ public final class TaskLocal<Value: Sendable>: Sendable, CustomStringConvertible
   @discardableResult
   public func withValue<R>(_ valueDuringOperation: Value, operation: () throws -> R,
                            file: String = #fileID, line: UInt = #line) rethrows -> R {
-    _taskLocalValuePush(key: key, value: valueDuringOperation)
-    defer { _taskLocalValuePop() }
+    Builtin.taskLocalValuePush(key, valueDuringOperation)
+    defer { Builtin.taskLocalValuePop() }
 
     return try operation()
   }
@@ -344,19 +344,6 @@ public final class TaskLocal<Value: Sendable>: Sendable, CustomStringConvertible
 
 // ==== ------------------------------------------------------------------------
 
-@available(SwiftStdlib 5.1, *)
-@usableFromInline
-@_silgen_name("swift_task_localValuePush")
-func _taskLocalValuePush<Value>(
-  key: Builtin.RawPointer/*: Key*/,
-  value: __owned Value
-) // where Key: TaskLocal
-
-@available(SwiftStdlib 5.1, *)
-@usableFromInline
-@_silgen_name("swift_task_localValuePop")
-func _taskLocalValuePop()
-
 @available(SwiftStdlib 5.1, *)
 @_silgen_name("swift_task_localValueGet")
 func _taskLocalValueGet(

stdlib/public/Observation/Sources/Observation/Observations.swift

@@ -11,31 +11,6 @@
 
 import _Concurrency
 
-@usableFromInline
-@available(SwiftStdlib 5.1, *)
-@_silgen_name("swift_task_addCancellationHandler")
-func _taskAddCancellationHandler(handler: () -> Void) -> UnsafeRawPointer /*CancellationNotificationStatusRecord*/
-
-@usableFromInline
-@available(SwiftStdlib 5.1, *)
-@_silgen_name("swift_task_removeCancellationHandler")
-func _taskRemoveCancellationHandler(
-  record: UnsafeRawPointer /*CancellationNotificationStatusRecord*/
-)
-
-func withIsolatedTaskCancellationHandler<T: Sendable>(
-  operation: @isolated(any) () async throws -> T,
-  onCancel handler: @Sendable () -> Void,
-  isolation: isolated (any Actor)? = #isolation
-) async rethrows -> T {
-  // unconditionally add the cancellation record to the task.
-  // if the task was already cancelled, it will be executed right away.
-  let record = _taskAddCancellationHandler(handler: handler)
-  defer { _taskRemoveCancellationHandler(record: record) }
-
-  return try await operation()
-}
-
 /// An asychronous sequence generated from a closure that tracks the transactional changes of `@Observable` types.
 ///
 /// `Observations` conforms to `AsyncSequence`, providing a intutive and safe mechanism to track changes to
@@ -260,7 +235,7 @@ public struct Observations<Element: Sendable, Failure: Error>: AsyncSequence, Se
           // this will mean our next await for the emission will ensure the suspension return of the willChange context
           // back to the trailing edges of the mutations. In short, this enables the transactionality bounded by the
           // isolation of the mutation.
-          await withIsolatedTaskCancellationHandler(operation: {
+          await withTaskCancellationHandler(operation: {
             await State.willChange(isolation: iterationIsolation, state: state, id: id)
           }, onCancel: {
             // ensure to clean out our continuation uon cancellation