Classes needed for lambda merging in ProGuard

[heckej]

This will add visitors that are used to implement lambda merging in ProGuard (see pull request for ProGuard: Implementation of lambda merging for Kotlin lambda classes #257).

[mrjameshamilton]

Can you add the ProGuardCORE header to all the classes?

[mrjameshamilton]

Here we should be using a ConstantPoolEditor to add a new constant. You can use a ConstantPoolShrinker after to remove unused ones.

        programMember.u2nameIndex =
            new ConstantPoolEditor(programClass).addUtf8Constant(newName);

[mrjameshamilton]

This might be replacable by the following Filter class which can delegate to another ClassVisitor if the the class is referenced.

It's extracted from proguard.backport.StaticInterfaceMethodConverter.MyReferencedClassFilter in ProGuard.

Usable like the following:

        this.programClassPool.classesAccept(
                new ClassNameFilter(regularExpression,
                new ReferencedClassFilter(
                    lambdaClass,
                    enclosingMethodUpdater)));

But I see that currentLambdaClass gets updated, so might not work. Can also be used with a ClassCounter:

ClassCounter counter = new ClassCounter();
programClass.accept(new ReferencedClassFilter(currentLambdaClass, counter))

package proguard.classfile.visitor;

import proguard.classfile.*;
import proguard.classfile.constant.*;
import proguard.classfile.constant.visitor.ConstantVisitor;
import proguard.classfile.visitor.ClassVisitor;

/**
 * This ClassVisitor delegates its visits to classes that
 * reference a given class via any RefConstant.
 */
public class ReferencedClassFilter
    implements ClassVisitor,
               ConstantVisitor
{
    private final Clazz        referencedClass;
    private final ClassVisitor classVisitor;

    private boolean referenceClassFound;


    public ReferencedClassFilter(Clazz referencedClass,
                                 ClassVisitor classVisitor)
    {
        this.referencedClass = referencedClass;
        this.classVisitor = classVisitor;
    }


    // Implementations for ClassVisitor.


    @Override
    public void visitAnyClass(Clazz clazz) {}


    @Override
    public void visitProgramClass(ProgramClass programClass)
    {
        referenceClassFound = false;
        programClass.constantPoolEntriesAccept(this);

        if (referenceClassFound)
        {
            programClass.accept(classVisitor);
        }
    }


    // Implementations for ConstantVisitor.


    public void visitAnyConstant(Clazz clazz, Constant constant) {}


    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
    {
        if (refConstant.referencedClass == referencedClass)
        {
            referenceClassFound = true;
        }
    }
}