org.objectweb.asm.Type Java Examples

private static boolean validate(String token) {
	// Void check
	if(token.equals("V"))
		return true;
	// Ensure type is not an array
	Type type = Type.getType(token);
	while(type.getSort() == Type.ARRAY)
		type = type.getElementType();
	// Check for primitives
	if(type.getSort() < Type.ARRAY)
		return true;
	// Verify L...; pattern
	// - getDescriptor doesn't modify the original element type (vs getInternalName)
	String desc = type.getDescriptor();
	return desc.startsWith("L") && desc.endsWith(";");
}
 

private void visitAnnotationArrayElement(final Expression expr, final int arrayElementType, final AnnotationVisitor av) {
    switch (arrayElementType) {
        case 1:
            AnnotationNode atAttr = (AnnotationNode) ((AnnotationConstantExpression) expr).getValue();
            AnnotationVisitor av2 = av.visitAnnotation(null, BytecodeHelper.getTypeDescription(atAttr.getClassNode()));
            visitAnnotationAttributes(atAttr, av2);
            av2.visitEnd();
            break;
        case 2:
            av.visit(null, ((ConstantExpression) expr).getValue());
            break;
        case 3:
            av.visit(null, Type.getType(BytecodeHelper.getTypeDescription(expr.getType())));
            break;
        case 4:
            PropertyExpression propExpr = (PropertyExpression) expr;
            av.visitEnum(null,
                    BytecodeHelper.getTypeDescription(propExpr.getObjectExpression().getType()),
                    String.valueOf(((ConstantExpression) propExpr.getProperty()).getValue()));
            break;
    }
}
 

@Override
public void generate(CodeEmitter code) {
    Label done = new Label();
    Label next = new Label();
    MethodVisitor mv = code.getMethodVisitor();
    BytecodeExpression tgt = code.evaluateOnce(target);
    code.exec(tgt);
    code.emitInstanceCheck(tgt.getType(), Iterable.class, done);
    AssignableValue item = this.item == null ? code.allocate(valueType) : this.item;
    AssignableValue iterator = code.allocate(Iterator.class);
    mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, Type.getInternalName(Iterable.class), "iterator", Type.getMethodDescriptor(Type.getType(Iterator.class)), true);
    code.exec(iterator.write(code.adapt(Iterator.class)));
    mv.visitLabel(next);
    code.exec(iterator.read());
    mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, Type.getInternalName(Iterator.class), "hasNext", Type.getMethodDescriptor(Type.BOOLEAN_TYPE), true);
    mv.visitJumpInsn(Opcodes.IFEQ, done);
    code.exec(iterator.read());
    mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, Type.getInternalName(Iterator.class), "next", Type.getMethodDescriptor(Type.getType(Object.class)), true);
    code.cast(valueType, AnyTypeWidget.getInstance()); // , next);   // don't skip nulls
    code.exec(item.write(item.getType()));
    loop.item(code, item.read(), done, next);
    mv.visitJumpInsn(Opcodes.GOTO, next);
    mv.visitLabel(done);
}
 

/**
 * This is where minecraft checks if you can steer llamas
 * @param methodNode
 * @param env
 */
@MethodPatch(
        mcpName = "canBeSteered",
        notchName = "cV",
        mcpDesc = "()Z")
public void canBeSteered(MethodNode methodNode, PatchManager.Environment env) {
    //create a list of instructions and add the needed instructions to call our hook function
    final InsnList insnList = new InsnList();
    //call our hook function
    insnList.add(new MethodInsnNode(INVOKESTATIC, Type.getInternalName(this.getClass()), "canBeSteeredHook", "()Z", false));
    //add a label to jump to
    final LabelNode jmp = new LabelNode();
    //add if equals and pass the label
    insnList.add(new JumpInsnNode(IFEQ, jmp));
    //add 1 or true
    insnList.add(new InsnNode(ICONST_1));
    //add return so the rest of the function doesn't get called
    insnList.add(new InsnNode(IRETURN));
    //add our label
    insnList.add(jmp);
    //insert the list of instructions at the top of the function
    methodNode.instructions.insert(insnList);
}
 

@Override
public DescAST visit(int lineNo, String line) throws ASTParseException {
	try {
		String trim = line.trim();
		// Verify
		if(trim.contains("(")) {
			Type type = Type.getMethodType(trim);
			if(!validate(type.getReturnType().getDescriptor()))
				throw new ASTParseException(lineNo,
						"Invalid method return type " + type.getReturnType().getDescriptor());
			for(Type arg : type.getArgumentTypes())
				if(!validate(arg.getDescriptor()))
					throw new ASTParseException(lineNo,
							"Invalid method arg type " + arg.getDescriptor());
		} else {
			if(!validate(trim))
				throw new ASTParseException(lineNo, "Invalid field descriptor: " + trim);
		}
		// Create AST
		int start = line.indexOf(trim);
		return new DescAST(lineNo, getOffset() + start, trim);
	} catch(Exception ex) {
		throw new ASTParseException(ex, lineNo, "Bad format for descriptor: " + ex.getMessage());
	}
}
 

@SuppressWarnings("unused")
protected void onMethodEnter() {
	if (done) return;

	overridden = true;
	Label start  = new Label();
	Label normal = new Label();
	super.visitLabel(start);
	super.visitFieldInsn(Opcodes.GETSTATIC, CONFIGURATION, CONFIGURATION_FIELD_NAME, Type.INT_TYPE.getDescriptor());
	super.visitInsn(Opcodes.DUP);
	super.visitJumpInsn(Opcodes.IFEQ, normal);
	super.visitInsn(Opcodes.IRETURN);
	super.visitLabel(normal);
	super.visitInsn(Opcodes.POP);
	Label end = new Label();
	super.visitJumpInsn(Opcodes.GOTO, end);
	super.visitLabel(end);
	super.visitTryCatchBlock(start, normal, end, Type.getType(Throwable.class).getDescriptor());
}
 

@Override
public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) {
  super.visit(version, access, name, signature, superName, interfaces);
  if (FingerprintUtil.isSynthetic(access) || Modifier.isPrivate(access))
    return;

  this.className = Type.getObjectType(name).getClassName();
  if (interfaces != null && interfaces.length != 0) {
    for (int i = 0; i < interfaces.length; ++i)
      interfaces[i] = interfaces[i].replace('/', '.');

    this.interfaces = new ArrayList<>();
    for (int i = 0; i < interfaces.length; ++i)
      this.interfaces.add(interfaces[i]);
  }

  this.superClass = superName == null || "java/lang/Object".equals(superName) ? null : Type.getObjectType(superName).getClassName();
}
 

private void pushDefault(Type type) {
    switch (type.getSort()) {
        case Type.VOID:
            break;
        case Type.DOUBLE:
            mv.visitInsn(DCONST_0);
            break;
        case Type.LONG:
            mv.visitInsn(LCONST_0);
            break;
        case Type.FLOAT:
            mv.visitInsn(FCONST_0);
            break;
        case Type.OBJECT:
        case Type.ARRAY:
            mv.visitInsn(ACONST_NULL);
            break;
        default:
            mv.visitInsn(ICONST_0);
            break;
    }
}
 

@Override
public void invokeSpecial(final Class<?> clazz, final List<BytecodeExpression> arguments) {
    final Type[] args = new Type[arguments.size()];
    for (int i = 0; i < arguments.size(); ++i) {
        args[i] = arguments.get(i).getType().getJVMType();
    }
    unit.setSuperInit(
            new BytecodeSequence() {
                @Override
                public void generate(CodeEmitter code) {
                    code.exec(code.getLocal("this"));
                    for (BytecodeExpression e : arguments) {
                        code.exec(e);
                    }
                    MethodVisitor mv = code.getMethodVisitor();
                    mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(clazz), "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, args), false);
                }
            }
    );
}
 

/**
 * Emits a bridge method for an instance method in a class. For example,
 *
 * <pre><code>
 *   class Foo {
 *     private X execute(A a) {...}
 *
 *     &#047;&#047; Synthetic bridge method for a static method.
 *     static X execute$bridge(Foo foo, A a) {
 *       return foo.execute(a);
 *     }
 *   }
 * </code></pre>
 */
@Override
public MethodVisitor visitClassInstanceMethod(MethodDeclInfo methodDeclInfo, ClassVisitor cv) {
  MethodDeclInfo bridgeMethod = methodDeclInfo.bridgeOfClassInstanceMethod();
  MethodVisitor mv = bridgeMethod.accept(cv);
  mv.visitCode();
  int slotOffset = 0;
  for (Type argType : bridgeMethod.argumentTypes()) {
    mv.visitVarInsn(argType.getOpcode(Opcodes.ILOAD), slotOffset);
    slotOffset += argType.getSize();
  }

  mv.visitMethodInsn(
      Opcodes.INVOKESPECIAL,
      methodDeclInfo.ownerName(),
      methodDeclInfo.name(),
      methodDeclInfo.descriptor(),
      /* isInterface= */ false);
  mv.visitInsn(bridgeMethod.returnType().getOpcode(Opcodes.IRETURN));
  mv.visitMaxs(slotOffset, slotOffset);
  mv.visitEnd();
  return mv;
}
 

@Override
public void toCode(MethodVisitor visitor, BytecodeFrontend assembler) {
	if (needsSort()) {
		sort();
	}

	int[] cases = new int[targets.size()];
	Label[] labels = new Label[targets.size()];
	int j = 0;
	for (Entry<Integer, BasicBlock> e : targets.entrySet()) {
		cases[j] = e.getKey();
		labels[j++] = assembler.getLabel(e.getValue());
	}

	expression.toCode(visitor, assembler);
	int[] cast = TypeUtils.getPrimitiveCastOpcodes(expression.getType(), Type.INT_TYPE); // widen
	for (int i = 0; i < cast.length; i++) {
		visitor.visitInsn(cast[i]);
	}
	boolean fitsIntoTable = fitsIntoTableSwitch();
	if (fitsIntoTable) {
		visitor.visitTableSwitchInsn(cases[0], cases[cases.length - 1], assembler.getLabel(defaultTarget), labels);
	} else {
		visitor.visitLookupSwitchInsn(assembler.getLabel(defaultTarget), cases, labels);
	}
}
 

@Test
@SuppressWarnings("unchecked")
public void testReceiverTypeTypeAnnotationsClassFileRetention() throws Exception {
    when(methodDescription.getParameters()).thenReturn((ParameterList) new ParameterList.Empty<ParameterDescription>());
    when(methodDescription.getReturnType()).thenReturn(TypeDescription.Generic.VOID);
    when(methodDescription.getTypeVariables()).thenReturn(new TypeList.Generic.Empty());
    when(methodDescription.getExceptionTypes()).thenReturn(new TypeList.Generic.Empty());
    when(methodDescription.getDeclaredAnnotations()).thenReturn(new AnnotationList.Empty());
    when(methodDescription.getReceiverType()).thenReturn(simpleAnnotatedType);
    when(simpleAnnotatedType.getDeclaredAnnotations()).thenReturn(new AnnotationList.ForLoadedAnnotations(new QuxBaz.Instance()));
    MethodAttributeAppender.ForInstrumentedMethod.INCLUDING_RECEIVER.apply(methodVisitor, methodDescription, annotationValueFilter);
    verify(methodVisitor).visitTypeAnnotation(TypeReference.newTypeReference(TypeReference.METHOD_RECEIVER).getValue(),
            null,
            Type.getDescriptor(AbstractAttributeAppenderTest.QuxBaz.class),
            false);
    verifyNoMoreInteractions(methodVisitor);
    verify(methodDescription).getDeclaredAnnotations();
    verify(methodDescription).getParameters();
    verify(methodDescription).getReturnType();
    verify(methodDescription).getExceptionTypes();
    verify(methodDescription).getTypeVariables();
    verify(methodDescription).getReceiverType();
    verifyNoMoreInteractions(methodDescription);
}
 

@Test
public void test() {
  ClassWriter cw = new ClassWriter(0);
  cw.visit(V1_6, ACC_PUBLIC + ACC_SUPER, "HelloGen", null, "java/lang/Object", null);

  FieldVisitor fv = cw.visitField(1, "_key", Type.getDescriptor(String.class), null, null);
  fv.visitEnd();

  fv = cw.visitField(1, "_value", Type.getDescriptor(InnerClass.class), null, null);
  fv.visitEnd();

  Class<?> clazz = new DynamicClassLoader().defineClass("HelloGen", cw.toByteArray());
  for(Field f : clazz.getDeclaredFields()) {
    System.out.println(f.getName());
  }
}
 

private Set<String> getClassDependencies(ClassRelevancyFilter filter, ClassReader reader) {
    Set<String> out = new HashSet<String>();
    char[] charBuffer = new char[reader.getMaxStringLength()];
    for (int i = 1; i < reader.getItemCount(); i++) {
        int itemOffset = reader.getItem(i);
        if (itemOffset > 0 && reader.readByte(itemOffset - 1) == 7) {
            // A CONSTANT_Class entry, read the class descriptor
            String classDescriptor = reader.readUTF8(itemOffset, charBuffer);
            Type type = Type.getObjectType(classDescriptor);
            while (type.getSort() == Type.ARRAY) {
                type = type.getElementType();
            }
            if (type.getSort() != Type.OBJECT) {
                // A primitive type
                continue;
            }
            String name = type.getClassName();
            if (filter.isRelevant(name)) {
                out.add(name);
            }
        }
    }
    return out;
}
 

@Override
public SourceValue unaryOperation(final AbstractInsnNode insn, final SourceValue value) {
  int size;
  switch (insn.getOpcode()) {
    case LNEG:
    case DNEG:
    case I2L:
    case I2D:
    case L2D:
    case F2L:
    case F2D:
    case D2L:
      size = 2;
      break;
    case GETFIELD:
      size = Type.getType(((FieldInsnNode) insn).desc).getSize();
      break;
    default:
      size = 1;
      break;
  }
  return new SourceValue(size, insn);
}
 

@Test
@SuppressWarnings("unchecked")
public void testMethodParameterTypeTypeAnnotationClassFileRetention() throws Exception {
    when(annotationValueFilter.isRelevant(any(AnnotationDescription.class), any(MethodDescription.InDefinedShape.class))).thenReturn(true);
    when(methodDescription.getDeclaredAnnotations()).thenReturn(new AnnotationList.Empty());
    ParameterDescription parameterDescription = mock(ParameterDescription.class);
    when(parameterDescription.getDeclaredAnnotations()).thenReturn(new AnnotationList.Empty());
    when(parameterDescription.getType()).thenReturn(simpleAnnotatedType);
    when(methodDescription.getParameters()).thenReturn((ParameterList) new ParameterList.Explicit<ParameterDescription>(parameterDescription));
    when(methodDescription.getReturnType()).thenReturn(TypeDescription.Generic.VOID);
    when(methodDescription.getTypeVariables()).thenReturn(new TypeList.Generic.Empty());
    when(methodDescription.getExceptionTypes()).thenReturn(new TypeList.Generic.Empty());
    when(simpleAnnotatedType.getDeclaredAnnotations()).thenReturn(new AnnotationList.ForLoadedAnnotations(new QuxBaz.Instance()));
    methodAttributeAppender.apply(methodVisitor, methodDescription, annotationValueFilter);
    verify(methodVisitor).visitTypeAnnotation(TypeReference.newFormalParameterReference(0).getValue(),
            null,
            Type.getDescriptor(QuxBaz.class),
            false);
    verifyNoMoreInteractions(methodVisitor);
}
 

private void visitSwap(MethodVisitor mv, Type topType) {
    if (topType.getSize() == 1) {
        mv.visitInsn(SWAP);
    } else {
        mv.visitInsn(DUP2_X1);
        mv.visitInsn(POP2);
    }
}
 

private static byte[] generateClass(String internalClassName, Type testClassType, int iThread, List<Actor> actors,
    List<Object> objArgs, boolean waitsEnabled)
{
    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
    CheckClassAdapter cca = new CheckClassAdapter(cw, false);
    cca.visit(52, ACC_PUBLIC + ACC_SUPER, internalClassName, null, TEST_THREAD_EXECUTION_TYPE.getInternalName(), null);
    generateConstructor(cca);
    generateRun(cca, testClassType, iThread, actors, objArgs, waitsEnabled);
    cca.visitEnd();
    return cw.toByteArray();
}
 

public void declare_field(int access, String name, Type type, Object value) {
    FieldInfo existing = (FieldInfo)fieldInfo.get(name);
    FieldInfo info = new FieldInfo(access, name, type, value);
    if (existing != null) {
        if (!info.equals(existing)) {
            throw new IllegalArgumentException("Field \"" + name + "\" has been declared differently");
        }
    } else {
        fieldInfo.put(name, info);
        cv.visitField(access, name, type.getDescriptor(), null, value);
    }
}
 

/**
 * Adds the chain info.
 *
 * @return the insn list
 */
private InsnList addChainInfo() {
	InsnList list = new InsnList();
	list.add(new VarInsnNode(Opcodes.ALOAD, 1));
	list.add(new MethodInsnNode(Opcodes.INVOKESTATIC,
			CLASSNAME_MAPREDUCEEXECUTIL, "addChainInfo", Type
					.getMethodDescriptor(Type.VOID_TYPE, TYPE_JOBCONF)));

	return list;
}
 

/**
  * @deprecated use {@link #append_string(CodeEmitter, Type, ArrayDelimiters, CustomizerRegistry)} instead
  */
@Deprecated
public static void append_string(final CodeEmitter e,
                                 Type type,
                                 final ArrayDelimiters delims,
                                 final Customizer customizer) {
    append_string(e, type, delims, CustomizerRegistry.singleton(customizer));
}
 

void addConstant(final Object constant) {
    if (constant instanceof Type) {
        addType((Type) constant);
    } else if (constant instanceof Handle) {
        Handle handle = (Handle) constant;
        addInternalType(handle.getOwner());
        addMethodTypes(handle.getDesc());
    }
}
 

@Override
public void visit(final String name, final Object value) {
  checkVisitEndNotCalled();
  checkName(name);
  if (!(value instanceof Byte
      || value instanceof Boolean
      || value instanceof Character
      || value instanceof Short
      || value instanceof Integer
      || value instanceof Long
      || value instanceof Float
      || value instanceof Double
      || value instanceof String
      || value instanceof Type
      || value instanceof byte[]
      || value instanceof boolean[]
      || value instanceof char[]
      || value instanceof short[]
      || value instanceof int[]
      || value instanceof long[]
      || value instanceof float[]
      || value instanceof double[])) {
    throw new IllegalArgumentException("Invalid annotation value");
  }
  if (value instanceof Type && ((Type) value).getSort() == Type.METHOD) {
    throw new IllegalArgumentException("Invalid annotation value");
  }
  super.visit(name, value);
}
 

@Override
public void visitVarInsn(final int opcode, final int var) {
  switch (opcode) {
    case Opcodes.ILOAD:
      load(var, Type.INT_TYPE);
      break;
    case Opcodes.LLOAD:
      load(var, Type.LONG_TYPE);
      break;
    case Opcodes.FLOAD:
      load(var, Type.FLOAT_TYPE);
      break;
    case Opcodes.DLOAD:
      load(var, Type.DOUBLE_TYPE);
      break;
    case Opcodes.ALOAD:
      load(var, OBJECT_TYPE);
      break;
    case Opcodes.ISTORE:
      store(var, Type.INT_TYPE);
      break;
    case Opcodes.LSTORE:
      store(var, Type.LONG_TYPE);
      break;
    case Opcodes.FSTORE:
      store(var, Type.FLOAT_TYPE);
      break;
    case Opcodes.DSTORE:
      store(var, Type.DOUBLE_TYPE);
      break;
    case Opcodes.ASTORE:
      store(var, OBJECT_TYPE);
      break;
    case Opcodes.RET:
      ret(var);
      break;
    default:
      throw new IllegalArgumentException();
  }
}
 

/**
 * Generates the instructions to unbox the top stack value. This value is replaced by its unboxed
 * equivalent on top of the stack.
 *
 * @param type the type of the top stack value.
 */
public void unbox(final Type type) {
  Type boxedType = NUMBER_TYPE;
  Method unboxMethod;
  switch (type.getSort()) {
    case Type.VOID:
      return;
    case Type.CHAR:
      boxedType = CHARACTER_TYPE;
      unboxMethod = CHAR_VALUE;
      break;
    case Type.BOOLEAN:
      boxedType = BOOLEAN_TYPE;
      unboxMethod = BOOLEAN_VALUE;
      break;
    case Type.DOUBLE:
      unboxMethod = DOUBLE_VALUE;
      break;
    case Type.FLOAT:
      unboxMethod = FLOAT_VALUE;
      break;
    case Type.LONG:
      unboxMethod = LONG_VALUE;
      break;
    case Type.INT:
    case Type.SHORT:
    case Type.BYTE:
      unboxMethod = INT_VALUE;
      break;
    default:
      unboxMethod = null;
      break;
  }
  if (unboxMethod == null) {
    checkCast(type);
  } else {
    checkCast(boxedType);
    invokeVirtual(boxedType, unboxMethod);
  }
}
 

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
  if (opcode == Opcodes.INVOKESPECIAL && "<init>".equals(name)) {
    int argumentSize = (Type.getArgumentsAndReturnSizes(desc) >> 2);
    InferredType receiverType = getTypeOfOperandFromTop(argumentSize - 1);
    if (receiverType.isUninitialized()) {
      InferredType realType = InferredType.create('L' + owner + ';');
      replaceUninitializedTypeInStack(receiverType, realType);
    }
  }
  switch (opcode) {
    case Opcodes.INVOKESPECIAL:
    case Opcodes.INVOKEVIRTUAL:
    case Opcodes.INVOKESTATIC:
    case Opcodes.INVOKEINTERFACE:
      popDescriptor(desc);
      if (opcode != Opcodes.INVOKESTATIC) {
        pop(); // Pop receiver.
      }
      pushDescriptor(desc);
      break;
    default:
      throw new RuntimeException(
          String.format(
              "Unhandled opcode %s, owner=%s, name=%s, desc=%s, itf=%s",
              opcode, owner, name, desc, itf));
  }
  super.visitMethodInsn(opcode, owner, name, desc, itf);
}
 

private static List<AdviceParameter> getAdviceParameters(
        Map<Integer, List<Type>> parameterAnnotationTypes, Type[] parameterTypes,
        List<Type> validBindAnnotationTypes, Type adviceAnnotationType)
        throws AdviceConstructionException {

    List<AdviceParameter> parameters = Lists.newArrayList();
    for (int i = 0; i < parameterTypes.length; i++) {
        if (parameterTypes[i].equals(ThreadContextType)) {
            parameters.add(ImmutableAdviceParameter.builder()
                    .kind(ParameterKind.THREAD_CONTEXT)
                    .type(ThreadContextType)
                    .build());
            continue;
        }
        if (parameterTypes[i].equals(OptionalThreadContextType)) {
            parameters.add(ImmutableAdviceParameter.builder()
                    .kind(ParameterKind.OPTIONAL_THREAD_CONTEXT)
                    .type(OptionalThreadContextType)
                    .build());
            continue;
        }
        Type validBindAnnotationType = getValidBindAnnotationType(
                checkNotNull(parameterAnnotationTypes.get(i)), validBindAnnotationTypes);
        if (validBindAnnotationType == null) {
            // no valid bind annotations found, provide a good error message
            List<String> validBindAnnotationNames = Lists.newArrayList();
            for (Type annotationType : validBindAnnotationTypes) {
                validBindAnnotationNames.add("@" + annotationType.getClassName());
            }
            throw new AdviceConstructionException("All parameters to @"
                    + adviceAnnotationType.getClassName() + " must be annotated with one"
                    + " of " + Joiner.on(", ").join(validBindAnnotationNames));
        }
        parameters.add(getAdviceParameter(validBindAnnotationType, parameterTypes[i]));
    }
    return parameters;
}
 

public static void processIndy(ClassNode classNode, String methodName, InvokeDynamicInsnNode indy) {
    MethodNode indyWrapper = new MethodNode(Opcodes.ASM7,
            Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_STATIC,
            methodName, indy.desc, null, new String[0]);

    int localVarsPosition = 0;
    for (Type arg : Type.getArgumentTypes(indy.desc)) {
        indyWrapper.instructions.add(new VarInsnNode(arg.getOpcode(Opcodes.ILOAD), localVarsPosition));
        localVarsPosition += arg.getSize();
    }

    indyWrapper.instructions.add(new InvokeDynamicInsnNode(indy.name, indy.desc, indy.bsm, indy.bsmArgs));
    indyWrapper.instructions.add(new InsnNode(Opcodes.ARETURN));
    classNode.methods.add(indyWrapper);
}
 

/**
 * add Throws statement with int param 2
 */
private void throwExIntParam(MethodVisitor mv, Class<?> exCls) {
	String exSig = Type.getInternalName(exCls);
	mv.visitTypeInsn(NEW, exSig);
	mv.visitInsn(DUP);
	mv.visitLdcInsn("mapping " + this.className + " failed to map field:");
	mv.visitVarInsn(ILOAD, 2);
	mv.visitMethodInsn(INVOKESTATIC, "java/lang/Integer", "toString", "(I)Ljava/lang/String;");
	mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/String", "concat", "(Ljava/lang/String;)Ljava/lang/String;");
	mv.visitMethodInsn(INVOKESPECIAL, exSig, "<init>", "(Ljava/lang/String;)V");
	mv.visitInsn(ATHROW);
}
 

public Type translateMethodType(Type methodType) {
  Type[] translated =
    translateTypes(
      mcClasses,
      Lists.asList(methodType.getReturnType(), methodType.getArgumentTypes())
        .toArray(new Type[]{}));
  return Type.getMethodType(translated[0], Arrays.copyOfRange(translated, 1, translated.length));
}