Lambda inlining optimization

base/src/main/java/proguard/Configuration.java

@@ -200,6 +200,11 @@ public class Configuration
      */
     public boolean                      mergeInterfacesAggressively      = false;
 
+    /**
+     * Specifies whether lambdas should be inlined.
+     */
+    public boolean                      lambdaInlining                   = true;
+
     ///////////////////////////////////////////////////////////////////////////
     // Obfuscation options.
     ///////////////////////////////////////////////////////////////////////////

base/src/main/java/proguard/ProGuard.java

@@ -38,6 +38,7 @@
 import proguard.optimize.LineNumberTrimmer;
 import proguard.optimize.Optimizer;
 import proguard.optimize.gson.GsonOptimizer;
+import proguard.optimize.inline.LambdaInliner;
 import proguard.optimize.peephole.LineNumberLinearizer;
 import proguard.pass.PassRunner;
 import proguard.preverify.PreverificationClearer;
@@ -195,6 +196,11 @@ public void execute() throws Exception
                 new ListParser(new NameParser()).parse(configuration.optimizations) :
                 new ConstantMatcher(true);
 
+            if (configuration.lambdaInlining)
+            {
+                inlineLambdas();
+            }
+
             if (configuration.optimize &&
                 filter.matches(Optimizer.LIBRARY_GSON))
             {
@@ -462,6 +468,11 @@ private void optimizeGson() throws Exception
         passRunner.run(new GsonOptimizer(configuration), appView);
     }
 
+    private void inlineLambdas() throws Exception
+    {
+        LambdaInliner lambdaInliner = new LambdaInliner();
+        passRunner.run(lambdaInliner, appView);
+    }
 
     /**
      * Performs the optimization step.

base/src/main/java/proguard/optimize/inline/CallReplacer.java

@@ -0,0 +1,48 @@
+package proguard.optimize.inline;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.Method;
+import proguard.classfile.ProgramClass;
+import proguard.classfile.attribute.CodeAttribute;
+import proguard.classfile.constant.AnyMethodrefConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.editor.CodeAttributeEditor;
+import proguard.classfile.editor.ConstantPoolEditor;
+import proguard.classfile.instruction.ConstantInstruction;
+import proguard.classfile.instruction.Instruction;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+
+public class CallReplacer implements InstructionVisitor {
+    private final CodeAttributeEditor codeAttributeEditor;
+    private final Clazz methodOwnerClazz;
+    private final Method oldMethod;
+    private final Method newMethod;
+
+    public CallReplacer(CodeAttributeEditor codeAttributeEditor, Clazz methodOwnerClazz, Method oldMethod, Method newMethod) {
+        this.codeAttributeEditor = codeAttributeEditor;
+        this.methodOwnerClazz = methodOwnerClazz;
+        this.oldMethod = oldMethod;
+        this.newMethod = newMethod;
+    }
+
+    @Override
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
+
+    @Override
+    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction) {
+        if (constantInstruction.opcode == Instruction.OP_INVOKESTATIC) {
+            ConstantPoolEditor constantPoolEditor = new ConstantPoolEditor((ProgramClass) clazz);
+            clazz.constantPoolEntryAccept(constantInstruction.constantIndex, new ConstantVisitor() {
+                @Override
+                public void visitAnyMethodrefConstant(Clazz clazz, AnyMethodrefConstant anyMethodrefConstant) {
+                    if (anyMethodrefConstant.referencedMethod != null && anyMethodrefConstant.referencedMethod.equals(oldMethod)) {
+                        int newMethodIndex = constantPoolEditor.addMethodrefConstant(methodOwnerClazz, newMethod);
+                        codeAttributeEditor.reset(codeAttribute.u4codeLength);
+                        codeAttributeEditor.replaceInstruction(offset, new ConstantInstruction(Instruction.OP_INVOKESTATIC, newMethodIndex));
+                        codeAttributeEditor.visitCodeAttribute(clazz, method, codeAttribute);
+                    }
+                }
+            });
+        }
+    }
+}

base/src/main/java/proguard/optimize/inline/CannotInlineException.java

@@ -0,0 +1,7 @@
+package proguard.optimize.inline;
+
+public class CannotInlineException extends RuntimeException {
+    public CannotInlineException(String reason) {
+        super(reason);
+    }
+}

base/src/main/java/proguard/optimize/inline/CastRemover.java

@@ -0,0 +1,75 @@
+package proguard.optimize.inline;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.Method;
+import proguard.classfile.attribute.CodeAttribute;
+import proguard.classfile.constant.AnyMethodrefConstant;
+import proguard.classfile.constant.NameAndTypeConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.editor.CodeAttributeEditor;
+import proguard.classfile.instruction.ConstantInstruction;
+import proguard.classfile.instruction.Instruction;
+import proguard.classfile.instruction.InstructionFactory;
+import proguard.classfile.instruction.VariableInstruction;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.visitor.ClassPrinter;
+
+import java.util.*;
+
+public class CastRemover implements InstructionVisitor {
+    private final CodeAttributeEditor codeAttributeEditor;
+    private List<Integer> keepList;
+    private int currentIndex;
+
+    public CastRemover(CodeAttributeEditor codeAttributeEditor, List<Integer> keepList) {
+        this.codeAttributeEditor = codeAttributeEditor;
+        this.currentIndex = 0;
+        this.keepList = keepList;
+    }
+
+    public CastRemover(CodeAttributeEditor codeAttributeEditor) {
+        this(codeAttributeEditor, new ArrayList<>());
+    }
+
+    @Override
+    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction) {
+        Set<String> castingMethodNames = new HashSet<>(Arrays.asList("intValue", "booleanValue", "byteValue", "shortValue", "longValue", "floatValue", "doubleValue", "charValue"));
+        if (constantInstruction.opcode == Instruction.OP_CHECKCAST) {
+            System.out.println("Removing " + InstructionFactory.create(codeAttribute.code, offset).toString(offset));
+            codeAttributeEditor.deleteInstruction(offset);
+        } else if (constantInstruction.opcode == Instruction.OP_INVOKESTATIC) {
+            if (getInvokedMethodName(clazz, constantInstruction).equals("valueOf")) {
+                if (!keepList.contains(currentIndex)) {
+                    System.out.print("Removing "); InstructionFactory.create(codeAttribute.code, offset).accept(clazz, method, codeAttribute, offset, new ClassPrinter());
+                    codeAttributeEditor.deleteInstruction(offset);
+                }
+
+                currentIndex++;
+            }
+        } else if (constantInstruction.opcode == Instruction.OP_INVOKEVIRTUAL) {
+            System.out.println("Removing " + InstructionFactory.create(codeAttribute.code, offset).toString(offset));
+            if (castingMethodNames.contains(getInvokedMethodName(clazz, constantInstruction))) {
+                codeAttributeEditor.deleteInstruction(offset);
+            }
+        }
+    }
+
+    @Override
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {
+    }
+
+    private String getInvokedMethodName(Clazz clazz, ConstantInstruction constantInstruction) {
+        final String[] invokedMethodName = new String[1];
+        clazz.constantPoolEntryAccept(constantInstruction.constantIndex, new ConstantVisitor() {
+            @Override public void visitAnyMethodrefConstant(Clazz clazz, AnyMethodrefConstant anyMethodrefConstant) {
+                clazz.constantPoolEntryAccept(anyMethodrefConstant.u2nameAndTypeIndex, new ConstantVisitor() {
+                    @Override
+                    public void visitNameAndTypeConstant(Clazz clazz, NameAndTypeConstant nameAndTypeConstant) {
+                        invokedMethodName[0] = nameAndTypeConstant.getName(clazz);
+                    }
+                });
+            }
+        });
+        return invokedMethodName[0];
+    }
+}

base/src/main/java/proguard/optimize/inline/DescriptorModifier.java

@@ -0,0 +1,50 @@
+package proguard.optimize.inline;
+
+import proguard.classfile.*;
+import proguard.classfile.editor.AttributeAdder;
+import proguard.classfile.editor.ClassBuilder;
+import proguard.classfile.editor.ClassEditor;
+import proguard.obfuscate.NameFactory;
+import proguard.obfuscate.SimpleNameFactory;
+import proguard.obfuscate.UniqueMemberNameFactory;
+import proguard.optimize.info.ProgramMemberOptimizationInfoSetter;
+
+import java.util.function.Function;
+
+public class DescriptorModifier {
+    private final ClassBuilder classBuilder;
+    private final NameFactory nameFactory;
+    private final Clazz clazz;
+
+    DescriptorModifier(Clazz clazz) {
+        classBuilder = new ClassBuilder((ProgramClass) clazz);
+        nameFactory = new UniqueMemberNameFactory(new SimpleNameFactory(), clazz);
+        this.clazz = clazz;
+    }
+
+    public ProgramMethod modify(ProgramMethod sourceMethod, Function<String, String> modifier) {
+        return modify(sourceMethod, modifier, false);
+    }
+
+    public ProgramMethod modify(ProgramMethod sourceMethod, Function<String, String> modifier, boolean removeOriginal) {
+        ProgramMethod newMethod = classBuilder.addAndReturnMethod(
+                sourceMethod.u2accessFlags,
+                nameFactory.nextName(),
+                modifier.apply(sourceMethod.getDescriptor(clazz))
+        );
+
+        sourceMethod.attributesAccept((ProgramClass) clazz,
+                new AttributeAdder((ProgramClass) clazz, newMethod, true));
+
+        if (removeOriginal)
+            removeOriginal(sourceMethod);
+
+        newMethod.accept(clazz, new ProgramMemberOptimizationInfoSetter());
+        return newMethod;
+    }
+
+    private void removeOriginal(ProgramMethod method) {
+        ClassEditor classEditor = new ClassEditor((ProgramClass) clazz);
+        classEditor.removeMethod(method);
+    }
+}

base/src/main/java/proguard/optimize/inline/InstructionAtOffset.java

@@ -0,0 +1,45 @@
+package proguard.optimize.inline;
+
+import proguard.classfile.instruction.Instruction;
+
+import java.util.Objects;
+
+public final class InstructionAtOffset {
+    private final Instruction instruction;
+    private final int offset;
+
+    InstructionAtOffset(Instruction instruction, int offset) {
+        this.instruction = instruction;
+        this.offset = offset;
+    }
+
+    public Instruction instruction() {
+        return instruction;
+    }
+
+    public int offset() {
+        return offset;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        InstructionAtOffset that = (InstructionAtOffset) obj;
+        return Objects.equals(this.instruction, that.instruction) &&
+                this.offset == that.offset;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(instruction, offset);
+    }
+
+    @Override
+    public String toString() {
+        return "InstructionAtOffset[" +
+                "instruction=" + instruction + ", " +
+                "offset=" + offset + ']';
+    }
+
+}

base/src/main/java/proguard/optimize/inline/LambdaImplementationVisitor.java

@@ -0,0 +1,66 @@
+package proguard.optimize.inline;
+
+import proguard.classfile.*;
+import proguard.classfile.constant.ClassConstant;
+import proguard.classfile.constant.FieldrefConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.visitor.AllMethodVisitor;
+import proguard.classfile.visitor.MemberVisitor;
+
+public class LambdaImplementationVisitor implements ConstantVisitor, MemberVisitor {
+    private final InvokeMethodVisitor invokeMethodVisitor;
+    private Clazz lambdaImplementationClass;
+    public LambdaImplementationVisitor(InvokeMethodVisitor invokeMethodHandler) {
+        this.invokeMethodVisitor = invokeMethodHandler;
+    }
+
+    @Override
+    public void visitFieldrefConstant(Clazz clazz, FieldrefConstant fieldrefConstant) {
+        lambdaImplementationClass = fieldrefConstant.referencedClass;
+        fieldrefConstant.referencedClass.interfaceConstantsAccept(this);
+    }
+
+    @Override
+    public void visitClassConstant(Clazz clazz, ClassConstant referencedClassConstant) {
+        referencedClassConstant.referencedClass.methodsAccept(this);
+    }
+
+    @Override
+    public void visitProgramMethod(ProgramClass interfaceClass, ProgramMethod programMethod)
+    {
+        getLambdaImplementation(interfaceClass, programMethod);
+    }
+
+    @Override
+    public void visitLibraryMethod(LibraryClass interfaceClass, LibraryMethod libraryMethod) {
+        getLambdaImplementation(interfaceClass, libraryMethod);
+    }
+
+    private void getLambdaImplementation(Clazz interfaceClazz, Method method) {
+        String descriptor = method.getDescriptor(interfaceClazz);
+        lambdaImplementationClass.methodAccept("invoke", descriptor, new MemberVisitor() {
+            @Override
+            public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod) {
+                System.out.println("Descriptor " + programMethod.getDescriptor(programClass));
+                String descriptor = programMethod.getDescriptor(programClass);
+                lambdaImplementationClass.accept(new AllMethodVisitor(new MemberVisitor() {
+                    @Override
+                    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod) {
+                        if (programMethod.getName(programClass).equals("invoke") && programMethod.u2accessFlags == (AccessConstants.PUBLIC | AccessConstants.FINAL)) {
+                            lambdaImplementationClass.methodAccept("invoke", programMethod.getDescriptor(programClass), new MemberVisitor() {
+                                @Override
+                                public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod) {
+                                    invokeMethodVisitor.visitInvokeMethod(programClass, programMethod, interfaceClazz, descriptor);
+                                }
+                            });
+                        }
+                    }
+                }));
+            }
+        });
+    }
+
+    public interface InvokeMethodVisitor {
+        void visitInvokeMethod(ProgramClass programClass, ProgramMethod programMethod, Clazz interfaceClass, String bridgeDescriptor);
+    }
+}