Use a Confinement Queue to Protect IncrementalCompilationState

This class is serendipitously used only from the main queue for the
Driver's usual use cases. But we have no reason to expect clients of
libSwiftDriver to manipulate this class in the same manner. Provide a serial
confinement queue and protect the mutable members of
IncrementalCompilationState with it.

In the future, we ought to drop the queue and use actors.

rdar://75744005

Author: CodaFi

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift

@@ -13,7 +13,25 @@ import TSCBasic
 import Foundation
 import SwiftOptions
 
-public class IncrementalCompilationState {
+/// An instance of `IncrementalCompilationState` encapsulates the data necessary
+/// to make incremental builds scheduling decisions.
+///
+/// The primary form of interaction with the incremental compilation state is
+/// using it as an oracle to discover the jobs to execute as the incremental
+/// build progresses. After a job completes, call
+/// `IncrementalCompilationState.collectJobsDiscoveredToBeNeededAfterFinishing(job:)`
+/// to both update the incremental state and recieve an array of jobs that
+/// need to be executed in response.
+///
+/// Jobs become "unstuck" as their inputs become available, or may be discovered
+/// by this class as fresh dependency information is integrated.
+///
+/// Threading Considerations
+/// ========================
+///
+/// The public API surface of this class is thread safe, but not re-entrant.
+/// FIXME: This should be an actor.
+public final class IncrementalCompilationState {
 
   /// The oracle for deciding what depends on what. Applies to this whole module.
   @_spi(Testing) public let moduleDependencyGraph: ModuleDependencyGraph
@@ -25,15 +43,24 @@ public class IncrementalCompilationState {
   /// Already batched, and in order of input files.
   public let mandatoryJobsInOrder: [Job]
 
+  /// Jobs to run *after* the last compile, for instance, link-editing.
+  public let jobsAfterCompiles: [Job]
+
+  /// A  high-priority confinement queue that must be used to protect the incremental compilation state.
+  private let confinementQueue: DispatchQueue = DispatchQueue(label: "com.apple.swift-driver.incremental-compilation-state", qos: .userInteractive)
+
   /// Sadly, has to be `var` for formBatchedJobs
+  ///
+  /// After initialization, mutating accesses to the driver must be protected by
+  /// the confinement queue.
   private var driver: Driver
 
   /// Keyed by primary input. As required compilations are discovered after the first wave, these shrink.
+  ///
+  /// This state is modified during the incremental build. All accesses must
+  /// be protected by the confinement queue.
   private var skippedCompileGroups = [TypedVirtualPath: CompileJobGroup]()
 
-  /// Jobs to run *after* the last compile, for instance, link-editing.
-  public let jobsAfterCompiles: [Job]
-
 // MARK: - Creating IncrementalCompilationState if possible
   /// Return nil if not compiling incrementally
   init?(
@@ -124,10 +151,6 @@ extension IncrementalCompilationState {
     /// for the first wave to execute.
     let mandatoryJobsInOrder: [Job]
   }
-
-
-
-
 }
 
 extension Driver {
@@ -203,7 +226,7 @@ extension IncrementalCompilationState {
     let invalidatedInputs = collectInputsInvalidatedByRunning(finishedJob)
     assert(Set(invalidatedInputs).isDisjoint(with: finishedJob.primaryInputs),
            "Primaries should not overlap secondaries.")
-    
+
     if let reporter = self.reporter {
       for input in invalidatedInputs {
         reporter.report(
@@ -222,17 +245,21 @@ extension IncrementalCompilationState {
 
   /// After `job` finished find out which inputs must compiled that were not known to need compilation before
   private func collectInputsInvalidatedByRunning(_ job: Job)-> Set<TypedVirtualPath> {
-    guard job.kind == .compile else {
-      return Set<TypedVirtualPath>()
-    }
-    return job.primaryInputs.reduce(into: Set()) { invalidatedInputs, primaryInput in
-      invalidatedInputs.formUnion(collectInputsInvalidated(byCompiling: primaryInput))
+    return self.confinementQueue.sync {
+      guard job.kind == .compile else {
+        return Set<TypedVirtualPath>()
+      }
+      return job.primaryInputs.reduce(into: Set()) { invalidatedInputs, primaryInput in
+        invalidatedInputs.formUnion(collectInputsInvalidated(byCompiling: primaryInput))
+      }
+      .subtracting(job.primaryInputs) // have already compiled these
     }
-    .subtracting(job.primaryInputs) // have already compiled these
   }
 
-  private func collectInputsInvalidated(byCompiling input: TypedVirtualPath)
-  -> TransitivelyInvalidatedInputSet {
+  private func collectInputsInvalidated(
+    byCompiling input: TypedVirtualPath
+  ) -> TransitivelyInvalidatedInputSet {
+    dispatchPrecondition(condition: .onQueue(self.confinementQueue))
     if let found = moduleDependencyGraph.collectInputsRequiringCompilation(byCompiling: input) {
       return found
     }
@@ -242,34 +269,41 @@ extension IncrementalCompilationState {
   }
 
   /// Find the jobs that now must be run that were not originally known to be needed.
-  private func getJobs(for invalidatedInputs: Set<TypedVirtualPath>
+  private func getJobs(
+    for invalidatedInputs: Set<TypedVirtualPath>
   ) throws -> [Job] {
-    let unbatched = invalidatedInputs.flatMap { input -> [Job] in
-      if let group = skippedCompileGroups.removeValue(forKey: input) {
-        let primaryInputs = group.compileJob.primaryInputs
-        assert(primaryInputs.count == 1)
-        assert(primaryInputs[0] == input)
-        self.reporter?.report("Scheduling invalidated", input)
-        return group.allJobs()
-      }
-      else {
-        self.reporter?.report("Tried to schedule invalidated input again", input)
-        return []
+    return try self.confinementQueue.sync {
+      let unbatched = invalidatedInputs.flatMap { input -> [Job] in
+        if let group = skippedCompileGroups.removeValue(forKey: input) {
+          let primaryInputs = group.compileJob.primaryInputs
+          assert(primaryInputs.count == 1)
+          assert(primaryInputs[0] == input)
+          self.reporter?.report("Scheduling invalidated", input)
+          return group.allJobs()
+        }
+        else {
+          self.reporter?.report("Tried to schedule invalidated input again", input)
+          return []
+        }
       }
+      return try driver.formBatchedJobs(unbatched, showJobLifecycle: driver.showJobLifecycle)
     }
-    return try driver.formBatchedJobs(unbatched, showJobLifecycle: driver.showJobLifecycle)
   }
 }
 
 // MARK: - After the build
 extension IncrementalCompilationState {
   var skippedCompilationInputs: Set<TypedVirtualPath> {
-    Set(skippedCompileGroups.keys)
+    return self.confinementQueue.sync {
+      Set(skippedCompileGroups.keys)
+    }
   }
   public var skippedJobs: [Job] {
-    skippedCompileGroups.values
-      .sorted {$0.primaryInput.file.name < $1.primaryInput.file.name}
-      .flatMap {$0.allJobs()}
+    return self.confinementQueue.sync {
+      skippedCompileGroups.values
+        .sorted {$0.primaryInput.file.name < $1.primaryInput.file.name}
+        .flatMap {$0.allJobs()}
+    }
   }
 }