[Build] Add an option to emit Swift module separately

This can enable more parallelism since downstream targets can begin
compiling without waiting for the entire module to finish building.

<rdar://problem/56747877>

Author: aciidgh

Sources/Build/BuildPlan.swift

@@ -136,6 +136,11 @@ public struct BuildParameters: Encodable {
     /// `.swiftmodule`s.
     public let enableParseableModuleInterfaces: Bool
 
+    /// Emit Swift module separately from object files. This can enable more parallelism
+    /// since downstream targets can begin compiling without waiting for the entire
+    /// module to finish building.
+    public let emitSwiftModuleSeparately: Bool
+
     /// Checks if stdout stream is tty.
     fileprivate let isTTY: Bool = {
         guard let stream = stdoutStream.stream as? LocalFileOutputByteStream else {
@@ -165,7 +170,8 @@ public struct BuildParameters: Encodable {
         enableCodeCoverage: Bool = false,
         indexStoreMode: IndexStoreMode = .auto,
         enableParseableModuleInterfaces: Bool = false,
-        enableTestDiscovery: Bool = false
+        enableTestDiscovery: Bool = false,
+        emitSwiftModuleSeparately: Bool = false
     ) {
         self.dataPath = dataPath
         self.configuration = configuration
@@ -180,6 +186,7 @@ public struct BuildParameters: Encodable {
         self.indexStoreMode = indexStoreMode
         self.enableParseableModuleInterfaces = enableParseableModuleInterfaces
         self.enableTestDiscovery = enableTestDiscovery
+        self.emitSwiftModuleSeparately = emitSwiftModuleSeparately
     }
 
     /// Returns the compiler arguments for the index store, if enabled.
@@ -701,11 +708,148 @@ public final class SwiftTargetBuildDescription {
         return args
     }
 
+    /// Command-line for emitting just the Swift module.
+    public func emitModuleCommandLine() -> [String] {
+        assert(buildParameters.emitSwiftModuleSeparately)
+
+        var result: [String] = []
+        result.append(buildParameters.toolchain.swiftCompiler.pathString)
+
+        result.append("-module-name")
+        result.append(target.c99name)
+        result.append("-emit-module")
+        result.append("-emit-module-path")
+        result.append(moduleOutputPath.pathString)
+        result += buildParameters.toolchain.extraSwiftCFlags
+
+        result.append("-Xfrontend")
+        result.append("-experimental-skip-non-inlinable-function-bodies")
+        result.append("-force-single-frontend-invocation")
+
+        if target.type == .library || target.type == .test {
+            result.append("-parse-as-library")
+        }
+
+        // FIXME: Handle WMO
+
+        for source in target.sources.paths {
+            result.append(source.pathString)
+        }
+
+        result.append("-I")
+        result.append(buildParameters.buildPath.pathString)
+
+        // FIXME: Maybe refactor these into "common args".
+        result += buildParameters.targetTripleArgs(for: target)
+        result += ["-swift-version", swiftVersion.rawValue]
+        result += optimizationArguments
+        result += ["-g"]
+        result += ["-j\(ProcessInfo.processInfo.activeProcessorCount)"]
+        result += activeCompilationConditions
+        result += additionalFlags
+        result += moduleCacheArgs
+        result += self.buildSettingsFlags()
+
+        return result
+    }
+
+    /// Command-line for emitting the object files.
+    ///
+    /// Note: This doesn't emit the module.
+    public func emitObjectsCommandLine() -> [String] {
+        assert(buildParameters.emitSwiftModuleSeparately)
+
+        var result: [String] = []
+        result.append(buildParameters.toolchain.swiftCompiler.pathString)
+
+        result.append("-module-name")
+        result.append(target.c99name)
+        result.append("-incremental")
+        result.append("-emit-dependencies")
+
+        result.append("-output-file-map")
+        // FIXME: Eliminate side effect.
+        result.append(try! writeOutputFileMap().pathString)
+
+        if target.type == .library || target.type == .test {
+            result.append("-parse-as-library")
+        }
+        // FIXME: Handle WMO
+
+        result.append("-c")
+        for source in target.sources.paths {
+            result.append(source.pathString)
+        }
+
+        result.append("-I")
+        result.append(buildParameters.buildPath.pathString)
+
+        result += buildParameters.targetTripleArgs(for: target)
+        result += ["-swift-version", swiftVersion.rawValue]
+
+        result += buildParameters.indexStoreArguments
+        result += buildParameters.toolchain.extraSwiftCFlags
+        result += optimizationArguments
+        result += ["-g"]
+        result += ["-j\(ProcessInfo.processInfo.activeProcessorCount)"]
+        result += activeCompilationConditions
+        result += additionalFlags
+        result += moduleCacheArgs
+        result += buildParameters.sanitizers.compileSwiftFlags()
+        result += ["-parseable-output"]
+        result += self.buildSettingsFlags()
+        result += buildParameters.swiftCompilerFlags
+        return result
+    }
+
     /// Returns true if ObjC compatibility header should be emitted.
     private var shouldEmitObjCCompatibilityHeader: Bool {
         return buildParameters.triple.isDarwin() && target.type == .library
     }
 
+    private func writeOutputFileMap() throws -> AbsolutePath {
+        let path = tempsPath.appending(component: "output-file-map.json")
+        let stream = BufferedOutputByteStream()
+
+        stream <<< "{\n"
+
+        let masterDepsPath = tempsPath.appending(component: "master.swiftdeps")
+
+        stream <<< "  \"\": {\n";
+        // FIXME: Handle WMO
+        stream <<< "    \"swift-dependencies\": \"" <<< masterDepsPath.pathString <<< "\"\n";
+        stream <<< "  },\n";
+
+        // Write out the entries for each source file.
+        let sources = target.sources.paths
+        for (idx, source) in sources.enumerated() {
+            let object = objects[idx]
+            let objectDir = object.parentDirectory
+
+            let sourceFileName = source.basenameWithoutExt
+            let partialModulePath = objectDir.appending(component: sourceFileName + "~partial.swiftmodule")
+
+            let swiftDepsPath = objectDir.appending(component: sourceFileName + ".swiftdeps")
+
+            stream <<< "  \"" <<< source.pathString <<< "\": {\n"
+            // FIXME: Handle WMO
+            let depsPath = objectDir.appending(component: sourceFileName + ".d")
+            stream <<< "    \"dependencies\": \"" <<< depsPath.pathString <<< "\",\n"
+            // FIXME: Need to record this deps file for processing it later.
+
+            stream <<< "    \"object\": \"" <<< object.pathString <<< "\",\n"
+            stream <<< "    \"swiftmodule\": \"" <<< partialModulePath.pathString <<< "\",\n";
+            stream <<< "    \"swift-dependencies\": \"" <<< swiftDepsPath.pathString <<< "\"\n";
+            stream <<< "  }" <<< ((idx + 1) < sources.count ? "," : "") <<< "\n"
+        }
+
+        stream <<< "}\n"
+
+        try localFileSystem.createDirectory(path.parentDirectory, recursive: true)
+        try localFileSystem.writeFileContents(path, bytes: stream.bytes)
+        return path
+    }
+
     /// Generates the module map for the Swift target and returns its path.
     private func generateModuleMap() throws -> AbsolutePath {
         let path = tempsPath.appending(component: moduleMapFilename)

Sources/Build/ManifestBuilder.swift

@@ -149,13 +149,57 @@ extension LLBuildManifestBuilder {
     private func createSwiftCompileCommand(
         _ target: SwiftTargetBuildDescription
     ) {
+        // Inputs.
         let inputs = computeSwiftCompileCmdInputs(target)
 
-        let cmdName = target.target.getCommandName(config: buildConfig)
+        // Outputs.
         let objectNodes = target.objects.map(Node.file)
         let moduleNode = Node.file(target.moduleOutputPath)
         let cmdOutputs = objectNodes + [moduleNode]
+
+        if buildParameters.emitSwiftModuleSeparately {
+            addSwiftCmdsEmitSwiftModuleSeparately(target, inputs: inputs, objectNodes: objectNodes, moduleNode: moduleNode)
+        } else {
+            addCmdWithBuiltinSwiftTool(target, inputs: inputs, cmdOutputs: cmdOutputs)
+        }
+
+        addTargetCmd(target, cmdOutputs: cmdOutputs)
+        addModuleWrapCmd(target)
+    }
+
+    private func addSwiftCmdsEmitSwiftModuleSeparately(
+        _ target: SwiftTargetBuildDescription,
+        inputs: [Node],
+        objectNodes: [Node],
+        moduleNode: Node
+    ) {
+        // FIXME: We need to ingest the emitted dependencies.
+
+        manifest.addShellCmd(
+            name: target.moduleOutputPath.pathString,
+            description: "Emitting module for \(target.target.name)",
+            inputs: inputs,
+            outputs: [moduleNode],
+            args: target.emitModuleCommandLine()
+        )
+
+        let cmdName = target.target.getCommandName(config: buildConfig)
+        manifest.addShellCmd(
+            name: cmdName,
+            description: "Compiling module \(target.target.name)",
+            inputs: inputs,
+            outputs: objectNodes,
+            args: target.emitObjectsCommandLine()
+        )
+    }
+
+    private func addCmdWithBuiltinSwiftTool(
+        _ target: SwiftTargetBuildDescription,
+        inputs: [Node],
+        cmdOutputs: [Node]
+    ) {
         let isLibrary = target.target.type == .library || target.target.type == .test
+        let cmdName = target.target.getCommandName(config: buildConfig)
 
         manifest.addSwiftCmd(
             name: cmdName,
@@ -172,9 +216,6 @@ extension LLBuildManifestBuilder {
             isLibrary: isLibrary,
             WMO: buildParameters.configuration == .release
         )
-
-        addTargetCmd(target, cmdOutputs: cmdOutputs)
-        addModuleWrapCmd(target)
     }
 
     private func computeSwiftCompileCmdInputs(

Sources/Commands/Options.swift

@@ -86,5 +86,8 @@ public class ToolOptions {
     /// Whether to enable llbuild manifest caching.
     public var enableBuildManifestCaching: Bool = false
 
+    /// Emit the Swift module separately from the object files.
+    public var emitSwiftModuleSeparately: Bool = false
+
     public required init() {}
 }

Sources/Commands/SwiftTool.swift

@@ -337,6 +337,10 @@ public class SwiftTool<Options: ToolOptions> {
             option: parser.add(option: "--enable-build-manifest-caching", kind: Bool.self, usage: nil),
             to: { $0.enableBuildManifestCaching = $1 })
 
+        binder.bind(
+            option: parser.add(option: "--emit-swift-module-separately", kind: Bool.self, usage: nil),
+            to: { $0.emitSwiftModuleSeparately = $1 })
+
         // Let subclasses bind arguments.
         type(of: self).defineArguments(parser: parser, binder: binder)
 
@@ -739,7 +743,8 @@ public class SwiftTool<Options: ToolOptions> {
                 enableCodeCoverage: options.shouldEnableCodeCoverage,
                 indexStoreMode: options.indexStoreMode,
                 enableParseableModuleInterfaces: options.shouldEnableParseableModuleInterfaces,
-                enableTestDiscovery: options.enableTestDiscovery
+                enableTestDiscovery: options.enableTestDiscovery,
+                emitSwiftModuleSeparately: options.emitSwiftModuleSeparately
             )
         })
     }()