Classes needed for lambda merging in ProGuard

src/main/java/proguard/classfile/ClassConstants.java

@@ -114,6 +114,10 @@ public class ClassConstants
     public static final String NAME_ANDROID_WEBKIT_WEB_VIEW                 = "android/webkit/WebView";
     public static final String NAME_ANDROID_SUPPORT_V4_APP_FRAGMENT         = "android/support/v4/app/Fragment";
 
+    public static final String NAME_KOTLIN_UNIT = "kotlin/Unit";
+    public static final String TYPE_KOTLIN_UNIT = "Lkotlin/Unit;";
+    public static final String FIELD_NAME_KOTLIN_UNIT_INSTANCE = "INSTANCE";
+
     public static final String NAME_JAVA_UTIL_CONCURRENT_ATOMIC_ATOMIC_INTEGER_FIELD_UPDATER   = "java/util/concurrent/atomic/AtomicIntegerFieldUpdater";
     public static final String NAME_JAVA_UTIL_CONCURRENT_ATOMIC_ATOMIC_LONG_FIELD_UPDATER      = "java/util/concurrent/atomic/AtomicLongFieldUpdater";
     public static final String NAME_JAVA_UTIL_CONCURRENT_ATOMIC_ATOMIC_REFERENCE_FIELD_UPDATER = "java/util/concurrent/atomic/AtomicReferenceFieldUpdater";

src/main/java/proguard/classfile/attribute/visitor/ClassConstantToClassVisitor.java

@@ -0,0 +1,27 @@
+package proguard.classfile.attribute.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.constant.ClassConstant;
+import proguard.classfile.constant.Constant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.visitor.ClassVisitor;
+
+public class ClassConstantToClassVisitor implements ConstantVisitor {
+
+    private final ClassVisitor classVisitor;
+
+    public ClassConstantToClassVisitor(ClassVisitor classVisitor)
+    {
+        this.classVisitor = classVisitor;
+    }
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+    @Override
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant) {
+        if (this.classVisitor != null && classConstant.referencedClass != null)
+        {
+            classConstant.referencedClass.accept(this.classVisitor);
+        }
+    }
+}

src/main/java/proguard/classfile/attribute/visitor/InnerClassInfoClassConstantVisitor.java

@@ -0,0 +1,30 @@
+package proguard.classfile.attribute.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.ProgramClass;
+import proguard.classfile.attribute.InnerClassesInfo;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+
+public class InnerClassInfoClassConstantVisitor implements InnerClassesInfoVisitor {
+
+    private final ConstantVisitor innerClassConstantVisitor;
+    private final ConstantVisitor outerClassConstantVisitor;
+
+    public InnerClassInfoClassConstantVisitor(ConstantVisitor innerClassConstantVisitor, ConstantVisitor outerClassConstantVisitor)
+    {
+        this.innerClassConstantVisitor = innerClassConstantVisitor;
+        this.outerClassConstantVisitor = outerClassConstantVisitor;
+    }
+
+    @Override
+    public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo) {
+        if (this.innerClassConstantVisitor != null)
+        {
+            innerClassesInfo.innerClassConstantAccept(clazz, this.innerClassConstantVisitor);
+        }
+        if (this.outerClassConstantVisitor != null)
+        {
+            innerClassesInfo.outerClassConstantAccept(clazz, this.outerClassConstantVisitor);
+        }
+    }
+}

src/main/java/proguard/classfile/attribute/visitor/ModifiedAllInnerClassesInfoVisitor.java

@@ -0,0 +1,25 @@
+package proguard.classfile.attribute.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.attribute.InnerClassesAttribute;
+
+/**
+ * This {@link AllInnerClassesInfoVisitor} revisits each {@link InnerClassesAttribute} everytime its amount of
+ * referenced classes has been modified in the meantime.
+ */
+public class ModifiedAllInnerClassesInfoVisitor extends AllInnerClassesInfoVisitor {
+
+    public ModifiedAllInnerClassesInfoVisitor(InnerClassesInfoVisitor innerClassesInfoVisitor) {
+        super(innerClassesInfoVisitor);
+    }
+
+    public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
+    {
+        int originalClassesCount = -1;
+        while (originalClassesCount != innerClassesAttribute.u2classesCount)
+        {
+            originalClassesCount = innerClassesAttribute.u2classesCount;
+            super.visitInnerClassesAttribute(clazz, innerClassesAttribute);
+        }
+    }
+}

src/main/java/proguard/classfile/visitor/ClassConstantReferenceUpdater.java

@@ -0,0 +1,28 @@
+package proguard.classfile.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.constant.ClassConstant;
+import proguard.classfile.constant.Constant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+
+public class ClassConstantReferenceUpdater implements ConstantVisitor
+{
+    private final Clazz originalClass;
+    private final Clazz replacingClass;
+    public ClassConstantReferenceUpdater(Clazz originalClass, Clazz replacingClass)
+    {
+        this.originalClass  = originalClass;
+        this.replacingClass = replacingClass;
+    }
+
+    @Override
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+    @Override
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant) {
+        if (classConstant.referencedClass == originalClass)
+        {
+            classConstant.referencedClass = replacingClass;
+        }
+    }
+}

src/main/java/proguard/classfile/visitor/ClassMethodFilter.java

@@ -0,0 +1,52 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2021 Guardsquare NV
+ */
+
+package proguard.classfile.visitor;
+
+import proguard.classfile.*;
+
+/**
+ * This {@link ClassVisitor} delegates its visits to given
+ * acceptVisitor when the visited class has method with
+ * given name and descriptor and delegates to rejectVisitor when
+ * none of the class methods match.
+ */
+public class ClassMethodFilter
+implements   ClassVisitor
+{
+    private final String       methodName;
+    private final String       descriptor;
+    private final ClassVisitor acceptVisitor;
+    private final ClassVisitor rejectVisitor;
+
+    public ClassMethodFilter(String       methodName,
+                             String       descriptor,
+                             ClassVisitor acceptVisitor,
+                             ClassVisitor rejectVisitor)
+    {
+        this.methodName    = methodName;
+        this.descriptor    = descriptor;
+        this.acceptVisitor = acceptVisitor;
+        this.rejectVisitor = rejectVisitor;
+    }
+
+    @Override
+    public void visitAnyClass(Clazz clazz)
+    {
+        ClassVisitor delegateVisitor = delegateVisitor(clazz);
+        if (delegateVisitor != null)
+        {
+            delegateVisitor.visitAnyClass(clazz);
+        }
+    }
+
+    private ClassVisitor delegateVisitor(Clazz clazz)
+    {
+        Method method = clazz.findMethod(methodName, descriptor);
+        return method != null ? acceptVisitor : rejectVisitor;
+    }
+}

src/main/java/proguard/classfile/visitor/ClassReferenceFinder.java

@@ -0,0 +1,32 @@
+package proguard.classfile.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.constant.ClassConstant;
+import proguard.classfile.constant.Constant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+
+public class ClassReferenceFinder implements ConstantVisitor
+{
+    private final Clazz referencedClass;
+    private boolean classIsReferenced = false;
+
+    public ClassReferenceFinder(Clazz referencedClass)
+    {
+        this.referencedClass = referencedClass;
+    }
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        if (classConstant.referencedClass != null && classConstant.referencedClass.equals(referencedClass))
+        {
+            this.classIsReferenced = true;
+        }
+    }
+
+    public boolean classReferenceFound()
+    {
+        return this.classIsReferenced;
+    }
+}

src/main/java/proguard/classfile/visitor/CodeSizeCounter.java

@@ -0,0 +1,29 @@
+package proguard.classfile.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.Method;
+import proguard.classfile.attribute.Attribute;
+import proguard.classfile.attribute.CodeAttribute;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+
+public class CodeSizeCounter
+implements AttributeVisitor
+{
+    private int totalCodeSize = 0;
+
+    // Implementations for AttributeVisitor
+
+    @Override
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+    @Override
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        totalCodeSize += codeAttribute.u4codeLength;
+    }
+
+    public int getCount()
+    {
+        return totalCodeSize;
+    }
+}

src/main/java/proguard/classfile/visitor/DescriptorTypeUpdater.java

@@ -0,0 +1,25 @@
+package proguard.classfile.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.constant.Constant;
+import proguard.classfile.constant.Utf8Constant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+
+public class DescriptorTypeUpdater implements ConstantVisitor
+{
+    private final String originalType;
+    private final String replacingType;
+    public DescriptorTypeUpdater(String originalType, String replacingType)
+    {
+        this.originalType  = originalType;
+        this.replacingType = replacingType;
+    }
+
+    @Override
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+    @Override
+    public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant) {
+        utf8Constant.setString(utf8Constant.getString().replace(originalType, replacingType));
+    }
+}

src/main/java/proguard/classfile/visitor/FieldCopier.java

@@ -0,0 +1,78 @@
+package proguard.classfile.visitor;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import proguard.classfile.*;
+import proguard.classfile.constant.FieldrefConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.editor.ClassBuilder;
+import proguard.classfile.editor.ClassEditor;
+
+public class FieldCopier implements MemberVisitor, ConstantVisitor {
+
+    private final ClassBuilder classBuilder;
+    private final ClassEditor classEditor;
+    private final FieldRenamer fieldRenamer;
+    private ProgramField lastCopiedField;
+    private boolean hasCopiedField = false;
+    private static final Logger logger = LogManager.getLogger(FieldCopier.class);
+
+    public FieldCopier(ClassBuilder builder, FieldRenamer renamer)
+    {
+        this.classBuilder = builder;
+        this.classEditor = new ClassEditor(builder.getProgramClass());
+        this.fieldRenamer = renamer;
+    }
+
+    @Override
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        String fieldName = programField.getName(programClass);
+        if (this.fieldRenamer != null)
+        {
+            fieldName = fieldRenamer.getNextFieldName();
+        }
+
+        String fieldDescriptor = programField.getDescriptor(programClass);
+        Field oldField = classBuilder.getProgramClass().findField(fieldName, null);
+        Field oldFieldSameDescriptor = classBuilder.getProgramClass().findField(fieldName, fieldDescriptor);
+        if (oldField != null && oldFieldSameDescriptor == null)
+        {
+            String oldFieldDescriptor = oldField.getDescriptor(classBuilder.getProgramClass());
+            //logger.warn("Field " + fieldName + " already exists in class " + classBuilder.getProgramClass() + " with different descriptor: " + oldFieldDescriptor + " <-> " + fieldDescriptor + ". The field will be duplicated with different descriptors.");
+                // Merge the field types: generalise to a common super type
+                //fieldDescriptor = ClassConstants.TYPE_JAVA_LANG_OBJECT;
+        }
+        else if (oldFieldSameDescriptor != null)
+        {
+            this.classEditor.removeField(oldFieldSameDescriptor);
+        }
+        ProgramField copiedField = classBuilder.addAndReturnField(programField.u2accessFlags, fieldName, fieldDescriptor);
+        if (this.fieldRenamer != null)
+        {
+            this.fieldRenamer.visitProgramField(classBuilder.getProgramClass(), copiedField);
+        }
+        this.lastCopiedField = copiedField;
+        this.hasCopiedField = true;
+    }
+
+    @Override
+    public void visitFieldrefConstant(Clazz clazz, FieldrefConstant fieldrefConstant) {
+        fieldrefConstant.referencedFieldAccept(this);
+    }
+
+    public ProgramField getLastCopiedField()
+    {
+        return this.lastCopiedField;
+    }
+
+    public boolean hasCopiedField()
+    {
+        return this.hasCopiedField;
+    }
+
+    public void reset()
+    {
+        this.hasCopiedField = false;
+    }
+}

src/main/java/proguard/classfile/visitor/FieldReferenceFinder.java

@@ -0,0 +1,46 @@
+package proguard.classfile.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.constant.Constant;
+import proguard.classfile.constant.FieldrefConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.ClassUtil;
+import proguard.util.ListParser;
+import proguard.util.NameParser;
+import proguard.util.StringMatcher;
+
+public class FieldReferenceFinder implements ConstantVisitor {
+
+    private final Clazz referencedClass;
+    private final StringMatcher regularExpressionMatcher;
+    private final ConstantVisitor constantVisitor;
+    private boolean fieldReferenceFound = false;
+
+    public FieldReferenceFinder(Clazz referencedClass,
+                                String fieldNameRegularExpression,
+                                ConstantVisitor constantVisitor)
+    {
+        this.referencedClass           = referencedClass;
+        this.regularExpressionMatcher = new ListParser(new NameParser(null)).parse(fieldNameRegularExpression);
+        this.constantVisitor           = constantVisitor;
+    }
+
+    @Override
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+    @Override
+    public void visitFieldrefConstant(Clazz clazz, FieldrefConstant fieldrefConstant)
+    {
+        if (fieldrefConstant.referencedClass == referencedClass
+                && this.regularExpressionMatcher.matches(fieldrefConstant.getName(clazz)))
+        {
+            this.fieldReferenceFound = true;
+            fieldrefConstant.accept(clazz, this.constantVisitor);
+        }
+    }
+
+    public boolean isFieldReferenceFound()
+    {
+        return this.fieldReferenceFound;
+    }
+}