Fail when the Checker Framework is enabled too late to run

Enabling the Checker Framework after Gradle has built the task graph, as
in a `gradle.taskGraph.whenReady` action, leaves the task that writes the
manifest out of the graph, because the manifest directory is an input of
a task only while the Checker Framework is enabled on it. The
compilation then discovered no annotation processor and silently checked
nothing. Fail instead, and check the manifest rather than when the task
was enabled, because a task that is enabled too late is still checked if
another task in the same build was enabled in time.

Also make two tests assert. Each returns early on a Java version that the
plugin under test does not support there, and then guarded its
assertions with the same condition, so the assertions never ran and the
tests only checked that the build failed, for any reason at all. Remove
the guards, and take the version from the JDK that runs the test's build
rather than from the JDK that runs the test, which is always 17. With
the assertions running, the Error Prone test needed the javac arguments
that Error Prone requires but that its Gradle plugin does not add.

Tested on JDK 17, 21, and 25, and on Gradle 7.3.3, 8.2.1, and 9.2.1.

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

Author: mernst

src/functionalTest/kotlin/org/checkerframework/plugin/gradle/CFGroovyPluginFunctionalTest.kt

@@ -467,6 +467,39 @@ class CFGroovyPluginFunctionalTest : GroovyPluginFunctionalTest() {
     assertThat(result.output).contains(NULLNESS_FAILURE)
   }
 
+  @Test
+  fun `test enabling the Checker Framework after the task graph is built fails`() {
+    buildFile.appendText(
+      """
+      checkerFramework {
+        version = "$TEST_CF_VERSION"
+        checkers = ["org.checkerframework.checker.nullness.NullnessChecker"]
+      }
+      compileJava {
+        options.checkerFrameworkCompile.enabled = false
+      }
+      gradle.taskGraph.whenReady {
+        tasks.compileJava.options.checkerFrameworkCompile.enabled = true
+      }
+      """
+        .trimIndent()
+    )
+    // given
+    testProjectDir.writeNullnessFailure()
+
+    // when
+    val result = testProjectDir.buildWithArgsAndFail("compileJava")
+
+    // then
+    // The task that writes the manifest was left out of the task graph, because the Checker
+    // Framework was disabled when the graph was built, so no checker can run on this compilation.
+    // The build fails rather than succeeding while checking nothing.
+    assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.FAILED)
+    assertThat(result.output)
+      .contains("The Checker Framework was enabled on :compileJava too late for it to run")
+    assertThat(result.output).doesNotContain(NULLNESS_FAILURE)
+  }
+
   @Test
   fun `test running the Checker Framework after a build that skipped it`() {
     buildFile.appendText(

src/functionalTest/kotlin/org/checkerframework/plugin/gradle/Fixtures.kt

@@ -6,6 +6,14 @@ import org.gradle.testkit.runner.GradleRunner
 import org.gradle.util.GradleVersion
 
 val testJavaHome = System.getProperty("test.java-home", System.getProperty("java.home"))
+
+/**
+ * The major version of [testJavaHome], the Java version that runs the builds that the tests launch
+ * and therefore compiles the code that the tests check. It is not necessarily the version that runs
+ * the tests themselves, which is the version of this build's Kotlin toolchain.
+ */
+val testJavaVersion: Int =
+  System.getProperty("test.java-version")?.toInt() ?: Runtime.version().feature()
 val testGradleVersion =
   System.getProperty("test.gradle-version")?.let(GradleVersion::version) ?: GradleVersion.current()
 

src/functionalTest/kotlin/org/checkerframework/plugin/gradle/OtherPluginsFunctionalTest.kt

@@ -20,8 +20,8 @@ class OtherPluginsFunctionalTest : KotlinPluginFunctionalTest() {
 
   @Test
   fun `test lombok 8 12 1`() {
-    val majorVersion = Runtime.version().feature()
-    if (majorVersion >= 25) {
+    // Lombok 8.12.1 does not support Java 25 and later.
+    if (testJavaVersion >= 25) {
       return
     }
     buildFile.appendText(
@@ -46,16 +46,13 @@ class OtherPluginsFunctionalTest : KotlinPluginFunctionalTest() {
     // when
     val result = testProjectDir.buildWithArgsAndFail("build")
 
-    if (majorVersion >= 25) {
-
-      // then
-      assertThat(result.output)
-        .contains(
-          "User.java:9: error: [argument] incompatible argument for parameter y of FooBuilder.y."
-        )
-      assertThat(result.output)
-        .contains("Foo.java:12: error: [assignment] incompatible types in assignment.")
-    }
+    // then
+    assertThat(result.output)
+      .contains(
+        "User.java:9: error: [argument] incompatible argument for parameter y of FooBuilder.y."
+      )
+    assertThat(result.output)
+      .contains("Foo.java:12: error: [assignment] incompatible types in assignment.")
   }
 
   @Test
@@ -281,8 +278,8 @@ class OtherPluginsFunctionalTest : KotlinPluginFunctionalTest() {
 
   @Test
   fun `test errorprone latest`() {
-    val majorVersion = Runtime.version().feature()
-    if (majorVersion < 21) {
+    // Error Prone 4.0.1 does not support Java versions before 21.
+    if (testJavaVersion < 21) {
       return
     }
     buildFile.delete()
@@ -308,6 +305,12 @@ class OtherPluginsFunctionalTest : KotlinPluginFunctionalTest() {
           }
           tasks.withType<JavaCompile>().configureEach {
               options.errorprone.warn("CollectionIncompatibleType")
+              // Error Prone requires these javac arguments, which its Gradle plugin does not add.
+              options.compilerArgs.addAll(
+                  listOf(
+                      "-XDcompilePolicy=simple",
+                      "--should-stop=ifError=FLOW",
+                      "-XDaddTypeAnnotationsToSymbol=true"))
           }
 
           configure<CheckerFrameworkExtension> {
@@ -324,16 +327,14 @@ class OtherPluginsFunctionalTest : KotlinPluginFunctionalTest() {
     // when
     val result = testProjectDir.buildWithArgsAndFail("build")
 
-    if (majorVersion < 21) {
-      // then
-      assertThat(result.output)
-        .contains(
-          "Demo.java:7: warning: [CollectionIncompatibleType] Argument 'i - 1' should not be passed to this method; its type int is not compatible with its collection's type argument Short"
-        )
-      assertThat(result.output)
-        .contains(
-          "Demo.java:8: error: [argument] incompatible argument for parameter arg0 of Set.add."
-        )
-    }
+    // then
+    assertThat(result.output)
+      .contains(
+        "Demo.java:7: warning: [CollectionIncompatibleType] Argument 'i - 1' should not be passed to this method; its type int is not compatible with its collection's type argument Short"
+      )
+    assertThat(result.output)
+      .contains(
+        "Demo.java:8: error: [argument] incompatible argument for parameter arg0 of Set.add."
+      )
   }
 }

src/main/kotlin/org/checkerframework/plugin/gradle/CheckerFrameworkPlugin.kt

@@ -716,6 +716,7 @@ class CheckerFrameworkPlugin @Inject constructor() : Plugin<Project> {
         undoFork(task)
         return
       }
+      requireManifest(task)
 
       // Must fork for the JVM arguments to be applied. Configuration time requests forking if the
       // Checker Framework was enabled then, but this ensures that no other configuration has undone
@@ -746,6 +747,36 @@ class CheckerFrameworkPlugin @Inject constructor() : Plugin<Project> {
       }
     }
 
+    /**
+     * Throws an exception if the manifest that makes javac discover the checkers has not been
+     * written, which means that no checker would run on the given task.
+     *
+     * The manifest directory is an input of every task that this plugin enables, so the task that
+     * writes it is in the task graph -- and has run by now -- if the Checker Framework was enabled
+     * on any task when Gradle built the graph. If it was enabled only afterwards, for example by a
+     * `gradle.taskGraph.whenReady` action, then adding the task that writes the manifest is no
+     * longer possible. Without this check, the compilation would succeed while checking nothing,
+     * because javac silently runs no annotation processor when it discovers none.
+     *
+     * The manifest is written once per project rather than once per task, so a task that is enabled
+     * too late still finds the manifest, and is checked, if another task in the same build was
+     * enabled in time. Hence this checks the manifest itself rather than when the task was enabled.
+     *
+     * @param task the task that the Checker Framework is enabled on
+     */
+    private fun requireManifest(task: Task) {
+      if (
+        cfManifestFiles.files.any { File(it, WriteCheckerManifestTask.PROCESSOR_FILE_NAME).isFile }
+      ) {
+        return
+      }
+      throw IllegalStateException(
+        "The Checker Framework was enabled on ${task.path} too late for it to run: the manifest" +
+          " that makes javac discover the checkers was not written. Enable the Checker Framework" +
+          " while the build is being configured, no later than when Gradle builds the task graph."
+      )
+    }
+
     /**
      * Undoes the forking that configuration time requested, when the Checker Framework was still
      * going to run on the task, so that a compilation that does not run the Checker Framework does