build: add per-recipe disable switch and a rewriteDiagnose task

Two follow-ups to the in-house OpenRewrite runner.

disabledRecipes lets a single recipe be switched off by name, e.g.

    openrewrite {
        disabledRecipes.add("org.openrewrite.java.testing.junit5.AssertThrowsOnLastStatement")
    }

The compiled composites (JUnit5BestPractices and friends) expose an immutable
recipeList, so the runner wraps the recipe tree in a FilteringRecipe that hides
the disabled names instead of mutating the list. This removes the need to fork a
recipe module or drop a whole composite; the JUnit 5 recipes are now enabled for
every test module and only AssertThrowsOnLastStatement is switched off, pending
openrewrite/rewrite-testing-frameworks#1048

rewriteDiagnose runs each active leaf recipe on its own and reports whether it
fails, would change files, or does nothing, so the problematic recipes can be
found without reading a full run. On jorphan: 183 leaf recipes, 0 fail in Java
mode, 21 would make changes. Note that a recipe which only fails as part of an
ordered composite (AssertThrowsOnLastStatement on Kotlin) passes in isolation, so
the per-leaf report is a lower bound; the composite run surfaces the rest as
non-fatal "Error while rewriting" warnings thanks to the lenient ExecutionContext.

-PopenrewriteKotlin=true flips Kotlin processing on from the command line for
experimenting with rewrite-kotlin.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: vlsi

build-logic/jvm/src/main/kotlin/build-logic.openrewrite.gradle.kts

@@ -44,12 +44,13 @@ openrewrite {
     activeRecipes.add("org.apache.jmeter.staticanalysis.CodeCleanup")
     activeRecipes.add("org.apache.jmeter.staticanalysis.CommonStaticAnalysis")
 
-    // The JUnit 5 recipes are Java-only: their JavaTemplate rewrites throw on Kotlin test
-    // sources, so enable them only for modules whose tests are pure Java.
-    if (!file("src/test/kotlin").isDirectory) {
-        plugins.withId("build-logic.test-junit5") {
-            activeRecipes.add("org.openrewrite.java.testing.junit5.JUnit5BestPractices")
-            activeRecipes.add("org.openrewrite.java.testing.junit5.CleanupAssertions")
-        }
+    plugins.withId("build-logic.test-junit5") {
+        activeRecipes.add("org.openrewrite.java.testing.junit5.JUnit5BestPractices")
+        activeRecipes.add("org.openrewrite.java.testing.junit5.CleanupAssertions")
     }
+
+    // Recipes that crash or corrupt output are disabled by name here instead of dropping the
+    // whole composite. AssertThrowsOnLastStatement throws on Kotlin sources; see the fix in
+    // https://github.com/openrewrite/rewrite-testing-frameworks/pull/1048
+    disabledRecipes.add("org.openrewrite.java.testing.junit5.AssertThrowsOnLastStatement")
 }

build-logic/openrewrite/src/main/kotlin/build-logic.openrewrite-base.gradle.kts

@@ -16,6 +16,7 @@
  */
 
 import org.apache.jmeter.buildtools.openrewrite.OpenRewriteBaseTask
+import org.apache.jmeter.buildtools.openrewrite.OpenRewriteDiagnoseTask
 import org.apache.jmeter.buildtools.openrewrite.OpenRewriteDryRunTask
 import org.apache.jmeter.buildtools.openrewrite.OpenRewriteExtension
 import org.apache.jmeter.buildtools.openrewrite.OpenRewriteRunTask
@@ -54,12 +55,18 @@ val openrewriteExtension = extensions.create<OpenRewriteExtension>(OpenRewriteEx
 fun configureCommon(task: OpenRewriteBaseTask) {
     task.group = "openrewrite"
     task.activeRecipes.set(openrewriteExtension.activeRecipes)
+    task.disabledRecipes.set(openrewriteExtension.disabledRecipes)
     task.activeStyles.set(openrewriteExtension.activeStyles)
     task.rewriteClasspath.from(openrewriteClasspath)
     task.configFile.set(openrewriteExtension.configFile)
     task.projectRootDir.set(layout.projectDirectory)
     task.logCompilationWarningsAndErrors.convention(false)
-    task.processKotlin.set(openrewriteExtension.processKotlin)
+    // Allow flipping Kotlin processing from the command line, e.g. -PopenrewriteKotlin=true
+    task.processKotlin.set(
+        providers.gradleProperty("openrewriteKotlin")
+            .map { it.toBoolean() }
+            .orElse(openrewriteExtension.processKotlin)
+    )
 }
 
 tasks.register<OpenRewriteRunTask>("rewriteRun") {
@@ -74,6 +81,12 @@ tasks.register<OpenRewriteDryRunTask>("rewriteDryRun") {
     failOnDryRunResults.set(openrewriteExtension.failOnDryRunResults)
 }
 
+tasks.register<OpenRewriteDiagnoseTask>("rewriteDiagnose") {
+    description = "Runs each active leaf recipe on its own and reports failures and no-ops"
+    configureCommon(this)
+    reportDir.set(layout.buildDirectory.dir("reports/openrewrite"))
+}
+
 plugins.withId("java") {
     the<JavaPluginExtension>().sourceSets.all {
         val sourceSet: SourceSet = this

build-logic/openrewrite/src/main/kotlin/org/apache/jmeter/buildtools/openrewrite/OpenRewriteExtension.kt

@@ -33,6 +33,9 @@ open class OpenRewriteExtension @Inject constructor(objects: ObjectFactory) {
 
     val activeRecipes = objects.setProperty<String>()
 
+    /** Fully qualified recipe names to prune from the active recipe tree, e.g. ones that crash. */
+    val disabledRecipes = objects.setProperty<String>()
+
     val failOnDryRunResults = objects.property<Boolean>().convention(true)
 
     /**

build-logic/openrewrite/src/main/kotlin/org/apache/jmeter/buildtools/openrewrite/OpenRewriteTasks.kt

@@ -49,6 +49,9 @@ abstract class OpenRewriteBaseTask @Inject constructor(
     @get:Input
     abstract val activeRecipes: SetProperty<String>
 
+    @get:Input
+    abstract val disabledRecipes: SetProperty<String>
+
     @get:Input
     abstract val activeStyles: SetProperty<String>
 
@@ -72,18 +75,20 @@ abstract class OpenRewriteBaseTask @Inject constructor(
     val sourceSets: NamedDomainObjectContainer<SourceSetConfig> =
         objects.domainObjectContainer(SourceSetConfig::class.java)
 
-    protected fun runRewrite(applyChanges: Boolean, patch: Provider<RegularFile>?) {
+    protected fun runRewrite(applyChanges: Boolean, patch: Provider<RegularFile>?, diagnose: Boolean = false) {
         val snapshots = sourceSets.map { it.toSnapshot() }
         val rewriteCp = rewriteClasspath.files
         val queue = executor.processIsolation {
             classpath.from(rewriteClasspath)
         }
         queue.submit(OpenRewriteWork::class) {
             this.applyChanges.set(applyChanges)
+            this.diagnose.set(diagnose)
             this.projectRoot.set(projectRootDir)
             patch?.let { this.patchFile.set(it) }
             this.configFile.set(this@OpenRewriteBaseTask.configFile)
             this.activeRecipes.set(this@OpenRewriteBaseTask.activeRecipes)
+            this.disabledRecipes.set(this@OpenRewriteBaseTask.disabledRecipes)
             this.activeStyles.set(this@OpenRewriteBaseTask.activeStyles)
             this.sourceSets.set(snapshots)
             this.rewriteClasspath.set(rewriteCp)
@@ -135,3 +140,18 @@ abstract class OpenRewriteDryRunTask @Inject constructor(
         const val PATCH_NAME = "rewrite.patch"
     }
 }
+
+/** Runs each active leaf recipe on its own and reports which fail, change, or do nothing. */
+abstract class OpenRewriteDiagnoseTask @Inject constructor(
+    objects: ObjectFactory,
+    executor: WorkerExecutor,
+) : OpenRewriteBaseTask(objects, executor) {
+    @get:OutputDirectory
+    abstract val reportDir: DirectoryProperty
+
+    @TaskAction
+    fun run() {
+        runRewrite(applyChanges = false, patch = reportDir.file("diagnose.txt"), diagnose = true)
+        logger.lifecycle("OpenRewrite diagnose report: {}", reportDir.file("diagnose.txt").get().asFile)
+    }
+}

build-logic/openrewrite/src/main/kotlin/org/apache/jmeter/buildtools/openrewrite/OpenRewriteWork.kt

@@ -110,8 +110,15 @@ interface OpenRewriteParameters : WorkParameters {
     /** Unified diff of the proposed changes, written in dry-run mode. */
     val patchFile: RegularFileProperty
 
+    /** When true, run each leaf recipe on its own and report which ones fail or make changes. */
+    val diagnose: Property<Boolean>
+
     val configFile: RegularFileProperty
     val activeRecipes: SetProperty<String>
+
+    /** Fully qualified recipe names to prune from the active recipe tree before running. */
+    val disabledRecipes: SetProperty<String>
+
     val activeStyles: SetProperty<String>
     val sourceSets: SetProperty<SourceSetSnapshot>
     val rewriteClasspath: SetProperty<File>
@@ -125,26 +132,18 @@ abstract class OpenRewriteWork : WorkAction<OpenRewriteParameters> {
     }
 
     override fun execute() {
-        val ctx: ExecutionContext = InMemoryExecutionContext { t -> logger.warn("Error while rewriting", t) }
-        val results = listResults(ctx)
-        if (parameters.applyChanges.get()) {
-            applyResults(results)
-        } else {
-            writePatch(results)
-        }
-    }
-
-    private fun listResults(ctx: ExecutionContext): List<Result> {
         val env = createEnvironment()
-        val recipe = env.activateRecipes(parameters.activeRecipes.get())
-        if (recipe.recipeList.isEmpty()) {
-            logger.warn(
-                "No recipes were activated. Add a recipe with openrewrite.activeRecipes in the build file."
-            )
-            return emptyList()
+        val activated = env.activateRecipes(parameters.activeRecipes.get())
+        val disabled = parameters.disabledRecipes.get()
+        val diagnose = parameters.diagnose.get()
+
+        if (activated.recipeList.isEmpty()) {
+            logger.warn("No recipes were activated. Add a recipe with openrewrite.activeRecipes in the build file.")
+            return
         }
         val styles = env.activateStyles(parameters.activeStyles.get())
 
+        val ctx: ExecutionContext = InMemoryExecutionContext { t -> logger.warn("Error while rewriting", t) }
         val sourceFiles = parse(ctx)
             .map { source ->
                 if (styles.isEmpty()) {
@@ -155,10 +154,88 @@ abstract class OpenRewriteWork : WorkAction<OpenRewriteParameters> {
             }
             .toList()
 
-        val recipeRun = recipe.run(InMemoryLargeSourceSet(sourceFiles), ctx)
-        return recipeRun.changeset.allResults
+        // In diagnose we test everything (disabled recipes are still reported, annotated) so the
+        // report is a complete picture. In normal runs we prune the disabled recipes from the tree.
+        if (diagnose) {
+            diagnose(activated, sourceFiles, disabled)
+            return
+        }
+
+        val recipe = if (disabled.isEmpty()) {
+            activated
+        } else {
+            val present = collectNames(activated).intersect(disabled)
+            logger.lifecycle("OpenRewrite disabled {} recipe(s): {}", present.size, present.sorted())
+            FilteringRecipe(activated, disabled)
+        }
+
+        val results = recipe.run(InMemoryLargeSourceSet(sourceFiles), ctx).changeset.allResults
+        if (parameters.applyChanges.get()) {
+            applyResults(results)
+        } else {
+            writePatch(results)
+        }
+    }
+
+    private fun collectNames(recipe: org.openrewrite.Recipe): Set<String> {
+        val names = mutableSetOf<String>()
+        fun visit(r: org.openrewrite.Recipe) {
+            names.add(r.name)
+            r.recipeList.forEach { visit(it) }
+        }
+        visit(recipe)
+        return names
+    }
+
+    /** Runs each leaf recipe individually so a single failure does not hide the others. */
+    private fun diagnose(recipe: org.openrewrite.Recipe, sourceFiles: List<SourceFile>, disabled: Set<String>) {
+        fun leaves(r: org.openrewrite.Recipe): List<org.openrewrite.Recipe> =
+            if (r.recipeList.isEmpty()) listOf(r) else r.recipeList.flatMap { leaves(it) }
+
+        val leaves = leaves(recipe).distinctBy { it.name }
+        val report = StringBuilder()
+        var failed = 0
+        var changed = 0
+        var clean = 0
+        for (leaf in leaves) {
+            val tag = if (leaf.name in disabled) " [disabled]" else ""
+            val errors = mutableListOf<Throwable>()
+            val ctx: ExecutionContext = InMemoryExecutionContext { errors.add(it) }
+            val line = try {
+                val results = leaf.run(InMemoryLargeSourceSet(sourceFiles), ctx).changeset.allResults
+                when {
+                    errors.isNotEmpty() -> {
+                        failed++
+                        "FAILED    ${leaf.name}$tag -> ${errors.first().firstMessageLine()}"
+                    }
+                    results.isNotEmpty() -> {
+                        changed++
+                        "changes:${results.size.toString().padStart(3)} ${leaf.name}$tag"
+                    }
+                    else -> {
+                        clean++
+                        "ok        ${leaf.name}$tag"
+                    }
+                }
+            } catch (t: Throwable) {
+                failed++
+                "FAILED    ${leaf.name}$tag -> ${t.firstMessageLine()}"
+            }
+            report.appendLine(line)
+            logger.lifecycle(line)
+        }
+        val summary = "OpenRewrite diagnose: ${leaves.size} recipes -> " +
+            "$failed failed, $changed would change, $clean no-op"
+        report.appendLine().appendLine(summary)
+        logger.lifecycle(summary)
+        val out = parameters.patchFile.get().asFile
+        out.parentFile.mkdirs()
+        out.writeText(report.toString())
     }
 
+    private fun Throwable.firstMessageLine(): String =
+        (message ?: this::class.java.simpleName).lineSequence().first().take(200)
+
     private fun applyResults(results: List<Result>) {
         val root = parameters.projectRoot.get().asFile.toPath()
         var changes = 0
@@ -326,3 +403,28 @@ abstract class OpenRewriteWork : WorkAction<OpenRewriteParameters> {
         return res
     }
 }
+
+/**
+ * Wraps a recipe tree and hides recipes whose name is in [disabled], so a crashing or unwanted
+ * recipe can be switched off by name without editing the third-party composite that declares it.
+ * The compiled composites expose an immutable recipeList, so filtering by wrapping is the reliable
+ * way to remove a recipe from the run.
+ */
+private class FilteringRecipe(
+    private val delegate: org.openrewrite.Recipe,
+    private val disabled: Set<String>,
+) : org.openrewrite.Recipe() {
+    private val filtered: List<org.openrewrite.Recipe> by lazy {
+        delegate.recipeList
+            .filter { it.name !in disabled }
+            .map { FilteringRecipe(it, disabled) }
+    }
+
+    override fun getName(): String = delegate.name
+    override fun getDisplayName(): String = delegate.displayName
+    override fun getDescription(): String =
+        delegate.description?.takeIf { it.isNotBlank() } ?: delegate.displayName
+    override fun getVisitor(): org.openrewrite.TreeVisitor<*, org.openrewrite.ExecutionContext> =
+        delegate.visitor
+    override fun getRecipeList(): List<org.openrewrite.Recipe> = filtered
+}