Remove some legacy Darwin-only code from Test.Clock. (#1606)

This PR removes some more Darwin-only legacy code from the clock
implementation. Our minimum deployment target is now high enough that
this code is no longer needed.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: grynspan

Documentation/Porting.md

@@ -116,7 +116,7 @@ Once the header is included, we can call `GetDateTime()` from `Clock.swift`:
 +  var seconds = CUnsignedLong(0)
 +  GetDateTime(&seconds)
 +  seconds -= 2_082_844_800 // seconds between epochs
-+  return TimeValue((seconds: Int64(seconds), attoseconds: 0))
++  return TimeValue(rawValue: .seconds(seconds))
  #else
  #warning("Platform-specific implementation missing: UTC time unavailable (no timespec)")
  #endif

Sources/Overlays/_Testing_Foundation/Events/Clock+Date.swift

@@ -24,9 +24,7 @@ extension Date {
   /// of ``Test/Clock/Instant`` to `SuspendingClock.Instant` instead of `Date`.
   @_spi(Experimental) @_spi(ForToolsIntegrationOnly)
   public init(_ testClockInstant: Test.Clock.Instant) {
-    let components = testClockInstant.timeComponentsSince1970
-    let secondsSince1970 = TimeInterval(components.seconds) + (TimeInterval(components.attoseconds) / TimeInterval(1_000_000_000_000_000_000))
-    self.init(timeIntervalSince1970: secondsSince1970)
+    self.init(timeIntervalSince1970: testClockInstant.durationSince1970 / .seconds(1))
   }
 }
 #endif

Sources/Testing/ABI/Encoded/ABI.EncodedInstant.swift

@@ -25,9 +25,9 @@ extension ABI {
     var since1970: Double
 
     init(encoding instant: borrowing Test.Clock.Instant) {
-      absolute = Double(instant.suspending)
+      absolute = instant.suspending.rawValue / .seconds(1)
 #if !SWT_NO_UTC_CLOCK
-      since1970 = Double(instant.wall)
+      since1970 = instant.wall.rawValue / .seconds(1)
 #else
       since1970 = 0
 #endif

Sources/Testing/ABI/Encoded/ABI.EncodedTest.swift

@@ -131,9 +131,7 @@ extension ABI {
         if !bugs.isEmpty {
           self.bugs = bugs
         }
-        self.timeLimit = test.timeLimit
-          .map(TimeValue.init)
-          .map(Double.init)
+        self.timeLimit = test.timeLimit.map { $0 / .seconds(1) }
       }
     }
   }

Sources/Testing/Events/Clock.swift

@@ -21,7 +21,7 @@ extension Test {
     /// An instant on the testing clock.
     public struct Instant: Sendable {
       /// The suspending-clock time corresponding to this instant.
-      fileprivate(set) var suspending = TimeValue(SuspendingClock.Instant.now)
+      fileprivate(set) var suspending = TimeValue(rawValue: SuspendingClock().systemEpoch.duration(to: .now))
 
 #if !SWT_NO_UTC_CLOCK
       /// The wall-clock time corresponding to this instant.
@@ -35,10 +35,10 @@ extension Test {
 #else
         timespec_get(&wall, TIME_UTC)
 #endif
-        return TimeValue(wall)
+        return TimeValue(rawValue: .seconds(wall.tv_sec) + .nanoseconds(wall.tv_nsec))
 #else
 #warning("Platform-specific implementation missing: UTC time unavailable (no timespec)")
-        return TimeValue((0, 0))
+        return TimeValue(rawValue: .zero)
 #endif
       }()
 #endif
@@ -63,52 +63,32 @@ extension SuspendingClock.Instant {
   /// - Parameters:
   ///   - testClockInstant: The equivalent instant on ``Test/Clock``.
   public init(_ testClockInstant: Test.Clock.Instant) {
-    self.init(testClockInstant.suspending)
+    self = SuspendingClock().systemEpoch + testClockInstant.suspending.rawValue
   }
 }
 
-extension Test.Clock.Instant {
 #if !SWT_NO_UTC_CLOCK
-  /// The duration since 1970 represented by this instance as a tuple of seconds
-  /// and attoseconds.
-  ///
-  /// The value of this property is the equivalent of `self` on the wall clock.
-  /// It is suitable for display to the user, but not for fine timing
-  /// calculations.
-  public var timeComponentsSince1970: (seconds: Int64, attoseconds: Int64) {
-    wall.components
-  }
-
+extension Test.Clock.Instant {
   /// The duration since 1970 represented by this instance.
   ///
-  /// The value of this property is the equivalent of `self` on the wall clock.
-  /// It is suitable for display to the user, but not for fine timing
-  /// calculations.
-  public var durationSince1970: Duration {
-    Duration(wall)
+  /// The Foundation overlay uses this property to implement `Date.init(_:)`.
+  package var durationSince1970: Duration {
+    wall.rawValue
   }
+}
 #endif
 
-  /// Get the number of nanoseconds from this instance to another.
-  ///
-  /// - Parameters:
-  ///   - other: The later instant.
-  ///
-  /// - Returns: The number of nanoseconds between `self` and `other`. If
-  ///   `other` is ordered before this instance, the result is negative.
-  func nanoseconds(until other: Self) -> Int64 {
-    if other < self {
-      return -other.nanoseconds(until: self)
-    }
-    let otherNanoseconds = (other.suspending.seconds * 1_000_000_000) + (other.suspending.attoseconds / 1_000_000_000)
-    let selfNanoseconds = (suspending.seconds * 1_000_000_000) + (suspending.attoseconds / 1_000_000_000)
-    return otherNanoseconds - selfNanoseconds
+// MARK: - Clock
+
+extension Test.Clock: _Concurrency.Clock {
+  public var now: Instant {
+    .now
   }
-}
 
-// MARK: - Sleeping
+  public var minimumResolution: Duration {
+    SuspendingClock().minimumResolution
+  }
 
-extension Test.Clock {
   /// Suspend the current task for the given duration.
   ///
   /// - Parameters:
@@ -124,35 +104,14 @@ extension Test.Clock {
 #if !SWT_NO_UNSTRUCTURED_TASKS
     return try await SuspendingClock().sleep(for: duration)
 #elseif !SWT_NO_TIMESPEC
-    let timeValue = TimeValue(duration)
-    var ts = timespec(timeValue)
+    var ts = timespec(tv_sec: .init(duration.components.seconds), tv_nsec: .init(duration.components.attoseconds / 1_000_000_000))
     var tsRemaining = ts
     while 0 != nanosleep(&ts, &tsRemaining) {
       try Task.checkCancellation()
       ts = tsRemaining
     }
 #else
 #warning("Platform-specific implementation missing: task sleep unavailable")
-#endif
-  }
-}
-
-// MARK: - Clock
-
-extension Test.Clock: _Concurrency.Clock {
-  public typealias Duration = SuspendingClock.Duration
-
-  public var now: Instant {
-    .now
-  }
-
-  public var minimumResolution: Duration {
-#if SWT_TARGET_OS_APPLE
-    var res = timespec()
-    _ = clock_getres(CLOCK_UPTIME_RAW, &res)
-    return Duration(TimeValue(res))
-#else
-    SuspendingClock().minimumResolution
 #endif
   }
 
@@ -170,59 +129,39 @@ extension Test.Clock: _Concurrency.Clock {
 
 extension Test.Clock.Instant: Equatable, Hashable, Comparable {
   public static func ==(lhs: Self, rhs: Self) -> Bool {
-    lhs.suspending == rhs.suspending
+    lhs.suspending.rawValue == rhs.suspending.rawValue
   }
 
   public func hash(into hasher: inout Hasher) {
-    hasher.combine(suspending)
+    hasher.combine(suspending.rawValue)
   }
 
   public static func <(lhs: Self, rhs: Self) -> Bool {
-    lhs.suspending < rhs.suspending
+    lhs.suspending.rawValue < rhs.suspending.rawValue
   }
 }
 
 // MARK: - InstantProtocol
 
 extension Test.Clock.Instant: InstantProtocol {
-  public typealias Duration = Swift.Duration
-
   public func advanced(by duration: Duration) -> Self {
     var result = self
 
-    result.suspending = TimeValue(Duration(result.suspending) + duration)
+    result.suspending = TimeValue(rawValue: result.suspending.rawValue + duration)
 #if !SWT_NO_UTC_CLOCK
-    result.wall = TimeValue(Duration(result.wall) + duration)
+    result.wall = TimeValue(rawValue: result.wall.rawValue + duration)
 #endif
 
     return result
   }
 
   public func duration(to other: Test.Clock.Instant) -> Duration {
-    Duration(other.suspending) - Duration(suspending)
-  }
-}
-
-// MARK: - Duration descriptions
-
-extension Test.Clock.Instant {
-  /// Get a description of the duration between this instance and another.
-  ///
-  /// - Parameters:
-  ///   - other: The later instant.
-  ///
-  /// - Returns: A string describing the duration between `self` and `other`,
-  ///   up to millisecond accuracy.
-  func descriptionOfDuration(to other: Test.Clock.Instant) -> String {
-#if SWT_TARGET_OS_APPLE
-    let (seconds, nanosecondsRemaining) = nanoseconds(until: other).quotientAndRemainder(dividingBy: 1_000_000_000)
-    return String(describing: TimeValue((seconds, nanosecondsRemaining * 1_000_000_000)))
-#else
-    return String(describing: TimeValue(Duration(other.suspending) - Duration(suspending)))
-#endif
+    other.suspending.rawValue - suspending.rawValue
   }
 }
 
+#if !SWT_NO_SNAPSHOT_TYPES
 // MARK: - Codable
 
 extension Test.Clock.Instant: Codable {}
+#endif

Sources/Testing/Events/Recorder/Event.HumanReadableOutputRecorder.swift

@@ -360,6 +360,11 @@ extension Event.HumanReadableOutputRecorder {
       }
     }
 
+    // A helper function for displaying test durations.
+    func descriptionOfDuration(from start: Test.Clock.Instant, to end: Test.Clock.Instant) -> String {
+      String(describing: TimeValue(rawValue: end.suspending.rawValue - start.suspending.rawValue))
+    }
+
     // Finally, produce any messages for the event.
     switch event.kind {
     case .testDiscovered:
@@ -429,7 +434,7 @@ extension Event.HumanReadableOutputRecorder {
       let testDataGraph = context.testData.subgraph(at: keyPath)
       let testData = testDataGraph?.value ?? .init(startInstant: instant)
       let issues = _issueCounts(in: testDataGraph)
-      let duration = testData.startInstant.descriptionOfDuration(to: instant)
+      let duration = descriptionOfDuration(from: testData.startInstant, to: instant)
       let testCasesCount = if test.isParameterized, let testDataGraph {
         " with \(testDataGraph.children.count.counting("test case"))"
       } else {
@@ -579,7 +584,7 @@ extension Event.HumanReadableOutputRecorder {
       let testDataGraph = context.testData.subgraph(at: keyPath)
       let testData = testDataGraph?.value ?? .init(startInstant: instant)
       let issues = _issueCounts(in: testDataGraph)
-      let duration = testData.startInstant.descriptionOfDuration(to: instant)
+      let duration = descriptionOfDuration(from: testData.startInstant, to: instant)
 
       var cancellationComment = "."
       let (symbol, verbed): (Event.Symbol, String)
@@ -608,7 +613,7 @@ extension Event.HumanReadableOutputRecorder {
       guard let iterationStartInstant = context.iterationStartInstant else {
         break
       }
-      let duration = iterationStartInstant.descriptionOfDuration(to: instant)
+      let duration = descriptionOfDuration(from: iterationStartInstant, to: instant)
 
       return [
         Message(
@@ -622,7 +627,7 @@ extension Event.HumanReadableOutputRecorder {
       let suiteCount = context.suiteCount
       let issues = _issueCounts(in: context.testData)
       let runStartInstant = context.runStartInstant ?? instant
-      let duration = runStartInstant.descriptionOfDuration(to: instant)
+      let duration = descriptionOfDuration(from: runStartInstant, to: instant)
 
       return if issues.errorIssueCount > 0 {
         [

Sources/Testing/Events/Recorder/Event.JUnitXMLRecorder.swift

@@ -148,8 +148,8 @@ extension Event.JUnitXMLRecorder {
         let skipCount = context.testData
           .compactMap(\.value?.skipInfo)
           .count
-        let durationNanoseconds = context.runStartInstant.map { $0.nanoseconds(until: instant) } ?? 0
-        let durationSeconds = Double(durationNanoseconds) / 1_000_000_000
+        let durationSeconds = context.runStartInstant
+          .map { (instant.suspending.rawValue - $0.suspending.rawValue) / .seconds(1) } ?? 0.0
         return #"""
             <testsuite name="TestResults" errors="0" tests="\#(context.testCount)" failures="\#(issueCount)" skipped="\#(skipCount)" time="\#(durationSeconds)">
           \#(Self._xml(for: context.testData))
@@ -185,8 +185,7 @@ extension Event.JUnitXMLRecorder {
       // an end instant; don't report timing for such tests.
       var timeClause = ""
       if let endInstant = testData.endInstant {
-        let durationNanoseconds = testData.startInstant.nanoseconds(until: endInstant)
-        let durationSeconds = Double(durationNanoseconds) / 1_000_000_000
+        let durationSeconds = (endInstant.suspending.rawValue - testData.startInstant.suspending.rawValue) / .seconds(1)
         timeClause = #"time="\#(durationSeconds)" "#
       }