Remove Final Traces of "Time Traveling Priors"

Time Traveling priors occur when a file system cache lies to us about the state of the incremental build. Since I'd rather not deal with three operating system's worth of file systems to fix that particular problem, let's make sure this can never happen again by relegating one of the files to the legacy incremental build path.

The idea is that the "incremental imports" flag controls things here:

Incremental Imports Enabled: Read and write Module.priors bitstream files
Incremental Imports Disabled: Read and write Module.swiftdeps YAML files

The only notable thing needed to make this work is the old fallback that used to "disable" incremental compilation by bailing out of the entire incremental build now instead constructs an empty module dependency graph and fires off a "clean" incremental build. This should be a pretty significant optimization as it now means that on the happy path we can reach a steady state in the incremental build in one build instead of two.

Author: CodaFi

Sources/SwiftDriver/Driver/Driver.swift

@@ -1424,30 +1424,69 @@ extension Driver {
     // In case the write fails, don't crash the build.
     // A mitigation to rdar://76359678.
     // If the write fails, import incrementality is lost, but it is not a fatal error.
-    if let incrementalCompilationState = self.incrementalCompilationState {
+    guard
+      let buildRecordInfo = self.buildRecordInfo,
+      let absPath = buildRecordInfo.buildRecordPath.absolutePath
+    else {
+      return
+    }
+
+    let buildRecord = buildRecordInfo.buildRecord(
+      jobs, self.incrementalCompilationState?.blockingConcurrentMutationToProtectedState{
+        $0.skippedCompilationInputs
+      })
+
+    if
+      let incrementalCompilationState = self.incrementalCompilationState,
+      incrementalCompilationState.info.isCrossModuleIncrementalBuildEnabled
+    {
       do {
-        try incrementalCompilationState.writeDependencyGraph(buildRecordInfo)
-      }
-      catch {
+        try incrementalCompilationState.writeDependencyGraph(to: buildRecordInfo.dependencyGraphPath, buildRecord)
+      } catch {
         diagnosticEngine.emit(
           .warning("next compile won't be incremental; could not write dependency graph: \(error.localizedDescription)"))
-          /// Ensure that a bogus dependency graph is not used next time.
-          buildRecordInfo?.removeBuildRecord()
-          return
+        /// Ensure that a bogus dependency graph is not used next time.
+        buildRecordInfo.removeBuildRecord()
+        buildRecordInfo.removeInterModuleDependencyGraph()
+        return
       }
       do {
         try incrementalCompilationState.writeInterModuleDependencyGraph(buildRecordInfo)
-      }
-      catch {
+      } catch {
         diagnosticEngine.emit(
           .warning("next compile must run a full dependency scan; could not write inter-module dependency graph: \(error.localizedDescription)"))
-        buildRecordInfo?.removeInterModuleDependencyGraph()
+        buildRecordInfo.removeBuildRecord()
+        buildRecordInfo.removeInterModuleDependencyGraph()
         return
       }
+    } else {
+      // FIXME: This is all legacy code. Once the cross module incremental build
+      // becomes the default:
+      //
+      // 1) Delete this branch
+      // 2) Delete the parts of the incremental build that talk about anything
+      //    derived from `buildRecordPath`
+      // 3) Delete the Yams dependency.
+
+      // 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
+      // doesn't matter if it fails.
+      // Added for the sake of compatibility with the legacy driver.
+      try? fileSystem.move(
+        from: absPath, to: absPath.appending(component: absPath.basename + "~"))
+      
+      guard let contents = buildRecord.encode(diagnosticEngine: diagnosticEngine) else {
+        diagnosticEngine.emit(.warning_could_not_write_build_record(absPath))
+        return
+      }
+
+      do {
+        try fileSystem.writeFileContents(absPath,
+                                         bytes: ByteString(encodingAsUTF8: contents))
+      } catch {
+        diagnosticEngine.emit(.warning_could_not_write_build_record(absPath))
+      }
     }
-    buildRecordInfo?.writeBuildRecord(
-      jobs,
-      incrementalCompilationState?.blockingConcurrentMutationToProtectedState{$0.skippedCompilationInputs})
   }
 
   private func printBindings(_ job: Job) {

Sources/SwiftDriver/IncrementalCompilation/FirstWaveComputer.swift

@@ -76,17 +76,16 @@ extension IncrementalCompilationState.FirstWaveComputer {
   throws -> (initiallySkippedCompileGroups: [TypedVirtualPath: CompileJobGroup],
              mandatoryJobsInOrder: [Job])
   {
-    precondition(sourceFiles.disappeared.isEmpty, "unimplemented")
-
     let compileGroups =
       Dictionary(uniqueKeysWithValues:
                   jobsInPhases.compileGroups.map { ($0.primaryInput, $0) })
-    guard let buildRecord = maybeBuildRecord else {
+    let buildRecord = self.moduleDependencyGraph.buildRecord
+    guard !buildRecord.inputInfos.isEmpty else {
       func everythingIsMandatory()
         throws -> (initiallySkippedCompileGroups: [TypedVirtualPath: CompileJobGroup],
                    mandatoryJobsInOrder: [Job])
       {
-        let mandatoryCompileGroupsInOrder = sourceFiles.currentInOrder.compactMap {
+        let mandatoryCompileGroupsInOrder = self.inputFiles.swiftSourceFiles.compactMap {
           input -> CompileJobGroup? in
           compileGroups[input.typedFile]
         }
@@ -166,7 +165,7 @@ extension IncrementalCompilationState.FirstWaveComputer {
       }
     }
 
-    let inputsMissingFromGraph = sourceFiles.currentInOrder.filter { sourceFile in
+    let inputsMissingFromGraph = self.inputFiles.swiftSourceFiles.filter { sourceFile in
       !moduleDependencyGraph.containsNodes(forSourceFile: sourceFile)
     }