honor !-driver-continue-building-after-errors

Author: David Ungar

Sources/SwiftDriver/Driver/Driver.swift

@@ -859,12 +859,14 @@ extension Driver {
                            recordedInputModificationDates: recordedInputModificationDates)
       return
     }
-
-    try performTheBuild(allJobs: jobs, forceResponseFiles: forceResponseFiles)
-
-    buildRecordInfo?.writeBuildRecord(
-      jobs,
-      incrementalCompilationState?.skippedCompilationInputs)
+    do {
+      defer {
+        buildRecordInfo?.writeBuildRecord(
+          jobs,
+          incrementalCompilationState?.skippedCompilationInputs)
+      }
+      try performTheBuild(allJobs: jobs, forceResponseFiles: forceResponseFiles)
+    }
 
     // If requested, warn for options that weren't used by the driver after the build is finished.
     if parsedOptions.hasArgument(.driverWarnUnusedOptions) {
@@ -896,8 +898,11 @@ extension Driver {
     allJobs: [Job],
     forceResponseFiles: Bool
   ) throws {
+    let continueBuildingAfterErrors = parsedOptions.contains(.continueBuildingAfterErrors)
     try executor.execute(
-      workload: .init(allJobs, incrementalCompilationState),
+      workload: .init(allJobs,
+                      incrementalCompilationState,
+                      continueBuildingAfterErrors: continueBuildingAfterErrors),
       delegate: createToolExecutionDelegate(),
       numParallelJobs: numParallelJobs ?? 1,
       forceResponseFiles: forceResponseFiles,

Sources/SwiftDriver/Execution/DriverExecutor.swift

@@ -47,12 +47,26 @@ public protocol DriverExecutor {
   func description(of job: Job, forceResponseFiles: Bool) throws -> String
 }
 
-public enum DriverExecutorWorkload {
-  case all([Job])
-  case incremental(IncrementalCompilationState)
+public struct DriverExecutorWorkload {
+  public let continueBuildingAfterErrors: Bool
+  public enum Kind {
+    case all([Job])
+    case incremental(IncrementalCompilationState)
+  }
+  public let kind: Kind
+
+  public init(_ allJobs: [Job],
+       _ incrementalCompilationState: IncrementalCompilationState?,
+       continueBuildingAfterErrors: Bool
+  ) {
+      self.continueBuildingAfterErrors = continueBuildingAfterErrors
+      self.kind = incrementalCompilationState
+        .map {.incremental($0)}
+        ?? .all(allJobs)
+  }
 
-  init(_ allJobs: [Job], _ incrementalCompilationState: IncrementalCompilationState?) {
-    self = incrementalCompilationState.map {.incremental($0)} ?? .all(allJobs)
+  static public func all(_ jobs: [Job]) -> Self {
+    .init(jobs, nil, continueBuildingAfterErrors: false)
   }
 }
 

Sources/SwiftDriverExecution/MultiJobExecutor.swift

@@ -87,6 +87,12 @@ public final class MultiJobExecutor {
     /// any newly-required job. Set only once.
     private(set) var executeAllJobsTaskBuildEngine: LLTaskBuildEngine? = nil
 
+    /// If a job fails, the driver needs to stop running jobs.
+    private(set) var shouldStopRunningJobs = false
+
+    /// The value of the option
+    let continueBuildingAfterErrors: Bool
+
 
     init(
       argsResolver: ArgsResolver,
@@ -106,7 +112,8 @@ public final class MultiJobExecutor {
         producerMap: self.producerMap,
         primaryIndices: self.primaryIndices,
         postCompileIndices: self.postCompileIndices,
-        incrementalCompilationState: self.incrementalCompilationState
+        incrementalCompilationState: self.incrementalCompilationState,
+        continueBuildingAfterErrors: self.continueBuildingAfterErrors
       ) = Self.fillInJobsAndProducers(workload)
 
       self.argsResolver = argsResolver
@@ -131,20 +138,21 @@ public final class MultiJobExecutor {
           producerMap: [VirtualPath: Int],
           primaryIndices: Range<Int>,
           postCompileIndices: Range<Int>,
-          incrementalCompilationState: IncrementalCompilationState?)
+          incrementalCompilationState: IncrementalCompilationState?,
+          continueBuildingAfterErrors: Bool)
     {
       var jobs = [Job]()
       var producerMap = [VirtualPath: Int]()
       let primaryIndices, postCompileIndices: Range<Int>
       let incrementalCompilationState: IncrementalCompilationState?
-      switch workload {
+      switch workload.kind {
       case let .incremental(ics):
         incrementalCompilationState = ics
         primaryIndices = Self.addJobs(
           ics.mandatoryPreOrCompileJobsInOrder,
           to: &jobs,
           producing: &producerMap
-          )
+        )
         postCompileIndices = Self.addJobs(
           ics.postCompileJobs,
           to: &jobs,
@@ -161,7 +169,8 @@ public final class MultiJobExecutor {
                producerMap: producerMap,
                primaryIndices: primaryIndices,
                postCompileIndices: postCompileIndices,
-               incrementalCompilationState: incrementalCompilationState)
+               incrementalCompilationState: incrementalCompilationState,
+               continueBuildingAfterErrors: workload.continueBuildingAfterErrors)
     }
 
     /// Allow for dynamically adding jobs, since some compile  jobs are added dynamically.
@@ -225,6 +234,19 @@ public final class MultiJobExecutor {
         executeAllJobsTaskBuildEngine!.taskNeedsInput(key, inputID: index)
       }
     }
+
+    fileprivate func decideIfShouldStopRunningJobs(_ result: ProcessResult) {
+      switch (result.exitStatus, continueBuildingAfterErrors) {
+      case (.terminated(let code), false) where code != EXIT_SUCCESS:
+         shouldStopRunningJobs = true
+       #if !os(Windows)
+       case (.signalled, _):
+         shouldStopRunningJobs = true
+       #endif
+      default:
+        break
+      }
+    }
   }
 
   /// The work to be done.
@@ -472,6 +494,10 @@ 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)
 
@@ -514,6 +540,8 @@ class ExecuteJobRule: LLBuildRule {
         context.executorDelegate.jobFinished(job: job, result: result, pid: pid)
       }
       value = .jobExecution(success: success)
+
+      context.decideIfShouldStopRunningJobs(result)
     } catch {
       if error is DiagnosticData {
         context.diagnosticsEngine.emit(error)