[Explicit Module Builds] Add backwards-compatibility shim for dependency graph getter

Author: artemcm

Sources/SwiftDriver/Driver/Driver.swift

@@ -253,11 +253,11 @@ public struct Driver {
   var forceEmitModuleBeforeCompile: Bool = false
 
   // FIXME: We should soon be able to remove this from being in the Driver's state.
-  // Its only remaining use outside of actual dependency-build planning is in
-  // command-line option generation for the main module compile.
+  // Its only remaining use outside of actual dependency build planning is in
+  // command-line input option generation for the explicit main module compile job.
   /// Planner for constructing module build jobs using Explicit Module Builds.
-  /// Constructed during the planning phase only when all modules will be prebuilt and treated
-  /// as explicit by the various compilation jobs.
+  /// Constructed during the planning phase only when all module dependencies will be prebuilt and treated
+  /// as explicit inputs by the various compilation jobs.
   @_spi(Testing) public var explicitDependencyBuildPlanner: ExplicitDependencyBuildPlanner? = nil
 
   /// An oracle for querying inter-module dependencies

Sources/SwiftDriver/Explicit Module Builds/Inter Module Dependencies/CommonDependencyOperations.swift

@@ -20,7 +20,22 @@
   }
 }
 
-internal extension InterModuleDependencyGraph {
+// This is a backwards-compatibility shim 
+public extension InterModuleDependencyGraph {
+  // This is a shim for backwards-compatibility with existing API used by SwiftPM.
+  // TODO: After SwiftPM switches to using the oracle, this should be deleted.
+  static func mergeModules(
+    from dependencyGraph: InterModuleDependencyGraph,
+    into discoveredModules: inout ModuleInfoMap
+  ) throws {
+    for (moduleId, moduleInfo) in dependencyGraph.modules {
+      try mergeModule(moduleId, moduleInfo, into: &discoveredModules)
+    }
+  }
+}
+
+
+@_spi(Testing) public extension InterModuleDependencyGraph {
   /// Merge a module with a given ID and Info into a ModuleInfoMap
   static func mergeModule(_ moduleId: ModuleDependencyId,
                           _ moduleInfo: ModuleInfo,

Sources/SwiftDriver/Explicit Module Builds/Inter Module Dependencies/InterModuleDependencyOracle.swift

@@ -10,39 +10,69 @@
 //
 //===----------------------------------------------------------------------===//
 
-
+// An inter-module dependency oracle, responsible for responding to queries about
+// dependencies of a given module, caching already-discovered dependencies along the way.
+//
 // The oracle is currently implemented as a simple store of ModuleInfo nodes.
-// It is the currently responsibility of the swift-driver to populate and update
+// It is the responsibility of the Driver to populate and update
 // the store. It does so by invoking individual -scan-dependencies jobs and
-// accumulating resulting dependency graphs.
+// accumulating resulting dependency graphs into the oracle's store.
 //
 // The design of the oracle's public API is meant to abstract that away,
-// allowing us to, in the future, replace the underlying implementation with
+// allowing us to replace the underlying implementation in the future, with
 // a persistent-across-targets dependency scanning library.
 //
 /// An abstraction of a cache and query-engine of inter-module dependencies
 public class InterModuleDependencyOracle {
-  // MARK: Public API
   /// Query the ModuleInfo of a module with a given ID
-  public func getModuleInfo(of moduleId: ModuleDependencyId) -> ModuleInfo? {
+  @_spi(Testing) public func getModuleInfo(of moduleId: ModuleDependencyId) -> ModuleInfo? {
     return modules[moduleId]
   }
 
   /// Query the direct dependencies of a module with a given ID
-  public func getDependencies(of moduleId: ModuleDependencyId) -> [ModuleDependencyId]? {
+  @_spi(Testing) public func getDependencies(of moduleId: ModuleDependencyId)
+  -> [ModuleDependencyId]? {
     return modules[moduleId]?.directDependencies
   }
 
-  // MARK: Private Implementation
-
   // TODO: This will require a SwiftDriver entry-point for scanning a module given
   // a command invocation and a set of source-files. As-is, the driver itself is responsible
   // for executing individual module dependency-scanning actions and updating oracle state.
+  // (Implemented with InterModuleDependencyOracle::mergeModules extension)
+  //
+  // func getFullDependencies(inputs: [TypedVirtualPath],
+  //                          commandLine: [Job.ArgTemplate]) -> InterModuleDependencyGraph {}
+  //
 
   /// The complete set of modules discovered so far, spanning potentially multiple targets
   internal var modules: ModuleInfoMap = [:]
 
-  /// Override the default initializer's internal access level for test access
+  /// Override the default initializer's access level for test access
   @_spi(Testing) public init() {}
 }
 
+// This is a shim for backwards-compatibility with existing API used by SwiftPM.
+// TODO: After SwiftPM switches to using the oracle, this should be deleted.
+extension Driver {
+  public var interModuleDependencyGraph: InterModuleDependencyGraph? {
+    let mainModuleId : ModuleDependencyId = .swift(moduleOutputInfo.name)
+    var mainModuleDependencyGraph =
+      InterModuleDependencyGraph(mainModuleName: moduleOutputInfo.name)
+
+    addModule(moduleId: mainModuleId,
+              moduleInfo: interModuleDependencyOracle.getModuleInfo(of: mainModuleId)!,
+              into: &mainModuleDependencyGraph)
+    return mainModuleDependencyGraph
+  }
+
+  private func addModule(moduleId: ModuleDependencyId,
+                         moduleInfo: ModuleInfo,
+                         into dependencyGraph: inout InterModuleDependencyGraph) {
+    dependencyGraph.modules[moduleId] = moduleInfo
+    moduleInfo.directDependencies?.forEach { dependencyId in
+      addModule(moduleId: dependencyId,
+                moduleInfo: interModuleDependencyOracle.getModuleInfo(of: dependencyId)!,
+                into: &dependencyGraph)
+    }
+  }
+}