Merge pull request #85312 from al45tair/concurrency-6.3-not-6.2

[Concurrency] Change all of the StdlibDeploymentTarget 6.2s to 6.3.

Author: al45tair

stdlib/public/Concurrency/Clock.swift

@@ -190,7 +190,7 @@ internal func _getClockRes(
   nanoseconds: UnsafeMutablePointer<Int64>,
   clock: CInt)
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 @_silgen_name("swift_sleep")
 internal func _sleep(
   seconds: Int64,

stdlib/public/Concurrency/ContinuousClock.swift

@@ -113,7 +113,7 @@ extension ContinuousClock: Clock {
   public func sleep(
     until deadline: Instant, tolerance: Swift.Duration? = nil
   ) async throws {
-    if #available(StdlibDeploymentTarget 6.2, *) {
+    if #available(StdlibDeploymentTarget 6.3, *) {
       try await Task._sleep(until: deadline,
                             tolerance: tolerance,
                             clock: self)

stdlib/public/Concurrency/CooperativeExecutor.swift

@@ -17,7 +17,7 @@ import Swift
 // Store the Timestamp in the executor private data, if it will fit; otherwise,
 // use the allocator to allocate space for it and stash a pointer in the private
 // data area.
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension ExecutorJob {
   fileprivate var cooperativeExecutorTimestampIsIndirect: Bool {
     return MemoryLayout<(Int, Int)>.size
@@ -99,7 +99,7 @@ extension ExecutorJob {
 
 #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 /// A wait queue is a specialised priority queue used to run a timer.
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 struct WaitQueue {
   var queue: PriorityQueue<UnownedJob>
   var clock: _ClockID
@@ -157,7 +157,7 @@ struct WaitQueue {
 
 /// A co-operative executor that can be used as the main executor or as a
 /// task executor.
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 final class CooperativeExecutor: Executor, @unchecked Sendable {
   var runQueue: PriorityQueue<UnownedJob>
   #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
@@ -282,7 +282,7 @@ extension CooperativeExecutor: SchedulingExecutor {
 }
 #endif
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension CooperativeExecutor: RunLoopExecutor {
   public func run() throws {
     try runUntil { false }
@@ -340,13 +340,13 @@ extension CooperativeExecutor: RunLoopExecutor {
   }
 }
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension CooperativeExecutor: SerialExecutor {}
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension CooperativeExecutor: TaskExecutor {}
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension CooperativeExecutor: MainExecutor {}
 
 #endif // !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY

stdlib/public/Concurrency/Executor.swift

@@ -38,7 +38,7 @@ public protocol Executor: AnyObject, Sendable {
 
   #if os(WASI) || !$Embedded
   /// `true` if this is the main executor.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   var isMainExecutor: Bool { get }
   #endif // os(WASI) || !$Embedded
 
@@ -49,12 +49,12 @@ public protocol Executor: AnyObject, Sendable {
   /// Executors that implement SchedulingExecutor should provide their
   /// own copy of this method, which will allow the compiler to avoid a
   /// potentially expensive runtime cast.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   var asSchedulingExecutor: (any SchedulingExecutor)? { get }
   #endif
 }
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 public protocol SchedulingExecutor: Executor {
 
   #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
@@ -74,7 +74,7 @@ public protocol SchedulingExecutor: Executor {
   /// - tolerance: The maximum additional delay permissible before the
   ///              job is executed.  `nil` means no limit.
   /// - clock:     The clock used for the delay.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   func enqueue<C: Clock>(_ job: consuming ExecutorJob,
                          after delay: C.Duration,
                          tolerance: C.Duration?,
@@ -94,7 +94,7 @@ public protocol SchedulingExecutor: Executor {
   /// - tolerance: The maximum additional delay permissible before the
   ///              job is executed.  `nil` means no limit.
   /// - clock:     The clock used for the delay.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   func enqueue<C: Clock>(_ job: consuming ExecutorJob,
                          at instant: C.Instant,
                          tolerance: C.Duration?,
@@ -138,7 +138,7 @@ extension Executor {
   /// Executors that implement SchedulingExecutor should provide their
   /// own copy of this method, which will allow the compiler to avoid a
   /// potentially expensive runtime cast.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public var asSchedulingExecutor: (any SchedulingExecutor)? {
     return self as? SchedulingExecutor
   }
@@ -162,19 +162,19 @@ extension Executor {
   #if os(WASI) || !$Embedded
   // This defaults to `false` so that existing third-party Executor
   // implementations will work as expected.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public var isMainExecutor: Bool { false }
   #endif // os(WASI) || !$Embedded
 
 }
 
 // Delay support
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension SchedulingExecutor {
 
   #if !$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public func enqueue<C: Clock>(_ job: consuming ExecutorJob,
                                 after delay: C.Duration,
                                 tolerance: C.Duration? = nil,
@@ -185,7 +185,7 @@ extension SchedulingExecutor {
             tolerance: tolerance, clock: clock)
   }
 
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public func enqueue<C: Clock>(_ job: consuming ExecutorJob,
                                 at instant: C.Instant,
                                 tolerance: C.Duration? = nil,
@@ -383,7 +383,7 @@ public protocol SerialExecutor: Executor {
 extension SerialExecutor {
 
   #if os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public var isMainExecutor: Bool { return MainActor.executor._isSameExecutor(self) }
   #endif // os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
 
@@ -397,13 +397,13 @@ extension SerialExecutor {
   }
 
   #if SWIFT_CONCURRENCY_USES_DISPATCH
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   private var _dispatchQueue: OpaquePointer? {
     return unsafe _getDispatchQueueForExecutor(self.asUnownedSerialExecutor())
   }
   #endif
 
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   internal func _isSameExecutor(_ rhs: some SerialExecutor) -> Bool {
     if rhs === self {
       return true
@@ -526,10 +526,10 @@ extension SerialExecutor {
 
 }
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension SerialExecutor where Self: Equatable {
 
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public func isSameExclusiveExecutionContext(other: Self) -> Bool {
     return self == other
   }
@@ -541,7 +541,7 @@ extension SerialExecutor where Self: Equatable {
 /// The idea here is that some executors may work by running a loop
 /// that processes events of some sort; we want a way to enter that loop,
 /// and we would also like a way to trigger the loop to exit.
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 public protocol RunLoopExecutor: Executor {
   /// Run the executor's run loop.
   ///
@@ -572,7 +572,7 @@ public protocol RunLoopExecutor: Executor {
   func stop()
 }
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 extension RunLoopExecutor {
 
   public func runUntil(_ condition: () -> Bool) throws {
@@ -584,14 +584,14 @@ extension RunLoopExecutor {
 
 /// The main executor must conform to these two protocols; we have to
 /// make this a protocol for compatibility with Embedded Swift.
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 public protocol MainExecutor: RunLoopExecutor, SerialExecutor {
 }
 
 
 /// An ExecutorFactory is used to create the default main and task
 /// executors.
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 public protocol ExecutorFactory {
   #if os(WASI) || !$Embedded
   /// Constructs and returns the main executor, which is started implicitly
@@ -607,7 +607,7 @@ public protocol ExecutorFactory {
 @available(StdlibDeploymentTarget 6.3, *)
 typealias DefaultExecutorFactory = PlatformExecutorFactory
 
-@available(StdlibDeploymentTarget 6.2, *)
+@available(StdlibDeploymentTarget 6.3, *)
 @_silgen_name("swift_createExecutors")
 public func _createExecutors<F: ExecutorFactory>(factory: F.Type) {
   #if os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
@@ -626,23 +626,23 @@ func _createDefaultExecutors() {
 
 #if os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
 extension MainActor {
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   static var _executor: (any MainExecutor)? = nil
 
   /// The main executor, which is started implicitly by the `async main`
   /// entry point and owns the "main" thread.
   ///
   /// Attempting to set this after the first `enqueue` on the main
   /// executor is a fatal error.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public static var executor: any MainExecutor {
     // It would be good if there was a Swift way to do this
     _createDefaultExecutorsOnce()
     return _executor!
   }
 
   /// An unowned version of the above, for performance
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   static var unownedExecutor: UnownedSerialExecutor {
     _createDefaultExecutorsOnce()
     return unsafe UnownedSerialExecutor(ordinary: _executor!)
@@ -651,23 +651,23 @@ extension MainActor {
 #endif // os(WASI) || (!$Embedded && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
 
 extension Task where Success == Never, Failure == Never {
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   static var _defaultExecutor: (any TaskExecutor)? = nil
 
   /// The default or global executor, which is the default place in which
   /// we run tasks.
   ///
   /// Attempting to set this after the first `enqueue` on the global
   /// executor is a fatal error.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public static var defaultExecutor: any TaskExecutor {
     // It would be good if there was a Swift way to do this
     _createDefaultExecutorsOnce()
     return _defaultExecutor!
   }
 
   /// An unowned version of the above, for performance
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   static var unownedDefaultExecutor: UnownedTaskExecutor {
     _createDefaultExecutorsOnce()
     return unsafe UnownedTaskExecutor(_defaultExecutor!)
@@ -686,7 +686,7 @@ extension Task where Success == Never, Failure == Never {
   ///   3. The task executor for the current thread
   ///
   ///  If none of these exist, returns the default executor.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   @_unavailableInEmbedded
   public static var currentExecutor: any Executor {
     if let activeExecutor = unsafe _getActiveExecutor().asSerialExecutor() {
@@ -700,7 +700,7 @@ extension Task where Success == Never, Failure == Never {
   }
 
   /// Get the preferred executor for the current `Task`, if any.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public static var preferredExecutor: (any TaskExecutor)? {
     if let taskExecutor = unsafe _getPreferredTaskExecutor().asTaskExecutor() {
       return taskExecutor
@@ -713,7 +713,7 @@ extension Task where Success == Never, Failure == Never {
   ///
   /// This follows the same logic as `currentExecutor`, except that it ignores
   /// any executor that isn't a `SchedulingExecutor`.
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public static var currentSchedulingExecutor: (any SchedulingExecutor)? {
     if let activeExecutor = unsafe _getActiveExecutor().asSerialExecutor(),
        let scheduling = activeExecutor.asSchedulingExecutor {
@@ -806,7 +806,7 @@ public struct UnownedSerialExecutor: Sendable {
     unsafe _executor_isComplexEquality(self)
   }
 
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public func asSerialExecutor() -> (any SerialExecutor)? {
     // The low bits of the witness table are used to encode the executor kind.
     // any SerialExecutor needs a raw witness table pointer, so mask off the low
@@ -843,13 +843,13 @@ public struct UnownedTaskExecutor: Sendable {
     unsafe self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
   }
 
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   @inlinable
   public init<E: TaskExecutor>(_ executor: __shared E) {
     unsafe self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor)
   }
 
-  @available(StdlibDeploymentTarget 6.2, *)
+  @available(StdlibDeploymentTarget 6.3, *)
   public func asTaskExecutor() -> (any TaskExecutor)? {
     return unsafe unsafeBitCast(executor, to: (any TaskExecutor)?.self)
   }