Split LLBuildManifestBuilder.swift into extension files (#6966)

`LLBuildManifestBuilder.swift` is getting too big, especially when there's a need to add new commands for additional build steps. Fortunately, it's already separated out into multiple extensions, with different commands implemented in each extension. Let's move those extensions into separate files for better readability and easier discovery/navigation.

Author: MaxDesiatov

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -553,7 +553,7 @@ public final class SwiftTargetBuildDescription {
         // // User arguments (from -Xcxx) should follow generated arguments to allow user overrides
         // args += self.buildParameters.flags.cxxCompilerFlags.asSwiftcCXXCompilerFlags()
 
-        // Enable the correct lto mode if requested.
+        // Enable the correct LTO mode if requested.
         switch self.buildParameters.linkTimeOptimizationMode {
         case nil:
             break

Sources/Build/BuildManifest/LLBuildManifestBuilder+Clang.swift

@@ -0,0 +1,136 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2015-2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct LLBuildManifest.Node
+import struct Basics.AbsolutePath
+import struct Basics.InternalError
+import class PackageGraph.ResolvedTarget
+import PackageModel
+
+extension LLBuildManifestBuilder {
+    /// Create a llbuild target for a Clang target description.
+    func createClangCompileCommand(
+        _ target: ClangTargetBuildDescription
+    ) throws {
+        let standards = [
+            (target.clangTarget.cxxLanguageStandard, SupportedLanguageExtension.cppExtensions),
+            (target.clangTarget.cLanguageStandard, SupportedLanguageExtension.cExtensions),
+        ]
+
+        var inputs: [Node] = []
+
+        // Add resources node as the input to the target. This isn't great because we
+        // don't need to block building of a module until its resources are assembled but
+        // we don't currently have a good way to express that resources should be built
+        // whenever a module is being built.
+        if let resourcesNode = try self.createResourcesBundle(for: .clang(target)) {
+            inputs.append(resourcesNode)
+        }
+
+        func addStaticTargetInputs(_ target: ResolvedTarget) {
+            if case .swift(let desc)? = self.plan.targetMap[target], target.type == .library {
+                inputs.append(file: desc.moduleOutputPath)
+            }
+        }
+
+        for dependency in target.target.dependencies(satisfying: self.buildEnvironment) {
+            switch dependency {
+            case .target(let target, _):
+                addStaticTargetInputs(target)
+
+            case .product(let product, _):
+                switch product.type {
+                case .executable, .snippet, .library(.dynamic), .macro:
+                    guard let planProduct = plan.productMap[product] else {
+                        throw InternalError("unknown product \(product)")
+                    }
+                    // Establish a dependency on binary of the product.
+                    let binary = try planProduct.binaryPath
+                    inputs.append(file: binary)
+
+                case .library(.automatic), .library(.static), .plugin:
+                    for target in product.targets {
+                        addStaticTargetInputs(target)
+                    }
+                case .test:
+                    break
+                }
+            }
+        }
+
+        for binaryPath in target.libraryBinaryPaths {
+            let path = destinationPath(forBinaryAt: binaryPath)
+            if self.fileSystem.isDirectory(binaryPath) {
+                inputs.append(directory: path)
+            } else {
+                inputs.append(file: path)
+            }
+        }
+
+        var objectFileNodes: [Node] = []
+
+        for path in try target.compilePaths() {
+            let isCXX = path.source.extension.map { SupportedLanguageExtension.cppExtensions.contains($0) } ?? false
+            let isC = path.source.extension.map { $0 == SupportedLanguageExtension.c.rawValue } ?? false
+
+            var args = try target.basicArguments(isCXX: isCXX, isC: isC)
+
+            args += ["-MD", "-MT", "dependencies", "-MF", path.deps.pathString]
+
+            // Add language standard flag if needed.
+            if let ext = path.source.extension {
+                for (standard, validExtensions) in standards {
+                    if let standard, validExtensions.contains(ext) {
+                        args += ["-std=\(standard)"]
+                    }
+                }
+            }
+
+            args += ["-c", path.source.pathString, "-o", path.object.pathString]
+
+            let clangCompiler = try buildParameters.toolchain.getClangCompiler().pathString
+            args.insert(clangCompiler, at: 0)
+
+            let objectFileNode: Node = .file(path.object)
+            objectFileNodes.append(objectFileNode)
+
+            self.manifest.addClangCmd(
+                name: path.object.pathString,
+                description: "Compiling \(target.target.name) \(path.filename)",
+                inputs: inputs + [.file(path.source)],
+                outputs: [objectFileNode],
+                arguments: args,
+                dependencies: path.deps.pathString
+            )
+        }
+
+        try addBuildToolPlugins(.clang(target))
+
+        // Create a phony node to represent the entire target.
+        let targetName = target.target.getLLBuildTargetName(config: self.buildConfig)
+        let output: Node = .virtual(targetName)
+
+        self.manifest.addNode(output, toTarget: targetName)
+        self.manifest.addPhonyCmd(
+            name: output.name,
+            inputs: objectFileNodes,
+            outputs: [output]
+        )
+
+        if self.plan.graph.isInRootPackages(target.target, satisfying: self.buildEnvironment) {
+            if !target.isTestTarget {
+                self.addNode(output, toTarget: .main)
+            }
+            self.addNode(output, toTarget: .test)
+        }
+    }
+}

Sources/Build/BuildManifest/LLBuildManifestBuilder+Resources.swift

@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2015-2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct LLBuildManifest.Node
+import struct Basics.RelativePath
+
+extension LLBuildManifestBuilder {
+    /// Adds command for creating the resources bundle of the given target.
+    ///
+    /// Returns the virtual node that will build the entire bundle.
+    func createResourcesBundle(
+        for target: TargetBuildDescription
+    ) throws -> Node? {
+        guard let bundlePath = target.bundlePath else { return nil }
+
+        var outputs: [Node] = []
+
+        let infoPlistDestination = try RelativePath(validating: "Info.plist")
+
+        // Create a copy command for each resource file.
+        for resource in target.resources {
+            switch resource.rule {
+            case .copy, .process:
+                let destination = try bundlePath.appending(resource.destination)
+                let (_, output) = addCopyCommand(from: resource.path, to: destination)
+                outputs.append(output)
+            case .embedInCode:
+                break
+            }
+        }
+
+        // Create a copy command for the Info.plist if a resource with the same name doesn't exist yet.
+        if let infoPlistPath = target.resourceBundleInfoPlistPath {
+            let destination = bundlePath.appending(infoPlistDestination)
+            let (_, output) = addCopyCommand(from: infoPlistPath, to: destination)
+            outputs.append(output)
+        }
+
+        let cmdName = target.target.getLLBuildResourcesCmdName(config: self.buildConfig)
+        self.manifest.addPhonyCmd(name: cmdName, inputs: outputs, outputs: [.virtual(cmdName)])
+
+        return .virtual(cmdName)
+    }
+}