[Incremental] Only warn if cannot write prior module dependencies, and print more error info

Sources/SwiftDriver/Driver/Driver.swift

@@ -988,10 +988,7 @@ extension Driver {
     if !childJobs.isEmpty {
       do {
         defer {
-          self.incrementalCompilationState?.writeDependencyGraph()
-          buildRecordInfo?.writeBuildRecord(
-            jobs,
-            incrementalCompilationState?.skippedCompilationInputs)
+          writeIncrementalBuildInformation(jobs)
         }
         try performTheBuild(allJobs: childJobs,
                             jobExecutionDelegate: toolExecutionDelegate,
@@ -1055,6 +1052,27 @@ extension Driver {
       recordedInputModificationDates: recordedInputModificationDates)
   }
 
+  private func writeIncrementalBuildInformation(_ jobs: [Job]) {
+    // 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 {
+      do {
+        try incrementalCompilationState.writeDependencyGraph()
+      }
+      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
+      }
+    }
+    buildRecordInfo?.writeBuildRecord(
+      jobs,
+      incrementalCompilationState?.skippedCompilationInputs)
+  }
+
   private func printBindings(_ job: Job) {
     stdoutStream <<< #"# ""# <<< targetTriple.triple
     stdoutStream <<< #"" - ""# <<< job.tool.basename

Sources/SwiftDriver/IncrementalCompilation/BuildRecordInfo.swift

@@ -184,6 +184,13 @@ import SwiftOptions
     }
   }
 
+  func removeBuildRecord() {
+    guard let absPath = buildRecordPath.absolutePath else {
+      return
+    }
+    try? fileSystem.removeFileTree(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
   /// doesn't matter if it fails.

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift

@@ -223,10 +223,6 @@ extension Diagnostic.Message {
   fileprivate static func remark_incremental_compilation(because why: String) -> Diagnostic.Message {
     .remark("Incremental compilation: \(why)")
   }
-
-  fileprivate static var warning_could_not_write_dependency_graph: Diagnostic.Message {
-    .warning("next compile won't be incremental; could not write dependency graph")
-  }
 }
 
 // MARK: - Scheduling the 2nd wave
@@ -496,23 +492,32 @@ extension IncrementalCompilationState {
 // MARK: - Serialization
 
 extension IncrementalCompilationState {
-  @_spi(Testing) public func writeDependencyGraph() {
+  enum WriteDependencyGraphError: LocalizedError {
+    case noBuildRecordInfo,
+         couldNotWrite(path: VirtualPath, error: Error)
+    var errorDescription: String? {
+      switch self {
+      case .noBuildRecordInfo:
+        return "No build record information"
+      case let .couldNotWrite(path, error):
+        return "Could not write to \(path), error: \(error.localizedDescription)"
+      }
+    }
+  }
+  @_spi(Testing) public func writeDependencyGraph() throws {
     // If the cross-module build is not enabled, the status quo dictates we
     // not emit this file.
     guard moduleDependencyGraph.info.isCrossModuleIncrementalBuildEnabled else {
       return
     }
-
     guard
       let recordInfo = self.driver.buildRecordInfo
     else {
-      self.driver.diagnosticEngine.emit(
-        .warning_could_not_write_dependency_graph)
-      return
+      throw WriteDependencyGraphError.noBuildRecordInfo
     }
-    self.moduleDependencyGraph.write(to: recordInfo.dependencyGraphPath,
-                                     on: self.driver.fileSystem,
-                                     compilerVersion: recordInfo.actualSwiftVersion)
+    try self.moduleDependencyGraph.write(to: recordInfo.dependencyGraphPath,
+                                         on: self.driver.fileSystem,
+                                         compilerVersion: recordInfo.actualSwiftVersion)
   }
 }
 

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraph.swift

@@ -663,19 +663,21 @@ extension ModuleDependencyGraph {
   ///   - fileSystem: The file system for this location.
   ///   - compilerVersion: A string containing version information for the
   ///                      driver used to create this file.
+  /// - Returns: true if had error
   @_spi(Testing) public func write(
     to path: VirtualPath,
     on fileSystem: FileSystem,
     compilerVersion: String
-  ) {
+  ) throws {
     let data = ModuleDependencyGraph.Serializer.serialize(self, compilerVersion)
 
     do {
       try fileSystem.writeFileContents(path,
                                        bytes: data,
                                        atomically: true)
-    } catch let e {
-      info.diagnosticEngine.emit(.error_could_not_write_dep_graph(to: path, error: e))
+    } catch {
+      throw IncrementalCompilationState.WriteDependencyGraphError.couldNotWrite(
+        path: path, error: error)
     }
   }
 
@@ -1034,15 +1036,6 @@ fileprivate extension DependencyKey.Designator {
   }
 }
 
-extension Diagnostic.Message {
-  fileprivate static func error_could_not_write_dep_graph(
-    to path: VirtualPath,
-    error: Swift.Error
-  ) -> Diagnostic.Message {
-      .error("could not write driver dependency graph to \(path). Returned error was: \(error)")
-  }
-}
-
 // MARK: - Checking Serialization
 
 extension ModuleDependencyGraph {

Tests/SwiftDriverTests/DependencyGraphSerializationTests.swift

@@ -18,7 +18,7 @@ class DependencyGraphSerializationTests: XCTestCase {
   func roundTrip(_ graph: ModuleDependencyGraph) throws {
     let mockPath = VirtualPath.absolute(AbsolutePath("/module-dependency-graph"))
     let fs = InMemoryFileSystem()
-    graph.write(to: mockPath, on: fs, compilerVersion: "Swift 99")
+    try graph.write(to: mockPath, on: fs, compilerVersion: "Swift 99")
 
     let deserializedGraph = try ModuleDependencyGraph.read(from: mockPath,
                                                            info: .mock(fileSystem: fs))!