Merge toolNamesToPaths and toolNamesToTriples (#5976)

neonichu · web-flow · commit aa089755c374 · 2022-12-19T10:22:07.000-08:00
These started out as separate dictionaries, this merges them into one dictionary with a tuple value.
diff --git a/Sources/Commands/PackageTools/PluginCommand.swift b/Sources/Commands/PackageTools/PluginCommand.swift
@@ -161,7 +161,7 @@ struct PluginCommand: SwiftCommand {
 
         // Build or bring up-to-date any executable host-side tools on which this plugin depends. Add them and any binary dependencies to the tool-names-to-path map.
         let buildSystem = try swiftTool.createBuildSystem(explicitBuildSystem: .native, cacheBuildManifest: false)
-        let (toolNamesToPaths, toolNamesToTriples) = try plugin.processAccessibleTools(packageGraph: packageGraph, fileSystem: swiftTool.fileSystem, environment: try swiftTool.buildParameters().buildEnvironment, for: try pluginScriptRunner.hostTriple) { name, path in
+        let accessibleTools = try plugin.processAccessibleTools(packageGraph: packageGraph, fileSystem: swiftTool.fileSystem, environment: try swiftTool.buildParameters().buildEnvironment, for: try pluginScriptRunner.hostTriple) { name, path in
             // Build the product referenced by the tool, and add the executable to the tool map. Product dependencies are not supported within a package, so if the tool happens to be from the same package, we instead find the executable that corresponds to the product. There is always one, because of autogeneration of implicit executables with the same name as the target if there isn't an explicit one.
             try buildSystem.build(subset: .product(name))
             if let builtTool = try buildSystem.buildPlan.buildProducts.first(where: { $0.product.name == name}) {
@@ -184,8 +184,7 @@ struct PluginCommand: SwiftCommand {
             workingDirectory: swiftTool.originalWorkingDirectory,
             outputDirectory: outputDir,
             toolSearchDirectories: toolSearchDirs,
-            toolNamesToPaths: toolNamesToPaths,
-            toolNamesToTriples: toolNamesToTriples,
+            accessibleTools: accessibleTools,
             writableDirectories: writableDirectories,
             readOnlyDirectories: readOnlyDirectories,
             fileSystem: swiftTool.fileSystem,
diff --git a/Sources/PackagePlugin/Context.swift b/Sources/PackagePlugin/Context.swift
@@ -38,16 +38,16 @@ public struct PluginContext {
     /// target on which the package plugin target depends. This function throws
     /// an error if the tool cannot be found. The lookup is case sensitive.
     public func tool(named name: String) throws -> Tool {
-        if let path = self.toolNamesToPaths[name] {
+        if let tool = self.accessibleTools[name] {
             // For PluginAccessibleTool.builtTool, the triples value is not saved, thus
             // the value is always nil; this is intentional since if we are able to
             // build the tool, it is by definition supporting the target platform.
             // For PluginAccessibleTool.vendedTool, only supported triples are saved,
             // so empty triples means the tool is not supported on the target platform.
-            if let triples = toolNamesToTriples[name], triples.isEmpty {
+            if let triples = tool.triples, triples.isEmpty {
                 throw PluginContextError.toolNotSupportedOnTargetPlatform(name: name)
             }
-            return Tool(name: name, path: path)
+            return Tool(name: name, path: tool.path)
         } else {
             for dir in toolSearchDirectories {
 #if os(Windows)
@@ -64,12 +64,9 @@ public struct PluginContext {
         throw PluginContextError.toolNotFound(name: name)
     }
 
-    /// A mapping from tool names to their definitions. Not directly available
+    /// A mapping from tool names to their paths and triples. Not directly available
     /// to the plugin, but used by the `tool(named:)` API.
-    let toolNamesToPaths: [String: Path]
-
-    /// Supported triples per tool name; looked up in `tool(named:)`
-    let toolNamesToTriples: [String: [String]]
+    let accessibleTools: [String: (path: Path, triples: [String]?)]
 
     /// The paths of directories of in which to search for tools that aren't in
     /// the `toolNamesToPaths` map.
diff --git a/Sources/PackagePlugin/Plugin.swift b/Sources/PackagePlugin/Plugin.swift
@@ -130,16 +130,15 @@ extension Plugin {
                 let toolSearchDirectories = try wireInput.toolSearchDirIds.map {
                     try deserializer.path(for: $0)
                 }
-                let toolNamesToPaths = try wireInput.toolNamesToPathIds.mapValues {
-                    try deserializer.path(for: $0)
+                let accessibleTools = try wireInput.accessibleTools.mapValues { (tool: HostToPluginMessage.InputContext.Tool) -> (Path, [String]?) in
+                    let path = try deserializer.path(for: tool.path)
+                    return (path, tool.triples)
                 }
-                let toolNamesToTriples = wireInput.toolNamesToTriples
 
                 context = PluginContext(
                     package: package,
                     pluginWorkDirectory: pluginWorkDirectory,
-                    toolNamesToPaths: toolNamesToPaths,
-                    toolNamesToTriples: toolNamesToTriples,
+                    accessibleTools: accessibleTools,
                     toolSearchDirectories: toolSearchDirectories)
                 target = try deserializer.target(for: targetId)
             }
@@ -211,16 +210,14 @@ extension Plugin {
                 let toolSearchDirectories = try wireInput.toolSearchDirIds.map {
                     try deserializer.path(for: $0)
                 }
-                let toolNamesToPaths = try wireInput.toolNamesToPathIds.mapValues {
-                    try deserializer.path(for: $0)
+                let accessibleTools = try wireInput.accessibleTools.mapValues { (tool: HostToPluginMessage.InputContext.Tool) -> (Path, [String]?) in
+                    let path = try deserializer.path(for: tool.path)
+                    return (path, tool.triples)
                 }
-
-                let toolNamesToTriples = wireInput.toolNamesToTriples
                 context = PluginContext(
                     package: package,
                     pluginWorkDirectory: pluginWorkDirectory,
-                    toolNamesToPaths: toolNamesToPaths,
-                    toolNamesToTriples: toolNamesToTriples,
+                    accessibleTools: accessibleTools,
                     toolSearchDirectories: toolSearchDirectories)
             }
             catch {
diff --git a/Sources/PackagePlugin/PluginMessages.swift b/Sources/PackagePlugin/PluginMessages.swift
@@ -26,8 +26,13 @@ enum HostToPluginMessage: Codable {
             let packages: [Package]
             let pluginWorkDirId: Path.Id
             let toolSearchDirIds: [Path.Id]
-            let toolNamesToPathIds: [String: Path.Id]
-            let toolNamesToTriples: [String: [String]]
+            let accessibleTools: [String: Tool]
+
+            // Wrapper struct for encoding information about a tool that's accessible to the plugin.
+            struct Tool: Codable {
+                let path: Path.Id
+                let triples: [String]?
+            }
 
             /// A single absolute path in the wire structure, represented as a tuple
             /// consisting of the ID of the base path and subpath off of that path.
diff --git a/Sources/SPMBuildCore/PluginInvocation.swift b/Sources/SPMBuildCore/PluginInvocation.swift
@@ -54,8 +54,7 @@ extension PluginTarget {
         workingDirectory: AbsolutePath,
         outputDirectory: AbsolutePath,
         toolSearchDirectories: [AbsolutePath],
-        toolNamesToPaths: [String: AbsolutePath],
-        toolNamesToTriples: [String: [String]],
+        accessibleTools: [String: (path: AbsolutePath, triples: [String]?)],
         writableDirectories: [AbsolutePath],
         readOnlyDirectories: [AbsolutePath],
         fileSystem: FileSystem,
@@ -78,8 +77,10 @@ extension PluginTarget {
             var serializer = PluginContextSerializer(fileSystem: fileSystem, buildEnvironment: buildEnvironment)
             let pluginWorkDirId = try serializer.serialize(path: outputDirectory)
             let toolSearchDirIds = try toolSearchDirectories.map{ try serializer.serialize(path: $0) }
-            let toolNamesToPathIds = try toolNamesToPaths.mapValues{ try serializer.serialize(path: $0) }
-            let toolNamesToTriplesDict = toolNamesToTriples
+            let accessibleTools = try accessibleTools.mapValues { (tool: (AbsolutePath, [String]?)) -> HostToPluginMessage.InputContext.Tool in
+                let path = try serializer.serialize(path: tool.0)
+                return .init(path: path, triples: tool.1)
+            }
             let actionMessage: HostToPluginMessage
             switch action {
                 
@@ -95,8 +96,7 @@ extension PluginTarget {
                     packages: serializer.packages,
                     pluginWorkDirId: pluginWorkDirId,
                     toolSearchDirIds: toolSearchDirIds,
-                    toolNamesToPathIds: toolNamesToPathIds,
-                    toolNamesToTriples: toolNamesToTriplesDict)
+                    accessibleTools: accessibleTools)
                 actionMessage = .createBuildToolCommands(
                     context: wireInput,
                     rootPackageId: rootPackageId,
@@ -110,8 +110,7 @@ extension PluginTarget {
                     packages: serializer.packages,
                     pluginWorkDirId: pluginWorkDirId,
                     toolSearchDirIds: toolSearchDirIds,
-                    toolNamesToPathIds: toolNamesToPathIds,
-                    toolNamesToTriples: toolNamesToTriples)
+                    accessibleTools: accessibleTools)
                 actionMessage = .performCommand(
                     context: wireInput,
                     rootPackageId: rootPackageId,
@@ -365,13 +364,13 @@ extension PackageGraph {
                 // Determine the tools to which this plugin has access, and create a name-to-path mapping from tool
                 // names to the corresponding paths. Built tools are assumed to be in the build tools directory.
                 var builtToolNames: [String] = []
-                let (toolNamesToPaths, toolNamesToTriples) = try pluginTarget.processAccessibleTools(packageGraph: self, fileSystem: fileSystem, environment: buildEnvironment, for: try pluginScriptRunner.hostTriple) { name, path in
+                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)
                 }
                 
                 // Determine additional input dependencies for any plugin commands, based on any executables the plugin target depends on.
-                let toolPaths = toolNamesToPaths.values.sorted()
+                let toolPaths = accessibleTools.values.map { $0.path }.sorted()
 
                 // Assign a plugin working directory based on the package, target, and plugin.
                 let pluginOutputDir = outputDir.appending(components: package.identity.description, target.name, pluginTarget.name)
@@ -462,8 +461,7 @@ extension PackageGraph {
                     workingDirectory: package.path,
                     outputDirectory: pluginOutputDir,
                     toolSearchDirectories: toolSearchDirectories,
-                    toolNamesToPaths: toolNamesToPaths,
-                    toolNamesToTriples: toolNamesToTriples,
+                    accessibleTools: accessibleTools,
                     writableDirectories: writableDirectories,
                     readOnlyDirectories: readOnlyDirectories,
                     fileSystem: fileSystem,
@@ -543,29 +541,26 @@ public extension PluginTarget {
         })
     }
 
-    func processAccessibleTools(packageGraph: PackageGraph, fileSystem: FileSystem, environment: BuildEnvironment, for hostTriple: Triple, builtToolHandler: (_ name: String, _ path: RelativePath) throws -> AbsolutePath?) throws -> (toolNamesToPaths: [String: AbsolutePath], toolNamesToTriples: [String: [String]]) {
-        var toolNamesToPaths: [String: AbsolutePath] = [:]
-        // Add supported triples info per tool so they can be looked up when running the tool
-        var toolNamesToTriples: [String: [String]] = [:]
+    func processAccessibleTools(packageGraph: PackageGraph, fileSystem: FileSystem, environment: BuildEnvironment, for hostTriple: Triple, builtToolHandler: (_ name: String, _ path: RelativePath) throws -> AbsolutePath?) throws -> [String: (path: AbsolutePath, triples: [String]?)] {
+        var pluginAccessibleTools: [String: (path: AbsolutePath, triples: [String]?)] = [:]
 
         for dep in try accessibleTools(packageGraph: packageGraph, fileSystem: fileSystem, environment: environment, for: hostTriple) {
             switch dep {
             case .builtTool(let name, let path):
                 if let path = try builtToolHandler(name, path) {
-                    toolNamesToPaths[name] = path
+                    pluginAccessibleTools[name] = (path, nil)
                 }
             case .vendedTool(let name, let path, let triples):
                 // Avoid having the path of an unsupported tool overwrite a supported one.
-                guard !triples.isEmpty || toolNamesToPaths[name] == nil else {
+                guard !triples.isEmpty || pluginAccessibleTools[name] == nil else {
                     continue
                 }
-                toolNamesToPaths[name] = path
-                // Need triples info for .vendedTool
-                toolNamesToTriples[name, default: []].append(contentsOf: triples)
+                let priorTriples = pluginAccessibleTools[name]?.triples ?? []
+                pluginAccessibleTools[name] = (path, priorTriples + triples)
             }
         }
 
-        return (toolNamesToPaths, toolNamesToTriples)
+        return pluginAccessibleTools
     }
 }
 
diff --git a/Tests/FunctionalTests/PluginTests.swift b/Tests/FunctionalTests/PluginTests.swift
@@ -460,7 +460,7 @@ class PluginTests: XCTestCase {
                         workingDirectory: package.path,
                         outputDirectory: pluginDir.appending(component: "output"),
                         toolSearchDirectories: toolSearchDirectories,
-                        toolNamesToPaths: [:],
+                        accessibleTools: [:],
                         writableDirectories: [pluginDir.appending(component: "output")],
                         readOnlyDirectories: [package.path],
                         fileSystem: localFileSystem,
@@ -721,7 +721,7 @@ class PluginTests: XCTestCase {
                 workingDirectory: package.path,
                 outputDirectory: pluginDir.appending(component: "output"),
                 toolSearchDirectories: [try UserToolchain.default.swiftCompilerPath.parentDirectory],
-                toolNamesToPaths: [:],
+                accessibleTools: [:],
                 writableDirectories: [pluginDir.appending(component: "output")],
                 readOnlyDirectories: [package.path],
                 fileSystem: localFileSystem,
