/** * {@inheritDoc} */ public String getName() { return parameterDescription.getName(); }
/** * {@inheritDoc} */ public StackManipulation toStackManipulation(ParameterDescription target, Assigner assigner, Assigner.Typing typing) { if (target.getType().isPrimitive()) { throw new IllegalStateException("Cannot assign null to " + target); } return NullConstant.INSTANCE; } }
/** * Creates a dispatcher for inlined advice method. * * @param adviceMethod The advice method. */ protected Inlining(MethodDescription.InDefinedShape adviceMethod) { this.adviceMethod = adviceMethod; namedTypes = new HashMap<String, TypeDefinition>(); for (ParameterDescription parameterDescription : adviceMethod.getParameters().filter(isAnnotatedWith(Local.class))) { String name = parameterDescription.getDeclaredAnnotations().ofType(Local.class).loadSilent().value(); TypeDefinition previous = namedTypes.put(name, parameterDescription.getType()); if (previous != null && !previous.equals(parameterDescription.getType())) { throw new IllegalStateException("Local variable for " + name + " is defined with inconsistent types"); } } }
/** * Creates a new offset binding for a parameter with a given index. * * @param parameterDescription The parameter triggering this binding. */ protected Unresolved(ParameterDescription parameterDescription) { this(parameterDescription.getType(), true, Assigner.Typing.STATIC, parameterDescription.getIndex()); }
/** * Increments the value of the supplied parameter. * * @param parameterDescription The parameter which to increment. * @param value The value to increment with. * @return A stack manipulation incrementing the supplied parameter. */ public static StackManipulation increment(ParameterDescription parameterDescription, int value) { return of(parameterDescription.getType()).increment(parameterDescription.getOffset(), value); }
@Override public boolean equals(Object other) { if (this == other) { return true; } else if (!(other instanceof ParameterDescription)) { return false; } ParameterDescription parameterDescription = (ParameterDescription) other; return getDeclaringMethod().equals(parameterDescription.getDeclaringMethod()) && getIndex() == parameterDescription.getIndex(); }
/** * {@inheritDoc} */ public MethodDefinition.ImplementationDefinition<S> define(MethodDescription methodDescription) { MethodDefinition.ParameterDefinition.Initial<S> initialParameterDefinition = methodDescription.isConstructor() ? defineConstructor(methodDescription.getModifiers()) : defineMethod(methodDescription.getInternalName(), methodDescription.getReturnType(), methodDescription.getModifiers()); ParameterList<?> parameterList = methodDescription.getParameters(); MethodDefinition.ExceptionDefinition<S> exceptionDefinition; if (parameterList.hasExplicitMetaData()) { MethodDefinition.ParameterDefinition<S> parameterDefinition = initialParameterDefinition; for (ParameterDescription parameter : parameterList) { parameterDefinition = parameterDefinition.withParameter(parameter.getType(), parameter.getName(), parameter.getModifiers()); } exceptionDefinition = parameterDefinition; } else { exceptionDefinition = initialParameterDefinition.withParameters(parameterList.asTypeList()); } MethodDefinition.TypeVariableDefinition<S> typeVariableDefinition = exceptionDefinition.throwing(methodDescription.getExceptionTypes()); for (TypeDescription.Generic typeVariable : methodDescription.getTypeVariables()) { typeVariableDefinition = typeVariableDefinition.typeVariable(typeVariable.getSymbol(), typeVariable.getUpperBounds()); } return typeVariableDefinition; }
@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; } } }
/** * @see me.seeber.gradle.ide.eclipse.annotations.Nullability#getParameterNullability(net.bytebuddy.description.method.ParameterDescription) */ @Override public Nullness getParameterNullability(ParameterDescription parameter) { PackageDescription pakkage = parameter.getDeclaringMethod().getDeclaringType().asErasure().getPackage(); Optional<AnnotationDescription> packageAnnotation = pakkage.getDeclaredAnnotations().stream() .filter(a -> a.getAnnotationType().getName().equals(this.nonnullParameterDefaultAnnotation)).findAny(); Nullness defaultNullness = Validate .notNull(packageAnnotation.map(a -> Nullness.NONNULL).orElse(Nullness.UNDEFINED)); Nullness nullability = getNullability(parameter.getDeclaredAnnotations()); return defaultNullness.override(nullability); }
parameterDescription.getIndex())); parameterAppender = parameterDescription.getType().accept(AnnotationAppender.ForTypeAnnotations.ofMethodParameterType(parameterAppender, annotationValueFilter, parameterDescription.getIndex())); for (AnnotationDescription annotation : parameterDescription.getDeclaredAnnotations()) { parameterAppender = parameterAppender.append(annotation, annotationValueFilter);
/** * {@inheritDoc} */ public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) { List<StackManipulation> stackManipulations = new ArrayList<StackManipulation>(); for (ParameterDescription parameterDescription : methodDescription.getParameters()) { TypeDescription parameterType = parameterDescription.getType().asErasure(); stackManipulations.add(of(parameterType).loadFrom(parameterDescription.getOffset())); stackManipulations.add(typeCastingHandler.ofIndex(parameterType, parameterDescription.getIndex())); } return new Compound(stackManipulations).apply(methodVisitor, implementationContext); }
/** * Creates a method attribute appender factory that writes all annotations of a given method, both the method * annotations themselves and all annotations that are defined for every parameter. * * @param methodDescription The method from which to extract the annotations. * @return A method attribute appender factory for an appender that writes all annotations of the supplied method. */ public static Factory of(MethodDescription methodDescription) { ParameterList<?> parameters = methodDescription.getParameters(); List<MethodAttributeAppender.Factory> methodAttributeAppenders = new ArrayList<MethodAttributeAppender.Factory>(parameters.size() + 1); methodAttributeAppenders.add(new Explicit(methodDescription.getDeclaredAnnotations())); for (ParameterDescription parameter : parameters) { methodAttributeAppenders.add(new Explicit(parameter.getIndex(), parameter.getDeclaredAnnotations())); } return new Factory.Compound(methodAttributeAppenders); }
@Override protected ParameterDescription resolve(MethodDescription instrumentedMethod) { if (!parameterDescription.getDeclaringMethod().equals(instrumentedMethod)) { throw new IllegalStateException(parameterDescription + " is not a parameter of " + instrumentedMethod); } return parameterDescription; }
/** * {@inheritDoc} */ public AnnotationList getDeclaredAnnotations() { return parameterDescription.getDeclaredAnnotations(); }
/** * {@inheritDoc} */ public int getModifiers() { return parameterDescription.getModifiers(); }
/** * {@inheritDoc} */ public InDefinedShape asDefined() { return parameterDescription.asDefined(); } }
/** * {@inheritDoc} */ public ByteCodeElement.Token.TokenList<ParameterDescription.Token> asTokenList(ElementMatcher<? super TypeDescription> matcher) { List<ParameterDescription.Token> tokens = new ArrayList<ParameterDescription.Token>(size()); for (ParameterDescription parameterDescription : this) { tokens.add(parameterDescription.asToken(matcher)); } return new ByteCodeElement.Token.TokenList<ParameterDescription.Token>(tokens); }
/** * Loads a parameter's value onto the operand stack. * * @param parameterDescription The parameter which to load onto the operand stack. * @return A stack manipulation loading a parameter onto the operand stack. */ public static StackManipulation load(ParameterDescription parameterDescription) { return of(parameterDescription.getType()).loadFrom(parameterDescription.getOffset()); }
for (ParameterDescription parameterDescription : instrumentedMethod.getParameters()) { parameterAccess.add(MethodVariableAccess.load(parameterDescription)); parameterAccess.add(Assigner.DEFAULT.assign(parameterDescription.getType(), specializedLambdaMethod.getParameterTypes().get(parameterDescription.getIndex()).asGenericType(), Assigner.Typing.DYNAMIC));
/** * {@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(); } }