Fix tests to prepare for immutable map

Author: David Ungar

Sources/SwiftDriver/IncrementalCompilation/DirectAndTransitiveCollections.swift

@@ -19,7 +19,7 @@ public struct Directly {}
 public struct InvalidatedSet<ClosureLevel, Element: Hashable>: Sequence {
   var contents: Set<Element>
 
-  init(_ s: Set<Element> = Set()) {
+  @_spi(Testing) public init(_ s: Set<Element> = Set()) {
     self.contents = s
   }
   init<Elements: Sequence>(_ elements: Elements)

Sources/SwiftDriver/IncrementalCompilation/ModuleDependencyGraphParts/InputDependencySourceMap.swift

@@ -45,6 +45,36 @@ extension InputDependencySourceMap {
     _ eachFn: (TypedVirtualPath, DependencySource) -> Void
   ) {
     biMap.forEach(eachFn)
+
+extension OutputFileMap {
+  @_spi(Testing) public func getDependencySource(
+    for sourceFile: TypedVirtualPath
+  ) -> DependencySource? {
+    assert(sourceFile.type == FileType.swift)
+    guard let swiftDepsPath = existingOutput(inputFile: sourceFile.fileHandle,
+                                             outputType: .swiftDeps)
+    else {
+      return nil
+   }
+    assert(VirtualPath.lookup(swiftDepsPath).extension == FileType.swiftDeps.rawValue)
+    let typedSwiftDepsFile = TypedVirtualPath(file: swiftDepsPath, type: .swiftDeps)
+    return DependencySource(typedSwiftDepsFile)
+  }
+}
+
+extension OutputFileMap {
+  @_spi(Testing) public func getDependencySource(
+    for sourceFile: TypedVirtualPath
+  ) -> DependencySource? {
+    assert(sourceFile.type == FileType.swift)
+    guard let swiftDepsPath = existingOutput(inputFile: sourceFile.fileHandle,
+                                             outputType: .swiftDeps)
+    else {
+      return nil
+   }
+    assert(VirtualPath.lookup(swiftDepsPath).extension == FileType.swiftDeps.rawValue)
+    let typedSwiftDepsFile = TypedVirtualPath(file: swiftDepsPath, type: .swiftDeps)
+    return DependencySource(typedSwiftDepsFile)
   }
 }
 

Tests/SwiftDriverTests/DependencyGraphSerializationTests.swift

@@ -14,7 +14,9 @@ import XCTest
 @_spi(Testing) import SwiftDriver
 import TSCBasic
 
-class DependencyGraphSerializationTests: XCTestCase {
+class DependencyGraphSerializationTests: XCTestCase, ModuleDependencyGraphMocker {
+  static let mockGraphCreator = MockModuleDependencyGraphCreator(maxIndex: 12)
+
   func roundTrip(_ graph: ModuleDependencyGraph) throws {
     let mockPath = VirtualPath.absolute(AbsolutePath("/module-dependency-graph"))
     let fs = InMemoryFileSystem()
@@ -216,8 +218,7 @@ class DependencyGraphSerializationTests: XCTestCase {
     ]
 
     for fixture in fixtures {
-      let de = DiagnosticsEngine()
-      let graph = ModuleDependencyGraph(mock: de)
+      let graph = Self.mockGraphCreator.mockUpAGraph()
       for loadCommand in fixture.commands {
         switch loadCommand {
         case .load(index: let index, nodes: let nodes, fingerprint: let fingerprint):

Tests/SwiftDriverTests/Helpers/MockingIncrementalCompilation.swift

@@ -13,6 +13,7 @@
 @_spi(Testing) import SwiftDriver
 import TSCBasic
 import Foundation
+import XCTest
 
 // MARK: - utilities for unit testing
 extension ModuleDependencyGraph {
@@ -119,13 +120,15 @@ extension BuildRecordInfo {
 extension IncrementalCompilationState.IncrementalDependencyAndInputSetup {
   static func mock(
     options: IncrementalCompilationState.Options = [.verifyDependencyGraphAfterEveryImport],
-    diagnosticEngine: DiagnosticsEngine = DiagnosticsEngine(),
-    fileSystem: FileSystem = localFileSystem) -> Self {
+    outputFileMap: OutputFileMap = OutputFileMap(),
+    fileSystem: FileSystem = localFileSystem,
+    diagnosticEngine: DiagnosticsEngine = DiagnosticsEngine()
+  ) -> Self {
     let diagnosticsEngine = DiagnosticsEngine()
-    let outputFileMap = OutputFileMap()
     return Self(options, outputFileMap,
                 BuildRecordInfo.mock(diagnosticsEngine, outputFileMap),
-                nil, nil, [], fileSystem, diagnosticsEngine)
+                nil, nil, [], fileSystem,
+                diagnosticsEngine)
   }
 }
 
@@ -139,3 +142,38 @@ extension Collection where Element: StringProtocol {
     sorted(by: `is`(dotFileName:lessThan:))
   }
 }
+
+// MARK: - Mocking up a ModuleDependencyGraph
+protocol ModuleDependencyGraphMocker {
+  static var mockGraphCreator: MockModuleDependencyGraphCreator {get}
+}
+
+struct MockModuleDependencyGraphCreator {
+  let maxIndex: Int
+  let info: IncrementalCompilationState.IncrementalDependencyAndInputSetup
+
+  /// maxIndex must be larger than any index used
+  init(maxIndex: Int) {
+    let outputFileMap = OutputFileMap.mock(maxIndex: maxIndex)
+    self.info = IncrementalCompilationState.IncrementalDependencyAndInputSetup
+      .mock(outputFileMap: outputFileMap)
+    self.maxIndex = maxIndex
+  }
+
+  func mockUpAGraph() -> ModuleDependencyGraph {
+    ModuleDependencyGraph(info, .buildingWithoutAPrior)
+  }
+}
+
+
+extension OutputFileMap {
+  fileprivate static func mock(maxIndex: Int) -> Self {
+    OutputFileMap( entries: (0...maxIndex) .reduce(into: [:]) {
+      entries, index in
+      let inputHandle = TypedVirtualPath(mockInput: index).file.intern()
+      let swiftDepsHandle = DependencySource(mock: index).file.intern()
+      entries[inputHandle] = [.swiftDeps: swiftDepsHandle]
+    }
+    )
+  }
+}