Preserve parent <-> child mapping in dependency resolution

Author: Su5eD

gradle.properties

@@ -11,7 +11,7 @@ versionAdapterDefinition=1.2.3
 versionMc=1.20.1
 versionForge=47.1.3
 versionForgeAutoRenamingTool=1.0.8
-versionFabricLoader=2.3.3+0.14.21+1.20.1
+versionFabricLoader=2.3.4+0.14.21+1.20.1
 versionAccessWidener=2.1.0
 versionFabricApi=0.87.0+1.9.6+1.20.1
 versionMixin=0.12.6+mixin.0.8.5

src/main/java/dev/su5ed/sinytra/connector/locator/ConnectorLocator.java

@@ -1,5 +1,7 @@
 package dev.su5ed.sinytra.connector.locator;
 
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
 import com.mojang.logging.LogUtils;
 import cpw.mods.jarhandling.SecureJar;
 import dev.su5ed.sinytra.connector.ConnectorUtil;
@@ -86,18 +88,18 @@ private List<IModFile> locateFabricMods(Iterable<IModFile> loadedMods) {
                 return !ConnectorUtil.DISABLED_MODS.contains(modid) && !loadedModIds.contains(modid);
             })
             .toList();
+        Multimap<JarTransformer.TransformableJar, JarTransformer.TransformableJar> parentToChildren = HashMultimap.create();
         // Discover fabric nested mod jars
         List<JarTransformer.TransformableJar> discoveredNestedJars = discoveredJars.stream()
             .flatMap(jar -> {
-                SecureJar secureJar = SecureJar.from(jar.input().toPath());
                 ConnectorLoaderModMetadata metadata = jar.modPath().metadata().modMetadata();
-                return discoverNestedJarsRecursive(tempDir, secureJar, metadata.getJars());
+                return discoverNestedJarsRecursive(tempDir, jar, metadata.getJars(), parentToChildren);
             })
             .toList();
         // Remove mods loaded by FML
         List<JarTransformer.TransformableJar> uniqueJars = handleDuplicateMods(discoveredJars, discoveredNestedJars, loadedModIds);
         // Ensure we have all required dependencies before transforming
-        List<JarTransformer.TransformableJar> candidates = DependencyResolver.resolveDependencies(uniqueJars, loadedMods);
+        List<JarTransformer.TransformableJar> candidates = DependencyResolver.resolveDependencies(uniqueJars, parentToChildren, loadedMods);
         // Get renamer library classpath
         List<Path> renameLibs = StreamSupport.stream(loadedMods.spliterator(), false).map(modFile -> modFile.getSecureJar().getRootPath()).toList();
         // Run jar transformations (or get existing outputs from cache)
@@ -138,14 +140,16 @@ private static boolean locateFabricModJar(Path path) {
         return false;
     }
 
-    private static Stream<JarTransformer.TransformableJar> discoverNestedJarsRecursive(Path tempDir, SecureJar secureJar, Collection<NestedJarEntry> jars) {
+    private static Stream<JarTransformer.TransformableJar> discoverNestedJarsRecursive(Path tempDir, JarTransformer.TransformableJar parent, Collection<NestedJarEntry> jars, Multimap<JarTransformer.TransformableJar, JarTransformer.TransformableJar> parentToChildren) {
+        SecureJar secureJar = SecureJar.from(parent.input().toPath());
         return jars.stream()
             .map(entry -> secureJar.getPath(entry.getFile()))
             .filter(Files::exists)
             .flatMap(path -> {
                 JarTransformer.TransformableJar jar = uncheck(() -> prepareNestedJar(tempDir, secureJar.getPrimaryPath().getFileName().toString(), path));
                 ConnectorLoaderModMetadata metadata = jar.modPath().metadata().modMetadata();
-                return Stream.concat(Stream.of(jar), discoverNestedJarsRecursive(tempDir, SecureJar.from(jar.input().toPath()), metadata.getJars()));
+                parentToChildren.put(parent, jar);
+                return Stream.concat(Stream.of(jar), discoverNestedJarsRecursive(tempDir, jar, metadata.getJars(), parentToChildren));
             });
     }
 

src/main/java/dev/su5ed/sinytra/connector/locator/DependencyResolver.java

@@ -1,5 +1,8 @@
 package dev.su5ed.sinytra.connector.locator;
 
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Multimap;
 import com.mojang.logging.LogUtils;
 import dev.su5ed.sinytra.connector.loader.ConnectorEarlyLoader;
 import dev.su5ed.sinytra.connector.transformer.JarTransformer;
@@ -21,8 +24,9 @@
 
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -37,28 +41,23 @@ public final class DependencyResolver {
     public static final VersionOverrides VERSION_OVERRIDES = new VersionOverrides();
     public static final DependencyOverrides DEPENDENCY_OVERRIDES = new DependencyOverrides(FMLPaths.CONFIGDIR.get());
 
-    public static List<JarTransformer.TransformableJar> resolveDependencies(List<JarTransformer.TransformableJar> jars, Iterable<IModFile> loadedMods) {
-        Map<ModCandidate, JarTransformer.TransformableJar> candidateToJar = new HashMap<>();
+    public static List<JarTransformer.TransformableJar> resolveDependencies(Collection<JarTransformer.TransformableJar> keys, Multimap<JarTransformer.TransformableJar, JarTransformer.TransformableJar> jars, Iterable<IModFile> loadedMods) {
+        BiMap<JarTransformer.TransformableJar, ModCandidate> jarToCandidate = HashBiMap.create();
         // Fabric candidates
-        Stream<ModCandidate> candidates = jars.stream()
-            .map(jar -> {
-                ModCandidate candidate = ModCandidate.createPlain(List.of(jar.modPath().path()), jar.modPath().metadata().modMetadata(), false, List.of());
-                candidateToJar.put(candidate, jar);
-                return candidate;
-            });
+        List<ModCandidate> candidates = createCandidatesRecursive(keys, jars, jarToCandidate);
         // Forge dependencies
         Stream<ModCandidate> forgeCandidates = StreamSupport.stream(loadedMods.spliterator(), false)
             .flatMap(modFile -> modFile.getModFileInfo() != null ? modFile.getModInfos().stream() : Stream.empty())
             .map(modInfo -> ModCandidate.createPlain(List.of(modInfo.getOwningFile().getFile().getFilePath()), new BuiltinMetadataWrapper(new FMLModMetadata(modInfo)), false, List.of()));
         Stream<ModCandidate> builtinCandidates = Stream.of(createJavaMod(), createFabricLoaderMod());
         // Merge
-        List<ModCandidate> allCandidates = Stream.of(candidates, forgeCandidates, builtinCandidates).flatMap(Function.identity()).toList();
+        List<ModCandidate> allCandidates = Stream.of(candidates.stream(), forgeCandidates, builtinCandidates).flatMap(Function.identity()).toList();
 
         EnvType envType = FabricLoader.getInstance().getEnvironmentType();
         try {
             List<ModCandidate> resolved = ModResolver.resolve(allCandidates, envType, Map.of());
             List<JarTransformer.TransformableJar> candidateJars = resolved.stream()
-                .map(candidateToJar::get)
+                .map(jarToCandidate.inverse()::get)
                 .filter(Objects::nonNull)
                 .toList();
             LOGGER.info("Dependency resolution found {} candidates to load", candidateJars.size());
@@ -68,6 +67,24 @@ public static List<JarTransformer.TransformableJar> resolveDependencies(List<Jar
         }
     }
 
+    private static List<ModCandidate> createCandidatesRecursive(Collection<JarTransformer.TransformableJar> candidateJars, Multimap<JarTransformer.TransformableJar, JarTransformer.TransformableJar> parentsToChildren, Map<JarTransformer.TransformableJar, ModCandidate> jarToCandidate) {
+        List<ModCandidate> candidates = new ArrayList<>();
+        for (JarTransformer.TransformableJar candidateJar : candidateJars) {
+            ModCandidate candidate = jarToCandidate.computeIfAbsent(candidateJar, j -> {
+                Collection<JarTransformer.TransformableJar> children = parentsToChildren.containsKey(candidateJar) ? parentsToChildren.get(candidateJar) : List.of();
+                List<ModCandidate> childCandidates = createCandidatesRecursive(children, parentsToChildren, jarToCandidate);
+                List<Path> paths = parentsToChildren.containsValue(candidateJar) ? null : List.of(candidateJar.modPath().path());
+                ModCandidate parent = ModCandidate.createPlain(paths, candidateJar.modPath().metadata().modMetadata(), false, childCandidates);
+                for (ModCandidate childCandidate : childCandidates) {
+                    childCandidate.addParent(parent);
+                }
+                return parent;
+            });
+            candidates.add(candidate);
+        }
+        return candidates;
+    }
+
     private static ModCandidate createJavaMod() {
         ModMetadata metadata = new BuiltinModMetadata.Builder("java", System.getProperty("java.specification.version").replaceFirst("^1\\.", ""))
             .setName(System.getProperty("java.vm.name"))