Make minifier more modular, convert Flags class into interface, add license

Author: sschr15

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vineflower team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/main/java/org/vineflower/tools/minifier/ExtensionsFinder.java

@@ -2,6 +2,9 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.vineflower.tools.minifier.patch.ClassPatch;
+import org.vineflower.tools.minifier.patch.ClassPatches;
+import org.vineflower.tools.minifier.patch.Visitors;
 
 import java.nio.file.*;
 import java.io.IOException;
@@ -24,9 +27,9 @@ public static void main(String[] args) throws IOException {
         try (FileSystem inputFs = FileSystems.newFileSystem(srcJar)) {
             Path root = inputFs.getPath("/");
             try (FileSystem outputFs = FileSystems.newFileSystem(destJar, Map.of("create", "true"))) {
-                Set<String> protobufExtensions = new HashSet<>();
-                Files.walkFileTree(root, new ExtensionsFinder(protobufExtensions));
-                Files.walkFileTree(root, new FileVisitor(outputFs.getPath("/"), root, protobufExtensions));
+                ClassPatch[] patches = ClassPatches.getPatches();
+                Files.walkFileTree(root, new Visitors.FirstPass(patches));
+                Files.walkFileTree(root, new Visitors.TransformPass(patches, outputFs.getPath("/"), root));
             }
         }
     }

src/main/java/org/vineflower/tools/minifier/FileVisitor.java

@@ -0,0 +1,5 @@
+
+@NullMarked
+package org.vineflower.tools.minifier;
+
+import org.jspecify.annotations.NullMarked;

src/main/java/org/vineflower/tools/minifier/Minifier.java

@@ -0,0 +1,91 @@
+package org.vineflower.tools.minifier.patch;
+
+import org.jspecify.annotations.Nullable;
+
+import java.lang.classfile.*;
+import java.lang.classfile.attribute.InnerClassesAttribute;
+import java.util.HashSet;
+import java.util.Set;
+
+public class BuilderRemoval implements ClassPatch {
+    private final Set<String> protobufExtensions = new HashSet<>();
+
+    private boolean isExtension(String check) {
+        return protobufExtensions.stream().anyMatch(check::startsWith);
+    }
+
+    private void parseTypeArg(Signature.TypeArg arg) {
+        if (arg instanceof Signature.TypeArg.Bounded boundedArg) {
+            Signature.ClassTypeSig classTypeSig = (Signature.ClassTypeSig) boundedArg.boundType();
+            protobufExtensions.add(classTypeSig.className());
+            if (!classTypeSig.typeArgs().isEmpty()) {
+                for (Signature.TypeArg arg2 : classTypeSig.typeArgs()) {
+                    parseTypeArg(arg2);
+                }
+            }
+        }
+    }
+
+    private boolean shouldExcludeMethod(MethodModel method) {
+        String desc = method.methodTypeSymbol().returnType().descriptorString();
+        if (desc.length() == 1) return false;
+        String returnType = desc.substring(desc.indexOf('L') + 1, desc.length() - 1);
+
+        if (isExtension(returnType)) return false;
+        if (isBuilder(returnType)) return true;
+
+        return false;
+    }
+
+    private static boolean isBuilder(String className) {
+        return className.endsWith("$Builder") || className.endsWith("OrBuilder");
+    }
+
+    @Override
+    public void firstPass(ClassModel clazz) {
+        for (FieldModel field : clazz.fields()) {
+            if (!field.fieldType().equalsString("Lkotlin/metadata/internal/protobuf/GeneratedMessageLite$GeneratedExtension;")) continue;
+
+            field.findAttribute(Attributes.signature()).ifPresent(sig -> {
+                Signature.ClassTypeSig classTypeSig = (Signature.ClassTypeSig) sig.asTypeSignature();
+                for (Signature.TypeArg arg : classTypeSig.typeArgs()) {
+                    parseTypeArg(arg);
+                }
+            });
+        }
+    }
+
+    @Override
+    @Nullable
+    public ClassTransform patch(ClassModel clazz) {
+        String className = clazz.thisClass().name().stringValue();
+        if (isExtension(className)) return ClassTransform.ACCEPT_ALL;
+        if (!className.startsWith("kotlin/metadata/internal/metadata")) return ClassTransform.ACCEPT_ALL;
+
+        if (isBuilder(className)) return null;
+
+        return ClassTransform.dropping(el -> {
+            if (el instanceof MethodModel method) {
+                return shouldExcludeMethod(method);
+            }
+            return false;
+        }).andThen((builder, el) -> {
+            switch (el) {
+                case InnerClassesAttribute attr -> builder.with(InnerClassesAttribute.of(
+                        attr.classes().stream().filter(c -> {
+                            String name = c.innerClass().asInternalName();
+                            if (isExtension(name)) return true;
+                            if (isBuilder(name)) return false;
+                            return true;
+                        }).toList()
+                ));
+                case Interfaces itfs -> builder.with(Interfaces.of(
+                        itfs.interfaces().stream().filter(
+                                entry -> isExtension(entry.asInternalName()) || !isBuilder(entry.asInternalName())
+                        ).toList()
+                ));
+                default -> builder.with(el);
+            }
+        });
+    }
+}

src/main/java/org/vineflower/tools/minifier/package-info.java

@@ -0,0 +1,19 @@
+package org.vineflower.tools.minifier.patch;
+
+import org.jspecify.annotations.Nullable;
+
+import java.lang.classfile.ClassModel;
+import java.lang.classfile.ClassTransform;
+
+public interface ClassPatch {
+    /**
+     * Always called with every class to allow for state initialization.
+     */
+    default void firstPass(ClassModel clazz) {}
+
+    /**
+     * @return a {@link ClassTransform} instance to transform, {@link ClassTransform#ACCEPT_ALL ACCEPT_ALL}
+     * to skip transforming by this patch, and {@code null} to remove the class.
+     */
+    @Nullable ClassTransform patch(ClassModel clazz);
+}

src/main/java/org/vineflower/tools/minifier/patch/BuilderRemoval.java

@@ -0,0 +1,20 @@
+package org.vineflower.tools.minifier.patch;
+
+import java.io.IOException;
+import java.lang.classfile.ClassFile;
+import java.lang.classfile.ClassModel;
+import java.lang.classfile.ClassTransform;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+
+public class ClassPatches {
+    public static ClassPatch[] getPatches() {
+        return new ClassPatch[] {
+                new KotlinRemoval(),
+                new BuilderRemoval(),
+                new FlagsToInterface(),
+        };
+    }
+}