[TaskExecutor] Remove underscore from new APIs (#71145)

Author: ktoso

include/swift/AST/ASTSynthesis.h

@@ -50,7 +50,7 @@ enum SingletonTypeSynthesizer {
   _void,
   _word,
   _serialExecutor, // the '_Concurrency.SerialExecutor' protocol
-  _taskExecutor,   // the '_Concurrency._TaskExecutor' protocol
+  _taskExecutor,   // the '_Concurrency.TaskExecutor' protocol
 };
 inline Type synthesizeType(SynthesisContext &SC,
                            SingletonTypeSynthesizer kind) {
@@ -71,7 +71,7 @@ inline Type synthesizeType(SynthesisContext &SC,
     return SC.Context.getProtocol(KnownProtocolKind::SerialExecutor)
       ->getDeclaredInterfaceType();
   case _taskExecutor:
-    return SC.Context.getProtocol(KnownProtocolKind::_TaskExecutor)
+    return SC.Context.getProtocol(KnownProtocolKind::TaskExecutor)
       ->getDeclaredInterfaceType();
   }
 }

include/swift/AST/KnownProtocols.def

@@ -86,7 +86,7 @@ PROTOCOL(FixedWidthInteger)
 PROTOCOL(RangeReplaceableCollection)
 PROTOCOL(Executor)
 PROTOCOL(SerialExecutor)
-PROTOCOL(_TaskExecutor)
+PROTOCOL(TaskExecutor)
 PROTOCOL(GlobalActor)
 
 PROTOCOL_(BridgedNSError)

include/swift/AST/KnownSDKTypes.def

@@ -44,7 +44,7 @@ KNOWN_SDK_TYPE_DECL(Concurrency, Job, StructDecl, 0) // legacy type; prefer Exec
 KNOWN_SDK_TYPE_DECL(Concurrency, ExecutorJob, StructDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, UnownedJob, StructDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, Executor, NominalTypeDecl, 0)
-KNOWN_SDK_TYPE_DECL(Concurrency, _TaskExecutor, NominalTypeDecl, 0)
+KNOWN_SDK_TYPE_DECL(Concurrency, TaskExecutor, NominalTypeDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, SerialExecutor, NominalTypeDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, UnownedSerialExecutor, NominalTypeDecl, 0)
 

include/swift/Demangling/StandardTypesMangling.def

@@ -88,7 +88,7 @@ STANDARD_TYPE_CONCURRENCY(Protocol, F, Executor)
 STANDARD_TYPE_CONCURRENCY(Protocol, f, SerialExecutor)
 STANDARD_TYPE_CONCURRENCY(Structure, G, TaskGroup)
 STANDARD_TYPE_CONCURRENCY(Structure, g, ThrowingTaskGroup)
-STANDARD_TYPE_CONCURRENCY(Protocol, h, _TaskExecutor)
+STANDARD_TYPE_CONCURRENCY(Protocol, h, TaskExecutor)
 STANDARD_TYPE_CONCURRENCY(Protocol, I, AsyncIteratorProtocol)
 STANDARD_TYPE_CONCURRENCY(Protocol, i, AsyncSequence)
 STANDARD_TYPE_CONCURRENCY(Structure, J, UnownedJob)

lib/AST/ASTContext.cpp

@@ -1218,7 +1218,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::AsyncSequence:
   case KnownProtocolKind::AsyncIteratorProtocol:
   case KnownProtocolKind::Executor:
-  case KnownProtocolKind::_TaskExecutor:
+  case KnownProtocolKind::TaskExecutor:
   case KnownProtocolKind::SerialExecutor:
     M = getLoadedModule(Id_Concurrency);
     break;

lib/IRGen/GenMeta.cpp

@@ -6574,7 +6574,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::UnsafeCxxMutableRandomAccessIterator:
   case KnownProtocolKind::Executor:
   case KnownProtocolKind::SerialExecutor:
-  case KnownProtocolKind::_TaskExecutor:
+  case KnownProtocolKind::TaskExecutor:
   case KnownProtocolKind::Sendable:
   case KnownProtocolKind::UnsafeSendable:
   case KnownProtocolKind::RangeReplaceableCollection:

lib/Sema/TypeCheckConcurrency.cpp

@@ -1389,7 +1389,7 @@ void swift::tryDiagnoseExecutorConformance(ASTContext &C,
                                            ProtocolDecl *proto) {
   assert(proto->isSpecificProtocol(KnownProtocolKind::Executor) ||
          proto->isSpecificProtocol(KnownProtocolKind::SerialExecutor) ||
-         proto->isSpecificProtocol(KnownProtocolKind::_TaskExecutor));
+         proto->isSpecificProtocol(KnownProtocolKind::TaskExecutor));
 
   auto &diags = C.Diags;
   auto module = nominal->getParentModule();

stdlib/public/Concurrency/Actor.cpp

@@ -1450,8 +1450,8 @@ static void defaultActorDrain(DefaultActorImpl *actor) {
   ExecutorTrackingInfo trackingInfo;
   trackingInfo.enterAndShadow(
       SerialExecutorRef::forDefaultActor(asAbstract(currentActor)),
-      /*taskExecutor, will be replaced per each job. */ TaskExecutorRef::
-          undefined());
+      /*taskExecutor, will be replaced per each job. */
+      TaskExecutorRef::undefined());
 
   while (true) {
     if (shouldYieldThread()) {

stdlib/public/Concurrency/Executor.swift

@@ -113,15 +113,15 @@ public protocol SerialExecutor: Executor {
 /// requirements.
 ///
 /// By setting a task executor preference, either with a
-/// ``_withTaskExecutorPreference(_:operation:)``, creating a task with a preference
-/// (`Task(_executorPreference:)`, or `group.addTask(executorPreference:)`), the task and all of its child
+/// ``withTaskExecutorPreference(_:operation:)``, creating a task with a preference
+/// (`Task(executorPreference:)`, or `group.addTask(executorPreference:)`), the task and all of its child
 /// tasks (unless a new preference is set) will be preferring to execute on
 /// the provided task executor.
 ///
 /// Unstructured tasks do not inherit the task executor.
 @_unavailableInEmbedded
 @available(SwiftStdlib 9999, *)
-public protocol _TaskExecutor: Executor {
+public protocol TaskExecutor: Executor {
   // This requirement is repeated here as a non-override so that we
   // get a redundant witness-table entry for it.  This allows us to
   // avoid drilling down to the base conformance just for the basic
@@ -153,7 +153,7 @@ public protocol _TaskExecutor: Executor {
 
 @_unavailableInEmbedded
 @available(SwiftStdlib 9999, *)
-extension _TaskExecutor {
+extension TaskExecutor {
   public func asUnownedTaskExecutor() -> UnownedTaskExecutor {
     UnownedTaskExecutor(ordinary: self)
   }
@@ -293,7 +293,7 @@ public struct UnownedTaskExecutor: Sendable {
   }
 
   @inlinable
-  public init<E: _TaskExecutor>(ordinary executor: __shared E) {
+  public init<E: TaskExecutor>(ordinary executor: __shared E) {
     #if $BuiltinBuildTaskExecutor
     self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
     #else
@@ -375,7 +375,7 @@ internal func _task_serialExecutor_getExecutorRef<E>(_ executor: E) -> Builtin.E
 @_unavailableInEmbedded
 @available(SwiftStdlib 9999, *)
 @_silgen_name("_task_executor_getTaskExecutorRef")
-internal func _task_executor_getTaskExecutorRef(_ taskExecutor: any _TaskExecutor) -> Builtin.Executor {
+internal func _task_executor_getTaskExecutorRef(_ taskExecutor: any TaskExecutor) -> Builtin.Executor {
   return taskExecutor.asUnownedTaskExecutor().executor
 }
 
@@ -398,7 +398,7 @@ where E: SerialExecutor {
 @_unavailableInEmbedded
 @available(SwiftStdlib 9999, *)
 @_silgen_name("_swift_task_enqueueOnTaskExecutor")
-internal func _enqueueOnTaskExecutor<E>(job unownedJob: UnownedJob, executor: E) where E: _TaskExecutor {
+internal func _enqueueOnTaskExecutor<E>(job unownedJob: UnownedJob, executor: E) where E: TaskExecutor {
   #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   executor.enqueue(ExecutorJob(context: unownedJob._context))
   #else // SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY

stdlib/public/Concurrency/GlobalConcurrentExecutor.swift

@@ -13,7 +13,7 @@
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
-// None of _TaskExecutor APIs are available in task-to-thread concurrency model.
+// None of TaskExecutor APIs are available in task-to-thread concurrency model.
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
 /// The global concurrent executor that is used by default for Swift Concurrency
@@ -27,13 +27,13 @@ import Swift
 /// You may pass this executor explicitly to a ``Task`` initializer as a task
 /// executor preference, in order to ensure and document that task be executed
 /// on the global executor, instead e.g. inheriting the enclosing actor's
-/// executor. Refer to ``_withTaskExecutorPreference(_:operation:)`` for a
+/// executor. Refer to ``withTaskExecutorPreference(_:operation:)`` for a
 /// detailed discussion of task executor preferences.
 ///
 /// Customizing the global concurrent executor is currently not supported.
 @available(SwiftStdlib 9999, *)
 nonisolated(unsafe)
-public var globalConcurrentExecutor: any _TaskExecutor {
+public var globalConcurrentExecutor: any TaskExecutor {
   get {
     _DefaultGlobalConcurrentExecutor.shared
   }
@@ -45,7 +45,7 @@ public var globalConcurrentExecutor: any _TaskExecutor {
 /// thread pool that is used as the default executor for Swift concurrency
 /// tasks.
 @available(SwiftStdlib 9999, *)
-internal final class _DefaultGlobalConcurrentExecutor: _TaskExecutor {
+internal final class _DefaultGlobalConcurrentExecutor: TaskExecutor {
   public static let shared: _DefaultGlobalConcurrentExecutor = .init()
 
   private init() {}

stdlib/public/Concurrency/Task+TaskExecutor.swift

@@ -13,17 +13,17 @@
 import Swift
 @_implementationOnly import _SwiftConcurrencyShims
 
-// None of _TaskExecutor APIs are available in task-to-thread concurrency model.
+// None of TaskExecutor APIs are available in task-to-thread concurrency model.
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
-/// Configure the current task hierarchy's task executor preference to the passed ``_TaskExecutor``,
+/// Configure the current task hierarchy's task executor preference to the passed ``TaskExecutor``,
 /// and execute the passed in closure by immediately hopping to that executor.
 ///
 /// ### Task executor preference semantics
 /// Task executors influence _where_ nonisolated asynchronous functions, and default actor methods execute.
 /// The preferred executor will be used whenever possible, rather than hopping to the global concurrent pool.
 ///
-/// For an in depth discussion of this topic, see ``_TaskExecutor``.
+/// For an in depth discussion of this topic, see ``TaskExecutor``.
 ///
 /// ### Disabling task executor preference
 /// Passing `nil` as executor means disabling any preference preference (if it was set) and the task hierarchy
@@ -126,12 +126,12 @@ import Swift
 ///   - operation: the operation to execute on the passed executor
 /// - Returns: the value returned from the `operation` closure
 /// - Throws: if the operation closure throws
-/// - SeeAlso: ``_TaskExecutor``
+/// - SeeAlso: ``TaskExecutor``
 @_unavailableInEmbedded
 @available(SwiftStdlib 9999, *)
 @_unsafeInheritExecutor // calling withTaskExecutor MUST NOT perform the "usual" hop to global
-public func _withTaskExecutorPreference<T: Sendable>(
-  _ taskExecutor: (any _TaskExecutor)?,
+public func withTaskExecutorPreference<T: Sendable>(
+  _ taskExecutor: (any TaskExecutor)?,
   operation: @Sendable () async throws -> T
   ) async rethrows -> T {
   guard let taskExecutor else {
@@ -166,9 +166,9 @@ extension Task where Failure == Never {
   /// Runs the given nonthrowing operation asynchronously
   /// as part of a new top-level task on behalf of the current actor.
   ///
-  /// This overload allows specifying a preferred ``_TaskExecutor`` on which
+  /// This overload allows specifying a preferred ``TaskExecutor`` on which
   /// the `operation`, as well as all child tasks created from this task will be
-  /// executing whenever possible. Refer to ``_TaskExecutor`` for a detailed discussion
+  /// executing whenever possible. Refer to ``TaskExecutor`` for a detailed discussion
   /// of the effect of task executors on execution semantics of asynchronous code.
   ///
   /// Use this function when creating asynchronous work
@@ -194,11 +194,11 @@ extension Task where Failure == Never {
   ///   - priority: The priority of the task.
   ///     Pass `nil` to use the priority from `Task.currentPriority`.
   ///   - operation: The operation to perform.
-  /// - SeeAlso: ``_withTaskExecutorPreference(_:operation:)``
+  /// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
   @discardableResult
   @_alwaysEmitIntoClient
   public init(
-    _executorPreference taskExecutor: (any _TaskExecutor)?,
+    executorPreference taskExecutor: (any TaskExecutor)?,
     priority: TaskPriority? = nil,
     operation: __owned @Sendable @escaping () async -> Success
   ) {
@@ -255,11 +255,11 @@ extension Task where Failure == Error {
   ///   - priority: The priority of the task.
   ///     Pass `nil` to use the priority from `Task.currentPriority`.
   ///   - operation: The operation to perform.
-  /// - SeeAlso: ``_withTaskExecutorPreference(_:operation:)``
+  /// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
   @discardableResult
   @_alwaysEmitIntoClient
   public init(
-    _executorPreference taskExecutor: (any _TaskExecutor)?,
+    executorPreference taskExecutor: (any TaskExecutor)?,
     priority: TaskPriority? = nil,
     operation: __owned @Sendable @escaping () async throws -> Success
   ) {
@@ -314,11 +314,11 @@ extension Task where Failure == Never {
   ///     Pass `nil` to use the priority from `Task.currentPriority`.
   ///   - operation: The operation to perform.
   /// - Returns: A reference to the newly created task.
-  /// - SeeAlso: ``_withTaskExecutorPreference(_:operation:)``
+  /// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
   @discardableResult
   @_alwaysEmitIntoClient
-  public static func _detached(
-    _executorPreference taskExecutor: (any _TaskExecutor)?,
+  public static func detached(
+    executorPreference taskExecutor: (any TaskExecutor)?,
     priority: TaskPriority? = nil,
     operation: __owned @Sendable @escaping () async -> Success
   ) -> Task<Success, Failure> {
@@ -373,11 +373,11 @@ extension Task where Failure == Error {
   ///     Pass `nil` to use the priority from `Task.currentPriority`.
   ///   - operation: The operation to perform.
   /// - Returns: A reference to the newly created task.
-  /// - SeeAlso: ``_withTaskExecutorPreference(_:operation:)``
+  /// - SeeAlso: ``withTaskExecutorPreference(_:operation:)``
   @discardableResult
   @_alwaysEmitIntoClient
-  public static func _detached(
-    _executorPreference taskExecutor: (any _TaskExecutor)?,
+  public static func detached(
+    executorPreference taskExecutor: (any TaskExecutor)?,
     priority: TaskPriority? = nil,
     operation: __owned @Sendable @escaping () async throws -> Success
   ) -> Task<Success, Failure> {
@@ -410,15 +410,15 @@ extension Task where Failure == Error {
 @available(SwiftStdlib 9999, *)
 extension UnsafeCurrentTask {
 
-  /// The current ``_TaskExecutor`` preference, if this task has one configured.
+  /// The current ``TaskExecutor`` preference, if this task has one configured.
   ///
   /// The executor may be used to compare for equality with an expected executor preference.
   ///
   /// The lifetime of an executor is not guaranteed by an ``UnownedTaskExecutor``,
   /// so accessing it must be handled with great case -- and the program must use other
   /// means to guarantee the executor remains alive while it is in use.
   @available(SwiftStdlib 9999, *)
-  public var _unownedTaskExecutor: UnownedTaskExecutor? {
+  public var unownedTaskExecutor: UnownedTaskExecutor? {
     let ref = _getPreferredTaskExecutor()
     return UnownedTaskExecutor(ref)
   }