// Generated by delombok at Sun Feb 26 12:31:38 KST 2017
package scouter.bytebuddy.implementation.bytecode.member;
import scouter.bytebuddy.description.method.MethodDescription;
import scouter.bytebuddy.description.type.TypeDescription;
import scouter.bytebuddy.description.type.TypeList;
import scouter.bytebuddy.implementation.Implementation;
import scouter.bytebuddy.implementation.bytecode.StackManipulation;
import scouter.bytebuddy.implementation.bytecode.assign.TypeCasting;
import scouter.bytebuddy.jar.asm.Handle;
import scouter.bytebuddy.jar.asm.MethodVisitor;
import scouter.bytebuddy.jar.asm.Opcodes;
import java.util.List;
/**
* A builder for a method invocation.
*/
public enum MethodInvocation {
/**
* A virtual method invocation.
*/
VIRTUAL(Opcodes.INVOKEVIRTUAL, Opcodes.H_INVOKEVIRTUAL), /**
* An interface-typed virtual method invocation.
*/
INTERFACE(Opcodes.INVOKEINTERFACE, Opcodes.H_INVOKEINTERFACE), /**
* A static method invocation.
*/
STATIC(Opcodes.INVOKESTATIC, Opcodes.H_INVOKESTATIC), /**
* A specialized pseudo-virtual method invocation for a non-constructor.
*/
SPECIAL(Opcodes.INVOKESPECIAL, Opcodes.H_INVOKESPECIAL), /**
* A specialized pseudo-virtual method invocation for a constructor.
*/
SPECIAL_CONSTRUCTOR(Opcodes.INVOKESPECIAL, Opcodes.H_NEWINVOKESPECIAL);
/**
* The opcode for invoking a method.
*/
private final int invocationOpcode;
/**
* The handle being used for a dynamic method invocation.
*/
private final int handle;
/**
* Creates a new type of method invocation.
*
* @param callOpcode The opcode for invoking a method.
* @param handle The handle being used for a dynamic method invocation.
*/
MethodInvocation(int callOpcode, int handle) {
this.invocationOpcode = callOpcode;
this.handle = handle;
}
/**
* Creates a method invocation with an implicitly determined invocation type.
*
* @param methodDescription The method to be invoked.
* @return A stack manipulation with implicitly determined invocation type.
*/
public static WithImplicitInvocationTargetType invoke(MethodDescription.InDefinedShape methodDescription) {
if (methodDescription.isTypeInitializer()) {
return IllegalInvocation.INSTANCE;
} else if (methodDescription.isStatic()) {
// Check this property first, private static methods must use INVOKESTATIC
return STATIC.new Invocation(methodDescription);
} else if (methodDescription.isConstructor()) {
return SPECIAL_CONSTRUCTOR.new Invocation(methodDescription); // Check this property second, constructors might be private
} else if (methodDescription.isPrivate()) {
return SPECIAL.new Invocation(methodDescription);
} else if (methodDescription.getDeclaringType().isInterface()) {
// Check this property last, default methods must be called by INVOKESPECIAL
return INTERFACE.new Invocation(methodDescription);
} else {
return VIRTUAL.new Invocation(methodDescription);
}
}
/**
* 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));
}
/**
* An illegal implicit method invocation.
*/
protected enum IllegalInvocation implements WithImplicitInvocationTargetType {
/**
* The singleton instance.
*/
INSTANCE;
@Override
public StackManipulation virtual(TypeDescription invocationTarget) {
return Illegal.INSTANCE;
}
@Override
public StackManipulation special(TypeDescription invocationTarget) {
return Illegal.INSTANCE;
}
@Override
public StackManipulation dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments) {
return Illegal.INSTANCE;
}
@Override
public StackManipulation onHandle(HandleType type) {
return Illegal.INSTANCE;
}
@Override
public boolean isValid() {
return false;
}
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) {
return Illegal.INSTANCE.apply(methodVisitor, implementationContext);
}
}
/**
* Represents a method invocation where the invocation type (static, virtual, special, interface) is derived
* from the given method's description.
*/
public interface WithImplicitInvocationTargetType extends StackManipulation {
/**
* Transforms this method invocation into a virtual (or interface) method invocation on the given type.
*
* @param invocationTarget The type on which the method is to be invoked virtually on.
* @return A stack manipulation representing this method invocation.
*/
StackManipulation virtual(TypeDescription invocationTarget);
/**
* Transforms this method invocation into a special invocation on the given type.
*
* @param invocationTarget The type on which the method is to be invoked specially on.
* @return A stack manipulation representing this method invocation.
*/
StackManipulation special(TypeDescription invocationTarget);
/**
* Invokes the method as a bootstrap method to bind a call site with the given properties. Note that the
* Java virtual machine currently only knows how to resolve bootstrap methods that link static methods
* or a constructor.
*
* @param methodName The name of the method to be bound.
* @param returnType The return type of the method to be bound.
* @param methodType The parameter types of the method to be bound.
* @param arguments The arguments to be passed to the bootstrap method.
* @return A stack manipulation that represents the dynamic method invocation.
*/
StackManipulation dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments);
/**
* Invokes the method via a {@code MethodHandle}.
*
* @param type The type of invocation.
* @return A stack manipulation that represents a method call of the specified method via a method handle.
*/
StackManipulation onHandle(HandleType type);
}
/**
* A method invocation of a generically resolved method.
*/
protected static class OfGenericMethod implements WithImplicitInvocationTargetType {
/**
* The generically resolved return type of the method.
*/
private final TypeDescription targetType;
/**
* The invocation of the method in its defined shape.
*/
private final WithImplicitInvocationTargetType invocation;
/**
* Creates a generic method invocation.
*
* @param targetType The generically resolved return type of the method.
* @param invocation The invocation of the method in its defined shape.
*/
protected OfGenericMethod(TypeDescription targetType, WithImplicitInvocationTargetType invocation) {
this.targetType = targetType;
this.invocation = invocation;
}
/**
* Creates a generic access dispatcher for a given method.
*
* @param methodDescription The generically resolved return type of the method.
* @param invocation The invocation of the method in its defined shape.
* @return A method access dispatcher for the given method.
*/
protected static WithImplicitInvocationTargetType of(MethodDescription methodDescription, WithImplicitInvocationTargetType invocation) {
return new OfGenericMethod(methodDescription.getReturnType().asErasure(), invocation);
}
@Override
public StackManipulation virtual(TypeDescription invocationTarget) {
return new StackManipulation.Compound(invocation.virtual(invocationTarget), TypeCasting.to(targetType));
}
@Override
public StackManipulation special(TypeDescription invocationTarget) {
return new StackManipulation.Compound(invocation.special(invocationTarget), TypeCasting.to(targetType));
}
@Override
public StackManipulation dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments) {
return invocation.dynamic(methodName, returnType, methodType, arguments);
}
@Override
public StackManipulation onHandle(HandleType type) {
return new Compound(invocation.onHandle(type), TypeCasting.to(targetType));
}
@Override
public boolean isValid() {
return invocation.isValid();
}
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) {
return new Compound(invocation, TypeCasting.to(targetType)).apply(methodVisitor, implementationContext);
}
@java.lang.Override
@java.lang.SuppressWarnings("all")
@javax.annotation.Generated("lombok")
public boolean equals(final java.lang.Object o) {
if (o == this) return true;
if (!(o instanceof MethodInvocation.OfGenericMethod)) return false;
final MethodInvocation.OfGenericMethod other = (MethodInvocation.OfGenericMethod) o;
if (!other.canEqual((java.lang.Object) this)) return false;
final java.lang.Object this$targetType = this.targetType;
final java.lang.Object other$targetType = other.targetType;
if (this$targetType == null ? other$targetType != null : !this$targetType.equals(other$targetType)) return false;
final java.lang.Object this$invocation = this.invocation;
final java.lang.Object other$invocation = other.invocation;
if (this$invocation == null ? other$invocation != null : !this$invocation.equals(other$invocation)) return false;
return true;
}
@java.lang.SuppressWarnings("all")
@javax.annotation.Generated("lombok")
protected boolean canEqual(final java.lang.Object other) {
return other instanceof MethodInvocation.OfGenericMethod;
}
@java.lang.Override
@java.lang.SuppressWarnings("all")
@javax.annotation.Generated("lombok")
public int hashCode() {
final int PRIME = 59;
int result = 1;
final java.lang.Object $targetType = this.targetType;
result = result * PRIME + ($targetType == null ? 43 : $targetType.hashCode());
final java.lang.Object $invocation = this.invocation;
result = result * PRIME + ($invocation == null ? 43 : $invocation.hashCode());
return result;
}
}
/**
* An implementation of a method invoking stack manipulation.
*/
protected class Invocation implements WithImplicitInvocationTargetType {
/**
* The method to be invoked.
*/
private final TypeDescription typeDescription;
/**
* The type on which this method is to be invoked.
*/
private final MethodDescription.InDefinedShape methodDescription;
/**
* Creates an invocation of a given method on its declaring type as an invocation target.
*
* @param methodDescription The method to be invoked.
*/
protected Invocation(MethodDescription.InDefinedShape methodDescription) {
this(methodDescription, methodDescription.getDeclaringType());
}
/**
* Creates an invocation of a given method on a given invocation target type.
*
* @param methodDescription The method to be invoked.
* @param typeDescription The type on which this method is to be invoked.
*/
protected Invocation(MethodDescription.InDefinedShape methodDescription, TypeDescription typeDescription) {
this.typeDescription = typeDescription;
this.methodDescription = methodDescription;
}
@Override
public boolean isValid() {
return true;
}
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) {
methodVisitor.visitMethodInsn(invocationOpcode, typeDescription.getInternalName(), methodDescription.getInternalName(), methodDescription.getDescriptor(), typeDescription.isInterface());
int parameterSize = methodDescription.getStackSize();
int returnValueSize = methodDescription.getReturnType().getStackSize().getSize();
return new Size(returnValueSize - parameterSize, Math.max(0, returnValueSize - parameterSize));
}
@Override
public StackManipulation virtual(TypeDescription invocationTarget) {
if (methodDescription.isPrivate() || methodDescription.isConstructor() || methodDescription.isStatic()) {
return Illegal.INSTANCE;
}
if (invocationTarget.isInterface()) {
return INTERFACE.new Invocation(methodDescription, invocationTarget);
} else {
return VIRTUAL.new Invocation(methodDescription, invocationTarget);
}
}
@Override
public StackManipulation special(TypeDescription invocationTarget) {
return methodDescription.isSpecializableFor(invocationTarget) ? SPECIAL.new Invocation(methodDescription, invocationTarget) : Illegal.INSTANCE;
}
@Override
public StackManipulation dynamic(String methodName, TypeDescription returnType, List<? extends TypeDescription> methodType, List<?> arguments) {
return methodDescription.isBootstrap() ? new DynamicInvocation(methodName, returnType, new TypeList.Explicit(methodType), methodDescription.asDefined(), arguments) : Illegal.INSTANCE;
}
@Override
public StackManipulation onHandle(HandleType type) {
return new HandleInvocation(methodDescription, type);
}
/**
* Returns the outer instance.
*
* @return The outer instance.
*/
private MethodInvocation getOuterInstance() {
return MethodInvocation.this;
}
// HE: Remove when Lombok support for getOuter is added.
@Override
public boolean equals(Object other) {
if (this == other) return true;
if (other == null || getClass() != other.getClass()) return false;
Invocation that = (Invocation) other;
return MethodInvocation.this.equals(((Invocation) other).getOuterInstance()) && methodDescription.asSignatureToken().equals(that.methodDescription.asSignatureToken()) && typeDescription.equals(that.typeDescription);
}
// HE: Remove when Lombok support for getOuter is added.
@Override
public int hashCode() {
int result = typeDescription.hashCode();
result = 31 * result + MethodInvocation.this.hashCode();
result = 31 * result + methodDescription.asSignatureToken().hashCode();
return result;
}
}
/**
* Performs a dynamic method invocation of the given method.
*/
protected class DynamicInvocation implements StackManipulation {
/**
* The internal name of the method that is to be bootstrapped.
*/
private final String methodName;
/**
* The return type of the method to be bootstrapped.
*/
private final TypeDescription returnType;
/**
* The parameter types of the method to be bootstrapped.
*/
private final TypeList parameterTypes;
/**
* The bootstrap method.
*/
private final MethodDescription.InDefinedShape bootstrapMethod;
/**
* The list of arguments to be handed over to the bootstrap method.
*/
private final List<?> arguments;
/**
* Creates a new dynamic method invocation.
*
* @param methodName The internal name of the method that is to be bootstrapped.
* @param returnType The return type of the method to be bootstrapped.
* @param parameterTypes The type of the parameters to be bootstrapped.
* @param bootstrapMethod The bootstrap method.
* @param arguments The list of arguments to be handed over to the bootstrap method.
*/
public DynamicInvocation(String methodName, TypeDescription returnType, TypeList parameterTypes, MethodDescription.InDefinedShape bootstrapMethod, List<?> arguments) {
this.methodName = methodName;
this.returnType = returnType;
this.parameterTypes = parameterTypes;
this.bootstrapMethod = bootstrapMethod;
this.arguments = arguments;
}
@Override
public boolean isValid() {
return true;
}
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) {
StringBuilder stringBuilder = new StringBuilder("(");
for (TypeDescription parameterType : parameterTypes) {
stringBuilder.append(parameterType.getDescriptor());
}
String methodDescriptor = stringBuilder.append(')').append(returnType.getDescriptor()).toString();
methodVisitor.visitInvokeDynamicInsn(methodName, methodDescriptor, new Handle(handle, bootstrapMethod.getDeclaringType().getInternalName(), bootstrapMethod.getInternalName(), bootstrapMethod.getDescriptor(), bootstrapMethod.getDeclaringType().isInterface()), arguments.toArray(new Object[arguments.size()]));
int stackSize = returnType.getStackSize().getSize() - parameterTypes.getStackSize();
return new Size(stackSize, Math.max(stackSize, 0));
}
@Override
public boolean equals(Object other) {
if (this == other) return true;
if (other == null || getClass() != other.getClass()) return false;
DynamicInvocation that = (DynamicInvocation) other;
return MethodInvocation.this == that.getOuter() && arguments.equals(that.arguments) && bootstrapMethod.equals(that.bootstrapMethod) && returnType.equals(that.returnType) && parameterTypes.equals(that.parameterTypes) && methodName.equals(that.methodName);
}
/**
* Returns the outer instance.
*
* @return The outer instance.
*/
private MethodInvocation getOuter() {
return MethodInvocation.this;
}
@Override
public int hashCode() {
int result = methodName.hashCode();
result = 31 * result + MethodInvocation.this.hashCode();
result = 31 * result + returnType.hashCode();
result = 31 * result + parameterTypes.hashCode();
result = 31 * result + bootstrapMethod.hashCode();
result = 31 * result + arguments.hashCode();
return result;
}
}
/**
* Performs a method invocation on a method handle with a polymorphic type signature.
*/
protected static class HandleInvocation implements StackManipulation {
/**
* The internal name of the method handle type.
*/
private static final String METHOD_HANDLE = "java/lang/invoke/MethodHandle";
/**
* The invoked method.
*/
private final MethodDescription.InDefinedShape methodDescription;
/**
* The type of method handle invocation.
*/
private final HandleType type;
/**
* Creates a new method handle invocation.
*
* @param methodDescription The invoked method.
* @param type The type of method handle invocation.
*/
protected HandleInvocation(MethodDescription.InDefinedShape methodDescription, HandleType type) {
this.methodDescription = methodDescription;
this.type = type;
}
@Override
public boolean isValid() {
return true;
}
@Override
public Size apply(MethodVisitor methodVisitor, Implementation.Context implementationContext) {
methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, METHOD_HANDLE, type.getMethodName(), methodDescription.isStatic() || methodDescription.isConstructor() ? methodDescription.getDescriptor() : "(" + methodDescription.getDeclaringType().getDescriptor() + methodDescription.getDescriptor().substring(1), false);
int parameterSize = 1 + methodDescription.getStackSize();
int returnValueSize = methodDescription.getReturnType().getStackSize().getSize();
return new Size(returnValueSize - parameterSize, Math.max(0, returnValueSize - parameterSize));
}
@java.lang.Override
@java.lang.SuppressWarnings("all")
@javax.annotation.Generated("lombok")
public boolean equals(final java.lang.Object o) {
if (o == this) return true;
if (!(o instanceof MethodInvocation.HandleInvocation)) return false;
final MethodInvocation.HandleInvocation other = (MethodInvocation.HandleInvocation) o;
if (!other.canEqual((java.lang.Object) this)) return false;
final java.lang.Object this$methodDescription = this.methodDescription;
final java.lang.Object other$methodDescription = other.methodDescription;
if (this$methodDescription == null ? other$methodDescription != null : !this$methodDescription.equals(other$methodDescription)) return false;
final java.lang.Object this$type = this.type;
final java.lang.Object other$type = other.type;
if (this$type == null ? other$type != null : !this$type.equals(other$type)) return false;
return true;
}
@java.lang.SuppressWarnings("all")
@javax.annotation.Generated("lombok")
protected boolean canEqual(final java.lang.Object other) {
return other instanceof MethodInvocation.HandleInvocation;
}
@java.lang.Override
@java.lang.SuppressWarnings("all")
@javax.annotation.Generated("lombok")
public int hashCode() {
final int PRIME = 59;
int result = 1;
final java.lang.Object $methodDescription = this.methodDescription;
result = result * PRIME + ($methodDescription == null ? 43 : $methodDescription.hashCode());
final java.lang.Object $type = this.type;
result = result * PRIME + ($type == null ? 43 : $type.hashCode());
return result;
}
}
/**
* The type of method handle invocation.
*/
public enum HandleType {
/**
* An exact invocation without type adjustments.
*/
EXACT("invokeExact"),
/**
* A regular invocation with standard type adjustments.
*/
REGULAR("invoke");
/**
* The name of the invoked method.
*/
private final String methodName;
/**
* Creates a new handle type.
*
* @param methodName The name of the invoked method.
*/
HandleType(String methodName) {
this.methodName = methodName;
}
/**
* Returns the name of the represented method.
*
* @return The name of the invoked method.
*/
protected String getMethodName() {
return methodName;
}
}
}