Incorporate Colton Schlosser's ideas.

Author: David Ungar

Sources/SwiftDriver/Driver/CompilerMode.swift

@@ -80,6 +80,10 @@ extension CompilerMode {
     }
   }
 
+  public var isBatchCompile: Bool {
+    batchModeInfo != nil
+  }
+
   // Whether this compilation mode supports the use of bridging pre-compiled
   // headers.
   public var supportsBridgingPCH: Bool {

Sources/SwiftDriver/Driver/Driver.swift

@@ -898,7 +898,7 @@ extension Driver {
     allJobs: [Job],
     forceResponseFiles: Bool
   ) throws {
-    let continueBuildingAfterErrors = parsedOptions.contains(.continueBuildingAfterErrors)
+    let continueBuildingAfterErrors = computeContinueBuildingAfterErrors()
     try executor.execute(
       workload: .init(allJobs,
                       incrementalCompilationState,
@@ -1419,8 +1419,25 @@ extension Driver {
 
     return numJobs
   }
+
+  private mutating func computeContinueBuildingAfterErrors() -> Bool {
+    // Note: Batch mode handling of serialized diagnostics requires that all
+    // batches get to run, in order to make sure that all diagnostics emitted
+    // during the compilation end up in at least one serialized diagnostic file.
+    // Therefore, treat batch mode as implying -continue-building-after-errors.
+    // (This behavior could be limited to only when serialized diagnostics are
+    // being emitted, but this seems more consistent and less surprising for
+    // users.)
+    // FIXME: We don't really need (or want) a full ContinueBuildingAfterErrors.
+    // If we fail to precompile a bridging header, for example, there's no need
+    // to go on to compilation of source files, and if compilation of source files
+    // fails, we shouldn't try to link. Instead, we'd want to let all jobs finish
+    // but not schedule any new ones.
+    return compilerMode.isBatchCompile || parsedOptions.contains(.continueBuildingAfterErrors)
+  }
 }
 
+
 extension Diagnostic.Message {
   static func remark_max_determinism_overriding(_ option: Option) -> Diagnostic.Message {
     .remark("SWIFTC_MAXIMUM_DETERMINISM overriding \(option.spelling)")

Sources/SwiftDriver/Jobs/Planning.swift

@@ -545,7 +545,7 @@ extension Driver {
   /// So, in order to avoid making jobs and rebatching, the code would have to just get outputs for each
   /// compilation. But `compileJob` intermixes the output computation with other stuff.
   mutating func formBatchedJobs(_ jobs: [Job], forIncremental: Bool) throws -> [Job] {
-    guard let _ = compilerMode.batchModeInfo else {
+    guard compilerMode.isBatchCompile else {
       // Don't even go through the logic so as to not print out confusing
       // "batched foobar" messages.
       return jobs

Sources/SwiftDriverExecution/MultiJobExecutor.swift

@@ -88,7 +88,7 @@ public final class MultiJobExecutor {
     private(set) var executeAllJobsTaskBuildEngine: LLTaskBuildEngine? = nil
 
     /// If a job fails, the driver needs to stop running jobs.
-    private(set) var shouldStopRunningJobs = false
+    private(set) var isBuildCancelled = false
 
     /// The value of the option
     let continueBuildingAfterErrors: Bool
@@ -235,13 +235,13 @@ public final class MultiJobExecutor {
       }
     }
 
-    fileprivate func decideIfShouldStopRunningJobs(_ result: ProcessResult) {
+    fileprivate func cancelBuildIfNeeded(_ result: ProcessResult) {
       switch (result.exitStatus, continueBuildingAfterErrors) {
       case (.terminated(let code), false) where code != EXIT_SUCCESS:
-         shouldStopRunningJobs = true
+         isBuildCancelled = true
        #if !os(Windows)
        case (.signalled, _):
-         shouldStopRunningJobs = true
+         isBuildCancelled = true
        #endif
       default:
         break
@@ -448,9 +448,9 @@ class ExecuteJobRule: LLBuildRule {
     rememberIfInputSucceeded(engine, value: value)
   }
 
+  /// Called when the build engine thinks all inputs are available in order to run the job.
   override func inputsAvailable(_ engine: LLTaskBuildEngine) {
-    // Return early any of the input failed.
-    guard allInputsSucceeded else {
+    guard allInputsSucceeded, !context.isBuildCancelled else {
       return engine.taskIsComplete(DriverBuildValue.jobExecution(success: false))
     }
 
@@ -486,6 +486,7 @@ class ExecuteJobRule: LLBuildRule {
   }
 
   private func executeJob(_ engine: LLTaskBuildEngine) {
+    precondition(!context.isBuildCancelled)
     let context = self.context
     let resolver = context.argsResolver
     let job = myJob
@@ -494,10 +495,6 @@ class ExecuteJobRule: LLBuildRule {
     let value: DriverBuildValue
     var pid = 0
     do {
-      if context.shouldStopRunningJobs {
-        engine.taskIsComplete(DriverBuildValue.jobExecution(success: false))
-        return
-      }
       let arguments: [String] = try resolver.resolveArgumentList(for: job,
                                                                  forceResponseFiles: context.forceResponseFiles)
 
@@ -541,7 +538,7 @@ class ExecuteJobRule: LLBuildRule {
       }
       value = .jobExecution(success: success)
 
-      context.decideIfShouldStopRunningJobs(result)
+      context.cancelBuildIfNeeded(result)
     } catch {
       if error is DiagnosticData {
         context.diagnosticsEngine.emit(error)

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -1471,6 +1471,31 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testBatchModeContinueAfterErrors() throws {
+    struct MockExecutor: DriverExecutor {
+      let resolver = try! ArgsResolver(fileSystem: localFileSystem)
+
+      func execute(job: Job, forceResponseFiles: Bool, recordedInputModificationDates: [TypedVirtualPath : Date]) throws -> ProcessResult {
+        fatalError()
+      }
+      func execute(workload: DriverExecutorWorkload,
+                   delegate: JobExecutionDelegate,
+                   numParallelJobs: Int,
+                   forceResponseFiles: Bool,
+                   recordedInputModificationDates: [TypedVirtualPath : Date]) throws {
+        XCTAssert(workload.continueBuildingAfterErrors)
+      }
+      func checkNonZeroExit(args: String..., environment: [String : String]) throws -> String {
+        fatalError()
+      }
+      func description(of job: Job, forceResponseFiles: Bool) throws -> String {
+        fatalError()
+      }
+    }
+
+    let driver = try Driver(args: ["swiftc", "foo1.swift", "bar1.swift", "-enable-batch-mode", "-driver-use-frontend-path", "/bin/echo"], executor: MockExecutor())
+  }
+
   func testSingleThreadedWholeModuleOptimizationCompiles() throws {
     var driver1 = try Driver(args: ["swiftc", "-whole-module-optimization", "foo.swift", "bar.swift", "-module-name", "Test", "-target", "x86_64-apple-macosx10.15", "-emit-module-interface", "-emit-objc-header-path", "Test-Swift.h", "-emit-private-module-interface-path", "Test.private.swiftinterface"])
     let plannedJobs = try driver1.planBuild()