Merge pull request #472 from davidungar/now-what

[Incremental] Support reading priors and incremental external dependencies.

Author: David Ungar

Sources/SwiftDriver/CMakeLists.txt

@@ -45,6 +45,7 @@ add_library(SwiftDriver
   "IncrementalCompilation/DictionaryOfDictionaries.swift"
   "IncrementalCompilation/ExternalDependencyAndFingerprintEnforcer.swift"
   "IncrementalCompilation/IncrementalCompilationState.swift"
+  "IncrementalCompilation/InitialStateComputer.swift"
   "IncrementalCompilation/InputInfo.swift"
   "IncrementalCompilation/KeyAndFingerprintHolder.swift"
   "IncrementalCompilation/ModuleDependencyGraph.swift"

Sources/SwiftDriver/IncrementalCompilation/BidirectionalMap.swift

@@ -10,35 +10,50 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Like a two-way dictionary, only works for accessing present members
+/// Like a two-way dictionary
 public struct BidirectionalMap<T1: Hashable, T2: Hashable>: Equatable, Sequence {
   private var map1: [T1: T2] = [:]
   private var map2: [T2: T1] = [:]
 
   public init() {}
 
-  public subscript(_ key: T1) -> T2 {
+  public subscript(_ key: T1) -> T2? {
     get {
       guard let value = map1[key]
       else {
-        fatalError("\(key) was not present")
+        return nil
       }
       return value
     }
     set {
-      map1[key] = newValue
-      map2[newValue] = key
+      if let newValue = newValue {
+        map1[key] = newValue
+        map2[newValue] = key
+        return
+      }
+      if let oldValue = map1.removeValue(forKey: key) {
+        map2.removeValue(forKey: oldValue)
+      }
     }
   }
-  public subscript(_ key: T2) -> T1 {
+  public subscript(_ key: T2) -> T1? {
     get {
       guard let value = map2[key]
       else {
-        fatalError("\(key) was not present")
+        return nil
       }
       return value
     }
-    set { self[newValue] = key }
+    set {
+      if let newValue = newValue {
+        map2[key] = newValue
+        map1[newValue] = key
+        return
+      }
+      if let oldValue = map2.removeValue(forKey: key) {
+        map1.removeValue(forKey: oldValue)
+      }
+    }
   }
   public func contains(key: T1) -> Bool {
     map1.keys.contains(key)

Sources/SwiftDriver/IncrementalCompilation/BuildRecordInfo.swift

@@ -47,7 +47,26 @@ import SwiftOptions
   // FIXME: Use an actor when possible.
   private let confinementQueue = DispatchQueue(label: "com.apple.swift-driver.jobresults")
 
-  init?(
+  @_spi(Testing) public init(
+    buildRecordPath: VirtualPath,
+    fileSystem: FileSystem,
+    currentArgsHash: String,
+    actualSwiftVersion: String,
+    timeBeforeFirstJob: Date,
+    diagnosticEngine: DiagnosticsEngine,
+    compilationInputModificationDates: [TypedVirtualPath: Date])
+  {
+    self.buildRecordPath = buildRecordPath
+    self.fileSystem = fileSystem
+    self.currentArgsHash = currentArgsHash
+    self.actualSwiftVersion = actualSwiftVersion
+    self.timeBeforeFirstJob = timeBeforeFirstJob
+    self.diagnosticEngine = diagnosticEngine
+    self.compilationInputModificationDates = compilationInputModificationDates
+  }
+
+
+  convenience init?(
     actualSwiftVersion: String,
     compilerOutputType: FileType?,
     workingDirectory: AbsolutePath?,
@@ -67,16 +86,20 @@ import SwiftOptions
     else {
       return nil
     }
-    self.actualSwiftVersion = actualSwiftVersion
-    self.currentArgsHash = Self.computeArgsHash(parsedOptions)
-    self.buildRecordPath = buildRecordPath
-    self.compilationInputModificationDates =
+    let currentArgsHash = Self.computeArgsHash(parsedOptions)
+    let compilationInputModificationDates =
       recordedInputModificationDates.filter { input, _ in
         input.type.isPartOfSwiftCompilation
       }
-    self.diagnosticEngine = diagnosticEngine
-    self.fileSystem = fileSystem
-    self.timeBeforeFirstJob = Date()
+
+    self.init(
+      buildRecordPath: buildRecordPath,
+      fileSystem: fileSystem,
+      currentArgsHash: currentArgsHash,
+      actualSwiftVersion: actualSwiftVersion,
+      timeBeforeFirstJob: Date(),
+      diagnosticEngine: diagnosticEngine,
+      compilationInputModificationDates: compilationInputModificationDates)
    }
 
   private static func computeArgsHash(_ parsedOptionsArg: ParsedOptions
@@ -205,7 +228,7 @@ import SwiftOptions
     guard outOfDateBuildRecord.argsHash.map({ $0 == currentArgsHash }) ?? true else {
       let why = "different arguments were passed to the compiler"
       // mimic legacy
-      reporter?.reportIncrementalCompilationHasBeenDisabled(" because " + why)
+      reporter?.reportIncrementalCompilationHasBeenDisabled("because " + why)
       reporter?.reportDisablingIncrementalBuild(why)
       return nil
     }
@@ -217,6 +240,18 @@ import SwiftOptions
       finishedJobResults.append(JobResult(job, result))
     }
   }
+
+  /// A build-record-relative path to the location of a serialized copy of the
+  /// driver's dependency graph.
+  ///
+  /// FIXME: This is a little ridiculous. We could probably just replace the
+  /// build record outright with a serialized format.
+  var dependencyGraphPath: VirtualPath {
+    let filename = buildRecordPath.basenameWithoutExt
+    return buildRecordPath
+      .parentDirectory
+      .appending(component: filename + ".priors")
+  }
 }
 
 fileprivate extension AbsolutePath {