Decouple build JDK from test JDK; upgrade shadow to 9.2.2

The CI matrix built the plugin fatjar and ran the TestKit tests with a
single JDK per row, pinning the whole build toolchain to the oldest JDK
under test (8). That blocked upgrading the shadow plugin, which now
requires Java 17+.

Split the two concerns:

- The plugin fatjar is always built with a fixed, modern JDK (17).
- The :plugin-test module compiles and runs on the JDK a given Gradle
  version requires, selected via a Gradle toolchain (-PtestJavaVersion).
  The matrix JDKs are already installed on the runner and exposed as
  JAVA_HOME_<version>_X64; org.gradle.java.installations.fromEnv points
  Gradle's toolchain detection at them (auto-detection does not scan the
  runner tool cache on its own).

With the build no longer constrained to old JDKs, bump shadow 8.3.6 ->
9.2.2 (keeps the Gradle 8.14.4 wrapper; shadow 9.3+ would require Gradle
9). Shadow 9 exposes `configurations` as a SetProperty and provides
native auto-relocation, so the manual per-package relocation loop is
replaced with enableAutoRelocation + relocationPrefix, producing an
equivalent relocated fatjar.

Disable toolchain auto-download so a misconfigured testJavaVersion fails
fast instead of silently provisioning a JDK.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: bigdaz

.github/workflows/gradle.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Set up JDK
         uses: actions/setup-java@v5
         with:
-            java-version: 11
+            java-version: 17
             distribution: temurin
 
       - name: Setup Gradle
@@ -35,7 +35,10 @@ jobs:
     needs: quick-check
     strategy:
       fail-fast: false
-      # Test earliest and latest supported version of 5.x, 6.x, 7.x, and 8.x
+      # Test earliest and latest supported version of 5.x, 6.x, 7.x, and 8.x.
+      # The plugin fatjar is always built with a fixed, modern JDK (see "Set up JDK" below);
+      # java-version here is only the JDK that each Gradle version under test runs on, selected
+      # via a Gradle toolchain (-PtestJavaVersion). Older Gradle versions require older JDKs.
       matrix:
         include:
           - gradle-version: "5.2.1"
@@ -62,19 +65,30 @@ jobs:
     steps:
       - uses: actions/checkout@v6
 
+      # Fixed build JDK: compiles the plugin and builds the shadow fatjar. Must satisfy the build
+      # tooling's own JDK requirement (the shadow plugin needs Java 17+), independent of the older
+      # JDK the Gradle version under test runs on.
       - name: Set up JDK
         uses: actions/setup-java@v5
         with:
-          java-version: ${{ matrix.java-version }}
+          java-version: 17
           distribution: temurin
 
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v6
         with:
           develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
 
+      # -PtestJavaVersion runs the :plugin-test module (and thus the Gradle version under test) on
+      # the matrix JDK via a Gradle toolchain. That JDK is already installed on the runner and
+      # exposed as JAVA_HOME_<version>_X64; org.gradle.java.installations.fromEnv points Gradle's
+      # toolchain detection at it (auto-detection does not scan the runner tool cache on its own).
       - name: Execute Gradle Build
-        run: ./gradlew -S build -DtestGradleVersion=${{ matrix.gradle-version }}
+        run: >
+          ./gradlew -S build
+          -DtestGradleVersion=${{ matrix.gradle-version }}
+          -PtestJavaVersion=${{ matrix.java-version }}
+          -Dorg.gradle.java.installations.fromEnv=JAVA_HOME_${{ matrix.java-version }}_X64
 
   # Aggregates the test-gradle-version matrix into a single status check.
   # Enable "merge when checks pass" / branch protection against this job rather than
@@ -101,7 +115,7 @@ jobs:
       - name: Set up JDK
         uses: actions/setup-java@v5
         with:
-            java-version: 11
+            java-version: 17
             distribution: temurin
 
       - name: Setup Gradle

gradle.properties

@@ -2,4 +2,9 @@ org.gradle.jvmargs=-Xmx5000m -XX:MaxMetaspaceSize=512m -XX:+HeapDumpOnOutOfMemor
 org.gradle.caching=true
 org.gradle.configuration-cache=true
 
+# Never auto-provision JDKs for toolchains: the required JDKs are expected to be already installed
+# (auto-detected locally, exposed via org.gradle.java.installations.fromEnv on CI). Downloading would
+# mask a misconfigured -PtestJavaVersion instead of failing fast.
+org.gradle.java.installations.auto-download=false
+
 systemProp.gradle.publish.skip.namespace.check=true

gradle/libs.versions.toml

@@ -25,5 +25,5 @@ jetbrains-annotations = { group = "org.jetbrains", name = "annotations", version
 google-gson = { group = "com.google.code.gson", name = "gson", version = "2.13.2" }
 
 [plugins]
-shadow-jar = { id = "com.gradleup.shadow", version = "8.3.6"}
+shadow-jar = { id = "com.gradleup.shadow", version = "9.2.2"}
 plugin-publish = { id = "com.gradle.plugin-publish", version = "2.1.0" }

plugin-test/build.gradle.kts

@@ -38,6 +38,24 @@ sourceSets.test {
     resources.srcDir(writeTestConfig.map { it.generatedResourceDirectory })
 }
 
+// Compile and run this module (and thus the Gradle version under test) on a specific JDK with
+// -PtestJavaVersion=8, decoupled from the JDK used to build the :plugin fatjar. This lets the
+// plugin be built with a fixed, modern JDK (as required by newer build tooling such as the
+// shadow plugin) while still exercising older Gradle versions on the older JDKs they require.
+// Test classes must be *compiled* for the test JDK too, not just executed on it, so we set a
+// project-wide toolchain rather than only the test task's launcher. When unset, the module uses
+// the JDK that is building the project.
+val testJavaVersion = providers.gradleProperty("testJavaVersion")
+    .map { JavaLanguageVersion.of(it.toInt()) }
+
+if (testJavaVersion.isPresent) {
+    java {
+        toolchain {
+            languageVersion = testJavaVersion.get()
+        }
+    }
+}
+
 tasks.withType<Test>().configureEach {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()

plugin/build.gradle.kts

@@ -3,7 +3,6 @@ import com.gradle.publish.PublishTask
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.util.jar.JarFile
 
 // Upgrade transitive dependencies in plugin classpath
 buildscript {
@@ -92,25 +91,11 @@ val shadowJarTask = tasks.named<ShadowJar>("shadowJar") {
     // Gradle versions. See https://github.com/gradle/gradle/issues/24390
     exclude("META-INF/versions/**")
     configurations = listOf(shadowImplementation)
-    val projectGroup = project.group
-    doFirst {
-        configurations.forEach { configuration ->
-            configuration.files.forEach { jar ->
-                JarFile(jar).use { jf ->
-                    jf.entries().iterator().forEach { entry ->
-                        if (entry.name.endsWith(".class") && entry.name != "module-info.class") {
-                            val packageName =
-                                entry
-                                    .name
-                                    .substring(0..entry.name.lastIndexOf('/'))
-                                    .replace('/', '.')
-                            relocate(packageName, "${projectGroup}.shadow.$packageName")
-                        }
-                    }
-                }
-            }
-        }
-    }
+    // Relocate every bundled package under `<group>.shadow.` so the plugin's own dependencies can
+    // never clash with those of the build it is applied to. shadow 9.x does this natively via
+    // auto-relocation, replacing the manual per-package relocation loop we maintained previously.
+    enableAutoRelocation = true
+    relocationPrefix = "${project.group}.shadow"
 }
 
 configurations.archives.get().artifacts.clear()