Migrate generate-pipeline to a SwiftPM build tool plug-in.

The biggest change that isn't just the plug-in use itself is how we
detect opt-in rules now. The previous version "cheated" by linking
the rules themselves into `generate-pipeline` and then used some
dynamic class lookup to get the actual value at runtime. This was
replaced with a syntax tree scan that looks for a simple `true` or
`false` return value in a static/class property named `isOptIn`.
(A future version of swift-format should probably use
compile-time constants for this property, when that's officially
supported.)

Author: allevato

Documentation/Development.md

@@ -1,31 +1,5 @@
 # Developing `swift-format`
 
-## Keeping the Pipeline and Tests Updated
-
-Since Swift does not yet have a runtime reflection system, we use code
-generation to keep the linting/formatting pipeline up-to-date. If you add or
-remove any rules from the `SwiftFormatRules` module, or if you add or remove
-any `visit` methods from an existing rule in that module, you must run the
-`generate-pipeline` tool update the pipeline and configuration sources.
-
-The easiest way to do this is to run the following command in your terminal:
-
-```shell
-swift run generate-pipeline
-```
-
-If successful, this tool will update
-`Sources/SwiftFormatConfiguration/RuleRegistry+Generated.swift` and
-`Sources/SwiftFormat/Pipelines+Generated.swift`.
-
-Likewise, you should keep the Linux XCTest manifests updated if you add or
-remove any tests from `swift-format` by running the following command in your
-terminal:
-
-```shell
-swift test --generate-linuxmain
-```
-
 ## Command Line Options for Debugging
 
 `swift-format` provides some hidden command line options to facilitate

Package.swift

@@ -48,10 +48,12 @@ let package = Package(
         .product(name: "SwiftSyntax", package: "swift-syntax"),
         .product(name: "SwiftOperators", package: "swift-syntax"),
         .product(name: "SwiftParser", package: "swift-syntax"),
-      ]
+      ],
+      plugins: ["generate-pipeline-plugin"]
     ),
     .target(
-      name: "SwiftFormatConfiguration"
+      name: "SwiftFormatConfiguration",
+      plugins: ["generate-pipeline-plugin"]
     ),
     .target(
       name: "SwiftFormatCore",
@@ -63,7 +65,8 @@ let package = Package(
     ),
     .target(
       name: "SwiftFormatRules",
-      dependencies: ["SwiftFormatCore", "SwiftFormatConfiguration"]
+      dependencies: ["SwiftFormatCore", "SwiftFormatConfiguration"],
+      plugins: ["generate-pipeline-plugin"]
     ),
     .target(
       name: "SwiftFormatPrettyPrint",
@@ -90,15 +93,22 @@ let package = Package(
       ]
     ),
 
+    .plugin(
+      name: "generate-pipeline-plugin",
+      capability: .buildTool(),
+      dependencies: [
+        "generate-pipeline"
+      ]
+    ),
     .executableTarget(
       name: "generate-pipeline",
       dependencies: [
-        "SwiftFormatCore",
-        "SwiftFormatRules",
+        .product(name: "ArgumentParser", package: "swift-argument-parser"),
         .product(name: "SwiftSyntax", package: "swift-syntax"),
         .product(name: "SwiftParser", package: "swift-syntax"),
       ]
     ),
+
     .executableTarget(
       name: "swift-format",
       dependencies: [

Plugins/generate-pipeline-plugin/GeneratePipelinePlugin.swift

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import PackagePlugin
+
+/// The name of the Swift file to generate for a particular target.
+let targetGeneratedSourceMapping = [
+  "SwiftFormat": "Pipelines+Generated.swift",
+  "SwiftFormatConfiguration": "RuleRegistry+Generated.swift",
+  "SwiftFormatRules": "RuleNameCache+Generated.swift",
+]
+
+/// A Swift Package Manager build tool that runs `generate-pipeline` to generate the format/lint
+/// pipelines from the current state of the rules.
+@main
+struct GeneratePipelinePlugin: BuildToolPlugin {
+  enum Error: Swift.Error, CustomStringConvertible {
+    /// The plugin was applied to a target that isn't supported.
+    case notApplicableToTarget(String)
+
+    var description: String {
+      switch self {
+      case .notApplicableToTarget(let target):
+        return """
+          'generate-pipeline-plugin' cannot be applied to '\(target)'; \
+          supported targets are \(targetGeneratedSourceMapping.keys)
+          """
+      }
+    }
+  }
+
+  func createBuildCommands(context: PluginContext, target: Target) throws -> [Command] {
+    guard let generatedSourceName = targetGeneratedSourceMapping[target.name] else {
+      throw Error.notApplicableToTarget(target.name)
+    }
+
+    let generatePipelineTool = try context.tool(named: "generate-pipeline")
+    let sourcesDir = context.package.directory.appending("Sources")
+    let outputFile = context.pluginWorkDirectory
+      .appending("GeneratedSources")
+      .appending(generatedSourceName)
+
+    return [
+      .buildCommand(
+        displayName: "Generating \(generatedSourceName) for \(target.name)",
+        executable: generatePipelineTool.path,
+        arguments: [
+          "--sources-directory",
+          sourcesDir.string,
+          "--output-file",
+          outputFile.string,
+          "--target",
+          target.name,
+        ],
+        outputFiles: [outputFile]
+      )
+    ]
+  }
+}