Rework how the Java and Gradle version trampolines work since Kotlin …

…build-scripts have trouble with multi-release jars (#4)

build.gradle

@@ -20,8 +20,6 @@ changelog {
 }
 
 repositories {
-    mavenCentral()
-    gradlePluginPortal()
     exclusiveContent {
         forRepository {
             maven {
@@ -40,27 +38,30 @@ repositories {
             includeGroup "net.neoforged"
         }
     }
+    mavenCentral()
+    gradlePluginPortal()
 }
 
 sourceSets {
-    java17
-    test {
-        compileClasspath += sourceSets.java17.output
-        runtimeClasspath += sourceSets.java17.output
+    java8
+    main {
+        compileClasspath += java8.output
+        runtimeClasspath += java8.output
     }
 }
 
 dependencies {
-    java17CompileOnly gradleApi()
-    java17CompileOnly "com.intellij:annotations:9.0.4"
-    java17Implementation "com.google.code.gson:gson:2.10.1"
-    java17Implementation "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:1.1.8"
-    java17Implementation "net.fabricmc:fabric-loom-native:0.2.1"
-    java17Implementation "net.neoforged:JarJarMetadata:0.4.1"
-    java17Implementation "net.neoforged:EclipseLaunchConfigs:0.1.11"
+    compileOnly gradleApi()
+    compileOnly "com.intellij:annotations:9.0.4"
+    implementation "com.google.code.gson:gson:2.10.1"
+    implementation "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:1.1.8"
+    implementation "net.neoforged:JarJarMetadata:0.4.1"
+    implementation "net.neoforged:EclipseLaunchConfigs:0.1.11"
     api "gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:1.1.8"
     api "net.neoforged:JarJarMetadata:0.4.1"
 
+    java8CompileOnly gradleApi()
+
     testImplementation(enforcedPlatform("org.junit:junit-bom:5.10.2"))
     testImplementation 'org.junit.jupiter:junit-jupiter-api'
     testImplementation 'org.junit.jupiter:junit-jupiter-params'
@@ -76,16 +77,10 @@ java {
 }
 
 jar {
-    into('META-INF/versions/17') {
-        from sourceSets.java17.output
-    }
-
-    manifest.attributes(
-            'Multi-Release': 'true'
-    )
+    from sourceSets.java8.output
 }
 
-tasks.named("compileJava").configure {
+tasks.named("compileJava8Java").configure {
     javaCompiler = javaToolchains.compilerFor {
         languageVersion = JavaLanguageVersion.of(8)
     }
@@ -112,11 +107,11 @@ gradlePlugin {
     plugins {
         moddev {
             id = 'net.neoforged.moddev'
-            implementationClass = 'net.neoforged.moddevgradle.ModDevPlugin'
+            implementationClass = 'net.neoforged.moddevgradle.boot.ModDevPlugin'
         }
         junit {
             id = 'net.neoforged.moddev.junit'
-            implementationClass = 'net.neoforged.moddevgradle.JUnitPlugin'
+            implementationClass = 'net.neoforged.moddevgradle.boot.JUnitPlugin'
         }
     }
 }

src/java8/java/net/neoforged/moddevgradle/boot/JUnitPlugin.java

@@ -0,0 +1,13 @@
+package net.neoforged.moddevgradle.boot;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+/**
+ * This is just a trampoline to perform the Java and Gradle version check, and is compiled for Java 8 in the real Jar.
+ */
+public class JUnitPlugin extends TrampolinePlugin<Project> {
+    public JUnitPlugin() {
+        super("net.neoforged.moddevgradle.internal.JUnitPlugin");
+    }
+}

src/java8/java/net/neoforged/moddevgradle/boot/ModDevPlugin.java

@@ -0,0 +1,9 @@
+package net.neoforged.moddevgradle.boot;
+
+import org.gradle.api.Project;
+
+public class ModDevPlugin extends TrampolinePlugin<Project> {
+    public ModDevPlugin() {
+        super("net.neoforged.moddevgradle.internal.ModDevPlugin");
+    }
+}

src/java8/java/net/neoforged/moddevgradle/boot/TrampolinePlugin.java

@@ -0,0 +1,65 @@
+package net.neoforged.moddevgradle.boot;
+
+import org.gradle.api.GradleException;
+import org.gradle.api.Plugin;
+import org.gradle.api.plugins.PluginAware;
+import org.gradle.util.GradleVersion;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * This is just a trampoline to perform the Java and Gradle version check, and is compiled for Java 8 in the real Jar.
+ */
+public abstract class TrampolinePlugin<T extends PluginAware> implements Plugin<T> {
+    private static final int MIN_JAVA_VERSION = 17;
+    private static final GradleVersion MIN_GRADLE_VERSION = GradleVersion.version("8.7");
+
+    private final String pluginClassName;
+
+    TrampolinePlugin(String pluginClassName) {
+        this.pluginClassName = pluginClassName;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public final void apply(T target) {
+        int javaMajorVersion = getJavaMajorVersion();
+
+        if (javaMajorVersion < MIN_JAVA_VERSION) {
+            throw new GradleException("To use the NeoForge plugin, please run Gradle with Java " + MIN_JAVA_VERSION + " or newer. You are currently running on Java " + javaMajorVersion + " (" + System.getProperty("java.specification.version") + ").");
+        }
+
+        if (GradleVersion.current().compareTo(MIN_GRADLE_VERSION) < 0) {
+            throw new GradleException("To use the NeoForge plugin, please use at least " + MIN_GRADLE_VERSION
+                                      + ". You are currently using " + GradleVersion.current() + ".");
+        }
+
+        try {
+            Class<? extends Plugin<?>> pluginClass = (Class<? extends Plugin<?>>) Class.forName(pluginClassName);
+            target.getPlugins().apply(pluginClass);
+        } catch (ClassNotFoundException e) {
+            throw new GradleException("Failed to find main plugin class.", e);
+        }
+    }
+
+    private int getJavaMajorVersion() {
+        String specVersion = System.getProperty("java.specification.version");
+        if (specVersion == null) {
+            return 0;
+        }
+
+        Pattern firstNumber = Pattern.compile("^(\\d+)\\D*");
+        Matcher matcher = firstNumber.matcher(specVersion);
+        if (!matcher.find()) {
+            return 0;
+        }
+
+        return Integer.parseInt(matcher.group(1));
+    }
+
+    @Override
+    public String toString() {
+        return "Trampoline for " + pluginClassName;
+    }
+}

src/main/java/net/neoforged/moddevgradle/internal/JUnitPlugin.java

@@ -0,0 +1,10 @@
+package net.neoforged.moddevgradle.internal;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+public class JUnitPlugin implements Plugin<Project> {
+    public void apply(Project project) {
+
+    }
+}

src/java17/java/net/neoforged/moddevgradle/internal/ModDevPluginImpl.java → src/main/java/net/neoforged/moddevgradle/internal/ModDevPlugin.java

@@ -6,6 +6,7 @@
 import net.neoforged.moddevgradle.internal.utils.ExtensionUtils;
 import net.neoforged.moddevgradle.internal.utils.StringUtils;
 import net.neoforged.moddevgradle.tasks.JarJar;
+import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.artifacts.Configuration;
@@ -50,12 +51,13 @@
 import java.util.Map;
 import java.util.stream.Collectors;
 
-public class ModDevPluginImpl {
+public class ModDevPlugin implements Plugin<Project> {
     private static final Attribute<String> ATTRIBUTE_DISTRIBUTION = Attribute.of("net.neoforged.distribution", String.class);
     private static final Attribute<String> ATTRIBUTE_OPERATING_SYSTEM = Attribute.of("net.neoforged.operatingsystem", String.class);
 
     private static final String JAR_JAR_GROUP = "jarjar";
 
+    @Override
     public void apply(Project project) {
         project.getPlugins().apply(JavaLibraryPlugin.class);
         var javaExtension = ExtensionUtils.getExtension(project, "java", JavaPluginExtension.class);

src/main/resources/META-INF/trick-gradle-into-thinking-loom-is-signed.SF

@@ -0,0 +1,4 @@
+Trick gradle into thinking that loom is signed to skip over transforming all classes in the jar.
+This is required to get the bootstrap to well bootstrap on older gradle versions that dont support java 16.
+
+See https://github.com/gradle/gradle/blob/master/subprojects/core/src/main/java/org/gradle/internal/classpath/InstrumentingClasspathFileTransformer.java#L129