Disable output file map diagnostic for non-incremental mode

Sources/SwiftDriver/Driver/Driver.swift

@@ -592,6 +592,7 @@ public struct Driver {
       fileSystem: fileSystem,
       moduleOutputInfo: moduleOutputInfo,
       outputFileMap: outputFileMap,
+      incremental: self.shouldAttemptIncrementalCompilation,
       parsedOptions: parsedOptions,
       recordedInputModificationDates: recordedInputModificationDates)
 

Sources/SwiftDriver/IncrementalCompilation/BuildRecordInfo.swift

@@ -74,12 +74,14 @@ import SwiftOptions
     fileSystem: FileSystem,
     moduleOutputInfo: ModuleOutputInfo,
     outputFileMap: OutputFileMap?,
+    incremental: Bool,
     parsedOptions: ParsedOptions,
     recordedInputModificationDates: [TypedVirtualPath: Date]
   ) {
     // Cannot write a buildRecord without a path.
     guard let buildRecordPath = Self.computeBuildRecordPath(
             outputFileMap: outputFileMap,
+            incremental: incremental,
             compilerOutputType: compilerOutputType,
             workingDirectory: workingDirectory,
             diagnosticEngine: diagnosticEngine)
@@ -124,6 +126,7 @@ import SwiftOptions
   /// Determine the input and output path for the build record
   private static func computeBuildRecordPath(
     outputFileMap: OutputFileMap?,
+    incremental: Bool,
     compilerOutputType: FileType?,
     workingDirectory: AbsolutePath?,
     diagnosticEngine: DiagnosticsEngine
@@ -136,7 +139,9 @@ import SwiftOptions
     guard let partialBuildRecordPath =
             ofm.existingOutputForSingleInput(outputType: .swiftDeps)
     else {
-      diagnosticEngine.emit(.warning_incremental_requires_build_record_entry)
+      if incremental {
+        diagnosticEngine.emit(.warning_incremental_requires_build_record_entry)
+      }
       return nil
     }
     return workingDirectory

Tests/SwiftDriverTests/IncrementalCompilationTests.swift

@@ -266,6 +266,45 @@ extension IncrementalCompilationTests {
     try checkPropagationOfTopLevelChange(checkDiagnostics: checkDiagnostics)
   }
 
+  func testFileMapMissingMainEntry() throws {
+    try buildInitialState(checkDiagnostics: true)
+    OutputFileMapCreator.write(
+      module: module, inputPaths: inputPathsAndContents.map {$0.0},
+      derivedData: derivedDataPath, to: OFM, excludeMainEntry: true)
+    try doABuild("output file map missing main entry", checkDiagnostics: true, extraArguments: [], whenAutolinking: []) {
+      missingMainDependencyEntry
+      disablingIncremental
+      foundBatchableJobs(2)
+      formingOneBatch
+      addingToBatchThenForming("main", "other")
+      compiling("main", "other")
+      startingLinking
+      finishedLinking
+    }
+  }
+
+  func testFileMapMissingMainEntryWMO() throws {
+    try buildInitialState(checkDiagnostics: true)
+    guard let sdkArgumentsForTesting = try Driver.sdkArgumentsForTesting()
+    else {
+      throw XCTSkip("Cannot perform this test on this host")
+    }
+
+    OutputFileMapCreator.write(
+      module: module, inputPaths: inputPathsAndContents.map {$0.0},
+      derivedData: derivedDataPath, to: OFM, excludeMainEntry: true)
+
+    let args = [
+      "swiftc",
+      "-module-name", module,
+      "-o", derivedDataPath.appending(component: module + ".o").pathString,
+      "-output-file-map", OFM.pathString,
+      "-whole-module-optimization",
+      "-no-color-diagnostics",
+    ] + inputPathsAndContents.map {$0.0.pathString}.sorted() + sdkArgumentsForTesting
+    _ = try doABuild(whenAutolinking: [], expecting: [], arguments: args)
+  }
+
   // FIXME: Expect failure in Linux in CI just as testIncrementalDiagnostics
   func testAlwaysRebuildDependents() throws {
 #if !os(Linux)
@@ -1257,6 +1296,12 @@ extension DiagVerifiable {
   @DiagsBuilder var disablingIncrementalCannotReadBuildRecord: [Diagnostic.Message] {
     "Incremental compilation: Disabling incremental build: could not read build record"
   }
+  @DiagsBuilder var missingMainDependencyEntry: [Diagnostic.Message] {
+    .warning("ignoring -incremental; output file map has no master dependencies entry (\"swift-dependencies\" under \"\")")
+  }
+  @DiagsBuilder var disablingIncremental: [Diagnostic.Message] {
+    "Incremental compilation: Disabling incremental build: no build record path"
+  }
   // MARK: - graph
   @DiagsBuilder var createdGraphFromSwiftdeps: [Diagnostic.Message] {
     "Incremental compilation: Created dependency graph from swiftdeps files"

Tests/TestUtilities/OutputFileMapCreator.swift

@@ -18,23 +18,28 @@ public struct OutputFileMapCreator {
   private let module: String
   private let inputPaths: [AbsolutePath]
   private let derivedData: AbsolutePath
+  // The main entry isn't required for some WMO builds
+  private let excludeMainEntry: Bool
 
-  private init(module: String, inputPaths: [AbsolutePath], derivedData: AbsolutePath) {
+  private init(module: String, inputPaths: [AbsolutePath], derivedData: AbsolutePath, excludeMainEntry: Bool) {
     self.module = module
     self.inputPaths = inputPaths
     self.derivedData = derivedData
+    self.excludeMainEntry = excludeMainEntry
   }
 
   public static func write(module: String,
                            inputPaths: [AbsolutePath],
                            derivedData: AbsolutePath,
-                           to dst: AbsolutePath) {
-    let creator = Self(module: module, inputPaths: inputPaths, derivedData: derivedData)
+                           to dst: AbsolutePath,
+                           excludeMainEntry: Bool = false) {
+    let creator = Self(module: module, inputPaths: inputPaths, derivedData: derivedData, excludeMainEntry: excludeMainEntry)
     try! localFileSystem.writeIfChanged(path: dst, bytes: ByteString(creator.generateData()))
   }
 
   private func generateDict() -> [String: [String: String]] {
     let master = ["swift-dependencies": "\(derivedData.pathString)/\(module)-master.swiftdeps"]
+    let mainEntryDict = self.excludeMainEntry ? [:] : ["": master]
     func baseNameEntry(_ s: AbsolutePath) -> [String: String] {
       [
         "dependencies": ".d",
@@ -46,10 +51,11 @@ public struct OutputFileMapCreator {
       ]
       .mapValues {"\(derivedData.appending(component: s.basenameWithoutExt))\($0)"}
     }
+
     return Dictionary(uniqueKeysWithValues:
                         inputPaths.map { ("\($0)", baseNameEntry($0)) }
     )
-    .merging(["": master]) {_, _ in fatalError()}
+    .merging(mainEntryDict) {_, _ in fatalError()}
   }
 
   private func generateData() -> Data {