/** * An order-sensitive invocation of {@link ClassVisitor#visitMethod(int, String, String, String, String[])}. * * @param modifiers The method's modifiers. * @param internalName The method's internal name. * @param descriptor The field type's descriptor. * @param signature The method's generic signature or {@code null} if the method is not generic. * @param exception The method's declared exceptions or {@code null} if no exceptions are declared. * @return A method visitor to visit the method or {@code null} to ignore it. */ protected MethodVisitor onVisitMethod(int modifiers, String internalName, String descriptor, String signature, String[] exception) { return super.visitMethod(modifiers, internalName, descriptor, signature, exception); }
/** * Visits a method of the class. This method <i>must</i> return a new {@link MethodVisitor} * instance (or {@literal null}) each time it is called, i.e., it should not return a previously * returned visitor. * * @param access the method's access flags (see {@link Opcodes}). This parameter also indicates if * the method is synthetic and/or deprecated. * @param name the method's name. * @param descriptor the method's descriptor (see {@link Type}). * @param signature the method's signature. May be {@literal null} if the method parameters, * return type and exceptions do not use generic types. * @param exceptions the internal names of the method's exception classes (see {@link * Type#getInternalName()}). May be {@literal null}. * @return an object to visit the byte code of the method, or {@literal null} if this class * visitor is not interested in visiting the code of this method. */ public MethodVisitor visitMethod( final int access, final String name, final String descriptor, final String signature, final String[] exceptions) { if (cv != null) { return cv.visitMethod(access, name, descriptor, signature, exceptions); } return null; }
@Override public MethodVisitor visitMethod(int modifiers, String internalName, String descriptor, String signature, String[] exception) { MethodDescription methodDescription = methods.get(internalName + descriptor); return methodDescription != null && methodMatcher.matches(methodDescription) ? REMOVE_METHOD : super.visitMethod(modifiers, internalName, descriptor, signature, exception); } }
@Override public MethodVisitor visitMethod(int modifiers, String name, String descriptor, String signature, String[] exception) { MethodVisitor methodVisitor = super.visitMethod(modifiers, name, descriptor, signature, exception); return supportsTypeConstants || methodVisitor == null ? methodVisitor : new TypeConstantDissolvingMethodVisitor(methodVisitor); }
@Override public MethodVisitor visitMethod(int modifiers, String name, String descriptor, String signature, String[] exceptions) { constraint.assertMethod(name, (modifiers & Opcodes.ACC_ABSTRACT) != 0, (modifiers & Opcodes.ACC_PUBLIC) != 0, (modifiers & Opcodes.ACC_PRIVATE) != 0, (modifiers & Opcodes.ACC_STATIC) != 0, !name.equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME) && !name.equals(MethodDescription.TYPE_INITIALIZER_INTERNAL_NAME) && (modifiers & (Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC)) == 0, name.equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME), !descriptor.startsWith(NO_PARAMETERS) || descriptor.endsWith(RETURNS_VOID), signature != null); MethodVisitor methodVisitor = super.visitMethod(modifiers, name, descriptor, signature, exceptions); return methodVisitor == null ? IGNORE_METHOD : new ValidatingMethodVisitor(methodVisitor, name); }
@Override public MethodVisitor visitMethod(int modifiers, String internalName, String descriptor, String signature, String[] exception) { MethodDescription methodDescription = methods.get(internalName + descriptor); if (methodDescription != null) { for (Adjustment<MethodDescription> adjustment : methodAdjustments) { if (adjustment.matches(methodDescription)) { modifiers = adjustment.resolve(modifiers); break; } } } return super.visitMethod(modifiers, internalName, descriptor, signature, exception); } }
@Override public MethodVisitor visitMethod(int modifiers, String internalName, String descriptor, String signature, String[] exceptionInternalName) { MethodVisitor methodVisitor = super.visitMethod(modifiers, internalName, descriptor, signature, exceptionInternalName); if (methodVisitor != null) { resolve(Type.getType(descriptor)); if (exceptionInternalName != null) { observedTypes.addAll(Arrays.asList(exceptionInternalName)); } return new TypeReferenceMethodVisitor(methodVisitor); } else { return IGNORE_METHOD; } }
@Override public MethodVisitor visitMethod(int modifiers, String internalName, String descriptor, String signature, String[] exceptions) { MethodVisitor methodVisitor = super.visitMethod(modifiers, internalName, descriptor, signature, exceptions); MethodDescription methodDescription = methods.get(internalName + descriptor); if (methodVisitor != null && methodDescription != null) { for (Entry entry : entries) { if (entry.matches(methodDescription)) { methodVisitor = entry.wrap(instrumentedType, methodDescription, methodVisitor, implementationContext, typePool, writerFlags, readerFlags); } } } return methodVisitor; } }
@Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor methodVisitor = super.visitMethod(access, name, desc, signature, exceptions); MethodList<?> methodList = typeDescription.getDeclaredMethods().filter((name.equals(MethodDescription.CONSTRUCTOR_INTERNAL_NAME) ? isConstructor() : ElementMatchers.<MethodDescription>named(name)).and(hasDescriptor(desc))); if (methodList.size() == 1 && methodList.getOnly().getParameters().hasExplicitMetaData()) { for (ParameterDescription parameterDescription : methodList.getOnly().getParameters()) { methodVisitor.visitParameter(parameterDescription.getName(), parameterDescription.getModifiers()); } return new MethodParameterStrippingMethodVisitor(methodVisitor); } else { return methodVisitor; } } }
classVisitor.visitMethod( context.currentMethodAccessFlags, context.currentMethodName,
/** * {@inheritDoc} */ public void apply(ClassVisitor classVisitor, Implementation.Context implementationContext, AnnotationValueFilter.Factory annotationValueFilterFactory) { MethodVisitor methodVisitor = classVisitor.visitMethod(getMethod().getActualModifiers(getSort().isImplemented(), getVisibility()), getMethod().getInternalName(), getMethod().getDescriptor(), getMethod().getGenericSignature(), getMethod().getExceptionTypes().asErasures().toInternalNames()); if (methodVisitor != null) { ParameterList<?> parameterList = getMethod().getParameters(); if (parameterList.hasExplicitMetaData()) { for (ParameterDescription parameterDescription : parameterList) { methodVisitor.visitParameter(parameterDescription.getName(), parameterDescription.getModifiers()); } } applyHead(methodVisitor); applyBody(methodVisitor, implementationContext, annotationValueFilterFactory); methodVisitor.visitEnd(); } }
MethodDescription.InDefinedShape bridgeMethod = new AccessorBridge(bridgeTarget, bridgeType, instrumentedType); MethodDescription.InDefinedShape bridgeTarget = new BridgeTarget(this.bridgeTarget, instrumentedType); MethodVisitor methodVisitor = classVisitor.visitMethod(bridgeMethod.getActualModifiers(true, getVisibility()), bridgeMethod.getInternalName(), bridgeMethod.getDescriptor(),
@Override public MethodVisitor visitMethod(int access, final String name, final String desc, final String signature, final String[] exceptions) { return super.visitMethod(removeFinal(access), name, desc, signature, exceptions); }
@Override public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { if (MethodDescription.CONSTRUCTOR_INTERNAL_NAME.equals(name)) { methodMaxLocals = new MethodMaxLocals(); return new MaxLocalsMethodVisitor(name, desc, methodMaxLocals); } return super.visitMethod(access, name, desc, signature, exceptions); }
@Override public MethodVisitor visitMethod(int i, String method, String desc, String signature, String[] strings) { List<String> parameterTypes = Arrays.stream(Type.getArgumentTypes(desc)) .map(Type::getClassName) .collect(Collectors.toList()); MethodSignatureBuilder builder = hookMetadata.newMethodSignature(parameterTypes); return new MethodVisitor(Opcodes.ASM5, super.visitMethod(i, method, desc, signature, strings)) { @Override public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) { if (visible && typeEquals(desc, Returned.class, Thrown.class)) { builder.markReturnedOrThrown(parameter); } return super.visitParameterAnnotation(parameter, desc, visible); } @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { if (visible && typeEquals(desc, Before.class, After.class)) { return new AnnotationValueCollector("method", builder::addMethodName, Opcodes.ASM5, super.visitAnnotation(desc, visible)); } else { return super.visitAnnotation(desc, visible); } } }; }