Obviate the need for a reverse mapping from swiftdeps to swift by keeping the swift file in the dependency source of the graph nodes

Author: David Ungar

Sources/SwiftDriver/CMakeLists.txt

@@ -33,13 +33,11 @@ add_library(SwiftDriver
   Execution/ParsableOutput.swift
   Execution/ProcessProtocol.swift
 
-  "IncrementalCompilation/ModuleDependencyGraphParts/InputDependencySourceMap.swift"
   "IncrementalCompilation/ModuleDependencyGraphParts/Integrator.swift"
   "IncrementalCompilation/ModuleDependencyGraphParts/Node.swift"
   "IncrementalCompilation/ModuleDependencyGraphParts/NodeFinder.swift"
   "IncrementalCompilation/ModuleDependencyGraphParts/DependencySource.swift"
   "IncrementalCompilation/ModuleDependencyGraphParts/Tracer.swift"
-  "IncrementalCompilation/BidirectionalMap.swift"
   "IncrementalCompilation/BuildRecord.swift"
   "IncrementalCompilation/BuildRecordInfo.swift"
   "IncrementalCompilation/DependencyGraphDotFileWriter.swift"

Sources/SwiftDriver/IncrementalCompilation/BidirectionalMap.swift

@@ -22,8 +22,8 @@ public class DependencyGraphDotFileWriter {
     self.info = info
   }
 
-  func write(_ sfdg: SourceFileDependencyGraph) {
-    let basename = sfdg.dependencySource.shortDescription
+  func write(_ sfdg: SourceFileDependencyGraph, for file: TypedVirtualPath) {
+    let basename = file.file.basename
     write(sfdg, basename: basename)
   }
 
@@ -41,6 +41,7 @@ fileprivate extension DependencyGraphDotFileWriter {
     try! info.fileSystem.writeFileContents(path) { stream in
       var s = DOTDependencyGraphSerializer<Graph>(
         graph,
+        graphID: basename,
         stream,
         includeExternals: info.dependencyDotFilesIncludeExternals,
         includeAPINotes: info.dependencyDotFilesIncludeAPINotes)
@@ -58,16 +59,12 @@ fileprivate extension DependencyGraphDotFileWriter {
 
 // MARK: - Making dependency graphs exportable
 fileprivate protocol ExportableGraph {
-  var graphID: String {get}
   associatedtype Node: ExportableNode
   func forEachExportableNode(_ visit: (Node) -> Void)
   func forEachExportableArc(_ visit: (Node, Node) -> Void)
 }
 
 extension SourceFileDependencyGraph: ExportableGraph {
-   fileprivate var graphID: String {
-    return try! VirtualPath(path: sourceFileName).basename
-  }
   fileprivate func forEachExportableNode<Node: ExportableNode>(_ visit: (Node) -> Void) {
     forEachNode { visit($0 as! Node) }
   }
@@ -180,17 +177,20 @@ fileprivate extension DependencyKey.Designator {
 fileprivate struct DOTDependencyGraphSerializer<Graph: ExportableGraph> {
   private let includeExternals: Bool
   private let includeAPINotes: Bool
+  private let graphID: String
   private let graph: Graph
   private var nodeIDs = [Graph.Node: Int]()
   private var out: WritableByteStream
 
   fileprivate init(
     _ graph: Graph,
+    graphID: String,
     _ stream: WritableByteStream,
     includeExternals: Bool,
     includeAPINotes: Bool
   ) {
     self.graph = graph
+    self.graphID = graphID
     self.out = stream
     self.includeExternals = includeExternals
     self.includeAPINotes = includeAPINotes
@@ -205,7 +205,7 @@ fileprivate struct DOTDependencyGraphSerializer<Graph: ExportableGraph> {
   }
 
   private func emitPrelude() {
-    out <<< "digraph " <<< graph.graphID.quoted <<< " {\n"
+    out <<< "digraph " <<< graphID.quoted <<< " {\n"
   }
   private mutating func emitLegend() {
     for dummy in DependencyKey.Designator.oneOfEachKind {

Sources/SwiftDriver/IncrementalCompilation/DependencyGraphDotFileWriter.swift

@@ -300,7 +300,7 @@ public struct DependencyKey: CustomStringConvertible {
       case let .externalDepend(externalDependency):
         return "import '\(externalDependency.shortDescription)'"
       case let .sourceFileProvide(name: name):
-        return "source file \((try? VirtualPath(path: name).basename) ?? name)"
+        return "source file from \((try? VirtualPath(path: name).basename) ?? name)"
       }
     }
   }

Sources/SwiftDriver/IncrementalCompilation/DependencyKey.swift

@@ -43,6 +43,9 @@ public struct InvalidatedSet<ClosureLevel, Element: Hashable>: Sequence {
   public func compactMap<R>(_ transform: (Element) -> R? ) -> InvalidatedArray<ClosureLevel, R> {
     InvalidatedArray(contents.compactMap(transform))
   }
+  public func filter(_ isIncluded: (Element) -> Bool) -> InvalidatedArray<ClosureLevel, Element> {
+    InvalidatedArray(contents.filter(isIncluded))
+  }
 }
 
 extension InvalidatedSet where Element: Comparable {

Sources/SwiftDriver/IncrementalCompilation/DirectAndTransitiveCollections.swift

@@ -236,7 +236,7 @@ extension IncrementalCompilationState.FirstWaveComputer {
         return nil
 
       case .upToDate:
-        reporter?.report("Scheduing changed input", input)
+        reporter?.report("Scheduling changed input", input)
       case .newlyAdded:
         reporter?.report("Scheduling new", input)
       case .needsCascadingBuild:
@@ -269,12 +269,13 @@ extension IncrementalCompilationState.FirstWaveComputer {
 
     return inputsToBeCertainlyRecompiled.reduce(into: Set()) {
       speculativelyRecompiledInputs, certainlyRecompiledInput in
-      let speculativeDependents = moduleDependencyGraph.collectInputsInvalidatedBy(input: certainlyRecompiledInput)
+      let speculativeDependents = moduleDependencyGraph.collectInputsInvalidatedBy(changedInput: certainlyRecompiledInput)
       for speculativeDependent in speculativeDependents
       where !inputsToBeCertainlyRecompiled.contains(speculativeDependent) {
         if speculativelyRecompiledInputs.insert(speculativeDependent).inserted {
           reporter?.report(
-            "Immediately scheduling dependent on \(certainlyRecompiledInput.file.basename)", speculativeDependent)
+            "Immediately scheduling dependent on \(certainlyRecompiledInput.file.basename)",
+            speculativeDependent)
         }
       }
     }

Sources/SwiftDriver/IncrementalCompilation/FirstWaveComputer.swift

@@ -542,22 +542,46 @@ extension OutputFileMap {
 }
 
 // MARK: SourceFiles
+
+/// Handy information about the source files in the current invocation
 @_spi(Testing) public struct SourceFiles {
+  /// The current files in same order as the invocation
   let currentInOrder: [TypedVirtualPath]
-  private let previous: Set<VirtualPath>
+
+  /// The set of current files (actually the handles)
+  let currentSet: Set<VirtualPath.Handle>
+
+  /// Handles of the input files in the previous invocation
+  private let previous: Set<VirtualPath.Handle>
+
+  /// The files that were in the previous but not in the current invocation
   let disappeared: [VirtualPath]
 
   init(inputFiles: [TypedVirtualPath], buildRecord: BuildRecord?) {
     self.currentInOrder = inputFiles.filter {$0.type == .swift}
-    let currentSet = Set(currentInOrder.map {$0.file} )
-    self.previous = buildRecord.map {
-      Set($0.inputInfos.keys)
-    } ?? Set()
-
-    self.disappeared = previous.filter {!currentSet.contains($0)}
+    self.currentSet = currentInOrder.reduce(into: Set()) {
+      currentSet, currentFile in
+      currentSet.insert(currentFile.fileHandle)
+    }
+    guard let buildRecord = buildRecord else {
+      self.previous = Set()
+      self.disappeared = []
+      return
+    }
+    var previous = Set<VirtualPath.Handle>()
+    var disappeared = [VirtualPath]()
+    for prevPath in buildRecord.inputInfos.keys {
+      let handle = prevPath.intern()
+      previous.insert(handle)
+      if !currentSet.contains(handle) {
+        disappeared.append(prevPath)
+      }
+    }
+    self.previous = previous
+    self.disappeared = disappeared.sorted {$0.name < $1.name}
   }
 
   func isANewInput(_ file: VirtualPath) -> Bool {
-    !previous.contains(file)
+    !previous.contains(file.intern())
   }
 }

Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift

@@ -234,7 +234,7 @@ extension IncrementalCompilationState.IncrementalDependencyAndInputSetup {
     let nodesDirectlyInvalidatedByExternals =
       graph.collectNodesInvalidatedByChangedOrAddedExternals()
     // Wait till the last minute to do the transitive closure as an optimization.
-    guard let inputsInvalidatedByExternals = graph.collectInputsUsingInvalidated(
+    guard let inputsInvalidatedByExternals = graph.collectInputsInBuildUsingInvalidated(
       nodes: nodesDirectlyInvalidatedByExternals)
     else {
       return nil