Fix BootstrapLauncher leaving dangling jars open in 1.20.1

Author: embeddedt

build.gradle

@@ -67,7 +67,6 @@ shadowJar {
     // Workaround: double-nest the jar.
     from shadowBugWorkaround
 }
-assemble.dependsOn shadowJar
 
 shadowJar {
     archiveClassifier.set('')
@@ -79,8 +78,22 @@ configurations {
     }
 }
 
+tasks.register("packageJar", Copy) {
+    from(tasks.named("shadowJar").get().archiveFile)
+    rename { String fileName ->
+        // a simple way is to remove the "-$version" from the jar filename
+        // but you can customize the filename replacement rule as you wish.
+        fileName.replace("-$project.version", "")
+    }
+    into("${rootProject.layout.buildDirectory.get()}/libs")
+}
+
+assemble.dependsOn tasks.named("packageJar")
+
 artifacts {
-    productionAgent(shadowJar)
+    productionAgent(rootProject.layout.buildDirectory.file("libs/blacksmith.jar")) {
+        builtBy(tasks.named("packageJar"))
+    }
 }
 
 publishing {

main/src/main/java/org/embeddedt/blacksmith/impl/TransformerCore.java

@@ -42,6 +42,7 @@ public class TransformerCore {
         TRANSFORMERS.add(new BackgroundScanHandlerTransformer());
         TRANSFORMERS.add(new TransformerDiscovererConstantsTransformer());
         TRANSFORMERS.add(new ModDirTransformerDiscovererTransformer());
+        TRANSFORMERS.add(new BootstrapLauncherTransformer());
     }
 
     public static void log(String s) {

main/src/main/java/org/embeddedt/blacksmith/impl/transformers/BootstrapLauncherTransformer.java

@@ -0,0 +1,50 @@
+package org.embeddedt.blacksmith.impl.transformers;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+import java.lang.instrument.IllegalClassFormatException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class BootstrapLauncherTransformer implements RuntimeTransformer {
+    @Override
+    public List<String> getTransformedClasses() {
+        return Arrays.asList("cpw/mods/bootstraplauncher/BootstrapLauncher");
+    }
+
+    @Override
+    public void transformClass(ClassNode data) throws IllegalClassFormatException {
+        for (MethodNode method : data.methods) {
+            if (method.name.equals("main") && (method.access & Opcodes.ACC_STATIC) != 0) {
+                Optional<MethodInsnNode> nameCaptureInLoop = RuntimeTransformer.streamInsnList(method.instructions)
+                        .filter(n -> n.getOpcode() == Opcodes.INVOKEINTERFACE)
+                        .map(MethodInsnNode.class::cast)
+                        .filter(m -> m.name.equals("name") && m.owner.equals("cpw/mods/jarhandling/SecureJar"))
+                        .findFirst();
+                nameCaptureInLoop.ifPresent(methodInsnNode -> RuntimeTransformer.searchBackward(methodInsnNode, insn -> insn.getOpcode() == Opcodes.ALOAD).ifPresent(aLoad -> {
+                    RuntimeTransformer.searchForward(methodInsnNode, insn -> {
+                        if (insn.getOpcode() == Opcodes.INVOKEVIRTUAL) {
+                            MethodInsnNode node = (MethodInsnNode) insn;
+                            return node.owner.equals("java/util/ArrayList") && node.name.equals("add");
+                        } else {
+                            return false;
+                        }
+                    }).ifPresent(listAdd -> {
+                        InsnList epilogueClose = new InsnList();
+                        epilogueClose.add(new VarInsnNode(Opcodes.ALOAD, ((VarInsnNode) aLoad).var));
+                        epilogueClose.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "cpw/mods/jarhandling/SecureJar", "getRootPath", "()Ljava/nio/file/Path;", true));
+                        epilogueClose.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/nio/file/Path", "getFileSystem", "()Ljava/nio/file/FileSystem;", true));
+                        epilogueClose.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/io/Closeable", "close", "()V", true));
+                        method.instructions.insert(listAdd, epilogueClose);
+                    });
+                }));
+            }
+        }
+    }
+}

main/src/main/java/org/embeddedt/blacksmith/impl/transformers/RuntimeTransformer.java

@@ -11,6 +11,9 @@
 
 import java.lang.instrument.IllegalClassFormatException;
 import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
@@ -48,4 +51,23 @@ static int nextLocalVariableIndex(MethodNode method) {
     static Stream<AbstractInsnNode> streamInsnList(InsnList list) {
         return StreamSupport.stream(list.spliterator(), false);
     }
+
+    static Optional<AbstractInsnNode> search(AbstractInsnNode current, Function<AbstractInsnNode, AbstractInsnNode> advancer, Predicate<AbstractInsnNode> filter) {
+        AbstractInsnNode next = advancer.apply(current);
+        while (next != null) {
+            if (filter.test(next)) {
+                return Optional.of(next);
+            }
+            next = advancer.apply(next);
+        }
+        return Optional.empty();
+    }
+
+    static Optional<AbstractInsnNode> searchForward(AbstractInsnNode current, Predicate<AbstractInsnNode> filter) {
+        return search(current, AbstractInsnNode::getNext, filter);
+    }
+
+    static Optional<AbstractInsnNode> searchBackward(AbstractInsnNode current, Predicate<AbstractInsnNode> filter) {
+        return search(current, AbstractInsnNode::getPrevious, filter);
+    }
 }