[Concurrency] Remove canonicalization code.

I don't think we actually need this.  If you have a non-canonical
(i.e. derived) clock, you can just implement `enqueue` and/or `run`
and call those methods on the clock you're wrapping.

Author: al45tair

stdlib/public/Concurrency/Clock.swift

@@ -34,7 +34,6 @@ import Swift
 public protocol Clock<Duration>: Sendable {
   associatedtype Duration
   associatedtype Instant: InstantProtocol where Instant.Duration == Duration
-  associatedtype CanonicalClock: Clock = Self
 
   var now: Instant { get }
   var minimumResolution: Instant.Duration { get }
@@ -76,58 +75,6 @@ public protocol Clock<Duration>: Sendable {
                on executor: some Executor,
                at instant: Instant, tolerance: Duration?)
 #endif
-
-  /// Obtain the equivalent, canonical clock, or `nil` if this clock
-  /// is already canonical.
-  ///
-  /// A non-canonical clock is a clock with some relationship to a base,
-  /// canonical, clock, to which it can be converted.
-  @available(StdlibDeploymentTarget 6.2, *)
-  var canonicalClock: CanonicalClock? { get }
-
-  /// Convert an Instant to the canonical clock's equivalent Instant.
-  ///
-  /// Parameters:
-  ///
-  /// - instant:    The `Instant` to convert.
-  ///
-  /// Returns:
-  ///
-  /// The equivalent `CanonicalClock.Instant`.
-  func convertToCanonical(instant: Instant) -> CanonicalClock.Instant
-
-  /// Convert a Duration to the canonical clock's equivalent Duration.
-  ///
-  /// Parameters:
-  ///
-  /// - duration:    The `Duration` to convert.
-  ///
-  /// Returns:
-  ///
-  /// The equivalent `CanonicalClock.Duration`.
-  func convertToCanonical(duration: Duration) -> CanonicalClock.Duration
-
-  /// Convert an Instant to the canonical clock's equivalent Instant.
-  ///
-  /// Parameters:
-  ///
-  /// - instant:    The `Instant` to convert, or `nil`.
-  ///
-  /// Returns:
-  ///
-  /// The equivalent `CanonicalClock.Instant`, or `nil` if `instant` was `nil`.
-  func maybeConvertToCanonical(instant: Instant?) -> CanonicalClock.Instant?
-
-  /// Convert a Duration to the canonical clock's equivalent Duration.
-  ///
-  /// Parameters:
-  ///
-  /// - duration:    The `Duration` to convert, or `nil`.
-  ///
-  /// Returns:
-  ///
-  /// The equivalent `CanonicalClock.Duration`, or `nil` if `duration` was `nil`.
-  func maybeConvertToCanonical(duration: Duration?) -> CanonicalClock.Duration?
 }
 
 extension Clock {
@@ -150,40 +97,6 @@ extension Clock {
   }
 }
 
-// Default implementations for canonicalization support
-extension Clock where CanonicalClock == Self {
-  public var canonicalClock: CanonicalClock? { return nil }
-
-  public func convertToCanonical(duration: Duration) -> CanonicalClock.Duration {
-    return duration
-  }
-
-  public func convertToCanonical(instant: Instant) -> CanonicalClock.Instant {
-    return instant
-  }
-}
-
-// nil-propagating versions of convertToCanonical()
-extension Clock {
-  public func maybeConvertToCanonical(duration: Duration?)
-    -> CanonicalClock.Duration?
-  {
-    if let duration {
-      return convertToCanonical(duration: duration)
-    }
-    return nil
-  }
-
-  public func maybeConvertToCanonical(instant: Instant?)
-    -> CanonicalClock.Instant?
-  {
-    if let instant {
-      return convertToCanonical(instant: instant)
-    }
-    return nil
-  }
-}
-
 @available(StdlibDeploymentTarget 5.7, *)
 extension Clock {
   /// Measure the elapsed time to execute a closure.
@@ -258,6 +171,7 @@ extension Clock {
 enum _ClockID: Int32 {
   case continuous = 1
   case suspending = 2
+  case walltime = 3
 }
 
 @available(StdlibDeploymentTarget 5.7, *)

stdlib/public/Concurrency/CooperativeExecutor.swift

@@ -202,22 +202,6 @@ extension CooperativeExecutor: SchedulingExecutor {
                                 after delay: C.Duration,
                                 tolerance: C.Duration? = nil,
                                 clock: C) {
-    // Convert the clock to its canonical equivalent, if any
-    if let canonical = clock.canonicalClock {
-      enqueueImpl(job,
-                  after: clock.convertToCanonical(duration: delay),
-                  tolerance: clock.maybeConvertToCanonical(duration: tolerance),
-                  clock: canonical)
-      return
-    }
-
-    enqueueImpl(job, after: delay, tolerance: tolerance, clock: clock)
-  }
-
-  private func enqueueImpl<C: Clock>(_ job: consuming ExecutorJob,
-                                after delay: C.Duration,
-                                tolerance: C.Duration? = nil,
-                                clock: C) {
     // If it's a clock we know, get the duration to wait
     let duration: Duration
     if let _ = clock as? ContinuousClock {

stdlib/public/Concurrency/DispatchExecutor.swift

@@ -105,6 +105,7 @@ public class DispatchGlobalTaskExecutor: TaskExecutor, SchedulingExecutor,
 enum DispatchClockID: CInt {
   case continuous = 1
   case suspending = 2
+  case walltime = 3
 }
 
 fileprivate func clamp(_ components: (seconds: Int64, attoseconds: Int64))
@@ -153,38 +154,6 @@ fileprivate func _dispatchEnqueue<C: Clock, E: Executor>(
   clock: C,
   executor: E,
   global: Bool
-) {
-  // Convert the clock to its canonical equivalent, if any
-  if let canonical = clock.canonicalClock {
-    _dispatchEnqueueImpl(
-      job,
-      at: clock.convertToCanonical(instant: instant),
-      tolerance: clock.maybeConvertToCanonical(duration: tolerance),
-      clock: canonical,
-      executor: executor,
-      global: global
-    )
-    return
-  }
-
-  _dispatchEnqueueImpl(
-    job,
-    at: instant,
-    tolerance: tolerance,
-    clock: clock,
-    executor: executor,
-    global: global
-  )
-}
-
-@available(StdlibDeploymentTarget 6.2, *)
-fileprivate func _dispatchEnqueueImpl<C: Clock, E: Executor>(
-  _ job: consuming ExecutorJob,
-  at instant: C.Instant,
-  tolerance: C.Duration?,
-  clock: C,
-  executor: E,
-  global: Bool
 ) {
   // If it's a clock we know, convert it to something we can use; otherwise,
   // call the clock's `enqueue` function to schedule the enqueue of the job.