Group supplementary module outputs

This should have no actual impact on compilation. The idea is that we
are grouping the supplementary outputs that are specific to a given
target. This will allow us to store two of them, one for the target and
one for the target-variant. The end goal being that we can emit the
target variant interface bits in the same driver invocation that
generates the zippered object files.

Author: etcwilde

Sources/SwiftDriver/Driver/Driver.swift

@@ -376,27 +376,130 @@ public struct Driver {
   /// Path to the TBD file (text-based dylib).
   let tbdPath: VirtualPath.Handle?
 
-  /// Path to the module documentation file.
-  let moduleDocOutputPath: VirtualPath.Handle?
+  /// Target-specific supplemental output file paths
+  struct SupplementalModuleTargetOutputPaths {
+    /// Path to the module documentation file.
+    let moduleDocOutputPath: VirtualPath.Handle?
 
-  /// Path to the Swift interface file.
-  let swiftInterfacePath: VirtualPath.Handle?
+    /// Path to the Swift interface file.
+    let swiftInterfacePath: VirtualPath.Handle?
 
-  /// Path to the Swift private interface file.
-  let swiftPrivateInterfacePath: VirtualPath.Handle?
+    /// Path to the Swift private interface file.
+    let swiftPrivateInterfacePath: VirtualPath.Handle?
 
-  /// Path to the Swift package interface file.
-  let swiftPackageInterfacePath: VirtualPath.Handle?
+    /// Path to the Swift package interface file.
+    let swiftPackageInterfacePath: VirtualPath.Handle?
+
+    /// Path to the Swift module source information file.
+    let moduleSourceInfoPath: VirtualPath.Handle?
+  }
+
+  private static func computeModuleOutputPaths(
+    _ parsedOptions: inout ParsedOptions,
+    moduleName: String,
+    packageName: String?,
+    moduleOutputInfo: ModuleOutputInfo,
+    compilerOutputType: FileType?,
+    compilerMode: CompilerMode,
+    emitModuleSeparately: Bool,
+    outputFileMap: OutputFileMap?,
+    projectDirectory: VirtualPath.Handle?) throws -> SupplementalModuleTargetOutputPaths {
+    let moduleDocOutputPath = try Self.computeModuleDocOutputPath(
+      &parsedOptions,
+      moduleOutputPath: moduleOutputInfo.output?.outputPath,
+      compilerOutputType: compilerOutputType,
+      compilerMode: compilerMode,
+      outputFileMap: outputFileMap,
+      moduleName: moduleOutputInfo.name)
+
+    let moduleSourceInfoPath = try Self.computeModuleSourceInfoOutputPath(
+        &parsedOptions,
+        moduleOutputPath: moduleOutputInfo.output?.outputPath,
+        compilerOutputType: compilerOutputType,
+        compilerMode: compilerMode,
+        outputFileMap: outputFileMap,
+        moduleName: moduleOutputInfo.name,
+        projectDirectory: projectDirectory)
+
+    // ---------------------
+    // Swift interface paths
+    let swiftInterfacePath = try Self.computeSupplementaryOutputPath(
+        &parsedOptions, type: .swiftInterface, isOutputOptions: [.emitModuleInterface],
+        outputPath: .emitModuleInterfacePath,
+        compilerOutputType: compilerOutputType,
+        compilerMode: compilerMode,
+        emitModuleSeparately: emitModuleSeparately,
+        outputFileMap: outputFileMap,
+        moduleName: moduleOutputInfo.name)
+
+    let givenPrivateInterfacePath = try Self.computeSupplementaryOutputPath(
+        &parsedOptions, type: .privateSwiftInterface, isOutputOptions: [],
+        outputPath: .emitPrivateModuleInterfacePath,
+        compilerOutputType: compilerOutputType,
+        compilerMode: compilerMode,
+        emitModuleSeparately: emitModuleSeparately,
+        outputFileMap: outputFileMap,
+        moduleName: moduleOutputInfo.name)
+    let givenPackageInterfacePath = try Self.computeSupplementaryOutputPath(
+        &parsedOptions, type: .packageSwiftInterface, isOutputOptions: [],
+        outputPath: .emitPackageModuleInterfacePath,
+        compilerOutputType: compilerOutputType,
+        compilerMode: compilerMode,
+        emitModuleSeparately: emitModuleSeparately,
+        outputFileMap: outputFileMap,
+        moduleName: moduleOutputInfo.name)
+
+    // Always emit the private swift interface if a public interface is emitted.
+    // With the introduction of features like @_spi_available, we may print
+    // public and private interfaces differently even from the same codebase.
+    // For this reason, we should always print private interfaces so that we
+    // don’t mix the public interfaces with private Clang modules.
+    let swiftPrivateInterfacePath: VirtualPath.Handle?
+    if let privateInterfacePath = givenPrivateInterfacePath {
+      swiftPrivateInterfacePath = privateInterfacePath
+    } else if let swiftInterfacePath = swiftInterfacePath {
+      swiftPrivateInterfacePath = try VirtualPath.lookup(swiftInterfacePath)
+        .replacingExtension(with: .privateSwiftInterface).intern()
+    } else {
+      swiftPrivateInterfacePath = nil
+    }
+
+    let swiftPackageInterfacePath: VirtualPath.Handle?
+    if let packageName = packageName,
+        !packageName.isEmpty {
+        // Generate a package interface if built with -package-name required for
+        // decls with the `package` access level. The `.package.swiftinterface`
+        // contains package decls as well as SPI and public decls (superset of a
+        // private interface).
+        if let givenPackageInterfacePath = givenPackageInterfacePath {
+          swiftPackageInterfacePath = givenPackageInterfacePath
+        } else if let swiftInterfacePath = swiftInterfacePath {
+          swiftPackageInterfacePath = try VirtualPath.lookup(swiftInterfacePath)
+              .replacingExtension(with: .packageSwiftInterface).intern()
+        } else {
+          swiftPackageInterfacePath = nil
+        }
+    } else {
+      swiftPackageInterfacePath = nil
+    }
+
+    return SupplementalModuleTargetOutputPaths(
+      moduleDocOutputPath: moduleDocOutputPath,
+      swiftInterfacePath: swiftInterfacePath,
+      swiftPrivateInterfacePath: swiftPrivateInterfacePath,
+      swiftPackageInterfacePath: swiftPackageInterfacePath,
+      moduleSourceInfoPath: moduleSourceInfoPath)
+  }
+
+  /// Structure storing paths to supplemental outputs for the target module
+  let moduleOutputPaths: SupplementalModuleTargetOutputPaths
 
   /// File type for the optimization record.
   let optimizationRecordFileType: FileType?
 
   /// Path to the optimization record.
   let optimizationRecordPath: VirtualPath.Handle?
 
-  /// Path to the Swift module source information file.
-  let moduleSourceInfoPath: VirtualPath.Handle?
-
   /// Path to the module's digester baseline file.
   let digesterBaselinePath: VirtualPath.Handle?
 
@@ -1023,24 +1126,22 @@ public struct Driver {
         emitModuleSeparately: emitModuleSeparately,
         outputFileMap: self.outputFileMap,
         moduleName: moduleOutputInfo.name)
-    self.moduleDocOutputPath = try Self.computeModuleDocOutputPath(
-        &parsedOptions, moduleOutputPath: self.moduleOutputInfo.output?.outputPath,
-        compilerOutputType: compilerOutputType,
-        compilerMode: compilerMode,
-        outputFileMap: self.outputFileMap,
-        moduleName: moduleOutputInfo.name)
 
     let projectDirectory = Self.computeProjectDirectoryPath(
-      moduleOutputPath: self.moduleOutputInfo.output?.outputPath,
+      moduleOutputPath: moduleOutputInfo.output?.outputPath,
       fileSystem: self.fileSystem)
-    self.moduleSourceInfoPath = try Self.computeModuleSourceInfoOutputPath(
-        &parsedOptions,
-        moduleOutputPath: self.moduleOutputInfo.output?.outputPath,
-        compilerOutputType: compilerOutputType,
-        compilerMode: compilerMode,
-        outputFileMap: self.outputFileMap,
-        moduleName: moduleOutputInfo.name,
-        projectDirectory: projectDirectory)
+
+    self.moduleOutputPaths = try Self.computeModuleOutputPaths(
+      &parsedOptions,
+      moduleName: moduleOutputInfo.name,
+      packageName: self.packageName,
+      moduleOutputInfo: self.moduleOutputInfo,
+      compilerOutputType: compilerOutputType,
+      compilerMode: compilerMode,
+      emitModuleSeparately: emitModuleSeparately,
+      outputFileMap: self.outputFileMap,
+      projectDirectory: projectDirectory)
+
     self.digesterBaselinePath = try Self.computeDigesterBaselineOutputPath(
       &parsedOptions,
       moduleOutputPath: self.moduleOutputInfo.output?.outputPath,
@@ -1050,59 +1151,6 @@ public struct Driver {
       outputFileMap: self.outputFileMap,
       moduleName: moduleOutputInfo.name,
       projectDirectory: projectDirectory)
-    self.swiftInterfacePath = try Self.computeSupplementaryOutputPath(
-        &parsedOptions, type: .swiftInterface, isOutputOptions: [.emitModuleInterface],
-        outputPath: .emitModuleInterfacePath,
-        compilerOutputType: compilerOutputType,
-        compilerMode: compilerMode,
-        emitModuleSeparately: emitModuleSeparately,
-        outputFileMap: self.outputFileMap,
-        moduleName: moduleOutputInfo.name)
-    let givenPrivateInterfacePath = try Self.computeSupplementaryOutputPath(
-        &parsedOptions, type: .privateSwiftInterface, isOutputOptions: [],
-        outputPath: .emitPrivateModuleInterfacePath,
-        compilerOutputType: compilerOutputType,
-        compilerMode: compilerMode,
-        emitModuleSeparately: emitModuleSeparately,
-        outputFileMap: self.outputFileMap,
-        moduleName: moduleOutputInfo.name)
-    let givenPackageInterfacePath = try Self.computeSupplementaryOutputPath(
-        &parsedOptions, type: .packageSwiftInterface, isOutputOptions: [],
-        outputPath: .emitPackageModuleInterfacePath,
-        compilerOutputType: compilerOutputType,
-        compilerMode: compilerMode,
-        emitModuleSeparately: emitModuleSeparately,
-        outputFileMap: self.outputFileMap,
-        moduleName: moduleOutputInfo.name)
-
-    // Always emitting private swift interfaces if public interfaces are emitted.'
-    // With the introduction of features like @_spi_available, we may print public
-    // and private interfaces differently even from the same codebase. For this reason,
-    // we should always print private interfaces so that we don’t mix the public interfaces
-    // with private Clang modules.
-    if let swiftInterfacePath = self.swiftInterfacePath,
-        givenPrivateInterfacePath == nil {
-      self.swiftPrivateInterfacePath = try VirtualPath.lookup(swiftInterfacePath)
-        .replacingExtension(with: .privateSwiftInterface).intern()
-    } else {
-      self.swiftPrivateInterfacePath = givenPrivateInterfacePath
-    }
-
-    if let packageNameInput = parsedOptions.getLastArgument(Option.packageName),
-        !packageNameInput.asSingle.isEmpty {
-      // Generate a package interface if built with `-package-name` required for decls
-      // with the `package` access level. The .package.swiftinterface contains package
-      // decls as well as SPI and public decls (superset of a private interface).
-      if let publicInterfacePath = self.swiftInterfacePath,
-         givenPackageInterfacePath == nil {
-        self.swiftPackageInterfacePath = try VirtualPath.lookup(publicInterfacePath)
-          .replacingExtension(with: .packageSwiftInterface).intern()
-      } else {
-        self.swiftPackageInterfacePath = givenPackageInterfacePath
-      }
-    } else {
-      self.swiftPackageInterfacePath = nil
-    }
 
     var optimizationRecordFileType = FileType.yamlOptimizationRecord
     if let argument = parsedOptions.getLastArgument(.saveOptimizationRecordEQ)?.asSingle {
@@ -1151,7 +1199,7 @@ public struct Driver {
     Self.validateDigesterArgs(&parsedOptions,
                               moduleOutputInfo: moduleOutputInfo,
                               digesterMode: self.digesterMode,
-                              swiftInterfacePath: self.swiftInterfacePath,
+                              swiftInterfacePath: self.moduleOutputPaths.swiftInterfacePath,
                               diagnosticEngine: diagnosticsEngine)
 
     try verifyOutputOptions()

Sources/SwiftDriver/Jobs/APIDigesterJobs.swift

@@ -46,7 +46,10 @@ extension Driver {
     var commandLine = [Job.ArgTemplate]()
     commandLine.appendFlag("-dump-sdk")
 
-    try addCommonDigesterOptions(&commandLine, modulePath: modulePath, mode: mode)
+    try addCommonDigesterOptions(&commandLine,
+      modulePath: modulePath,
+      swiftModuleInterfacePath: self.moduleOutputPaths.swiftInterfacePath,
+      mode: mode)
 
     commandLine.appendFlag(.o)
     commandLine.appendPath(VirtualPath.lookup(outputPath))
@@ -74,7 +77,11 @@ extension Driver {
     }
     guard let currentABI = getDescriptorPath(for: mode) else {
       // we don't have existing descriptor to use so we have to load the module from interface/swiftmodule
-      return try digesterCompareToBaselineJob(modulePath: modulePath, baselinePath: baselinePath, mode: digesterMode)
+      return try digesterCompareToBaselineJob(
+        modulePath: modulePath,
+        swiftModuleInterfacePath: self.moduleOutputPaths.swiftInterfacePath,
+        baselinePath: baselinePath,
+        mode: digesterMode)
     }
     var commandLine = [Job.ArgTemplate]()
     commandLine.appendFlag("-diagnose-sdk")
@@ -105,14 +112,20 @@ extension Driver {
     )
   }
 
-  mutating func digesterCompareToBaselineJob(modulePath: VirtualPath.Handle, baselinePath: VirtualPath.Handle, mode: DigesterMode) throws -> Job {
+  mutating func digesterCompareToBaselineJob(modulePath: VirtualPath.Handle,
+    swiftModuleInterfacePath: VirtualPath.Handle?,
+    baselinePath: VirtualPath.Handle,
+    mode: DigesterMode) throws -> Job {
     var commandLine = [Job.ArgTemplate]()
     commandLine.appendFlag("-diagnose-sdk")
     commandLine.appendFlag("-disable-fail-on-error")
     commandLine.appendFlag("-baseline-path")
     commandLine.appendPath(VirtualPath.lookup(baselinePath))
 
-    try addCommonDigesterOptions(&commandLine, modulePath: modulePath, mode: mode)
+    try addCommonDigesterOptions(&commandLine,
+      modulePath: modulePath,
+      swiftModuleInterfacePath: swiftModuleInterfacePath,
+      mode: mode)
 
     var serializedDiagnosticsPath: VirtualPath.Handle?
     if let arg = parsedOptions.getLastArgument(.serializeBreakingChangesPath)?.asSingle {
@@ -130,7 +143,7 @@ extension Driver {
     var inputs: [TypedVirtualPath] = [.init(file: modulePath, type: .swiftModule),
                                       .init(file: baselinePath, type: mode.baselineFileType)]
     // If a module interface was emitted, treat it as an input in ABI mode.
-    if let interfacePath = self.swiftInterfacePath, mode == .abi {
+    if let interfacePath = swiftModuleInterfacePath, mode == .abi {
       inputs.append(.init(file: interfacePath, type: .swiftInterface))
     }
 
@@ -147,6 +160,7 @@ extension Driver {
 
   private mutating func addCommonDigesterOptions(_ commandLine: inout [Job.ArgTemplate],
                                                  modulePath: VirtualPath.Handle,
+                                                 swiftModuleInterfacePath: VirtualPath.Handle?,
                                                  mode: DigesterMode) throws {
     commandLine.appendFlag("-module")
     commandLine.appendFlag(moduleOutputInfo.name)
@@ -160,7 +174,7 @@ extension Driver {
     let searchPath = VirtualPath.lookup(modulePath).parentDirectory
     commandLine.appendFlag(.I)
     commandLine.appendPath(searchPath)
-    if let interfacePath = self.swiftInterfacePath  {
+    if let interfacePath = swiftModuleInterfacePath {
       let interfaceSearchPath = VirtualPath.lookup(interfacePath).parentDirectory
       if interfaceSearchPath != searchPath {
         commandLine.appendFlag(.I)

Sources/SwiftDriver/Jobs/CompileJob.swift

@@ -277,6 +277,8 @@ extension Driver {
       primaryInputs: primaryInputs,
       inputsGeneratingCodeCount: inputsGeneratingCodeCount,
       inputOutputMap: &inputOutputMap,
+      moduleOutputInfo: self.moduleOutputInfo,
+      moduleOutputPaths: self.moduleOutputPaths,
       includeModuleTracePath: emitModuleTrace,
       indexFilePath: indexFilePath)
 

Sources/SwiftDriver/Jobs/EmitModuleJob.swift

@@ -17,6 +17,7 @@ extension Driver {
   mutating func addCommonModuleOptions(
       commandLine: inout [Job.ArgTemplate],
       outputs: inout [TypedVirtualPath],
+      moduleOutputPaths: SupplementalModuleTargetOutputPaths,
       isMergeModule: Bool
   ) throws {
     // Add supplemental outputs.
@@ -28,12 +29,12 @@ extension Driver {
       outputs.append(.init(file: path, type: type))
     }
 
-    addSupplementalOutput(path: moduleDocOutputPath, flag: "-emit-module-doc-path", type: .swiftDocumentation)
-    addSupplementalOutput(path: moduleSourceInfoPath, flag: "-emit-module-source-info-path", type: .swiftSourceInfoFile)
-    addSupplementalOutput(path: swiftInterfacePath, flag: "-emit-module-interface-path", type: .swiftInterface)
-    addSupplementalOutput(path: swiftPrivateInterfacePath, flag: "-emit-private-module-interface-path", type: .privateSwiftInterface)
+    addSupplementalOutput(path: moduleOutputPaths.moduleDocOutputPath, flag: "-emit-module-doc-path", type: .swiftDocumentation)
+    addSupplementalOutput(path: moduleOutputPaths.moduleSourceInfoPath, flag: "-emit-module-source-info-path", type: .swiftSourceInfoFile)
+    addSupplementalOutput(path: moduleOutputPaths.swiftInterfacePath, flag: "-emit-module-interface-path", type: .swiftInterface)
+    addSupplementalOutput(path: moduleOutputPaths.swiftPrivateInterfacePath, flag: "-emit-private-module-interface-path", type: .privateSwiftInterface)
     if let pkgName = packageName, !pkgName.isEmpty {
-      addSupplementalOutput(path: swiftPackageInterfacePath, flag: "-emit-package-module-interface-path", type: .packageSwiftInterface)
+      addSupplementalOutput(path: moduleOutputPaths.swiftPackageInterfacePath, flag: "-emit-package-module-interface-path", type: .packageSwiftInterface)
     }
     addSupplementalOutput(path: objcGeneratedHeaderPath, flag: "-emit-objc-header-path", type: .objcHeader)
     addSupplementalOutput(path: tbdPath, flag: "-emit-tbd-path", type: .tbd)
@@ -102,7 +103,7 @@ extension Driver {
     try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs, kind: .emitModule)
     // FIXME: Add MSVC runtime library flags
 
-    try addCommonModuleOptions(commandLine: &commandLine, outputs: &outputs, isMergeModule: false)
+    try addCommonModuleOptions(commandLine: &commandLine, outputs: &outputs, moduleOutputPaths: moduleOutputPaths,isMergeModule: false)
     try addCommonSymbolGraphOptions(commandLine: &commandLine)
 
     try commandLine.appendLast(.checkApiAvailabilityOnly, from: &parsedOptions)