[Concurrency] Don't pass negative times to the Dispatch code.

Dispatch uses unsigned times, and cannot cope with times before its
clock started.  As such, passing negative times from Swift through to
the C++ code results in large unsigned values, which then causes us to
wait forever.  This is undesirable.

rdar://148899609

Author: al45tair

stdlib/public/Concurrency/DispatchExecutor.swift

@@ -161,20 +161,29 @@ enum DispatchClockID: CInt {
 @available(SwiftStdlib 6.2, *)
 extension DispatchExecutorProtocol {
 
+  func clamp(_ components: (seconds: Int64, attoseconds: Int64))
+    -> (seconds: Int64, attoseconds: Int64) {
+    if components.seconds < 0
+         || components.seconds == 0 && components.attoseconds < 0 {
+      return (seconds: 0, attoseconds: 0)
+    }
+    return (seconds: components.seconds, attoseconds: components.attoseconds)
+  }
+
   func timestamp<C: Clock>(for instant: C.Instant, clock: C)
     -> (clockID: DispatchClockID, seconds: Int64, nanoseconds: Int64) {
     if clock.traits.contains(.continuous) {
         let dispatchClock: ContinuousClock = .continuous
         let instant = dispatchClock.convert(instant: instant, from: clock)!
-        let (seconds, attoseconds) = instant._value.components
+        let (seconds, attoseconds) = clamp(instant._value.components)
         let nanoseconds = attoseconds / 1_000_000_000
         return (clockID: .continuous,
                 seconds: Int64(seconds),
                 nanoseconds: Int64(nanoseconds))
     } else {
         let dispatchClock: SuspendingClock = .suspending
         let instant = dispatchClock.convert(instant: instant, from: clock)!
-        let (seconds, attoseconds) = instant._value.components
+        let (seconds, attoseconds) = clamp(instant._value.components)
         let nanoseconds = attoseconds / 1_000_000_000
         return (clockID: .suspending,
                 seconds: Int64(seconds),
@@ -185,7 +194,7 @@ extension DispatchExecutorProtocol {
   func delay<C: Clock>(from duration: C.Duration, clock: C)
     -> (seconds: Int64, nanoseconds: Int64) {
     let swiftDuration = clock.convert(from: duration)!
-    let (seconds, attoseconds) = swiftDuration.components
+    let (seconds, attoseconds) = clamp(swiftDuration.components)
     let nanoseconds = attoseconds / 1_000_000_000
     return (seconds: seconds, nanoseconds: nanoseconds)
   }