stage2/ml9: Support KotlinForForge 5

Author: Johni0702

stage2/modlauncher9/src/main/java/gg/essential/loader/stage2/SelfRenamingJarMetadata.java

@@ -17,6 +17,8 @@
 import java.util.List;
 import java.util.Set;
 
+import static gg.essential.loader.stage2.util.KFFMerger.isJarJarKff;
+
 /**
  * A jar metadata which takes the name of another jar with the same packages in the same layer.
  *
@@ -57,10 +59,19 @@ public String name() {
                 } catch (SelfRenamingReEntranceException ignored) {
                     continue;
                 }
-                if (compatibilityLayer.getPackages(otherJar).stream().anyMatch(ourPackages::contains)) {
+                Set<String> otherPackages = compatibilityLayer.getPackages(otherJar);
+                if (otherPackages.stream().anyMatch(ourPackages::contains)) {
                     LOGGER.debug("Found existing module with name {}, renaming {} to match.", otherModuleName, defaultName);
                     return otherModuleName;
                 }
+                // Special case for fully-JarJar-reliant KFF which no longer contains any code itself and doesn't
+                // declare its module name in its manifest either.
+                // We still need to make the KFF we ship to use the same module name though, because otherwise it'll
+                // be loaded and we'll end up with two modules exporting Kotlin.
+                if (defaultName.equals("thedarkcolour.kotlinforforge") && otherPackages.isEmpty() && isJarJarKff(otherJar)) {
+                    LOGGER.debug("Found existing JarJar KFF with name {}, renaming {} to match.", otherModuleName, defaultName);
+                    return otherModuleName;
+                }
             }
         } catch (Throwable e) {
             LOGGER.error("Exception occurred while trying to self-rename module " + defaultName + ": ", e);

stage2/modlauncher9/src/main/java/gg/essential/loader/stage2/util/KFFMerger.java

@@ -109,6 +109,19 @@ public List<SecureJar> maybeMergeInto(SecureJar secureJar) {
             return null;
         }
 
+        // If this is a KotlinForForge version which uses JarJar to bundle Kotlin (KFF 5+, potentially 4.12),
+        // we no longer need to merge the Kotlin jars into it, we merely need to add our Kotlin jars to the to-be-loaded
+        // list too.
+        if (isJarJarKff(secureJar)) {
+            LOGGER.info("Looks like KotlinForForge is using JarJar now, all good to go: {}", secureJar);
+            List<SecureJar> allJars = new ArrayList<>();
+            allJars.add(secureJar); // keep user-installed jar
+            allJars.addAll(ourCoreJars.jars);
+            allJars.addAll(ourCoroutinesJars.jars);
+            allJars.addAll(ourSerializationJars.jars);
+            return allJars;
+        }
+
         // Only care about a jar if it contains a Kotlin we can overwrite
         if (!compatibilityLayer.getPackages(secureJar).contains("kotlin")) {
             return null;
@@ -126,6 +139,13 @@ public List<SecureJar> maybeMergeInto(SecureJar secureJar) {
         boolean updateCoroutines = theirCoroutinesVersion < ourCoroutinesJars.version;
         int theirSerializationVersion = updateCore || updateCoroutines ? 0 : ourSerializationJars.version;
 
+        // If the jar contains only core but not coroutine libs, then it's not the fat KFF jar but rather KFF is
+        // using JarJar, and we should be able to find that one later.
+        if (theirCoreVersion != 0 && theirCoroutinesVersion == 0) {
+            LOGGER.info("Looks like a standalone Kotlin jar. Keeping as is, we should be finding a JarJar KFF jar.");
+            return null;
+        }
+
         List<Path> injectedJars = new ArrayList<>();
         ourCoreJars.maybeUpgrade(injectedJars, theirCoreVersion);
         ourCoroutinesJars.maybeUpgrade(injectedJars, theirCoroutinesVersion);
@@ -188,6 +208,26 @@ public String name() {
         }
     }
 
+    public static boolean isJarJarKff(SecureJar jar) {
+        try {
+            Path jarjarPath = jar.getRootPath().resolve("META-INF").resolve("jarjar");
+            if (!Files.exists(jarjarPath)) return false;
+            try (Stream<Path> stream = Files.list(jarjarPath)) {
+                List<String> files = stream
+                    .map(it -> it.getFileName().toString())
+                    .filter(it -> it.endsWith(".jar"))
+                    .toList();
+                // A JarJar-using KotlinForForge jar can be recognized by the fact that it bundles both the KFF mod as
+                // well as the Kotlin Standard Library
+                return files.stream().anyMatch(it -> it.startsWith("kffmod-"))
+                    && files.stream().anyMatch(it -> it.startsWith("kotlin-stdlib-"));
+            }
+        } catch (Throwable t) {
+            LOGGER.error("Failed to determine version of potential KFF jar at " + jar + ":", t);
+            return false;
+        }
+    }
+
     private int detectKotlinCoreVersion(SecureJar jar, Path root) {
         try {
             if (Files.notExists(root.resolve("kotlin").resolve("KotlinVersion.class"))) {