renamings (#493)

Author: David Ungar

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift

@@ -442,7 +442,7 @@ extension IncrementalCompilationState {
         fileSystem: fileSystem,
         reporter: reporter)
 
-    let externallyChangedInputs = computeExternallyChangedInputs(
+    let externallyChangedInputs = collectInputsInvalidatedByChangedExternals(
       buildTime: outOfDateBuildRecord.buildTime,
       fileSystem: fileSystem,
       moduleDependencyGraph: moduleDependencyGraph,
@@ -470,7 +470,7 @@ extension IncrementalCompilationState {
     // first wave, even though they may not require compilation.
     // Any such inputs missed, will be found by the rereading of swiftDeps
     // as each first wave job finished.
-    let speculativeInputs = computeSpeculativeInputs(
+    let speculativeInputs = collectInputsToBeSpeculativelyRecompiled(
       changedInputs: changedInputs,
       externalDependents: externallyChangedInputs,
       inputsMissingOutputs: Set(inputsMissingOutputs),
@@ -555,18 +555,18 @@ extension IncrementalCompilationState {
   }
 
   /// Any files dependent on modified files from other modules must be compiled, too.
-  private static func computeExternallyChangedInputs(
+  private static func collectInputsInvalidatedByChangedExternals(
     buildTime: Date,
     fileSystem: FileSystem,
     moduleDependencyGraph: ModuleDependencyGraph,
     reporter: IncrementalCompilationState.Reporter?
   ) -> [TypedVirtualPath] {
     var externalDependencySources = Set<DependencySource>()
-    for extDepAndPrint in moduleDependencyGraph.fingerprintedExternalDependencies {
-      let extDep = extDepAndPrint.externalDependency
+    for fingerprintedExternalDependency in moduleDependencyGraph.fingerprintedExternalDependencies {
+      let extDep = fingerprintedExternalDependency.externalDependency
       let extModTime = extDep.modTime(fileSystem) ?? Date.distantFuture
       if extModTime >= buildTime {
-        for dependent in moduleDependencyGraph.untracedDependents(of: extDepAndPrint) {
+        for dependent in moduleDependencyGraph.collectUntracedNodesDirectlyUsing(fingerprintedExternalDependency) {
           guard let dependencySource = dependent.dependencySource else {
             fatalError("Dependent \(dependent) does not have dependencies file!")
           }
@@ -586,7 +586,7 @@ extension IncrementalCompilationState {
   /// The needs[Non}CascadingBuild stuff was cargo-culted from the legacy driver.
   /// TODO: something better, e.g. return nothing here, but process changed dependencySource
   /// before the whole frontend job finished.
-  private static func computeSpeculativeInputs(
+  private static func collectInputsToBeSpeculativelyRecompiled(
     changedInputs: [ChangedInput],
     externalDependents: [TypedVirtualPath],
     inputsMissingOutputs: Set<TypedVirtualPath>,
@@ -605,7 +605,7 @@ extension IncrementalCompilationState {
     let cascadingFileSet = Set(cascadingChangedInputs).union(cascadingExternalDependents)
     for cascadingFile in cascadingFileSet {
        let dependentsOfOneFile = moduleDependencyGraph
-        .findDependentSourceFiles(of: cascadingFile)
+        .collectInputsTransitivelyInvalidatedBy(input: cascadingFile)
       for dep in dependentsOfOneFile where !cascadingFileSet.contains(dep) {
         if dependentFiles.insert(dep).0 {
           reporter?.report(
@@ -671,7 +671,7 @@ extension IncrementalCompilationState {
   /// If no more compiles are needed, return nil.
   /// Careful: job may not be primary.
 
-  public func getJobsDiscoveredToBeNeededAfterFinishing(
+  public func collectJobsDiscoveredToBeNeededAfterFinishing(
     job finishedJob: Job, result: ProcessResult
    ) throws -> [Job]? {
     return try confinementQueue.sync {
@@ -682,17 +682,17 @@ extension IncrementalCompilationState {
       }
 
       // Find and deal with inputs that how need to be compiled
-      let discoveredInputs = collectInputsDiscovered(from: finishedJob)
-      assert(Set(discoveredInputs).isDisjoint(with: finishedJob.primaryInputs),
+      let invalidatedInputs = collectInputsInvalidatedByRunning(finishedJob)
+      assert(Set(invalidatedInputs).isDisjoint(with: finishedJob.primaryInputs),
              "Primaries should not overlap secondaries.")
 
       if let reporter = self.reporter {
-        for input in discoveredInputs {
+        for input in invalidatedInputs {
           reporter.report(
             "Queuing because of dependencies discovered later:", input)
         }
       }
-      let newJobs = try getJobsFor(discoveredCompilationInputs: discoveredInputs)
+      let newJobs = try getJobs(for: invalidatedInputs)
       unfinishedJobs.formUnion(newJobs)
       if unfinishedJobs.isEmpty {
         // no more compilations are possible
@@ -703,15 +703,17 @@ extension IncrementalCompilationState {
  }
 
   /// After `job` finished find out which inputs must compiled that were not known to need compilation before
-  private func collectInputsDiscovered(from job: Job)  -> [TypedVirtualPath] {
+  private func collectInputsInvalidatedByRunning(_ job: Job)  -> [TypedVirtualPath] {
     guard job.kind == .compile else {
       return []
     }
     return Array(
       Set(
         job.primaryInputs.flatMap {
           input -> [TypedVirtualPath] in
-          if let found = moduleDependencyGraph.findSourcesToCompileAfterCompiling(input, on: self.driver.fileSystem) {
+          if let found = moduleDependencyGraph.collectInputsInvalidated(
+              byCompiling: input,
+              on: self.driver.fileSystem) {
             return found
           }
           self.reporter?.report(
@@ -724,9 +726,9 @@ extension IncrementalCompilationState {
     .sorted {$0.file.name < $1.file.name}
   }
 
-  /// Find the jobs that now must be run that were not originally known to be needed.
-  private func getJobsFor(
-    discoveredCompilationInputs inputs: [TypedVirtualPath]
+  /// Find the jobs that now must be run to compile the given inputs.
+  private func getJobs(
+    for inputs: [TypedVirtualPath]
   ) throws -> [Job] {
     let unbatched = inputs.flatMap { input -> [Job] in
       if let group = skippedCompileGroups.removeValue(forKey: input) {

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraph.swift

@@ -176,7 +176,7 @@ extension ModuleDependencyGraph {
     else {
       return nil
     }
-    return results.changedNodes.union(externallyCausedChanges)
+    return results.allInvalidatedNodes.union(externallyCausedChanges)
   }
 
   /// Returns changed nodes
@@ -194,7 +194,7 @@ extension ModuleDependencyGraph {
         externalDependency: edp,
         fileSystem: fileSystem)
       if let result = resultIfOK {
-        changedNodes.formUnion(result.changedNodes)
+        changedNodes.formUnion(result.allInvalidatedNodes)
         workList.formUnion(result.discoveredExternalDependencies)
       }
       else {
@@ -232,15 +232,15 @@ extension ModuleDependencyGraph {
 extension ModuleDependencyGraph {
   /// Find all the sources that depend on `sourceFile`. For some source files, these will be
   /// speculatively scheduled in the first wave.
-  func findDependentSourceFiles(
-    of sourceFile: TypedVirtualPath
+  func collectInputsTransitivelyInvalidatedBy(
+    input sourceFile: TypedVirtualPath
   ) -> [TypedVirtualPath] {
     var allDependencySourcesToRecompile = Set<DependencySource>()
 
     let dependencySource = inputDependencySourceMap[sourceFile]
 
     for dependencySourceToRecompile in
-      findSwiftDepsToRecompileWhenDependencySourceChanges( dependencySource ) {
+      collectSwiftDepsTransitivelyUsing( dependencySource ) {
       if dependencySourceToRecompile != dependencySource {
         allDependencySourcesToRecompile.insert(dependencySourceToRecompile)
       }
@@ -255,73 +255,73 @@ extension ModuleDependencyGraph {
 
   /// Find all the swiftDeps files that depend on `dependencySource`.
   /// Really private, except for testing.
-  /*@_spi(Testing)*/ public func findSwiftDepsToRecompileWhenDependencySourceChanges(
+  /*@_spi(Testing)*/ public func collectSwiftDepsTransitivelyUsing(
     _ dependencySource: DependencySource  ) -> Set<DependencySource> {
     let nodes = nodeFinder.findNodes(for: dependencySource) ?? [:]
     /// Tests expect this to be reflexive
-    return findSwiftDepsToRecompileWhenNodesChange(nodes.values)
+    return collectSwiftDepsUsingTransitivelyInvalidated(nodes: nodes.values)
   }
 }
 // MARK: - Scheduling the 2nd wave
 extension ModuleDependencyGraph {
   /// After `source` has been compiled, figure out what other source files need compiling.
   /// Used to schedule the 2nd wave.
   /// Return nil in case of an error.
-  func findSourcesToCompileAfterCompiling(
-    _ source: TypedVirtualPath,
+  func collectInputsInvalidated(
+    byCompiling input: TypedVirtualPath,
     on fileSystem: FileSystem
   ) -> [TypedVirtualPath]? {
-    findSourcesToCompileAfterIntegrating(
-      input: source,
-      dependencySource: inputDependencySourceMap[source],
+    collectInputsRequiringCompilation(
+      byCompiling: input,
+      dependencySource: inputDependencySourceMap[input],
       on: fileSystem)
   }
 
   /// After a compile job has finished, read its swiftDeps file and return the source files needing
   /// recompilation.
   /// Return nil in case of an error.
   /// May return a source that has already been compiled.
-  private func findSourcesToCompileAfterIntegrating(
-    input: TypedVirtualPath,
+  private func     collectInputsRequiringCompilation(
+    byCompiling: TypedVirtualPath,
     dependencySource: DependencySource,
     on fileSystem: FileSystem
   ) -> [TypedVirtualPath]? {
-    let swiftDeps = inputDependencySourceMap[input].typedFile
+    let swiftDeps = inputDependencySourceMap[byCompiling].typedFile
     let changedNodesIfOK = integrate(swiftDeps: swiftDeps)
     guard let changedNodes = changedNodesIfOK else {
       return nil
     }
-    return findSwiftDepsToRecompileWhenNodesChange(changedNodes)
+    return collectSwiftDepsUsingTransitivelyInvalidated(nodes: changedNodes)
       .map { inputDependencySourceMap[$0] }
   }
 }
 
 // MARK: - Scheduling either wave
 extension ModuleDependencyGraph {
   /// Find all the swiftDeps affected when the nodes change.
-  /*@_spi(Testing)*/ public func findSwiftDepsToRecompileWhenNodesChange<Nodes: Sequence>(
-    _ nodes: Nodes
+  /*@_spi(Testing)*/ public func collectSwiftDepsUsingTransitivelyInvalidated<Nodes: Sequence>(
+    nodes: Nodes
   ) -> Set<DependencySource>
     where Nodes.Element == Node
   {
-    let affectedNodes = Tracer.findPreviouslyUntracedUsesOf(
-      defs: nodes,
+    let affectedNodes = Tracer.collectPreviouslyUntracedNodesUsing(
+      defNodes: nodes,
       in: self,
       diagnosticEngine: diagnosticEngine)
       .tracedUses
     return Set(affectedNodes.compactMap {$0.dependencySource})
   }
 
-  /*@_spi(Testing)*/ public func untracedDependents(
-    of extDepAndPrint: FingerprintedExternalDependency
+  /*@_spi(Testing)*/ public func collectUntracedNodesDirectlyUsing(
+    _ fingerprintedExternalDependency: FingerprintedExternalDependency
   ) -> [ModuleDependencyGraph.Node] {
     // These nodes will depend on the *interface* of the external Decl.
-    let key = DependencyKey(interfaceFor: extDepAndPrint.externalDependency)
+    let key = DependencyKey(interfaceFor: fingerprintedExternalDependency.externalDependency)
     // DependencySource is OK as a nil placeholder because it's only used to find
     // the corresponding implementation node and there won't be any for an
     // external dependency node.
     let node = Node(key: key,
-                    fingerprint: extDepAndPrint.fingerprint,
+                    fingerprint: fingerprintedExternalDependency.fingerprint,
                     dependencySource: nil)
     return nodeFinder
       .orderedUses(of: node)

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraphParts/Integrator.swift

@@ -24,7 +24,7 @@ extension ModuleDependencyGraph {
 
     /*@_spi(Testing)*/
     public struct Results {
-      var changedNodes = Set<Node>()
+      var allInvalidatedNodes = Set<Node>()
       var discoveredExternalDependencies = Set<FingerprintedExternalDependency>()
     }
     public private(set) var results = Results()
@@ -80,14 +80,14 @@ extension ModuleDependencyGraph.Integrator {
   private mutating func integrate() {
     integrateEachSourceNode()
     handleDisappearedNodes()
-    destination.ensureGraphWillRetraceDependents(of: results.changedNodes)
+    destination.ensureGraphWillRetraceDependents(of: results.allInvalidatedNodes)
   }
   private mutating func integrateEachSourceNode() {
     sourceGraph.forEachNode { integrate(oneNode: $0) }
   }
   private mutating func handleDisappearedNodes() {
     for (_, node) in disappearedNodes {
-      results.changedNodes.insert(node)
+      results.allInvalidatedNodes.insert(node)
       destination.nodeFinder.remove(node)
     }
   }
@@ -125,7 +125,7 @@ extension ModuleDependencyGraph.Integrator {
     // Node was and still is. Do not remove it.
     disappearedNodes.removeValue(forKey: matchHere.key)
     if matchHere.fingerprint != integrand.fingerprint {
-      results.changedNodes.insert(matchHere)
+      results.allInvalidatedNodes.insert(matchHere)
     }
     return matchHere
   }
@@ -145,7 +145,7 @@ extension ModuleDependencyGraph.Integrator {
       .replace(expat,
                newDependencySource: sourceGraph.dependencySource,
                newFingerprint: integrand.fingerprint)
-    results.changedNodes.insert(integratedNode)
+    results.allInvalidatedNodes.insert(integratedNode)
     return integratedNode
   }
 
@@ -160,7 +160,7 @@ extension ModuleDependencyGraph.Integrator {
       dependencySource: sourceGraph.dependencySource)
     let oldNode = destination.nodeFinder.insert(newNode)
     assert(oldNode == nil, "Should be new!")
-    results.changedNodes.insert(newNode)
+    results.allInvalidatedNodes.insert(newNode)
     return newNode
   }
 
@@ -181,13 +181,13 @@ extension ModuleDependencyGraph.Integrator {
         return
       }
       // Check both in case we reread a prior ModDepGraph from a different mode
-      let extDepAndPrint = FingerprintedExternalDependency(externalDependency,
+      let fingerprintedExternalDependency = FingerprintedExternalDependency(externalDependency,
                                                            def.fingerprint)
-      let isKnown = destination.fingerprintedExternalDependencies.contains(extDepAndPrint)
+      let isKnown = destination.fingerprintedExternalDependencies.contains(fingerprintedExternalDependency)
       guard !isKnown else {return}
 
-      results.discoveredExternalDependencies.insert(extDepAndPrint)
-      results.changedNodes.insert(moduleUseNode)
+      results.discoveredExternalDependencies.insert(fingerprintedExternalDependency)
+      results.allInvalidatedNodes.insert(moduleUseNode)
     }
   }
 }

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraphParts/Tracer.swift

@@ -37,21 +37,21 @@ extension ModuleDependencyGraph.Tracer {
 
   /// Find all uses of `defs` that have not already been traced.
   /// (If already traced, jobs have already been scheduled.)
-  static func findPreviouslyUntracedUsesOf<Nodes: Sequence> (
-    defs: Nodes,
+  static func collectPreviouslyUntracedNodesUsing<Nodes: Sequence> (
+    defNodes: Nodes,
     in graph: ModuleDependencyGraph,
     diagnosticEngine: DiagnosticsEngine
   ) -> Self
   where Nodes.Element == ModuleDependencyGraph.Node
   {
-    var tracer = Self(findingUsesOf: defs,
+    var tracer = Self(collectingUsesOf: defNodes,
                       in: graph,
                       diagnosticEngine: diagnosticEngine)
-    tracer.findPreviouslyUntracedDependents()
+    tracer.collectPreviouslyUntracedDependents()
     return tracer
   }
 
-  private init<Nodes: Sequence>(findingUsesOf defs: Nodes,
+  private init<Nodes: Sequence>(collectingUsesOf defs: Nodes,
                in graph: ModuleDependencyGraph,
                diagnosticEngine: DiagnosticsEngine)
   where Nodes.Element == ModuleDependencyGraph.Node
@@ -63,13 +63,13 @@ extension ModuleDependencyGraph.Tracer {
     self.diagnosticEngine = diagnosticEngine
   }
 
-  private mutating func findPreviouslyUntracedDependents() {
+  private mutating func collectPreviouslyUntracedDependents() {
     for n in startingPoints {
-      findNextPreviouslyUntracedDependent(of: n)
+      collectNextPreviouslyUntracedDependent(of: n)
     }
   }
 
-  private mutating func findNextPreviouslyUntracedDependent(
+  private mutating func collectNextPreviouslyUntracedDependent(
     of definition: ModuleDependencyGraph.Node
   ) {
     guard graph.isUntraced(definition) else { return }
@@ -85,7 +85,7 @@ extension ModuleDependencyGraph.Tracer {
 
     // If this use also provides something, follow it
     for use in graph.nodeFinder.orderedUses(of: definition) {
-      findNextPreviouslyUntracedDependent(of: use)
+      collectNextPreviouslyUntracedDependent(of: use)
     }
     traceDeparture(pathLengthAfterArrival);
   }

Sources/SwiftDriverExecution/MultiJobExecutor.swift

@@ -218,7 +218,7 @@ public final class MultiJobExecutor {
         return
       }
       if let newJobs = try incrementalCompilationState?
-          .getJobsDiscoveredToBeNeededAfterFinishing(job: job, result: result) {
+          .collectJobsDiscoveredToBeNeededAfterFinishing(job: job, result: result) {
         let newJobIndices = Self.addJobs(newJobs, to: &jobs, producing: &producerMap)
         needInputFor(indices: newJobIndices)
       }