Merge pull request #81335 from al45tair/eng/PR-148899609-6.2

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

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)
   }

test/Concurrency/Runtime/async_task_sleep.swift

@@ -14,11 +14,14 @@ import Dispatch
 @available(SwiftStdlib 5.1, *)
 @main struct Main {
   static let pause = 500_000_000 // 500ms
-  
+
   static func main() async {
     await testSleepDuration()
     await testSleepDoesNotBlock()
     await testSleepHuge()
+    if #available(SwiftStdlib 5.7, *) {
+      await testSleepNegative()
+    }
   }
 
   static func testSleepDuration() async {
@@ -34,7 +37,7 @@ import Dispatch
 
   static func testSleepDoesNotBlock() async {
     // FIXME: Should run on main executor
-    let task = detach {
+    let task = Task.detached {
       print("Run first")
     }
 
@@ -50,10 +53,10 @@ import Dispatch
   static func testSleepHuge() async {
     // Make sure nanoseconds values about Int64.max don't get interpreted as
     // negative and fail to sleep.
-    let task1 = detach {
+    let task1 = Task.detached {
       try await Task.sleep(nanoseconds: UInt64(Int64.max) + 1)
     }
-    let task2 = detach {
+    let task2 = Task.detached {
       try await Task.sleep(nanoseconds: UInt64.max)
     }
 
@@ -73,4 +76,28 @@ import Dispatch
       fatalError("Sleep 2 completed early.")
     } catch {}
   }
+
+  @available(SwiftStdlib 5.7, *)
+  static func testSleepNegative() async {
+    // Make sure that "negative" times don't cause us to sleep forever
+    let negativeDuration = Duration(secondsComponent: -60,
+                                    attosecondsComponent: 0)
+    let negativeTime = unsafe unsafeBitCast(negativeDuration,
+                                            to: ContinuousClock.Instant.self)
+
+    let task = Task.detached {
+      try await Task.sleep(until: negativeTime)
+    }
+
+    try! await Task.sleep(nanoseconds: UInt64(pause))
+
+    task.cancel()
+
+    // The sleep should complete; if they throw, this is a failure.
+    do {
+      _ = try await task.value
+    } catch {
+      fatalError("Sleep tried to wait for a negative time")
+    }
+  }
 }