Lambda inlining optimization

base/build.gradle

@@ -33,6 +33,7 @@ dependencies {
     testImplementation 'io.kotest:kotest-assertions-core-jvm:5.5.4' // for kotest core jvm assertions
     testImplementation 'io.kotest:kotest-property-jvm:5.5.4' // for kotest property test
     testImplementation 'io.mockk:mockk:1.13.2' // for mocking
+    testImplementation 'com.guardsquare:proguard-retrace:7.3.2'
 
     testImplementation(testFixtures("com.guardsquare:proguard-core:9.0.8")) {
         exclude group: 'com.guardsquare', module: 'proguard-core'

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                   = false;
+
     ///////////////////////////////////////////////////////////////////////////
     // Obfuscation options.
     ///////////////////////////////////////////////////////////////////////////

base/src/main/java/proguard/ConfigurationConstants.java

@@ -114,6 +114,7 @@ public class ConfigurationConstants
 
     public static final String KEEP_KOTLIN_METADATA                              = "-keepkotlinmetadata";
     public static final String DONT_PROCESS_KOTLIN_METADATA                      = "-dontprocesskotlinmetadata";
+    public static final String INLINE_KOTLIN_LAMBDAS                             = "-inlinekotlinlambdas";
     public static final String OPTIMIZE_AGGRESSIVELY                             = "-optimizeaggressively";
 
     public static final String ANY_FILE_KEYWORD            = "**";

base/src/main/java/proguard/ConfigurationParser.java

@@ -212,6 +212,7 @@ else if (ConfigurationConstants.REPACKAGE_CLASSES_OPTION
             else if (ConfigurationConstants.ADAPT_RESOURCE_FILE_CONTENTS_OPTION              .startsWith(nextWord)) configuration.adaptResourceFileContents             = parseCommaSeparatedList("resource file name", true, true, false, true, false, true, false, false, false, configuration.adaptResourceFileContents);
             else if (ConfigurationConstants.DONT_PROCESS_KOTLIN_METADATA                     .startsWith(nextWord)) configuration.dontProcessKotlinMetadata             = parseNoArgument(true);
             else if (ConfigurationConstants.KEEP_KOTLIN_METADATA                             .startsWith(nextWord)) configuration.keepKotlinMetadata                    = parseKeepKotlinMetadata();
+            else if (ConfigurationConstants.INLINE_KOTLIN_LAMBDAS                            .startsWith(nextWord)) configuration.lambdaInlining                        = parseNoArgument(true);
 
             else if (ConfigurationConstants.DONT_PREVERIFY_OPTION                            .startsWith(nextWord)) configuration.preverify                             = parseNoArgument(false);
             else if (ConfigurationConstants.MICRO_EDITION_OPTION                             .startsWith(nextWord)) configuration.microEdition                          = parseNoArgument(true);

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.lambdainline.LambdaInliner;
 import proguard.optimize.peephole.LineNumberLinearizer;
 import proguard.pass.PassRunner;
 import proguard.preverify.PreverificationClearer;
@@ -195,6 +196,13 @@ public void execute() throws Exception
                 new ListParser(new NameParser()).parse(configuration.optimizations) :
                 new ConstantMatcher(true);
 
+            // Inline kotlin lambdas passed as arguments to methods as long as they are
+            // created in the arguments or created in a local variable and passed as an argument
+            if (configuration.lambdaInlining)
+            {
+                inlineLambdas();
+            }
+
             if (configuration.optimize &&
                 filter.matches(Optimizer.LIBRARY_GSON))
             {
@@ -462,6 +470,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/lambdainline/CannotInlineException.java

@@ -0,0 +1,31 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2020 Guardsquare NV
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize.lambdainline;
+
+/**
+ * An exception thrown by the RecursiveInliner that is caught by the BaseLambdaInliner, this allows it to jump out of
+ * the visitor it is currently in and abort the inlining process.
+ */
+public class CannotInlineException extends RuntimeException {
+    public CannotInlineException(String reason) {
+        super(reason);
+    }
+}

base/src/main/java/proguard/optimize/lambdainline/CastPatternRemover.java

@@ -0,0 +1,79 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2020 Guardsquare NV
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize.lambdainline;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import proguard.classfile.Clazz;
+import proguard.classfile.Method;
+import proguard.classfile.attribute.CodeAttribute;
+import proguard.classfile.constant.Constant;
+import proguard.classfile.constant.MethodrefConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.editor.CodeAttributeEditor;
+import proguard.classfile.editor.InstructionSequenceBuilder;
+import proguard.classfile.instruction.Instruction;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.InstructionSequenceMatcher;
+import proguard.classfile.visitor.ClassPrinter;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+/**
+ * This class removes the casting at the end of a lambda invoke method, it does this through pattern matching. It
+ * replaces the pattern invokestatic valueOf, return with just return.
+ */
+public class CastPatternRemover implements InstructionVisitor {
+    private final Logger logger = LogManager.getLogger(this.getClass());
+    private final InstructionSequenceMatcher insSeqMatcher;
+    private final CodeAttributeEditor codeAttributeEditor;
+
+    public CastPatternRemover(CodeAttributeEditor codeAttributeEditor) {
+        InstructionSequenceBuilder ____ = new InstructionSequenceBuilder();
+        Constant[] constants = ____.constants();
+        Instruction[] pattern = ____.invokestatic(InstructionSequenceMatcher.X).areturn().__();
+        this.insSeqMatcher = new InstructionSequenceMatcher(constants, pattern);
+        this.codeAttributeEditor = codeAttributeEditor;
+    }
+
+    @Override
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {
+        instruction.accept(clazz, method, codeAttribute, offset, insSeqMatcher);
+        if (insSeqMatcher.isMatching()) {
+            int constantIndex = insSeqMatcher.matchedConstantIndex(InstructionSequenceMatcher.X);
+            clazz.constantPoolEntryAccept(constantIndex, new ConstantVisitor() {
+                @Override
+                public void visitMethodrefConstant(Clazz clazz, MethodrefConstant methodrefConstant) {
+                    if (methodrefConstant.getName(clazz).equals("valueOf")) {
+                        if (logger.isDebugEnabled()) {
+                            StringWriter stringWriter = new StringWriter();
+                            instruction.accept(clazz, method, codeAttribute, offset, new ClassPrinter(new PrintWriter(stringWriter)));
+                            logger.debug("Removing " + stringWriter);
+                        }
+
+                        codeAttributeEditor.deleteInstruction(insSeqMatcher.matchedInstructionOffset(0));
+                    }
+                }
+            });
+        }
+    }
+}

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

@@ -0,0 +1,108 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2020 Guardsquare NV
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize.lambdainline;
+
+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.visitor.InstructionVisitor;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * A general cast remover class used for removing the casts before and after a bridge method invoke call. It has a
+ * keepList which is a list of argument indexes for which it should keep the cast. The argIndex indicates the current
+ * argument it is processing.
+ */
+public class CastRemover implements InstructionVisitor {
+    private final CodeAttributeEditor codeAttributeEditor;
+    private final List<Integer> keepList;
+    private final int argIndex;
+
+    // The names of all methods taking a boxed type variable and returning the variable with the unboxed type
+    private final Set<String> castingMethodNames = new HashSet<>(Arrays.asList("intValue", "booleanValue", "byteValue", "shortValue", "longValue", "floatValue", "doubleValue", "charValue"));
+
+    public CastRemover(CodeAttributeEditor codeAttributeEditor, List<Integer> keepList, int argIndex) {
+        this.codeAttributeEditor = codeAttributeEditor;
+        this.argIndex = argIndex;
+        this.keepList = keepList;
+    }
+
+    public CastRemover(CodeAttributeEditor codeAttributeEditor) {
+        this(codeAttributeEditor, new ArrayList<>(), -1);
+    }
+
+    @Override
+    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction) {
+        /* Casting on a lambda invoke call looks like this :
+         * iload
+         * invokestatic valueOf
+         * invokeinterface invoke   //lambda call
+         * checkast
+         * invokevirtual intValue
+         * istore
+         *
+         * We remove valueOf, checkast and intValue
+         */
+        if (constantInstruction.opcode == Instruction.OP_CHECKCAST) {
+            codeAttributeEditor.deleteInstruction(offset);
+        } else if (constantInstruction.opcode == Instruction.OP_INVOKESTATIC) {
+            if (getInvokedMethodName(clazz, constantInstruction).equals("valueOf")) {
+                // Don't remove valueOf call when the lambda takes an object as argument
+                if (!keepList.contains(argIndex)) {
+                    codeAttributeEditor.deleteInstruction(offset);
+                }
+            }
+        } else if (constantInstruction.opcode == Instruction.OP_INVOKEVIRTUAL) {
+            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/lambdainline/DescriptorModifier.java

@@ -0,0 +1,77 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2020 Guardsquare NV
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.optimize.lambdainline;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.ProgramClass;
+import proguard.classfile.ProgramMethod;
+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;
+
+/**
+ * A class that takes a method and creates a new method with a different name that has an updated descriptor. The
+ * descriptor is made using a lambda that takes in the old descriptor and then returns the new descriptor. Optionally
+ * the original method can be deleted.
+ */
+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);
+    }
+}