classfile/util/DynamicMemberReferenceInitializer.java

/*
 * ProGuard -- shrinking, optimization, obfuscation, and preverification
 *             of Java bytecode.
 *
 * Copyright (c) 2002-2009 Eric Lafortune (eric@graphics.cornell.edu)
 *
 * 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.classfile.util;

import proguard.classfile.*;
import proguard.classfile.attribute.CodeAttribute;
import proguard.classfile.attribute.visitor.AttributeVisitor;
import proguard.classfile.constant.*;
import proguard.classfile.constant.visitor.ConstantVisitor;
import proguard.classfile.instruction.*;
import proguard.classfile.instruction.visitor.InstructionVisitor;
import proguard.classfile.visitor.*;
import proguard.util.StringMatcher;

/**
 * This InstructionVisitor initializes any constant
 * <code>Class.get[Declared]{Field,Method}</code> references of all instructions
 * it visits. More specifically, it fills out the references of string constant
 * pool entries that refer to a class member in the program class pool or in the
 * library class pool.
 * <p>
 * It optionally prints notes if on usage of
 * <code>(SomeClass)Class.forName(variable).newInstance()</code>.
 * <p>
 * The class hierarchy and references must be initialized before using this
 * visitor.
 *
 * @see ClassSuperHierarchyInitializer
 * @see ClassReferenceInitializer
 *
 * @author Eric Lafortune
 */
public class DynamicMemberReferenceInitializer
extends      SimplifiedVisitor
implements   InstructionVisitor,
             ConstantVisitor,
             AttributeVisitor,
             MemberVisitor
{
    public static final int X = InstructionSequenceMatcher.X;
    public static final int Y = InstructionSequenceMatcher.Y;
    public static final int Z = InstructionSequenceMatcher.Z;

    public static final int A = InstructionSequenceMatcher.A;
    public static final int B = InstructionSequenceMatcher.B;
    public static final int C = InstructionSequenceMatcher.C;
    public static final int D = InstructionSequenceMatcher.D;


    private final Constant[] GET_FIELD_CONSTANTS = new Constant[]
    {
        new MethodrefConstant(1, 2, null, null),
        new ClassConstant(3, null),
        new NameAndTypeConstant(4, 5),
        new Utf8Constant(ClassConstants.INTERNAL_NAME_JAVA_LANG_CLASS),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_CLASS_GET_FIELD),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_CLASS_GET_FIELD),
    };

    private final Constant[] GET_DECLARED_FIELD_CONSTANTS = new Constant[]
    {
        new MethodrefConstant(1, 2, null, null),
        new ClassConstant(3, null),
        new NameAndTypeConstant(4, 5),
        new Utf8Constant(ClassConstants.INTERNAL_NAME_JAVA_LANG_CLASS),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_CLASS_GET_DECLARED_FIELD),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_CLASS_GET_DECLARED_FIELD),
    };

    private final Constant[] GET_METHOD_CONSTANTS = new Constant[]
    {
        new MethodrefConstant(1, 2, null, null),
        new ClassConstant(3, null),
        new NameAndTypeConstant(4, 5),
        new Utf8Constant(ClassConstants.INTERNAL_NAME_JAVA_LANG_CLASS),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_CLASS_GET_METHOD),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_CLASS_GET_METHOD),
    };

    private final Constant[] GET_DECLARED_METHOD_CONSTANTS = new Constant[]
    {
        new MethodrefConstant(1, 2, null, null),
        new ClassConstant(3, null),
        new NameAndTypeConstant(4, 5),
        new Utf8Constant(ClassConstants.INTERNAL_NAME_JAVA_LANG_CLASS),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_CLASS_GET_DECLARED_METHOD),
        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_CLASS_GET_DECLARED_METHOD),
    };

    // SomeClass.class.get[Declared]Field("someField").
    private final Instruction[] CONSTANT_GET_FIELD_INSTRUCTIONS = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, X),
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };

    // SomeClass.class.get[Declared]Method("someMethod", new Class[] {}).
    private final Instruction[] CONSTANT_GET_METHOD_INSTRUCTIONS0 = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, X),
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new SimpleInstruction(InstructionConstants.OP_ICONST_0),
        new ConstantInstruction(InstructionConstants.OP_ANEWARRAY, 1),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };

    // SomeClass.class.get[Declared]Method("someMethod", new Class[] { A.class }).
    private final Instruction[] CONSTANT_GET_METHOD_INSTRUCTIONS1 = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, X),
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new SimpleInstruction(InstructionConstants.OP_ICONST_1),
        new ConstantInstruction(InstructionConstants.OP_ANEWARRAY, 1),
        new SimpleInstruction(InstructionConstants.OP_DUP),
        new SimpleInstruction(InstructionConstants.OP_ICONST_0),
        new ConstantInstruction(InstructionConstants.OP_LDC, A),
        new SimpleInstruction(InstructionConstants.OP_AASTORE),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };

    // SomeClass.class.get[Declared]Method("someMethod", new Class[] { A.class, B.class }).
    private final Instruction[] CONSTANT_GET_METHOD_INSTRUCTIONS2 = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, X),
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new SimpleInstruction(InstructionConstants.OP_ICONST_2),
        new ConstantInstruction(InstructionConstants.OP_ANEWARRAY, 1),
        new SimpleInstruction(InstructionConstants.OP_DUP),
        new SimpleInstruction(InstructionConstants.OP_ICONST_0),
        new ConstantInstruction(InstructionConstants.OP_LDC, A),
        new SimpleInstruction(InstructionConstants.OP_AASTORE),
        new SimpleInstruction(InstructionConstants.OP_DUP),
        new SimpleInstruction(InstructionConstants.OP_ICONST_1),
        new ConstantInstruction(InstructionConstants.OP_LDC, B),
        new SimpleInstruction(InstructionConstants.OP_AASTORE),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };

    // get[Declared]Field("someField").
    private final Instruction[] GET_FIELD_INSTRUCTIONS = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };

    // get[Declared]Method("someMethod", new Class[] {}).
    private final Instruction[] GET_METHOD_INSTRUCTIONS0 = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new SimpleInstruction(InstructionConstants.OP_ICONST_0),
        new ConstantInstruction(InstructionConstants.OP_ANEWARRAY, 1),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };

    // get[Declared]Method("someMethod", new Class[] { A.class }).
    private final Instruction[] GET_METHOD_INSTRUCTIONS1 = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new SimpleInstruction(InstructionConstants.OP_ICONST_1),
        new ConstantInstruction(InstructionConstants.OP_ANEWARRAY, 1),
        new SimpleInstruction(InstructionConstants.OP_DUP),
        new SimpleInstruction(InstructionConstants.OP_ICONST_0),
        new ConstantInstruction(InstructionConstants.OP_LDC, A),
        new SimpleInstruction(InstructionConstants.OP_AASTORE),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };

    // get[Declared]Method("someMethod", new Class[] { A.class, B.class }).
    private final Instruction[] GET_METHOD_INSTRUCTIONS2 = new Instruction[]
    {
        new ConstantInstruction(InstructionConstants.OP_LDC, Y),
        new SimpleInstruction(InstructionConstants.OP_ICONST_2),
        new ConstantInstruction(InstructionConstants.OP_ANEWARRAY, 1),
        new SimpleInstruction(InstructionConstants.OP_DUP),
        new SimpleInstruction(InstructionConstants.OP_ICONST_0),
        new ConstantInstruction(InstructionConstants.OP_LDC, A),
        new SimpleInstruction(InstructionConstants.OP_AASTORE),
        new SimpleInstruction(InstructionConstants.OP_DUP),
        new SimpleInstruction(InstructionConstants.OP_ICONST_1),
        new ConstantInstruction(InstructionConstants.OP_LDC, B),
        new SimpleInstruction(InstructionConstants.OP_AASTORE),
        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 0),
    };


    private final ClassPool      programClassPool;
    private final ClassPool      libraryClassPool;
    private final WarningPrinter notePrinter;
    private final StringMatcher  noteFieldExceptionMatcher;
    private final StringMatcher  noteMethodExceptionMatcher;


    private final InstructionSequenceMatcher constantGetFieldMatcher =
        new InstructionSequenceMatcher(GET_FIELD_CONSTANTS,
                                       CONSTANT_GET_FIELD_INSTRUCTIONS);

    private final InstructionSequenceMatcher constantGetDeclaredFieldMatcher =
        new InstructionSequenceMatcher(GET_DECLARED_FIELD_CONSTANTS,
                                       CONSTANT_GET_FIELD_INSTRUCTIONS);

    private final InstructionSequenceMatcher constantGetMethodMatcher0 =
        new InstructionSequenceMatcher(GET_METHOD_CONSTANTS,
                                       CONSTANT_GET_METHOD_INSTRUCTIONS0);

    private final InstructionSequenceMatcher constantGetDeclaredMethodMatcher0 =
        new InstructionSequenceMatcher(GET_DECLARED_METHOD_CONSTANTS,
                                       CONSTANT_GET_METHOD_INSTRUCTIONS0);

    private final InstructionSequenceMatcher constantGetMethodMatcher1 =
        new InstructionSequenceMatcher(GET_METHOD_CONSTANTS,
                                       CONSTANT_GET_METHOD_INSTRUCTIONS1);

    private final InstructionSequenceMatcher constantGetDeclaredMethodMatcher1 =
        new InstructionSequenceMatcher(GET_DECLARED_METHOD_CONSTANTS,
                                       CONSTANT_GET_METHOD_INSTRUCTIONS1);

    private final InstructionSequenceMatcher constantGetMethodMatcher2 =
        new InstructionSequenceMatcher(GET_METHOD_CONSTANTS,
                                       CONSTANT_GET_METHOD_INSTRUCTIONS2);

    private final InstructionSequenceMatcher constantGetDeclaredMethodMatcher2 =
        new InstructionSequenceMatcher(GET_DECLARED_METHOD_CONSTANTS,
                                       CONSTANT_GET_METHOD_INSTRUCTIONS2);

    private final InstructionSequenceMatcher getFieldMatcher =
        new InstructionSequenceMatcher(GET_FIELD_CONSTANTS,
                                       GET_FIELD_INSTRUCTIONS);

    private final InstructionSequenceMatcher getDeclaredFieldMatcher =
        new InstructionSequenceMatcher(GET_DECLARED_FIELD_CONSTANTS,
                                       GET_FIELD_INSTRUCTIONS);

    private final InstructionSequenceMatcher getMethodMatcher0 =
        new InstructionSequenceMatcher(GET_METHOD_CONSTANTS,
                                       GET_METHOD_INSTRUCTIONS0);

    private final InstructionSequenceMatcher getDeclaredMethodMatcher0 =
        new InstructionSequenceMatcher(GET_DECLARED_METHOD_CONSTANTS,
                                       GET_METHOD_INSTRUCTIONS0);

    private final InstructionSequenceMatcher getMethodMatcher1 =
        new InstructionSequenceMatcher(GET_METHOD_CONSTANTS,
                                       GET_METHOD_INSTRUCTIONS1);

    private final InstructionSequenceMatcher getDeclaredMethodMatcher1 =
        new InstructionSequenceMatcher(GET_DECLARED_METHOD_CONSTANTS,
                                       GET_METHOD_INSTRUCTIONS1);

    private final InstructionSequenceMatcher getMethodMatcher2 =
        new InstructionSequenceMatcher(GET_METHOD_CONSTANTS,
                                       GET_METHOD_INSTRUCTIONS2);

    private final InstructionSequenceMatcher getDeclaredMethodMatcher2 =
        new InstructionSequenceMatcher(GET_DECLARED_METHOD_CONSTANTS,
                                       GET_METHOD_INSTRUCTIONS2);

    private final MemberFinder memberFinder = new MemberFinder();


    // Fields acting as parameters for the visitors.
    private Clazz   referencedClass;
    private boolean isDeclared;
    private boolean isField;


    /**
     * Creates a new DynamicMemberReferenceInitializer.
     */
    public DynamicMemberReferenceInitializer(ClassPool      programClassPool,
                                             ClassPool      libraryClassPool,
                                             WarningPrinter notePrinter,
                                             StringMatcher  noteFieldExceptionMatcher,
                                             StringMatcher  noteMethodExceptionMatcher)
    {
        this.programClassPool           = programClassPool;
        this.libraryClassPool           = libraryClassPool;
        this.notePrinter                = notePrinter;
        this.noteFieldExceptionMatcher  = noteFieldExceptionMatcher;
        this.noteMethodExceptionMatcher = noteMethodExceptionMatcher;
    }


    // Implementations for InstructionVisitor.

    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
    {
        // Try to match the SomeClass.class.getField("someField") construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetFieldMatcher,
                       getFieldMatcher, true, false);

        // Try to match the SomeClass.class.getDeclaredField("someField") construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetDeclaredFieldMatcher,
                       getDeclaredFieldMatcher, true, true);

        // Try to match the SomeClass.class.getMethod("someMethod", new Class[]
        // {}) construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetMethodMatcher0,
                       getMethodMatcher0, false, false);

        // Try to match the SomeClass.class.getDeclaredMethod("someMethod",
        //  new Class[] {}) construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetDeclaredMethodMatcher0,
                       getDeclaredMethodMatcher0, false, true);

        // Try to match the SomeClass.class.getMethod("someMethod", new Class[]
        // { A.class }) construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetMethodMatcher1,
                       getMethodMatcher1, false, false);

        // Try to match the SomeClass.class.getDeclaredMethod("someMethod",
        //  new Class[] { A.class }) construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetDeclaredMethodMatcher1,
                       getDeclaredMethodMatcher1, false, true);

        // Try to match the SomeClass.class.getMethod("someMethod", new Class[]
        // { A.class, B.class }) construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetMethodMatcher2,
                       getMethodMatcher2, false, false);

        // Try to match the SomeClass.class.getDeclaredMethod("someMethod",
        //  new Class[] { A.class, B.class }) construct.
        matchGetMember(clazz, method, codeAttribute, offset, instruction,
                       constantGetDeclaredMethodMatcher2,
                       getDeclaredMethodMatcher2, false, true);
    }


    /**
     * Tries to match the next instruction and fills out the string constant
     * or prints out a note accordingly.
     */
    private void matchGetMember(Clazz                      clazz,
                                Method                     method,
                                CodeAttribute              codeAttribute,
                                int                        offset,
                                Instruction                instruction,
                                InstructionSequenceMatcher constantSequenceMatcher,
                                InstructionSequenceMatcher variableSequenceMatcher,
                                boolean                    isField,
                                boolean                    isDeclared)
    {
        // Try to match the next instruction in the constant sequence.
        instruction.accept(clazz, method, codeAttribute, offset,
                           constantSequenceMatcher);

        // Did we find a match to fill out the string constant?
        if (constantSequenceMatcher.isMatching())
        {
            this.isField    = isField;
            this.isDeclared = isDeclared;

            // Get the member's class.
            clazz.constantPoolEntryAccept(constantSequenceMatcher.matchedConstantIndex(X), this);

            // Fill out the matched string constant.
            clazz.constantPoolEntryAccept(constantSequenceMatcher.matchedConstantIndex(Y), this);

            // Don't look for the dynamic construct.
            variableSequenceMatcher.reset();
        }

        // Try to match the next instruction in the variable sequence.
        instruction.accept(clazz, method, codeAttribute, offset,
                           variableSequenceMatcher);

        // Did we find a match to print out a note?
        if (variableSequenceMatcher.isMatching())
        {
            // Print out a note about the dynamic invocation.
            printDynamicInvocationNote(clazz,
                                       variableSequenceMatcher,
                                       isField,
                                       isDeclared);
        }
    }


    // Implementations for ConstantVisitor.

    /**
     * Remembers the referenced class.
     */
    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
    {
        // Remember the referenced class.
        referencedClass = ClassUtil.isInternalArrayType(classConstant.getName(clazz)) ?
            null :
            classConstant.referencedClass;
    }


    /**
     * Fills out the link to the referenced class member.
     */
    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
    {
        if (referencedClass != null)
        {
            String name = stringConstant.getString(clazz);

            // See if we can find the referenced class member locally, or
            // somewhere in the hierarchy.
            Member referencedMember = isDeclared ? isField ?
                (Member)referencedClass.findField(name, null) :
                (Member)referencedClass.findMethod(name, null) :
                (Member)memberFinder.findMember(clazz,
                                                referencedClass,
                                                name,
                                                null,
                                                isField);
            if (referencedMember != null)
            {
                stringConstant.referencedMember = referencedMember;
                stringConstant.referencedClass  = isDeclared ?
                    referencedClass :
                    memberFinder.correspondingClass();
            }
        }
    }


    // Small utility methods.

    /**
     * Prints out a note on the matched dynamic invocation, if necessary.
     */
    private void printDynamicInvocationNote(Clazz                      clazz,
                                            InstructionSequenceMatcher noteSequenceMatcher,
                                            boolean                    isField,
                                            boolean                    isDeclared)
    {
        // Print out a note about the dynamic invocation.
        if (notePrinter != null &&
            notePrinter.accepts(clazz.getName()))
        {
            // Is the class member name in the list of exceptions?
            StringMatcher noteExceptionMatcher = isField ?
                noteFieldExceptionMatcher :
                noteMethodExceptionMatcher;

            int    memberNameIndex = noteSequenceMatcher.matchedConstantIndex(Y);
            String memberName      = clazz.getStringString(memberNameIndex);

            if (noteExceptionMatcher == null ||
                !noteExceptionMatcher.matches(memberName))
            {
                // Compose the external member name and partial descriptor.
                String externalMemberDescription = memberName;

                if (!isField)
                {
                    externalMemberDescription += '(';
                    for (int count = 0; count < 2; count++)
                    {
                        int memberArgumentIndex = noteSequenceMatcher.matchedConstantIndex(A + count);
                        if (memberArgumentIndex > 0)
                        {
                            if (count > 0)
                            {
                                externalMemberDescription += ',';
                            }
                            String className = clazz.getClassName(memberArgumentIndex);
                            externalMemberDescription += ClassUtil.isInternalArrayType(className) ?
                                ClassUtil.externalType(className) :
                                ClassUtil.externalClassName(className);
                        }
                    }
                    externalMemberDescription += ')';
                }

                // Print out the actual note.
                notePrinter.print(clazz.getName(),
                                  "Note: " +
                                  ClassUtil.externalClassName(clazz.getName()) +
                                  " accesses a " +
                                  (isDeclared ? "declared " : "") +
                                  (isField    ? "field" : "method") +
                                  " '" +
                                  externalMemberDescription +
                                  "' dynamically");

                // Print out notes about potential candidates.
                ClassVisitor classVisitor;

                if (isField)
                {
                    classVisitor =
                       new AllFieldVisitor(
                       new MemberNameFilter(memberName, this));
                }
                else
                {
                    // Compose the partial method descriptor.
                    String methodDescriptor = "(";
                    for (int count = 0; count < 2; count++)
                    {
                        int memberArgumentIndex = noteSequenceMatcher.matchedConstantIndex(A + count);
                        if (memberArgumentIndex > 0)
                        {
                            if (count > 0)
                            {
                                methodDescriptor += ',';
                            }
                            String className = clazz.getClassName(memberArgumentIndex);
                            methodDescriptor += ClassUtil.isInternalArrayType(className) ?
                                className :
                                ClassUtil.internalTypeFromClassName(className);
                        }
                    }
                    methodDescriptor += ")L///;";

                    classVisitor =
                        new AllMethodVisitor(
                        new MemberNameFilter(memberName,
                        new MemberDescriptorFilter(methodDescriptor, this)));
                }

                programClassPool.classesAcceptAlphabetically(classVisitor);
                libraryClassPool.classesAcceptAlphabetically(classVisitor);
            }
        }
    }


    // Implementations for MemberVisitor.

    public void visitProgramField(ProgramClass programClass, ProgramField programField)
    {
        if (notePrinter.accepts(programClass.getName()))
        {
            System.out.println("      Maybe this is program field '" +
                               ClassUtil.externalFullClassDescription(0, programClass.getName()) +
                               " { " +
                               ClassUtil.externalFullFieldDescription(0, programField.getName(programClass), programField.getDescriptor(programClass)) +
                               "; }'");
        }
    }


    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
    {
        if (notePrinter.accepts(programClass.getName()))
        {
            System.out.println("      Maybe this is program method '" +
                               ClassUtil.externalFullClassDescription(0, programClass.getName()) +
                               " { " +
                               ClassUtil.externalFullMethodDescription(null, 0, programMethod.getName(programClass), programMethod.getDescriptor(programClass)) +
                               "; }'");
        }
    }


    public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
    {
        if (notePrinter.accepts(libraryClass.getName()))
        {
            System.out.println("      Maybe this is library field '" +
                               ClassUtil.externalFullClassDescription(0, libraryClass.getName()) +
                               " { " +
                               ClassUtil.externalFullFieldDescription(0, libraryField.getName(libraryClass), libraryField.getDescriptor(libraryClass)) +
                               "; }'");
        }
    }


    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
    {
        if (notePrinter.accepts(libraryClass.getName()))
        {
            System.out.println("      Maybe this is library method '" +
                               ClassUtil.externalFullClassDescription(0, libraryClass.getName()) +
                               " { " +
                               ClassUtil.externalFullMethodDescription(null, 0, libraryMethod.getName(libraryClass), libraryMethod.getDescriptor(libraryClass)) +
                               "; }'");
        }
    }
}