/** * An order-sensitive invocation of {@link ClassVisitor#visitInnerClass(String, String, String, int)}. * * @param name The internal name of the inner class. * @param outerName The internal name of the outer class. * @param innerName The inner class's simple name or {@code null} for an anonymous class. * @param modifiers The inner class's source code modifiers. */ protected void onVisitInnerClass(String name, String outerName, String innerName, int modifiers) { super.visitInnerClass(name, outerName, innerName, modifiers); }
/** * Visits information about an inner class. This inner class is not necessarily a member of the * class being visited. * * @param name the internal name of an inner class (see {@link Type#getInternalName()}). * @param outerName the internal name of the class to which the inner class belongs (see {@link * Type#getInternalName()}). May be {@literal null} for not member classes. * @param innerName the (simple) name of the inner class inside its enclosing class. May be * {@literal null} for anonymous inner classes. * @param access the access flags of the inner class as originally declared in the enclosing * class. */ public void visitInnerClass( final String name, final String outerName, final String innerName, final int access) { if (cv != null) { cv.visitInnerClass(name, outerName, innerName, access); } }
@Override public void visitInnerClass(String internalName, String outerName, String innerName, int modifiers) { visitedInnerTypes.add(internalName); super.visitInnerClass(internalName, outerName, innerName, modifiers); }
@Override public void visitInnerClass(String internalName, String outerName, String innerName, int modifiers) { if (instrumentedType.getInternalName().equals(internalName)) { for (Adjustment<TypeDescription> adjustment : typeAdjustments) { if (adjustment.matches(instrumentedType)) { modifiers = adjustment.resolve(modifiers); break; } } } super.visitInnerClass(internalName, outerName, innerName, modifiers); }
if (!filter.matches(typeDescription)) { while (typeDescription != null && typeDescription.isNestedClass()) { super.visitInnerClass(typeDescription.getInternalName(), typeDescription.isMemberType() ? typeDescription.getDeclaringType().getInternalName()
int currentClassesOffset = innerClassesOffset + 2; while (numberOfClasses-- > 0) { classVisitor.visitInnerClass( readClass(currentClassesOffset, charBuffer), readClass(currentClassesOffset + 2, charBuffer),
classVisitor.visitInnerClass(instrumentedType.getInternalName(), declaringType.getInternalName(), instrumentedType.getSimpleName(), instrumentedType.getModifiers()); } else if (instrumentedType.isLocalType()) { classVisitor.visitInnerClass(instrumentedType.getInternalName(), NO_REFERENCE, instrumentedType.getSimpleName(), instrumentedType.getModifiers()); } else if (instrumentedType.isAnonymousType()) { classVisitor.visitInnerClass(instrumentedType.getInternalName(), NO_REFERENCE, NO_REFERENCE, classVisitor.visitInnerClass(typeDescription.getInternalName(), typeDescription.isMemberType() ? instrumentedType.getInternalName()
@Override public void visitInnerClass(String name, String outerName, String innerName, int access) { super.visitInnerClass(name, outerName, innerName, removeFinal(access)); }