move back to Task.ID

Author: ktoso

benchmark/CMakeLists.txt

@@ -211,7 +211,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Suffix
     single-source/SuperChars
     single-source/TaskGroups
-    single-source/TaskIdentifier
+    single-source/TaskID
     single-source/TaskLocalGet
     single-source/ToddCoxeter
     single-source/TwoSum

…hmark/single-source/TaskIdentifier.swift benchmark/single-source/TaskID.swiftbenchmark/single-source/TaskIdentifier.swift renamed to benchmark/single-source/TaskID.swift benchmark/single-source/TaskIdentifier.swift renamed to benchmark/single-source/TaskID.swift

@@ -1,4 +1,4 @@
-//===--- TaskIdentifier.swift ---------------------------------------------===//
+//===--- TaskID.swift -----------------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// Measures the cost of reading the current Task's identity.
+// Measures the cost of reading the current Task's ID.
 
 import TestsUtils
 
@@ -20,40 +20,40 @@ public var benchmarks: [BenchmarkInfo] {
   }
   return [
     BenchmarkInfo(
-      name: "TaskIdentifier.currentIdentifier",
-      runFunction: run_TaskIdentifier_currentIdentifier,
+      name: "TaskID.currentID",
+      runFunction: run_TaskID_currentID,
       tags: [.concurrency]
     ),
     BenchmarkInfo(
-      name: "TaskIdentifier.withUnsafeCurrentTask.identifier",
-      runFunction: run_TaskIdentifier_withUnsafeCurrentTask,
+      name: "TaskID.withUnsafeCurrentTask.id",
+      runFunction: run_TaskID_withUnsafeCurrentTask,
       tags: [.concurrency]
     ),
     BenchmarkInfo(
-      name: "TaskIdentifier.directBuiltins",
-      runFunction: run_TaskIdentifier_directBuiltins,
+      name: "TaskID.directBuiltins",
+      runFunction: run_TaskID_directBuiltins,
       tags: [.concurrency]
     ),
   ]
 }
 
 // Direct accessor: single runtime call, no closure, no ARC on the task.
 @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
-private func run_TaskIdentifier_currentIdentifier(_ n: Int) async {
+private func run_TaskID_currentID(_ n: Int) async {
   for _ in 0..<n {
     for _ in 0..<10_000 {
-      blackHole(Task.currentIdentifier)
+      blackHole(Task.currentID)
     }
   }
 }
 
 // Equivalent shape built on withUnsafeCurrentTask.
 @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
-private func run_TaskIdentifier_withUnsafeCurrentTask(_ n: Int) async {
+private func run_TaskID_withUnsafeCurrentTask(_ n: Int) async {
   for _ in 0..<n {
     for _ in 0..<10_000 {
       withUnsafeCurrentTask { task in
-        blackHole(task?.identifier)
+        blackHole(task?.id)
       }
     }
   }
@@ -75,7 +75,7 @@ private let _bench_swift_task_getJobTaskId: _GetJobTaskIdFn = unsafeBitCast(
 )
 
 @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
-private func run_TaskIdentifier_directBuiltins(_ n: Int) async {
+private func run_TaskID_directBuiltins(_ n: Int) async {
   for _ in 0..<n {
     for _ in 0..<10_000 {
       if let task = _bench_swift_task_getCurrent() {
@@ -88,5 +88,5 @@ private func run_TaskIdentifier_directBuiltins(_ n: Int) async {
 }
 #else
 @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
-private func run_TaskIdentifier_directBuiltins(_ n: Int) async {}
+private func run_TaskID_directBuiltins(_ n: Int) async {}
 #endif

benchmark/utils/main.swift

@@ -216,7 +216,7 @@ import SubstringTest
 import Suffix
 import SuperChars
 import TaskGroups
-import TaskIdentifier
+import TaskID
 import TaskLocalGet
 import ToddCoxeter
 import TwoSum
@@ -434,7 +434,7 @@ register(SubstringTest.benchmarks)
 register(Suffix.benchmarks)
 register(SuperChars.benchmarks)
 register(TaskGroups.benchmarks)
-register(TaskIdentifier.benchmarks)
+register(TaskID.benchmarks)
 register(TaskLocalGet.benchmarks)
 register(ToddCoxeter.benchmarks)
 register(TwoSum.benchmarks)

stdlib/public/Concurrency/Task.swift

@@ -291,23 +291,23 @@ extension Task: Equatable {
 }
 
 // ==== -----------------------------------------------------------------------
-// MARK: Task Identifier
+// MARK: Task ID
 
 /// An opaque, process-unique identifier for a Swift ``Task``.
 ///
-/// A `TaskIdentifier` is assigned at task creation, never changes for the
-/// lifetime of the task, and is never reused once a task has completed.
-/// Identifiers are scoped to the current process and are not suitable for
-/// cross-process correlation.
+/// A `TaskID` is assigned at task creation, never changes for the lifetime
+/// of the task, and is never reused once a task has completed. IDs are
+/// scoped to the current process and are not suitable for cross-process
+/// correlation.
 ///
-/// Reading the identifier of the currently-executing task is fast.
+/// Reading the ID of the currently-executing task is fast.
 ///
-/// - See: ``Task/currentIdentifier``
-/// - See: ``Task/identifier``
-/// - See: ``UnsafeCurrentTask/identifier``
+/// - See: ``Task/currentID``
+/// - See: ``Task/id``
+/// - See: ``UnsafeCurrentTask/id``
 @available(StdlibDeploymentTarget 6.5, *)
 @frozen
-public struct TaskIdentifier: Sendable, Hashable {
+public struct TaskID: Sendable, Hashable {
   @usableFromInline
   internal var _rawValue: UInt64
 
@@ -316,21 +316,21 @@ public struct TaskIdentifier: Sendable, Hashable {
     self._rawValue = _rawValue
   }
 
-  /// The raw 64-bit value of this identifier.
+  /// The raw 64-bit value of this ID.
   ///
   /// This is the only escape hatch from the opaque type and is intended for
   /// serialization, logging, or interop with tools that expect a numeric
   /// task ID. The numeric value carries no semantic meaning beyond the
-  /// guarantees on `TaskIdentifier` itself.
+  /// guarantees on `TaskID` itself.
   @_alwaysEmitIntoClient
   public var rawValue: UInt64 { _rawValue }
 }
 
 @available(StdlibDeploymentTarget 6.5, *)
 extension Task {
-  /// A type alias for ``TaskIdentifier``, providing the spelling
-  /// `Task.Identifier` at the use site.
-  public typealias Identifier = TaskIdentifier
+  /// A type alias for ``TaskID``, providing the spelling
+  /// `Task.ID` at the use site.
+  public typealias ID = TaskID
 }
 
 // ==== Task Priority ----------------------------------------------------------
@@ -482,27 +482,27 @@ extension Task where Success == Never, Failure == Never {
     }
   }
 
-  /// The stable identifier of the currently-executing task.
+  /// The stable ID of the currently-executing task.
   ///
   /// If you access this static property outside the execution context of a
   /// task, it will return `nil`.
   ///
-  /// This identifier is quick to obtain and can be used to reliably identify
-  /// a task, instead of its memory address which may be reused once the task
+  /// This ID is quick to obtain and can be used to reliably identify a
+  /// task, instead of its memory address which may be reused once the task
   /// has been destroyed. No guarantees are made about its exact numeric
   /// value.
   ///
-  /// - SeeAlso: ``Task/identifier``
-  /// - SeeAlso: ``UnsafeCurrentTask/identifier``
+  /// - SeeAlso: ``Task/id``
+  /// - SeeAlso: ``UnsafeCurrentTask/id``
   @available(StdlibDeploymentTarget 6.5, *)
   @_alwaysEmitIntoClient
-  public static var currentIdentifier: Task.Identifier? {
+  public static var currentID: Task.ID? {
     // Direct runtime call: reads the id on the current AsyncTask without
     // ever surfacing the task reference to Swift, so there's no ARC dance.
     // The runtime returns 0 when there is no current task; task IDs are
     // guaranteed to be non-zero.
     let id = _getCurrentTaskId()
-    return id == 0 ? nil : TaskIdentifier(_rawValue: id)
+    return id == 0 ? nil : TaskID(_rawValue: id)
   }
 
 }
@@ -710,22 +710,22 @@ extension Task {
     }
   }
 
-  /// A stable identifier for this task.
+  /// A stable ID for this task.
   ///
-  /// This identifier is quick to obtain and can be used to reliably identify
-  /// a task, instead of its memory address which may be reused once the task
+  /// This ID is quick to obtain and can be used to reliably identify a
+  /// task, instead of its memory address which may be reused once the task
   /// has been destroyed. No guarantees are made about its exact numeric
   /// value.
   ///
-  /// The same identifier is visible in tools such as `swift-inspect` and
+  /// The same ID is visible in tools such as `swift-inspect` and
   /// Instruments, which makes it a convenient correlation key for tracing
   /// and logging.
   ///
-  /// - SeeAlso: ``Task/currentIdentifier``
-  /// - SeeAlso: ``UnsafeCurrentTask/identifier``
+  /// - SeeAlso: ``Task/currentID``
+  /// - SeeAlso: ``UnsafeCurrentTask/id``
   @available(StdlibDeploymentTarget 6.5, *)
   @_alwaysEmitIntoClient
-  public var identifier: Identifier {
+  public var id: ID {
     unsafe .init(
       _rawValue: _getJobTaskId(unsafeBitCast(_task, to: UnownedJob.self)))
   }
@@ -987,21 +987,21 @@ public struct UnsafeCurrentTask {
     }
   }
 
-  /// A stable identifier for the current task.
+  /// A stable ID for the current task.
   ///
-  /// This identifier is quick to obtain and can be used to reliably identify
-  /// a task, instead of its memory address which may be reused once the task
+  /// This ID is quick to obtain and can be used to reliably identify a
+  /// task, instead of its memory address which may be reused once the task
   /// has been destroyed. No guarantees are made about its exact numeric
   /// value.
   ///
-  /// Returns the same value as ``Task/identifier`` read on the owning task.
+  /// Returns the same value as ``Task/id`` read on the owning task.
   ///
-  /// - SeeAlso: ``Task/identifier``
-  /// - SeeAlso: ``Task/currentIdentifier``
+  /// - SeeAlso: ``Task/id``
+  /// - SeeAlso: ``Task/currentID``
   @available(StdlibDeploymentTarget 6.5, *)
   @_alwaysEmitIntoClient
-  public var identifier: Task.Identifier {
-    unsafe TaskIdentifier(
+  public var id: Task.ID {
+    unsafe TaskID(
       _rawValue: _getJobTaskId(unsafeBitCast(_task, to: UnownedJob.self)))
   }
 }

…ency/Runtime/async_task_identifier.swift …/Concurrency/Runtime/async_task_id.swifttest/Concurrency/Runtime/async_task_identifier.swift renamed to test/Concurrency/Runtime/async_task_id.swift test/Concurrency/Runtime/async_task_identifier.swift renamed to test/Concurrency/Runtime/async_task_id.swift

@@ -9,33 +9,33 @@
 @available(SwiftStdlib 6.5, *)
 @main struct Main {
   static func main() async {
-    // Task.currentIdentifier is non-nil inside a task
-    let current = Task.currentIdentifier
+    // Task.currentID is non-nil inside a task
+    let current = Task.currentID
     print("current id is some: \(current != nil)")
     // CHECK: current id is some: true
 
-    // identifier is stable: reading twice yields the same value
-    let first = Task.currentIdentifier
-    let second = Task.currentIdentifier
+    // id is stable: reading twice yields the same value
+    let first = Task.currentID
+    let second = Task.currentID
     print("stable: \(first == second)")
     // CHECK: stable: true
 
-    // UnsafeCurrentTask.identifier agrees with Task.currentIdentifier
+    // UnsafeCurrentTask.id agrees with Task.currentID
     let matchesUnsafe: Bool = withUnsafeCurrentTask { task in
       guard let task else { return false }
-      return task.identifier == Task.currentIdentifier
+      return task.id == Task.currentID
     }
     print("unsafe matches: \(matchesUnsafe)")
     // CHECK: unsafe matches: true
 
-    // Task.Identifier exposes the raw 64-bit value
-    let raw = Task.currentIdentifier?.rawValue ?? 0
+    // Task.ID exposes the raw 64-bit value
+    let raw = Task.currentID?.rawValue ?? 0
     print("raw is non-zero: \(raw != 0)")
     // CHECK: raw is non-zero: true
 
-    // Different child tasks have different identifiers
-    let t1 = Task { Task.currentIdentifier }
-    let t2 = Task { Task.currentIdentifier }
+    // Different child tasks have different IDs
+    let t1 = Task { Task.currentID }
+    let t2 = Task { Task.currentID }
     let id1 = await t1.value
     let id2 = await t2.value
     print("both non-nil: \(id1 != nil && id2 != nil)")

test/abi/macOS/arm64/concurrency.swift

@@ -443,24 +443,24 @@ Added: _$sScT2ids6UInt64VvpMV
 Added: _$sSct2ids6UInt64VvpMV
 Added: _$sScTss5NeverORszABRs_rlE9currentIDs6UInt64VSgvpZMV
 
-// Task.identifier / UnsafeCurrentTask.identifier / Task.currentIdentifier
+// Task.id / UnsafeCurrentTask.id / Task.currentID
 Added: _swift_task_getCurrentTaskId
-Added: _$sScT10identifiers14TaskIdentifierVvpMV
-Added: _$sSct10identifiers14TaskIdentifierVvpMV
-Added: _$sScTss5NeverORszABRs_rlE17currentIdentifiers04TaskC0VSgvpZMV
-
-// TaskIdentifier struct (Sendable, Hashable)
-Added: _$ss14TaskIdentifierVMa
-Added: _$ss14TaskIdentifierVMn
-Added: _$ss14TaskIdentifierVN
-Added: _$ss14TaskIdentifierVSHsMc
-Added: _$ss14TaskIdentifierVSQsMc
-Added: _$ss14TaskIdentifierV2eeoiySbAB_ABtFZ
-Added: _$ss14TaskIdentifierV4hash4intoys6HasherVz_tF
-Added: _$ss14TaskIdentifierV8rawValues6UInt64VvpMV
-Added: _$ss14TaskIdentifierV9hashValueSivg
-Added: _$ss14TaskIdentifierV9hashValueSivpMV
-Added: _$ss14TaskIdentifierV9_rawValues6UInt64Vvg
-Added: _$ss14TaskIdentifierV9_rawValues6UInt64VvM
-Added: _$ss14TaskIdentifierV9_rawValues6UInt64VvpMV
-Added: _$ss14TaskIdentifierV9_rawValues6UInt64Vvs
+Added: _$sScT2ids6TaskIDVvpMV
+Added: _$sSct2ids6TaskIDVvpMV
+Added: _$sScTss5NeverORszABRs_rlE9currentIDs6TaskIDVSgvpZMV
+
+// TaskID struct (Sendable, Hashable)
+Added: _$ss6TaskIDVMa
+Added: _$ss6TaskIDVMn
+Added: _$ss6TaskIDVN
+Added: _$ss6TaskIDVSHsMc
+Added: _$ss6TaskIDVSQsMc
+Added: _$ss6TaskIDV2eeoiySbAB_ABtFZ
+Added: _$ss6TaskIDV4hash4intoys6HasherVz_tF
+Added: _$ss6TaskIDV8rawValues6UInt64VvpMV
+Added: _$ss6TaskIDV9hashValueSivg
+Added: _$ss6TaskIDV9hashValueSivpMV
+Added: _$ss6TaskIDV9_rawValues6UInt64Vvg
+Added: _$ss6TaskIDV9_rawValues6UInt64VvM
+Added: _$ss6TaskIDV9_rawValues6UInt64VvpMV
+Added: _$ss6TaskIDV9_rawValues6UInt64Vvs