Revert "fix/gradle: fix configuration cache issues"

This reverts commit e976e40.

Not needed now that the CLI disables the configuration cache.

Author: christoph-sg

scip-gradle-plugin/src/main/java/org/scip_code/scip_java/gradle/ScipGradlePlugin.java

@@ -5,7 +5,6 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -21,6 +20,8 @@
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.SourceSetContainer;
+import org.gradle.api.tasks.TaskProvider;
+import org.gradle.api.tasks.TaskState;
 import org.gradle.api.tasks.compile.CompileOptions;
 import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.process.CommandLineArgumentProvider;
@@ -138,75 +139,41 @@ private void configureProject(Project project) {
       }
     }
 
-    // Kotlin sources are not indexed inside kotlinc: after each Kotlin compile
-    // task, its sources and classpath are dumped for the scip-java CLI to index
-    // after the build, decoupling indexing from the build's Kotlin compiler
-    // version. The dump is a finalizer rather than an action of the compile
-    // task, because Gradle skips the compile task's actions when it is up to
+    // Kotlin sources are not indexed inside kotlinc: after the Kotlin compile
+    // tasks, their sources and classpath are dumped for the scip-java CLI to
+    // index after the build, decoupling indexing from the build's Kotlin
+    // compiler version. The dump is a finalizer rather than an action of the
+    // compile tasks, because Gradle skips their actions when they are up to
     // date or restored from the build cache, while the CLI deletes the
     // targetroot before every build. The finalizer declares no outputs, so
-    // Gradle runs it every time. A rule creates it on demand, because tasks
-    // can't be registered from configureEach, and it captures only file
-    // collections rather than the compile task, so it works with the
-    // configuration cache.
-    Map<String, String> kotlinConfigTasks = new HashMap<>();
-    project
-        .getTasks()
-        .addRule(
-            "Pattern: scipKotlinConfig<Task>: dumps a Kotlin compile task's configuration",
-            name -> {
-              String compileName = kotlinConfigTasks.get(name);
-              if (compileName == null) {
-                return;
-              }
-              Task compile = project.getTasks().getByName(compileName);
-              String compilePath = compile.getPath();
-              // Referring to KotlinCompile directly triggers NoClassDefFoundError -
-              // the plugin classpath is murky and we deliberately don't bundle the
-              // Kotlin Gradle plugin. So we commit the sins of reflection.
-              FileCollection libraries = fileCollection(compile, "getLibraries");
-              if (libraries == null) {
-                libraries = fileCollection(compile, "getClasspath");
-              }
-              if (libraries == null) {
-                throw new IllegalStateException(
-                    "scip-java: failed to extract Kotlin compile configuration for task '"
-                        + compileName
-                        + "': no libraries or classpath");
-              }
-              FileCollection classpath = libraries;
-              FileCollection sources = compile.getInputs().getSourceFiles();
-              // Kotlin Gradle Plugin without javaSources (pre 1.7) has none.
-              FileCollection javaSources = fileCollection(compile, "getJavaSources");
-              FileCollection allJavaSources = javaSources != null ? javaSources : project.files();
-              project
-                  .getTasks()
-                  .create(
-                      name,
-                      export ->
-                          export.doLast(
-                              ignored ->
-                                  writeKotlinConfig(
-                                      compilePath,
-                                      classpath,
-                                      sources,
-                                      allJavaSources,
-                                      sourceRoot,
-                                      targetRoot)));
-            });
+    // Gradle runs it every time.
+    List<Task> kotlinCompileTasks = new ArrayList<>();
+    TaskProvider<Task> kotlinConfigs =
+        project
+            .getTasks()
+            .register(
+                "scipKotlinConfigs",
+                export ->
+                    export.doLast(
+                        ignored -> {
+                          for (Task task : kotlinCompileTasks) {
+                            // Only tasks of this build that succeeded; up-to-date
+                            // and cached tasks count as executed.
+                            TaskState state = task.getState();
+                            if (state.getExecuted() && state.getFailure() == null) {
+                              writeKotlinConfig(task, sourceRoot, targetRoot);
+                            }
+                          }
+                        }));
     // Not limited to the plugin checks above: AGP 9's built-in Kotlin adds
     // Kotlin compile tasks to Android modules without applying a Kotlin plugin.
     project
         .getTasks()
         .configureEach(
             task -> {
               if (task.getClass().getSimpleName().contains("KotlinCompile")) {
-                String name =
-                    "scipKotlinConfig"
-                        + Character.toUpperCase(task.getName().charAt(0))
-                        + task.getName().substring(1);
-                kotlinConfigTasks.put(name, task.getName());
-                task.finalizedBy(name);
+                kotlinCompileTasks.add(task);
+                task.finalizedBy(kotlinConfigs);
               }
             });
 
@@ -303,57 +270,59 @@ private static Set<String> addJavacPlugin(Project project, Object javacPluginDep
     return pluginTasks;
   }
 
-  private static FileCollection fileCollection(Task task, String getter) {
-    try {
-      return (FileCollection) task.getClass().getMethod(getter).invoke(task);
-    } catch (ReflectiveOperationException exc) {
-      return null;
-    }
-  }
-
   /**
    * Dumps the sources and classpath of a Kotlin compile task to {@code kotlin-configs/<task>.txt}.
    */
-  private static void writeKotlinConfig(
-      String taskPath,
-      FileCollection libraries,
-      FileCollection kotlinSources,
-      FileCollection javaSources,
-      String sourceRoot,
-      String targetRoot) {
+  private static void writeKotlinConfig(Task task, String sourceRoot, String targetRoot) {
     try {
       List<String> lines = new ArrayList<>();
       lines.add("sourceroot " + sourceRoot);
+
+      // Referring to KotlinCompile directly triggers NoClassDefFoundError -
+      // the plugin classpath is murky and we deliberately don't bundle the
+      // Kotlin Gradle plugin. So we commit the sins of reflection.
+      FileCollection libraries;
+      try {
+        libraries = (FileCollection) task.getClass().getMethod("getLibraries").invoke(task);
+      } catch (ReflectiveOperationException exc) {
+        libraries = (FileCollection) task.getClass().getMethod("getClasspath").invoke(task);
+      }
       for (File entry : libraries.getFiles()) {
         lines.add("classpath " + entry.getAbsolutePath());
       }
 
       int sources = 0;
-      for (File file : kotlinSources.getFiles()) {
+      for (File file : task.getInputs().getSourceFiles().getFiles()) {
         if (file.getName().endsWith(".kt") || file.getName().endsWith(".kts")) {
           lines.add("source " + file.getAbsolutePath());
           sources++;
         }
       }
       // Java sources of the same module are listed too, so Kotlin
       // references to them resolve. The indexer only emits Kotlin files.
-      for (File file : javaSources.getFiles()) {
-        if (file.getName().endsWith(".java")) {
-          lines.add("source " + file.getAbsolutePath());
+      try {
+        FileCollection javaSources =
+            (FileCollection) task.getClass().getMethod("getJavaSources").invoke(task);
+        for (File file : javaSources.getFiles()) {
+          if (file.getName().endsWith(".java")) {
+            lines.add("source " + file.getAbsolutePath());
+          }
         }
+      } catch (ReflectiveOperationException exc) {
+        // Kotlin Gradle Plugin without javaSources (pre 1.7).
       }
       if (sources == 0) {
         return;
       }
 
       Path configDir = Paths.get(targetRoot, "kotlin-configs");
       Files.createDirectories(configDir);
-      String fileName = taskPath.replaceAll("[^A-Za-z0-9]", "-") + ".txt";
+      String fileName = task.getPath().replaceAll("[^A-Za-z0-9]", "-") + ".txt";
       Files.write(configDir.resolve(fileName), lines);
     } catch (Exception exc) {
       throw new RuntimeException(
           "scip-java: failed to extract Kotlin compile configuration for task '"
-              + taskPath
+              + task.getName()
               + "': "
               + exc,
           exc);

scip-java/src/test/kotlin/tests/GradleBuildToolTest.kt

@@ -186,8 +186,7 @@ class GradleBuildToolTest : BuildToolHarness() {
         add(checkGradleBuild("kotlin2", "gradle/kotlin2", expectedScipFiles = 4))
         // Regression tests: Kotlin sources must be indexed again when the Kotlin
         // compile tasks are restored from the build cache, or are up to date
-        // because the build command doesn't clean. The second run of the latter
-        // also reuses the configuration cache entry of the first.
+        // because the build command doesn't clean.
         add(
             checkGradleBuild(
                 "kotlin-build-cache",
@@ -200,8 +199,8 @@ class GradleBuildToolTest : BuildToolHarness() {
             checkGradleBuild(
                 "kotlin-up-to-date",
                 "gradle/kotlin2",
-                expectedScipFiles = 1,
-                extraArguments = listOf("--", "--configuration-cache", "compileKotlin"),
+                expectedScipFiles = 2,
+                extraArguments = listOf("--", "compileKotlin", "compileJava"),
                 runs = 2,
             )
         )