WIP: Support for building plugin dependencies for the host

Hacky support for building plugin dependencies for the host. This is achieved by creating a second build operation with altered build parameters and individually building dependencies using that build operation, somewhat similar to how command plugins operate.

Author: neonichu

Sources/Build/BuildOperation.swift

@@ -394,13 +394,15 @@ public final class BuildOperation: PackageStructureDelegate, SPMBuildCore.BuildS
         let prebuildCommandResults: [ResolvedTarget: [PrebuildCommandResult]]
         // Invoke any build tool plugins in the graph to generate prebuild commands and build commands.
         if let pluginConfiguration = self.pluginConfiguration  {
+            let buildOperationForPluginDependencies = try BuildOperation(buildParameters: self.buildParameters.withDestination(self.buildParameters.hostTriple), cacheBuildManifest: false, packageGraphLoader: { return graph }, additionalFileRules: self.additionalFileRules, pkgConfigDirectories: self.pkgConfigDirectories, outputStream: self.outputStream, logLevel: self.logLevel, fileSystem: self.fileSystem, observabilityScope: self.observabilityScope)
             buildToolPluginInvocationResults = try graph.invokeBuildToolPlugins(
                 outputDir: pluginConfiguration.workDirectory.appending(component: "outputs"),
                 builtToolsDir: self.buildParameters.buildPath,
                 buildEnvironment: self.buildParameters.buildEnvironment,
                 toolSearchDirectories: [self.buildParameters.toolchain.swiftCompilerPath.parentDirectory],
                 pkgConfigDirectories: self.pkgConfigDirectories,
                 pluginScriptRunner: pluginConfiguration.scriptRunner,
+                buildSystemForPluginDependencies: buildOperationForPluginDependencies,
                 observabilityScope: self.observabilityScope,
                 fileSystem: self.fileSystem
             )

Sources/SPMBuildCore/BuildParameters.swift

@@ -293,6 +293,50 @@ public struct BuildParameters: Encodable {
         self.verboseOutput = verboseOutput
     }
 
+    public func withDestination(_ destinationTriple: Triple) throws -> BuildParameters {
+        let forceTestDiscovery: Bool
+        let testEntryPointPath: AbsolutePath?
+        switch self.testProductStyle {
+        case .entryPointExecutable(let explicitlyEnabledDiscovery, let explicitlySpecifiedPath):
+            forceTestDiscovery = explicitlyEnabledDiscovery
+            testEntryPointPath = explicitlySpecifiedPath
+        case .loadableBundle:
+            forceTestDiscovery = false
+            testEntryPointPath = nil
+        }
+
+        return .init(
+            dataPath: self.dataPath.parentDirectory.appending(components: ["plugins", "tools"]),
+            configuration: self.configuration,
+            toolchain: try UserToolchain(destination: Destination.hostDestination()),
+            hostTriple: self.hostTriple,
+            destinationTriple: destinationTriple,
+            flags: BuildFlags(),
+            pkgConfigDirectories: self.pkgConfigDirectories,
+            architectures: nil,
+            workers: self.workers,
+            shouldLinkStaticSwiftStdlib: self.shouldLinkStaticSwiftStdlib,
+            shouldEnableManifestCaching: self.shouldEnableManifestCaching,
+            canRenameEntrypointFunctionName: self.canRenameEntrypointFunctionName,
+            shouldCreateDylibForDynamicProducts: self.shouldCreateDylibForDynamicProducts,
+            sanitizers: self.sanitizers,
+            enableCodeCoverage: self.enableCodeCoverage,
+            indexStoreMode: self.indexStoreMode,
+            enableParseableModuleInterfaces: self.enableParseableModuleInterfaces,
+            emitSwiftModuleSeparately: self.emitSwiftModuleSeparately,
+            useIntegratedSwiftDriver: self.useIntegratedSwiftDriver,
+            useExplicitModuleBuild: self.useExplicitModuleBuild,
+            isXcodeBuildSystemEnabled: self.isXcodeBuildSystemEnabled,
+            enableTestability: self.enableTestability,
+            forceTestDiscovery: forceTestDiscovery,
+            testEntryPointPath: testEntryPointPath,
+            explicitTargetDependencyImportCheckingMode: self.explicitTargetDependencyImportCheckingMode,
+            linkerDeadStrip: self.linkerDeadStrip,
+            colorizedOutput: self.colorizedOutput,
+            verboseOutput: self.verboseOutput
+        )
+    }
+
     /// The path to the build directory (inside the data directory).
     public var buildPath: AbsolutePath {
         if isXcodeBuildSystemEnabled {

Sources/SPMBuildCore/PluginInvocation.swift

@@ -332,6 +332,7 @@ extension PackageGraph {
         toolSearchDirectories: [AbsolutePath],
         pkgConfigDirectories: [AbsolutePath],
         pluginScriptRunner: PluginScriptRunner,
+        buildSystemForPluginDependencies: BuildSystem? = nil,
         observabilityScope: ObservabilityScope,
         fileSystem: FileSystem
     ) throws -> [ResolvedTarget: [BuildToolPluginInvocationResult]] {
@@ -372,8 +373,17 @@ extension PackageGraph {
                 // names to the corresponding paths. Built tools are assumed to be in the build tools directory.
                 var builtToolNames: [String] = []
                 let accessibleTools = try pluginTarget.processAccessibleTools(packageGraph: self, fileSystem: fileSystem, environment: buildEnvironment, for: try pluginScriptRunner.hostTriple) { name, path in
-                    builtToolNames.append(name)
-                    return builtToolsDir.appending(path)
+                    if let buildSystem = buildSystemForPluginDependencies {
+                        try buildSystem.build(subset: .product(name))
+                        if let builtTool = try buildSystem.buildPlan.buildProducts.first(where: { $0.product.name == name}) {
+                            return builtTool.binaryPath
+                        } else {
+                            return nil
+                        }
+                    } else {
+                        builtToolNames.append(name)
+                        return builtToolsDir.appending(path)
+                    }
                 }
 
                 // Determine additional input dependencies for any plugin commands, based on any executables the plugin target depends on.