Merge pull request #1171 from CodaFi/time-lords

Replace Foundation.Date with TimePoint

Author: CodaFi

Sources/SwiftDriver/Driver/Driver.swift

@@ -12,7 +12,6 @@
 import TSCBasic
 import SwiftOptions
 
-import struct Foundation.Date
 import class Dispatch.DispatchQueue
 
 import enum TSCUtility.Diagnostics
@@ -179,7 +178,7 @@ public struct Driver {
   @_spi(Testing) public let inputFiles: [TypedVirtualPath]
 
   /// The last time each input file was modified, recorded at the start of the build.
-  @_spi(Testing) public let recordedInputModificationDates: [TypedVirtualPath: Date]
+  @_spi(Testing) public let recordedInputModificationDates: [TypedVirtualPath: TimePoint]
 
   /// The mapping from input files to output files for each kind.
   let outputFileMap: OutputFileMap?

Sources/SwiftDriver/Execution/DriverExecutor.swift

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 import TSCBasic
-import struct Foundation.Date
 import struct Foundation.Data
 import class Foundation.JSONDecoder
 import var Foundation.EXIT_SUCCESS
@@ -25,23 +24,23 @@ public protocol DriverExecutor {
   @discardableResult
   func execute(job: Job,
                forceResponseFiles: Bool,
-               recordedInputModificationDates: [TypedVirtualPath: Date]) throws -> ProcessResult
+               recordedInputModificationDates: [TypedVirtualPath: TimePoint]) throws -> ProcessResult
 
   /// Execute multiple jobs, tracking job status using the provided execution delegate.
   /// Pass in the `IncrementalCompilationState` to allow for incremental compilation.
   func execute(workload: DriverExecutorWorkload,
                delegate: JobExecutionDelegate,
                numParallelJobs: Int,
                forceResponseFiles: Bool,
-               recordedInputModificationDates: [TypedVirtualPath: Date]
+               recordedInputModificationDates: [TypedVirtualPath: TimePoint]
   ) throws
 
   /// Execute multiple jobs, tracking job status using the provided execution delegate.
   func execute(jobs: [Job],
                delegate: JobExecutionDelegate,
                numParallelJobs: Int,
                forceResponseFiles: Bool,
-               recordedInputModificationDates: [TypedVirtualPath: Date]
+               recordedInputModificationDates: [TypedVirtualPath: TimePoint]
   ) throws
 
   /// Launch a process with the given command line and report the result.
@@ -86,7 +85,7 @@ extension DriverExecutor {
   func execute<T: Decodable>(job: Job,
                              capturingJSONOutputAs outputType: T.Type,
                              forceResponseFiles: Bool,
-                             recordedInputModificationDates: [TypedVirtualPath: Date]) throws -> T {
+                             recordedInputModificationDates: [TypedVirtualPath: TimePoint]) throws -> T {
     let result = try execute(job: job,
                              forceResponseFiles: forceResponseFiles,
                              recordedInputModificationDates: recordedInputModificationDates)
@@ -111,7 +110,7 @@ extension DriverExecutor {
     delegate: JobExecutionDelegate,
     numParallelJobs: Int,
     forceResponseFiles: Bool,
-    recordedInputModificationDates: [TypedVirtualPath: Date]
+    recordedInputModificationDates: [TypedVirtualPath: TimePoint]
   ) throws {
     try execute(
       workload: .all(jobs),

Sources/SwiftDriver/IncrementalCompilation/BuildRecord.swift

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 import TSCBasic
 @_implementationOnly import Yams
-import struct Foundation.Date
 
 /// Holds the info about inputs needed to plan incremenal compilation
 /// A.k.a. BuildRecord was the legacy name
@@ -20,16 +19,16 @@ public struct BuildRecord {
   /// When testing, the argsHash may be missing from the build record
   public let argsHash: String?
   /// Next compile, will compare an input mod time against the start time of the previous build
-  public let buildStartTime: Date
+  public let buildStartTime: TimePoint
   /// Next compile, will compare an output mod time against the end time of the previous build
-  public let buildEndTime: Date
+  public let buildEndTime: TimePoint
   /// The date is the modification time of the main input file the last time the driver ran
   public let inputInfos: [VirtualPath: InputInfo]
 
   public init(argsHash: String?,
               swiftVersion: String,
-              buildStartTime: Date,
-              buildEndTime: Date,
+              buildStartTime: TimePoint,
+              buildEndTime: TimePoint,
               inputInfos: [VirtualPath: InputInfo]) {
     self.argsHash = argsHash
     self.swiftVersion = swiftVersion
@@ -67,8 +66,8 @@ public extension BuildRecord {
     var argsHash: String?
     var swiftVersion: String?
     // Legacy driver does not disable incremental if no buildTime field.
-    var buildStartTime: Date = .distantPast
-    var buildEndTime: Date = .distantFuture
+    var buildStartTime: TimePoint = .distantPast
+    var buildEndTime: TimePoint = .distantFuture
     var inputInfos: [VirtualPath: InputInfo]?
     for (key, value) in sections {
       guard let k = key.string else {
@@ -138,7 +137,7 @@ public extension BuildRecord {
     _ node: Yams.Node,
     forInputInfo: Bool,
     _ failedToReadOutOfDateMap: (String) -> Void
-  ) -> Date? {
+  ) -> TimePoint? {
     guard let vals = node.sequence else {
       failedToReadOutOfDateMap(
         forInputInfo
@@ -153,7 +152,7 @@ public extension BuildRecord {
       failedToReadOutOfDateMap("could not read time value in build record")
       return nil
     }
-    return Date(legacyDriverSecs: secs, nanos: ns)
+    return TimePoint(seconds: UInt64(secs), nanoseconds: UInt32(ns))
   }
 
   private static func decodeInputInfos(
@@ -197,11 +196,11 @@ extension BuildRecord {
   init(jobs: [Job],
        finishedJobResults: [BuildRecordInfo.JobResult],
        skippedInputs: Set<TypedVirtualPath>?,
-       compilationInputModificationDates: [TypedVirtualPath: Date],
+       compilationInputModificationDates: [TypedVirtualPath: TimePoint],
        actualSwiftVersion: String,
        argsHash: String!,
-       timeBeforeFirstJob: Date,
-       timeAfterLastJob: Date
+       timeBeforeFirstJob: TimePoint,
+       timeAfterLastJob: TimePoint
   ) {
     let jobResultsByInput = Dictionary(uniqueKeysWithValues:
       finishedJobResults.flatMap { entry in
@@ -256,10 +255,9 @@ extension BuildRecord {
     }
   }
 
-  private static func encode(_ date: Date, tag tagString: String? = nil) -> Yams.Node {
-    let secsAndNanos = date.legacyDriverSecsAndNanos
+  private static func encode(_ date: TimePoint, tag tagString: String? = nil) -> Yams.Node {
     return Yams.Node(
-      secsAndNanos.map {Yams.Node(String($0))},
+      [ Yams.Node(String(date.seconds)), Yams.Node(String(date.nanoseconds)) ],
       tagString.map {Yams.Tag(Yams.Tag.Name(rawValue: $0))} ?? .implicit,
       .flow)
   }

Sources/SwiftDriver/IncrementalCompilation/BuildRecordInfo.swift

@@ -12,7 +12,6 @@
 
 import TSCBasic
 import SwiftOptions
-import struct Foundation.Date
 import class Dispatch.DispatchQueue
 
 /// Holds information required to read and write the build record (aka
@@ -38,9 +37,9 @@ import class Dispatch.DispatchQueue
   let fileSystem: FileSystem
   let currentArgsHash: String
   @_spi(Testing) public let actualSwiftVersion: String
-  @_spi(Testing) public let timeBeforeFirstJob: Date
+  @_spi(Testing) public let timeBeforeFirstJob: TimePoint
   let diagnosticEngine: DiagnosticsEngine
-  let compilationInputModificationDates: [TypedVirtualPath: Date]
+  let compilationInputModificationDates: [TypedVirtualPath: TimePoint]
 
   private var finishedJobResults = [JobResult]()
   // A confinement queue that protects concurrent access to the
@@ -53,9 +52,9 @@ import class Dispatch.DispatchQueue
     fileSystem: FileSystem,
     currentArgsHash: String,
     actualSwiftVersion: String,
-    timeBeforeFirstJob: Date,
+    timeBeforeFirstJob: TimePoint,
     diagnosticEngine: DiagnosticsEngine,
-    compilationInputModificationDates: [TypedVirtualPath: Date])
+    compilationInputModificationDates: [TypedVirtualPath: TimePoint])
   {
     self.buildRecordPath = buildRecordPath
     self.fileSystem = fileSystem
@@ -77,7 +76,7 @@ import class Dispatch.DispatchQueue
     outputFileMap: OutputFileMap?,
     incremental: Bool,
     parsedOptions: ParsedOptions,
-    recordedInputModificationDates: [TypedVirtualPath: Date]
+    recordedInputModificationDates: [TypedVirtualPath: TimePoint]
   ) {
     // Cannot write a buildRecord without a path.
     guard let buildRecordPath = Self.computeBuildRecordPath(
@@ -100,7 +99,7 @@ import class Dispatch.DispatchQueue
       fileSystem: fileSystem,
       currentArgsHash: currentArgsHash,
       actualSwiftVersion: actualSwiftVersion,
-      timeBeforeFirstJob: Date(),
+      timeBeforeFirstJob: .now(),
       diagnosticEngine: diagnosticEngine,
       compilationInputModificationDates: compilationInputModificationDates)
    }
@@ -165,7 +164,7 @@ import class Dispatch.DispatchQueue
         actualSwiftVersion: actualSwiftVersion,
         argsHash: currentArgsHash,
         timeBeforeFirstJob: timeBeforeFirstJob,
-        timeAfterLastJob: Date())
+        timeAfterLastJob: .now())
     }
 
     guard let contents = buildRecord.encode(currentArgsHash: currentArgsHash,

Sources/SwiftDriver/IncrementalCompilation/FirstWaveComputer.swift

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 import TSCBasic
-import struct Foundation.Date
 import class Dispatch.DispatchQueue
 
 extension IncrementalCompilationState {
@@ -257,21 +256,13 @@ extension IncrementalCompilationState.FirstWaveComputer {
   ) -> [ChangedInput] {
     jobsInPhases.compileGroups.compactMap { group in
       let input = group.primaryInput
-      let modDate = buildRecordInfo.compilationInputModificationDates[input]
-        ?? Date.distantFuture
+      let modDate = buildRecordInfo.compilationInputModificationDates[input] ?? .distantFuture
       let inputInfo = outOfDateBuildRecord.inputInfos[input.file]
       let previousCompilationStatus = inputInfo?.status ?? .newlyAdded
       let previousModTime = inputInfo?.previousModTime
 
-      // Because legacy driver reads/writes dates wrt 1970,
-      // and because converting time intervals to/from Dates from 1970
-      // exceeds Double precision, must not compare dates directly
-      var datesMatch: Bool {
-        modDate.timeIntervalSince1970 == previousModTime?.timeIntervalSince1970
-      }
-
       switch previousCompilationStatus {
-      case .upToDate where datesMatch:
+      case .upToDate where modDate == previousModTime:
         reporter?.report("May skip current input:", input)
         return nil
 
@@ -286,7 +277,7 @@ extension IncrementalCompilationState.FirstWaveComputer {
       }
       return ChangedInput(typedFile: input,
                           status: previousCompilationStatus,
-                          datesMatch: datesMatch)
+                          datesMatch: modDate == previousModTime)
     }
   }
 

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState+Extensions.swift

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 import TSCBasic
 import SwiftOptions
-import struct Foundation.Date
 import protocol Foundation.LocalizedError
 
 /// In a separate file to ensure that ``IncrementalCompilationState/protectedState``
@@ -50,9 +49,9 @@ extension IncrementalCompilationState {
     /// Compiler options related to incremental builds.
     let incrementalOptions: IncrementalCompilationState.Options
     /// The last time this compilation was started. Used to compare against e.g. input file mod dates.
-    let buildStartTime: Date
+    let buildStartTime: TimePoint
     /// The last time this compilation finished. Used to compare against output file mod dates
-    let buildEndTime: Date
+    let buildEndTime: TimePoint
   }
 }
 
@@ -175,8 +174,7 @@ extension IncrementalCompilationState {
       report(skipping: false, "No outputs")
       return false
     }
-    guard .distantPast < oldestOutputModTime
-    else {
+    guard .distantPast < oldestOutputModTime else {
       report(skipping: false, "Missing output", oldestOutput)
       return false
     }
@@ -189,29 +187,29 @@ extension IncrementalCompilationState {
     return true
   }
 
-  private func findOldestOutputForSkipping(postCompileJob: Job) -> (TypedVirtualPath, Date)? {
-    var oldestOutputAndModTime: (TypedVirtualPath, Date)? = nil
+  private func findOldestOutputForSkipping(postCompileJob: Job) -> (TypedVirtualPath, TimePoint)? {
+    var oldestOutputAndModTime: (TypedVirtualPath, TimePoint)? = nil
     for output in postCompileJob.outputs {
-      guard let outputModTime = modTime(output)
-      else {
-        oldestOutputAndModTime = (output, .distantPast)
-        break
+      guard let outputModTime = try? self.fileSystem.lastModificationTime(for: output.file) else {
+        return (output, .distantPast)
       }
-      oldestOutputAndModTime = oldestOutputAndModTime.map {
-        $0.1 < outputModTime ? $0 : (output, outputModTime)
+
+      if let candidate = oldestOutputAndModTime {
+        oldestOutputAndModTime = candidate.1 < outputModTime ? candidate : (output, outputModTime)
+      } else {
+        oldestOutputAndModTime = (output, outputModTime)
       }
-      ?? (output, outputModTime)
     }
     return oldestOutputAndModTime
   }
-  private func findAnInputOf( postCompileJob: Job, newerThan outputModTime: Date) -> TypedVirtualPath? {
+  private func findAnInputOf( postCompileJob: Job, newerThan outputModTime: TimePoint) -> TypedVirtualPath? {
     postCompileJob.inputs.first { input in
-      outputModTime < (modTime(input) ?? .distantFuture)
+      guard let modTime = try? self.fileSystem.lastModificationTime(for: input.file) else {
+        return false
+      }
+      return outputModTime < modTime
     }
   }
-  private func modTime(_ path: TypedVirtualPath) -> Date? {
-    try? fileSystem.lastModificationTime(for: path.file)
-  }
 }
 
 

Sources/SwiftDriver/IncrementalCompilation/IncrementalDependencyAndInputSetup.swift

@@ -12,7 +12,6 @@
 
 import TSCBasic
 import SwiftOptions
-import struct Foundation.Date
 import class Dispatch.DispatchQueue
 
 // Initial incremental state computation
@@ -121,8 +120,8 @@ extension IncrementalCompilationState {
     @_spi(Testing) public let dependencyDotFilesIncludeExternals: Bool = true
     @_spi(Testing) public let dependencyDotFilesIncludeAPINotes: Bool = false
 
-    @_spi(Testing) public let buildStartTime: Date
-    @_spi(Testing) public let buildEndTime: Date
+    @_spi(Testing) public let buildStartTime: TimePoint
+    @_spi(Testing) public let buildEndTime: TimePoint
 
     // Do not try to reuse a graph from a different compilation, so check
     // the build record.
@@ -249,11 +248,10 @@ extension IncrementalCompilationState.IncrementalDependencyAndInputSetup {
       graphIfPresent = nil
     }
     catch let ModuleDependencyGraph.ReadError.timeTravellingPriors(priorsModTime: priorsModTime,
-                                                                   buildStartTime: buildStartTime,
-                                                                   priorsTimeIntervalSinceStart: priorsTimeIntervalSinceStart) {
+                                                                   buildStartTime: buildStartTime) {
       diagnosticEngine.emit(
         warning: "Will not do cross-module incremental builds, priors saved at \(priorsModTime)), " +
-        "but the previous build started at \(buildStartTime) [priorsTimeIntervalSinceStart: \(priorsTimeIntervalSinceStart)], at '\(dependencyGraphPath)'")
+        "but the previous build started at \(buildStartTime), at '\(dependencyGraphPath)'")
       graphIfPresent = nil
     }
     catch {

Sources/SwiftDriver/IncrementalCompilation/InputInfo.swift

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 import TSCBasic
-import struct Foundation.Date
 
 /// Contains information about the current status of an input to the incremental
 /// build.
@@ -24,9 +23,9 @@ import struct Foundation.Date
   /// The current status of the input file.
   /*@_spi(Testing)*/ public let status: Status
   /// The last known modification time of this input.
-  /*@_spi(Testing)*/ public let previousModTime: Date
+  /*@_spi(Testing)*/ public let previousModTime: TimePoint
 
-  /*@_spi(Testing)*/ public init(status: Status, previousModTime: Date) {
+  /*@_spi(Testing)*/ public init(status: Status, previousModTime: TimePoint) {
     self.status = status
     self.previousModTime = previousModTime
   }
@@ -119,7 +118,7 @@ fileprivate extension ProcessResult {
 
 // MARK: - reading
 public extension InputInfo {
-  init?(tag: String, previousModTime: Date,
+  init?(tag: String, previousModTime: TimePoint,
         failedToReadOutOfDateMap: (String) -> Void
   ) {
     guard let status = Status(identifier: tag) else {