Improve handling of missing plugins (#5652)

- if a plugin is referenced by its product name in the same package, automatically use the target instead
- if a plugin referenced in the same package doesn't exist, emit an error

fixes #5650
rdar://96664671

Author: neonichu

Fixtures/Miscellaneous/Plugins/MissingPlugin/Package.swift

@@ -0,0 +1,10 @@
+// swift-tools-version: 5.7
+
+import PackageDescription
+
+let package = Package(
+    name: "MissingPlugin",
+    targets: [
+        .target(name: "MissingPlugin", plugins: ["NonExistingPlugin"]),
+    ]
+)

Fixtures/Miscellaneous/Plugins/MissingPlugin/Sources/MissingPlugin/MissingPlugin.swift

@@ -0,0 +1,6 @@
+public struct MissingPlugin {
+    public private(set) var text = "Hello, World!"
+
+    public init() {
+    }
+}

Fixtures/Miscellaneous/Plugins/PluginCanBeReferencedByProductName/Package.swift

@@ -0,0 +1,15 @@
+// swift-tools-version: 5.7
+
+import PackageDescription
+
+let package = Package(
+    name: "PluginCanBeReferencedByProductName",
+    products: [
+        .plugin(name: "MyPluginProduct", targets: ["MyPlugin"]),
+    ],
+    targets: [
+        .target(name: "PluginCanBeReferencedByProductName", plugins: ["MyPluginProduct"]),
+        .executableTarget(name: "Exec"),
+        .plugin(name: "MyPlugin", capability: .buildTool(), dependencies: ["Exec"]),
+    ]
+)

Fixtures/Miscellaneous/Plugins/PluginCanBeReferencedByProductName/Plugins/MyPlugin/plugin.swift

@@ -0,0 +1,14 @@
+import PackagePlugin
+
+@main
+struct MyPlugin: BuildToolPlugin {
+    func createBuildCommands(context: PackagePlugin.PluginContext, target: PackagePlugin.Target) async throws -> [PackagePlugin.Command] {
+        let output = context.pluginWorkDirectory.appending("gen.swift")
+        return [
+            .buildCommand(displayName: "Generating code",
+                          executable: try context.tool(named: "Exec").path,
+                          arguments: [output.string],
+                          outputFiles: [output])
+        ]
+    }
+}

Fixtures/Miscellaneous/Plugins/PluginCanBeReferencedByProductName/Sources/Exec/main.swift

@@ -0,0 +1,4 @@
+import Foundation
+
+let output = ProcessInfo.processInfo.arguments[1]
+try "let stringConstant = \"Hello, World!\"".write(to: URL(fileURLWithPath: output), atomically: true, encoding: .utf8)

Fixtures/Miscellaneous/Plugins/PluginCanBeReferencedByProductName/Sources/PluginCanBeReferencedByProductName/PluginCanBeReferencedByProductName.swift

@@ -0,0 +1,6 @@
+public struct PluginCanBeReferencedByProductName {
+    public private(set) var text = stringConstant
+
+    public init() {
+    }
+}

Sources/PackageLoading/Diagnostics.swift

@@ -82,6 +82,10 @@ extension Basics.Diagnostic {
         .error("executable product '\(product)' should not have more than one executable target")
     }
 
+    static func pluginNotFound(name: String) -> Self {
+        .error("no plugin named '\(name)' found")
+    }
+
     static func pluginProductWithNoTargets(product: String) -> Self {
         .error("plugin product '\(product)' should have at least one plugin target")
     }

Sources/PackageLoading/PackageBuilder.swift

@@ -557,6 +557,17 @@ public final class PackageBuilder {
             throw ModuleError.moduleNotFound(missingModuleName, type)
         }
 
+        let products = Dictionary(manifest.products.map({ ($0.name, $0) }), uniquingKeysWith: { $1 })
+
+        // If there happens to be a plugin product with the right name in the same package, we want to use that automatically.
+        func pluginTargetName(for productName: String) -> String? {
+            if let product = products[productName], product.type == .plugin {
+                return product.targets.first
+            } else {
+                return nil
+            }
+        }
+
         let potentialModuleMap = Dictionary(potentialModules.map({ ($0.name, $0) }), uniquingKeysWith: { $1 })
         let successors: (PotentialModule) -> [PotentialModule] = {
             // No reference of this target in manifest, i.e. it has no dependencies.
@@ -580,8 +591,16 @@ public final class PackageBuilder {
             if let pluginUsages = target.pluginUsages {
                 successors += pluginUsages.compactMap({
                     switch $0 {
-                    case .plugin(let name, let package):
-                        return (package == nil) ? potentialModuleMap[name] : nil
+                    case .plugin(_, .some(_)):
+                        return nil
+                    case .plugin(let name, nil):
+                        if let potentialModule = potentialModuleMap[name] {
+                            return potentialModule
+                        } else if let targetName = pluginTargetName(for: name), let potentialModule = potentialModuleMap[targetName] {
+                            return potentialModule
+                        } else {
+                            return nil
+                        }
                     }
                 })
             }
@@ -649,8 +668,15 @@ public final class PackageBuilder {
                             return .product(Target.ProductReference(name: name, package: package), conditions: [])
                         }
                         else {
-                            guard let target = targets[name] else { return nil }
-                            return .target(target, conditions: [])
+                            if let target = targets[name] {
+                                return .target(target, conditions: [])
+                            } else if let targetName = pluginTargetName(for: name), let target = targets[targetName] {
+                                return .target(target, conditions: [])
+                            } else {
+                                self.observabilityScope.emit(.pluginNotFound(name: name))
+                                return nil
+                            }
+
                         }
                     }
                 }

Sources/PackageModel/Manifest.swift

@@ -214,6 +214,7 @@ public final class Manifest {
 
     /// Returns the targets required for building the provided products.
     public func targetsRequired(for products: [ProductDescription]) -> [TargetDescription] {
+        let productsByName = Dictionary(products.map({ ($0.name, $0) }), uniquingKeysWith: { $1 })
         let targetsByName = Dictionary(targets.map({ ($0.name, $0) }), uniquingKeysWith: { $1 })
         let productTargetNames = products.flatMap({ $0.targets })
 
@@ -233,7 +234,13 @@ public final class Manifest {
                 let plugins: [String] = target.pluginUsages?.compactMap { pluginUsage in
                     switch pluginUsage {
                     case .plugin(name: let name, package: nil):
-                        return targetsByName.keys.contains(name) ? name : nil
+                        if targetsByName.keys.contains(name) {
+                            return name
+                        } else if let targetName = productsByName[name]?.targets.first {
+                            return targetName
+                        } else {
+                            return nil
+                        }
                     default:
                         return nil
                     }

Tests/FunctionalTests/PluginTests.swift

@@ -909,4 +909,30 @@ class PluginTests: XCTestCase {
             XCTAssert(stdout.contains("Build complete!"), "stdout:\n\(stdout)")
         }
     }
+
+    func testMissingPlugin() throws {
+        // Only run the test if the environment in which we're running actually supports Swift concurrency (which the plugin APIs require).
+        try XCTSkipIf(!UserToolchain.default.supportsSwiftConcurrency(), "skipping because test environment doesn't support concurrency")
+
+        try fixture(name: "Miscellaneous/Plugins") { fixturePath in
+            do {
+                try executeSwiftBuild(fixturePath.appending(component: "MissingPlugin"))
+            } catch SwiftPMProductError.executionFailure(_, _, let stderr) {
+                XCTAssert(stderr.contains("error: 'missingplugin': no plugin named 'NonExistingPlugin' found"), "stderr:\n\(stderr)")
+            }
+        }
+    }
+
+    func testPluginCanBeReferencedByProductName() throws {
+        // Only run the test if the environment in which we're running actually supports Swift concurrency (which the plugin APIs require).
+        try XCTSkipIf(!UserToolchain.default.supportsSwiftConcurrency(), "skipping because test environment doesn't support concurrency")
+
+        try fixture(name: "Miscellaneous/Plugins") { fixturePath in
+            let (stdout, _) = try executeSwiftBuild(fixturePath.appending(component: "PluginCanBeReferencedByProductName"))
+            XCTAssert(stdout.contains("Compiling plugin MyPlugin..."), "stdout:\n\(stdout)")
+            XCTAssert(stdout.contains("Compiling PluginCanBeReferencedByProductName gen.swift"), "stdout:\n\(stdout)")
+            XCTAssert(stdout.contains("Compiling PluginCanBeReferencedByProductName PluginCanBeReferencedByProductName.swift"), "stdout:\n\(stdout)")
+            XCTAssert(stdout.contains("Build complete!"), "stdout:\n\(stdout)")
+        }
+    }
 }