[NFC] Build/PackageModel: split Target.swift and BuildPlan.swift (#6972)

### Motivation:

The `Build` module is not very well documented and the overall flow of
build planning is not obvious when trying to read its code.

### Modifications:

`Target.swift` and `BuildPlan.swift` are split into separate files that
contain either separate types or extensions with corresponding
functionality. Now that both files are split, their extensions mostly
correspond to types of targets that SwiftPM supports:

* Clang
* Swift
* Plugin
* System Library

This separation is also closely reflected in `BuildPlan` extensions:

* Clang
* Product
* Swift
* Test

Also moved product-related build manifest code to
`LLBuildManifestBuilder+Product.swift`.

### Result:

Now it's much easier to navigate across the `Build` module codebase, and
each step of build planning has a separate directory that describes the
overall flow:

1. Build description is formed (the existing `BuildDescription`
directory);
2. Build planning assigns necessary flags, options, and arguments (the
new `BuildPlan` directory);
3. Build manifest is written out for llbuild (the existing
`BuildManifest` directory).

As a bonus, these files can now be built in parallel, but I don't think
it's noticeable when building. Another benefit is that imports for each
new file are explicit and don't pollute the corresponding namespace with
wildcard imports of whole modules.

Author: MaxDesiatov

Sources/Build/BuildDescription/ProductBuildDescription.swift

@@ -124,7 +124,7 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
                 // during GC, and it removes Swift metadata sections like swift5_protocols
                 // We should add support of SHF_GNU_RETAIN-like flag for __attribute__((retain))
                 // to LLVM and wasm-ld
-                // This workaround is required for not only WASI but also all WebAssembly archs
+                // This workaround is required for not only WASI but also all WebAssembly triples
                 // using wasm-ld (e.g. wasm32-unknown-unknown). So this branch is conditioned by
                 // arch == .wasm32
                 return []

Sources/Build/BuildManifest/LLBuildManifestBuilder+Product.swift

@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 Basics.AbsolutePath
+import struct LLBuildManifest.Node
+
+extension LLBuildManifestBuilder {
+    func createProductCommand(_ buildProduct: ProductBuildDescription) throws {
+        let cmdName = try buildProduct.product.getCommandName(config: self.buildConfig)
+
+        // Add dependency on Info.plist generation on Darwin platforms.
+        let testInputs: [AbsolutePath]
+        if buildProduct.product.type == .test
+            && buildProduct.buildParameters.targetTriple.isDarwin()
+            && buildProduct.buildParameters.experimentalTestOutput {
+            let testBundleInfoPlistPath = try buildProduct.binaryPath.parentDirectory.parentDirectory.appending(component: "Info.plist")
+            testInputs = [testBundleInfoPlistPath]
+
+            self.manifest.addWriteInfoPlistCommand(
+                principalClass: "\(buildProduct.product.targets[0].c99name).SwiftPMXCTestObserver",
+                outputPath: testBundleInfoPlistPath
+            )
+        } else {
+            testInputs = []
+        }
+
+        switch buildProduct.product.type {
+        case .library(.static):
+            try self.manifest.addShellCmd(
+                name: cmdName,
+                description: "Archiving \(buildProduct.binaryPath.prettyPath())",
+                inputs: (buildProduct.objects + [buildProduct.linkFileListPath]).map(Node.file),
+                outputs: [.file(buildProduct.binaryPath)],
+                arguments: try buildProduct.archiveArguments()
+            )
+
+        default:
+            let inputs = try buildProduct.objects
+                + buildProduct.dylibs.map { try $0.binaryPath }
+                + [buildProduct.linkFileListPath]
+                + testInputs
+
+            try self.manifest.addShellCmd(
+                name: cmdName,
+                description: "Linking \(buildProduct.binaryPath.prettyPath())",
+                inputs: inputs.map(Node.file),
+                outputs: [.file(buildProduct.binaryPath)],
+                arguments: try buildProduct.linkArguments()
+            )
+        }
+
+        // Create a phony node to represent the entire target.
+        let targetName = try buildProduct.product.getLLBuildTargetName(config: self.buildConfig)
+        let output: Node = .virtual(targetName)
+
+        self.manifest.addNode(output, toTarget: targetName)
+        try self.manifest.addPhonyCmd(
+            name: output.name,
+            inputs: [.file(buildProduct.binaryPath)],
+            outputs: [output]
+        )
+
+        if self.plan.graph.reachableProducts.contains(buildProduct.product) {
+            if buildProduct.product.type != .test {
+                self.addNode(output, toTarget: .main)
+            }
+            self.addNode(output, toTarget: .test)
+        }
+
+        self.manifest.addWriteLinkFileListCommand(
+            objects: Array(buildProduct.objects),
+            linkFileListPath: buildProduct.linkFileListPath
+        )
+    }
+}

Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift

@@ -14,11 +14,13 @@
 @_implementationOnly import SwiftDriver
 import struct Basics.InternalError
 import struct Basics.AbsolutePath
+import struct Basics.RelativePath
 import struct Basics.TSCAbsolutePath
 import struct LLBuildManifest.Node
 import struct LLBuildManifest.BuildManifest
 import struct SPMBuildCore.BuildParameters
 import class PackageGraph.ResolvedTarget
+import protocol TSCBasic.FileSystem
 import enum TSCBasic.ProcessEnv
 import func TSCBasic.topologicalSort
 
@@ -556,3 +558,22 @@ private class UniqueExplicitDependencyJobTracker {
         return new
     }
 }
+
+extension TypedVirtualPath {
+    /// Resolve a typed virtual path provided by the Swift driver to
+    /// a node in the build graph.
+    fileprivate func resolveToNode(fileSystem: some FileSystem) throws -> Node {
+        if let absolutePath = (file.absolutePath.flatMap { AbsolutePath($0) }) {
+            return Node.file(absolutePath)
+        } else if let relativePath = (file.relativePath.flatMap { RelativePath($0) }) {
+            guard let workingDirectory: AbsolutePath = fileSystem.currentWorkingDirectory else {
+                throw InternalError("unknown working directory")
+            }
+            return Node.file(workingDirectory.appending(relativePath))
+        } else if let temporaryFileName = file.temporaryFileName {
+            return Node.virtual(temporaryFileName.pathString)
+        } else {
+            throw InternalError("Cannot resolve VirtualPath: \(file)")
+        }
+    }
+}

Sources/Build/BuildManifest/LLBuildManifestBuilder.swift

@@ -130,7 +130,7 @@ extension LLBuildManifestBuilder {
 
             // Add the output paths of any prebuilds that were run, so that we redo the plan if they change.
             var derivedSourceDirPaths: [AbsolutePath] = []
-            for result in plan.prebuildCommandResults.values.flatMap({ $0 }) {
+            for result in self.plan.prebuildCommandResults.values.flatMap({ $0 }) {
                 derivedSourceDirPaths.append(contentsOf: result.outputDirectories)
             }
             inputs.append(contentsOf: derivedSourceDirPaths.sorted().map { Node.directoryStructure($0) })
@@ -213,7 +213,7 @@ extension LLBuildManifestBuilder {
     private func addTestDiscoveryGenerationCommand() throws {
         for testDiscoveryTarget in self.plan.targets.compactMap(\.testDiscoveryTargetBuildDescription) {
             let testTargets = testDiscoveryTarget.target.dependencies
-                .compactMap(\.target).compactMap { plan.targetMap[$0] }
+                .compactMap(\.target).compactMap { self.plan.targetMap[$0] }
             let objectFiles = try testTargets.flatMap { try $0.objects }.sorted().map(Node.file)
             let outputs = testDiscoveryTarget.target.sources.paths
 
@@ -241,7 +241,7 @@ extension LLBuildManifestBuilder {
             // depends on.
             let discoveredTargetDependencyBuildDescriptions = testEntryPointTarget.target.dependencies
                 .compactMap(\.target)
-                .compactMap { plan.targetMap[$0] }
+                .compactMap { self.plan.targetMap[$0] }
                 .compactMap(\.testDiscoveryTargetBuildDescription)
 
             // The module outputs of the discovery targets this synthesized entry point target depends on are
@@ -273,70 +273,6 @@ extension TargetBuildDescription {
     }
 }
 
-// MARK: - Product Command
-
-extension LLBuildManifestBuilder {
-    private func createProductCommand(_ buildProduct: ProductBuildDescription) throws {
-        let cmdName = try buildProduct.product.getCommandName(config: self.buildConfig)
-
-        // Add dependency on Info.plist generation on Darwin platforms.
-        let testInputs: [AbsolutePath]
-        if buildProduct.product.type == .test, buildProduct.buildParameters.targetTriple.isDarwin(), buildProduct.buildParameters.experimentalTestOutput {
-            let testBundleInfoPlistPath = try buildProduct.binaryPath.parentDirectory.parentDirectory.appending(component: "Info.plist")
-            testInputs = [testBundleInfoPlistPath]
-
-            self.manifest.addWriteInfoPlistCommand(principalClass: "\(buildProduct.product.targets[0].c99name).SwiftPMXCTestObserver", outputPath: testBundleInfoPlistPath)
-        } else {
-            testInputs = []
-        }
-
-        switch buildProduct.product.type {
-        case .library(.static):
-            try self.manifest.addShellCmd(
-                name: cmdName,
-                description: "Archiving \(buildProduct.binaryPath.prettyPath())",
-                inputs: (buildProduct.objects + [buildProduct.linkFileListPath]).map(Node.file),
-                outputs: [.file(buildProduct.binaryPath)],
-                arguments: try buildProduct.archiveArguments()
-            )
-
-        default:
-            let inputs = try buildProduct.objects
-                + buildProduct.dylibs.map { try $0.binaryPath }
-                + [buildProduct.linkFileListPath]
-                + testInputs
-
-            try self.manifest.addShellCmd(
-                name: cmdName,
-                description: "Linking \(buildProduct.binaryPath.prettyPath())",
-                inputs: inputs.map(Node.file),
-                outputs: [.file(buildProduct.binaryPath)],
-                arguments: try buildProduct.linkArguments()
-            )
-        }
-
-        // Create a phony node to represent the entire target.
-        let targetName = try buildProduct.product.getLLBuildTargetName(config: self.buildConfig)
-        let output: Node = .virtual(targetName)
-
-        self.manifest.addNode(output, toTarget: targetName)
-        try self.manifest.addPhonyCmd(
-            name: output.name,
-            inputs: [.file(buildProduct.binaryPath)],
-            outputs: [output]
-        )
-
-        if self.plan.graph.reachableProducts.contains(buildProduct.product) {
-            if buildProduct.product.type != .test {
-                self.addNode(output, toTarget: .main)
-            }
-            self.addNode(output, toTarget: .test)
-        }
-
-        self.manifest.addWriteLinkFileListCommand(objects: Array(buildProduct.objects), linkFileListPath: buildProduct.linkFileListPath)
-    }
-}
-
 extension ResolvedTarget {
     public func getCommandName(config: String) -> String {
         "C." + self.getLLBuildTargetName(config: config)
@@ -404,25 +340,6 @@ extension LLBuildManifestBuilder {
     }
 }
 
-extension TypedVirtualPath {
-    /// Resolve a typed virtual path provided by the Swift driver to
-    /// a node in the build graph.
-    func resolveToNode(fileSystem: FileSystem) throws -> Node {
-        if let absolutePath = (file.absolutePath.flatMap{ AbsolutePath($0) }) {
-            return Node.file(absolutePath)
-        } else if let relativePath = (file.relativePath.flatMap{ RelativePath($0) }) {
-            guard let workingDirectory: AbsolutePath = fileSystem.currentWorkingDirectory else {
-                throw InternalError("unknown working directory")
-            }
-            return Node.file(workingDirectory.appending(relativePath))
-        } else if let temporaryFileName = file.temporaryFileName {
-            return Node.virtual(temporaryFileName.pathString)
-        } else {
-            throw InternalError("Cannot resolve VirtualPath: \(file)")
-        }
-    }
-}
-
 extension Sequence where Element: Hashable {
     /// Unique the elements in a sequence.
     func uniqued() -> [Element] {