Pass supported triples info to invoke/run plugin for better diagnostics (#5843)

* Pass supported triples info to invoke/run plugin for better diagnostics
Resolves rdar://91000836

Author: elsh

Sources/Build/BuildPlan.swift

@@ -2442,7 +2442,8 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
     /// Extracts the artifacts  from an artifactsArchive
     private func parseArtifactsArchive(for target: BinaryTarget) throws -> [ExecutableInfo] {
         try self.externalExecutablesCache.memoize(key: target) {
-            return try target.parseArtifactArchives(for: self.buildParameters.triple, fileSystem: self.fileSystem)
+            let execInfos = try target.parseArtifactArchives(for: self.buildParameters.triple, fileSystem: self.fileSystem)
+            return execInfos.filter{!$0.supportedTriples.isEmpty}
         }
     }
 }

Sources/Commands/PackageTools/PluginCommand.swift

@@ -161,6 +161,8 @@ 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.
         var toolNamesToPaths: [String: AbsolutePath] = [:]
+        // Add supported triples info per tool so they can be looked up when running the tool
+        var toolNamesToTriples: [String: [String]] = [:]
         for dep in try plugin.accessibleTools(packageGraph: packageGraph, fileSystem: swiftTool.fileSystem, environment: try swiftTool.buildParameters().buildEnvironment, for: try pluginScriptRunner.hostTriple) {
             let buildSystem = try swiftTool.createBuildSystem(explicitBuildSystem: .native, cacheBuildManifest: false)
             switch dep {
@@ -170,8 +172,10 @@ struct PluginCommand: SwiftCommand {
                 if let builtTool = try buildSystem.buildPlan.buildProducts.first(where: { $0.product.name == name}) {
                     toolNamesToPaths[name] = builtTool.binaryPath
                 }
-            case .vendedTool(let name, let path):
+            case .vendedTool(let name, let path, let triples):
                 toolNamesToPaths[name] = path
+                // Need triples info for .vendedTool
+                toolNamesToTriples[name] = triples
             }
         }
 
@@ -189,6 +193,7 @@ struct PluginCommand: SwiftCommand {
             outputDirectory: outputDir,
             toolSearchDirectories: toolSearchDirs,
             toolNamesToPaths: toolNamesToPaths,
+            toolNamesToTriples: toolNamesToTriples,
             writableDirectories: writableDirectories,
             readOnlyDirectories: readOnlyDirectories,
             fileSystem: swiftTool.fileSystem,

Sources/PackagePlugin/Context.swift

@@ -39,6 +39,14 @@ public struct PluginContext {
     /// 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] {
+            // 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 {
+                throw PluginContextError.toolNotSupportedOnTargetPlatform(name: name)
+            }
             return Tool(name: name, path: path)
         } else {
             for dir in toolSearchDirectories {
@@ -59,7 +67,10 @@ public struct PluginContext {
     /// A mapping from tool names to their definitions. 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]]
+
     /// The paths of directories of in which to search for tools that aren't in
     /// the `toolNamesToPaths` map.
     let toolSearchDirectories: [Path]

Sources/PackagePlugin/Errors.swift

@@ -15,6 +15,9 @@ public enum PluginContextError: Error {
     /// it doesn't exist, or because the plugin doesn't have a dependency on it.
     case toolNotFound(name: String)
 
+    /// Tool is not supported on the target platform
+    case toolNotSupportedOnTargetPlatform(name: String)
+
     /// Could not find a target with the given name.
     case targetNotFound(name: String, package: Package)
 
@@ -27,6 +30,8 @@ extension PluginContextError: CustomStringConvertible {
         switch self {
         case .toolNotFound(let name):
             return "Plugin does not have access to a tool named ‘\(name)’"
+        case .toolNotSupportedOnTargetPlatform(let name):
+            return "Tool ‘\(name)’ is not supported on the target platform"
         case .targetNotFound(let name, let package):
             return "Package ‘\(package.displayName)’ has no target named ‘\(name)’"
         case .productNotFound(let name, let package):

Sources/PackagePlugin/Plugin.swift

@@ -133,10 +133,13 @@ extension Plugin {
                 let toolNamesToPaths = try wireInput.toolNamesToPathIds.mapValues {
                     try deserializer.path(for: $0)
                 }
+                let toolNamesToTriples = wireInput.toolNamesToTriples
+
                 context = PluginContext(
                     package: package,
                     pluginWorkDirectory: pluginWorkDirectory,
                     toolNamesToPaths: toolNamesToPaths,
+                    toolNamesToTriples: toolNamesToTriples,
                     toolSearchDirectories: toolSearchDirectories)
                 target = try deserializer.target(for: targetId)
             }
@@ -211,10 +214,13 @@ extension Plugin {
                 let toolNamesToPaths = try wireInput.toolNamesToPathIds.mapValues {
                     try deserializer.path(for: $0)
                 }
+
+                let toolNamesToTriples = wireInput.toolNamesToTriples
                 context = PluginContext(
                     package: package,
                     pluginWorkDirectory: pluginWorkDirectory,
                     toolNamesToPaths: toolNamesToPaths,
+                    toolNamesToTriples: toolNamesToTriples,
                     toolSearchDirectories: toolSearchDirectories)
             }
             catch {

Sources/PackagePlugin/PluginMessages.swift

@@ -27,6 +27,7 @@ enum HostToPluginMessage: Codable {
             let pluginWorkDirId: Path.Id
             let toolSearchDirIds: [Path.Id]
             let toolNamesToPathIds: [String: Path.Id]
+            let toolNamesToTriples: [String: [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.

Sources/SPMBuildCore/BinaryTarget+Extensions.swift

@@ -35,6 +35,9 @@ public struct ExecutableInfo: Equatable {
 
     /// The path to the executable.
     public let executablePath: AbsolutePath
+
+    /// Supported triples, e.g. `x86_64-apple-macosx`
+    public let supportedTriples: [Triple]
 }
 
 
@@ -68,11 +71,10 @@ extension BinaryTarget {
         let executables = metadata.artifacts.filter { $0.value.type == .executable }
         // Construct an ExecutableInfo for each matching variant.
         return try executables.flatMap { entry in
-            // FIXME: this filter needs to become more sophisticated
-            try entry.value.variants.filter {
-                return $0.supportedTriples.contains(versionLessTriple)
-            }.map{
-                ExecutableInfo(name: entry.key, executablePath: try AbsolutePath(validating: $0.path, relativeTo: self.artifactPath))
+            // Filter supported triples with versionLessTriple and pass into
+            // ExecutableInfo; empty if non matching triples found.
+            try entry.value.variants.map{
+                ExecutableInfo(name: entry.key, executablePath: try AbsolutePath(validating: $0.path, relativeTo: self.artifactPath), supportedTriples: $0.supportedTriples.filter({$0 == versionLessTriple}))
             }
         }
     }

Sources/SPMBuildCore/PluginInvocation.swift

@@ -55,6 +55,7 @@ extension PluginTarget {
         outputDirectory: AbsolutePath,
         toolSearchDirectories: [AbsolutePath],
         toolNamesToPaths: [String: AbsolutePath],
+        toolNamesToTriples: [String: [String]],
         writableDirectories: [AbsolutePath],
         readOnlyDirectories: [AbsolutePath],
         fileSystem: FileSystem,
@@ -78,6 +79,7 @@ extension PluginTarget {
             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 actionMessage: HostToPluginMessage
             switch action {
 
@@ -93,12 +95,12 @@ extension PluginTarget {
                     packages: serializer.packages,
                     pluginWorkDirId: pluginWorkDirId,
                     toolSearchDirIds: toolSearchDirIds,
-                    toolNamesToPathIds: toolNamesToPathIds)
+                    toolNamesToPathIds: toolNamesToPathIds,
+                    toolNamesToTriples: toolNamesToTriplesDict)
                 actionMessage = .createBuildToolCommands(
                     context: wireInput,
                     rootPackageId: rootPackageId,
                     targetId: targetId)
-            
             case .performCommand(let package, let arguments):
                 let rootPackageId = try serializer.serialize(package: package)
                 let wireInput = WireInput(
@@ -108,7 +110,8 @@ extension PluginTarget {
                     packages: serializer.packages,
                     pluginWorkDirId: pluginWorkDirId,
                     toolSearchDirIds: toolSearchDirIds,
-                    toolNamesToPathIds: toolNamesToPathIds)
+                    toolNamesToPathIds: toolNamesToPathIds,
+                    toolNamesToTriples: toolNamesToTriples)
                 actionMessage = .performCommand(
                     context: wireInput,
                     rootPackageId: rootPackageId,
@@ -320,7 +323,6 @@ extension PackageGraph {
         fileSystem: FileSystem
     ) throws -> [ResolvedTarget: [BuildToolPluginInvocationResult]] {
         var pluginResultsByTarget: [ResolvedTarget: [BuildToolPluginInvocationResult]] = [:]
-
         for target in self.reachableTargets.sorted(by: { $0.name < $1.name }) {
             // Infer plugins from the declared dependencies, and collect them as well as any regular dependencies. Although usage of build tool plugins is declared separately from dependencies in the manifest, in the internal model we currently consider both to be dependencies.
             var pluginTargets: [PluginTarget] = []
@@ -360,14 +362,22 @@ extension PackageGraph {
                     switch tool {
                     case .builtTool(let name, let path):
                         dict[name] = builtToolsDir.appending(path)
-                    case .vendedTool(let name, let path):
+                    case .vendedTool(let name, let path, _):
                         dict[name] = path
                     }
                 })
 
                 // Determine additional input dependencies for any plugin commands, based on any executables the plugin target depends on.
                 let toolPaths = toolNamesToPaths.values.sorted()
 
+                let toolNamesToTriples = accessibleTools.reduce(into: [String: [String]](), { dict, tool in
+                    switch tool {
+                    case .vendedTool(let name, _, let triple):
+                        dict[name] = triple
+                    default: break
+                    }
+                })
+
                 // Assign a plugin working directory based on the package, target, and plugin.
                 let pluginOutputDir = outputDir.appending(components: package.identity.description, target.name, pluginTarget.name)
 
@@ -430,7 +440,7 @@ extension PackageGraph {
                         dispatchPrecondition(condition: .onQueue(delegateQueue))
                         // executable must exist before running prebuild command
                         if !fileSystem.exists(executable) {
-                            diagnostics.append(.error("exectuable target '\(executable.basename)' is not pre-built; a plugin running a prebuild command should only rely on an existing binary; as a workaround, build '\(executable.basename)' first and then run the plugin "))
+                            diagnostics.append(.error("executable target '\(executable.basename)' is not pre-built; a plugin running a prebuild command should only rely on an existing binary; as a workaround, build '\(executable.basename)' first and then run the plugin "))
                             return
                         }
                         prebuildCommands.append(.init(
@@ -455,6 +465,7 @@ extension PackageGraph {
                     outputDirectory: pluginOutputDir,
                     toolSearchDirectories: toolSearchDirectories,
                     toolNamesToPaths: toolNamesToPaths,
+                    toolNamesToTriples: toolNamesToTriples,
                     writableDirectories: writableDirectories,
                     readOnlyDirectories: readOnlyDirectories,
                     fileSystem: fileSystem,
@@ -492,7 +503,7 @@ public enum PluginAccessibleTool: Hashable {
     case builtTool(name: String, path: RelativePath)
 
     /// A tool that is vended by a BinaryTarget (the path is absolute and refers to an unpackaged binary target).
-    case vendedTool(name: String, path: AbsolutePath)
+    case vendedTool(name: String, path: AbsolutePath, supportedTriples: [String])
 }
 
 public extension PluginTarget {
@@ -522,7 +533,7 @@ public extension PluginTarget {
             if let target = executableOrBinaryTarget as? BinaryTarget {
                 // TODO: Memoize this result for the host triple
                 let execInfos = try target.parseArtifactArchives(for: hostTriple, fileSystem: fileSystem)
-                return execInfos.map{ .vendedTool(name: $0.name, path: $0.executablePath) }
+                return execInfos.map{ .vendedTool(name: $0.name, path: $0.executablePath, supportedTriples: $0.supportedTriples.map{$0.tripleString}) }
             }
             // For an executable target we create a `builtTool`.
             else if executableOrBinaryTarget.type == .executable {

Sources/Workspace/DefaultPluginScriptRunner.swift

@@ -211,7 +211,6 @@ public struct DefaultPluginScriptRunner: PluginScriptRunner, Cancellable {
         if (verboseOutput) {
             commandLine.append("-v")
         }
-        
         // Pass through the compilation environment.
         let environment = toolchain.swiftCompilerEnvironment