/** * {@inheritDoc} */ public InDefinedShape asDefined() { return methodDescription.asDefined(); }
/** * {@inheritDoc} */ public MethodList<MethodDescription.InDefinedShape> asDefined() { List<MethodDescription.InDefinedShape> declaredForms = new ArrayList<MethodDescription.InDefinedShape>(size()); for (MethodDescription methodDescription : this) { declaredForms.add(methodDescription.asDefined()); } return new Explicit<MethodDescription.InDefinedShape>(declaredForms); } }
/** * {@inheritDoc} */ public Target resolve(TypeDescription instrumentedType, MethodDescription instrumentedMethod, Assigner assigner, ArgumentHandler argumentHandler, Sort sort) { if (!isRepresentable(instrumentedMethod)) { throw new IllegalStateException("Cannot represent " + instrumentedMethod + " as given method constant"); } return Target.ForStackManipulation.of(instrumentedMethod.asDefined()); }
/** * {@inheritDoc} */ public Entry<U> extendBy(MethodDescription methodDescription, Harmonizer<U> harmonizer) { return new Resolved<U>(key.extend(methodDescription.asDefined(), harmonizer), methodDescription, methodDescription.getVisibility(), Resolved.NOT_MADE_VISIBLE); }
@Override public boolean isOverridden(Object instance, Method origin) { SoftReference<MethodGraph> reference = graphs.get(instance.getClass()); MethodGraph methodGraph = reference == null ? null : reference.get(); if (methodGraph == null) { methodGraph = compiler.compile(new TypeDescription.ForLoadedType(instance.getClass())); graphs.put(instance.getClass(), new SoftReference<MethodGraph>(methodGraph)); } MethodGraph.Node node = methodGraph.locate(new MethodDescription.ForLoadedMethod(origin).asSignatureToken()); return !node.getSort().isResolved() || !node.getRepresentative().asDefined().getDeclaringType().represents(origin.getDeclaringClass()); }
/** * {@inheritDoc} */ public Entry<U> extendBy(MethodDescription methodDescription, Harmonizer<U> harmonizer) { Harmonized<U> key = this.key.extend(methodDescription.asDefined(), harmonizer); LinkedHashSet<MethodDescription> methodDescriptions = new LinkedHashSet<MethodDescription>(); TypeDescription declaringType = methodDescription.getDeclaringType().asErasure(); boolean bridge = methodDescription.isBridge(); Visibility visibility = this.visibility; for (MethodDescription extendedMethod : this.methodDescriptions) { if (extendedMethod.getDeclaringType().asErasure().equals(declaringType)) { if (extendedMethod.isBridge() ^ bridge) { methodDescriptions.add(bridge ? extendedMethod : methodDescription); } else { methodDescriptions.add(methodDescription); methodDescriptions.add(extendedMethod); } } visibility = visibility.expandTo(extendedMethod.getVisibility()); } if (methodDescriptions.isEmpty()) { return new Resolved<U>(key, methodDescription, visibility, bridge); } else if (methodDescriptions.size() == 1) { return new Resolved<U>(key, methodDescriptions.iterator().next(), visibility, Resolved.NOT_MADE_VISIBLE); } else { return new Ambiguous<U>(key, methodDescriptions, visibility); } }
/** * {@inheritDoc} */ public MethodDescription transform(TypeDescription instrumentedType, MethodDescription methodDescription) { return new TransformedMethod(instrumentedType, methodDescription.getDeclaringType(), transformer.transform(instrumentedType, methodDescription.asToken(none())), methodDescription.asDefined()); }
/** * {@inheritDoc} */ public Entry<U> extendBy(MethodDescription methodDescription, Harmonizer<U> harmonizer) { Harmonized<U> key = this.key.extend(methodDescription.asDefined(), harmonizer); Visibility visibility = this.visibility.expandTo(methodDescription.getVisibility()); return methodDescription.getDeclaringType().equals(this.methodDescription.getDeclaringType()) ? Ambiguous.of(key, methodDescription, this.methodDescription, visibility) : Resolved.of(key, methodDescription, this.methodDescription, visibility); }
/** * Creates a method invocation with an implicitly determined invocation type. If the method's return type derives from its declared shape, the value * is additionally casted to the value of the generically resolved method. * * @param methodDescription The method to be invoked. * @return A stack manipulation with implicitly determined invocation type. */ public static WithImplicitInvocationTargetType invoke(MethodDescription methodDescription) { MethodDescription.InDefinedShape declaredMethod = methodDescription.asDefined(); return declaredMethod.getReturnType().asErasure().equals(methodDescription.getReturnType().asErasure()) ? invoke(declaredMethod) : OfGenericMethod.of(methodDescription, invoke(declaredMethod)); }
} else if (parameterType.represents(Method.class)) { return source.isMethod() ? new MethodDelegationBinder.ParameterBinding.Anonymous(methodConstant(annotation.loadSilent(), source.asDefined())) : MethodDelegationBinder.ParameterBinding.Illegal.INSTANCE; } else if (parameterType.represents(Constructor.class)) { return source.isConstructor() ? new MethodDelegationBinder.ParameterBinding.Anonymous(methodConstant(annotation.loadSilent(), source.asDefined())) : MethodDelegationBinder.ParameterBinding.Illegal.INSTANCE; } else if (JavaType.EXECUTABLE.getTypeStub().equals(parameterType)) { return new MethodDelegationBinder.ParameterBinding.Anonymous(methodConstant(annotation.loadSilent(), source.asDefined())); } else if (parameterType.represents(String.class)) { return new MethodDelegationBinder.ParameterBinding.Anonymous(new TextConstant(source.toString())); return new MethodDelegationBinder.ParameterBinding.Anonymous(IntegerConstant.forValue(source.getModifiers())); } else if (parameterType.equals(JavaType.METHOD_HANDLE.getTypeStub())) { return new MethodDelegationBinder.ParameterBinding.Anonymous(new JavaConstantValue(JavaConstant.MethodHandle.of(source.asDefined()))); } else if (parameterType.equals(JavaType.METHOD_TYPE.getTypeStub())) { return new MethodDelegationBinder.ParameterBinding.Anonymous(new JavaConstantValue(JavaConstant.MethodType.of(source.asDefined()))); } else { throw new IllegalStateException("The " + target + " method's " + target.getIndex() +
/** * {@inheritDoc} */ public Size apply(MethodVisitor methodVisitor, Context implementationContext, MethodDescription instrumentedMethod) { StackManipulation.Size stackSize = new StackManipulation.Compound( MethodVariableAccess.loadThis(), MethodInvocation.invoke(StaticFieldConstructor.INSTANCE.objectTypeDefaultConstructor), MethodVariableAccess.allArgumentsOf(instrumentedMethod.asDefined()).prependThisReference(), FieldAccess.forField(fieldDescription).write(), MethodReturn.VOID ).apply(methodVisitor, implementationContext); return new Size(stackSize.getMaximalSize(), instrumentedMethod.getStackSize()); } }