Read and Write The Driver's Dependency Graph For Cross-Module Builds

The refactoring of the incremental compilation state class is in three pieces:

1) Formalize the type of the InitialState computed by the initializer
2) Internalize computeModuleDependencyGraph and instead make a unified computeInitialState entrypoint (we'll need this for testing later)
3) Divide the status quo and cross-module initial state computations. There is no change to the status quo outside of the breakup of Driver.getBuildInfo

The cross-module path is slightly different than the status quo. For one, the incremental build need not fail entirely when either the build record or dependency graph cannot be read. In fact, it is a requirement that the incremental build proceed but schedule every single input file to rebuild, otherwise we won't have a module dependency graph to serialize!

As an aside, we ought to consider unifying the build record with the module dependency graph state we're writing here. They're read and written in lock-step when cross-module builds are turned on.

Author: CodaFi

Sources/SwiftDriver/Driver/Driver.swift

@@ -201,6 +201,22 @@ public struct Driver {
   /// Only used for reading when compiling incrementally.
   let buildRecordInfo: BuildRecordInfo?
 
+  /// 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 driverDependencyGraphPath: AbsolutePath? {
+    guard
+      let recordInfo = self.buildRecordInfo,
+      let recordPath = recordInfo.buildRecordPath.absolutePath
+    else {
+      return nil
+    }
+    let filename = recordPath.basenameWithoutExt
+    return recordPath.parentDirectory.appending(component: filename + ".priors")
+  }
+  
   /// Code & data for incremental compilation. Nil if not running in incremental mode.
   /// Set during planning because needs the jobs to look at outputs.
   @_spi(Testing) public private(set) var incrementalCompilationState: IncrementalCompilationState? = nil
@@ -910,6 +926,7 @@ extension Driver {
     if !childJobs.isEmpty {
       do {
         defer {
+          self.incrementalCompilationState?.writeDependencyGraph()
           buildRecordInfo?.writeBuildRecord(
             jobs,
             incrementalCompilationState?.skippedCompilationInputs)

Sources/SwiftDriver/IncrementalCompilation/BuildRecordInfo.swift

@@ -18,7 +18,7 @@ import SwiftOptions
 /// compilation record).
 ///
 /// This info is always written, but only read for incremental compilation.
-final class BuildRecordInfo {
+@_spi(Testing) public final class BuildRecordInfo {
   /// A pair of a `Job` and the `ProcessResult` corresponding to the outcome of
   /// its execution during this compilation session.
   struct JobResult {
@@ -122,16 +122,19 @@ final class BuildRecordInfo {
   }
 
   /// Write out the build record.
-  /// `Jobs` must include all of the compilation jobs.
-  /// `Inputs` will hold all the primary inputs that were not compiled because of incremental compilation
-  func writeBuildRecord(_ jobs: [Job], _ skippedInputs: Set<TypedVirtualPath>? ) {
+  ///
+  /// - Parameters:
+  ///   - jobs: All compilation jobs formed during this build.
+  ///   - skippedInputs: All primary inputs that were not compiled because the
+  ///                    incremental build plan determined they could be
+  ///                    skipped.
+  func writeBuildRecord(_ jobs: [Job], _ skippedInputs: Set<TypedVirtualPath>?) {
     guard let absPath = buildRecordPath.absolutePath else {
       diagnosticEngine.emit(
         .warning_could_not_write_build_record_not_absolutePath(buildRecordPath))
       return
     }
     preservePreviousBuildRecord(absPath)
-    
 
     let buildRecord = self.confinementQueue.sync {
       BuildRecord(
@@ -155,7 +158,7 @@ final class BuildRecordInfo {
     } catch {
       diagnosticEngine.emit(.warning_could_not_write_build_record(absPath))
     }
- }
+  }
 
   /// Before writing to the dependencies file path, preserve any previous file
   /// that may have been there. No error handling -- this is just a nicety, it