public void visitFunctionDeclaration(FunctionDeclarationContext function) {
    symbolTable.newScope();

    Function f = buildFunction(function);
    returnType = f.getReturnValueType();

    f.getArguments().stream().forEach(symbolTable::defineVariable);
    Type[] argTypes =
        f.getArguments()
            .stream()
            .flatMap(variable -> Stream.of(variable.getValueType().toAsmType()))
            .toArray(Type[]::new);
    String descriptor = Type.getMethodDescriptor(f.getReturnValueType().toAsmType(), argTypes);
    if ("main".equals(f.getName())) {
      if (!f.getArguments().isEmpty()) {
        throw new GenerationException("Main function must have zero arguments");
      }
      descriptor = Type.getMethodDescriptor(Type.VOID_TYPE, Type.getType(String[].class));
    }
    method = writer.visitMethod(ACC_PUBLIC | ACC_STATIC, f.getName(), descriptor, null, null);

    BlockContext block = function.functionBody().block();
    visitBlock(block);
    checkReturn(block);

    method.visitMaxs(0, 0);
    method.visitEnd();

    symbolTable.dropScope();
  }
  private void writeSetter(ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
    WeaklyTypeReferencingMethod<?, Void> weakSetter = property.getSetter();
    // There is no setter for this property
    if (weakSetter == null) {
      return;
    }

    String propertyName = property.getName();
    Class<?> propertyClass = property.getType().getConcreteClass();
    Type propertyType = Type.getType(propertyClass);
    Label calledOutsideOfConstructor = new Label();

    Method setter = weakSetter.getMethod();

    // the regular typed setter
    String methodDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, propertyType);
    MethodVisitor methodVisitor =
        declareMethod(
            visitor, setter.getName(), methodDescriptor, AsmClassGeneratorUtils.signature(setter));

    putCanCallSettersFieldValueOnStack(methodVisitor, generatedType);
    jumpToLabelIfStackEvaluatesToTrue(methodVisitor, calledOutsideOfConstructor);
    throwExceptionBecauseCalledOnItself(methodVisitor);

    methodVisitor.visitLabel(calledOutsideOfConstructor);
    putStateFieldValueOnStack(methodVisitor, generatedType);
    putConstantOnStack(methodVisitor, propertyName);
    putFirstMethodArgumentOnStack(methodVisitor, propertyType);
    if (propertyClass.isPrimitive()) {
      boxType(methodVisitor, propertyClass);
    }
    invokeStateSetMethod(methodVisitor);

    finishVisitingMethod(methodVisitor);
  }
Example #3
0
  /**
   * Translates a simple type descriptor, specifically. Only translates names in the descriptor, if
   * they are represented by class mirrors.
   */
  protected String translateDescriptor(final String descriptor) {
    Type type = Type.getType(descriptor);

    type = getMirrorType(type);

    return type.getDescriptor();
  }
  public TouchMethodVisitor(
      String owner,
      MethodNode methodNode,
      MethodVisitor methodVisitor,
      Set<Label> jumpLabels,
      Map<Label, Integer> lineLabels,
      Map<Label, SwitchHolder> switchLabels) {

    super(Opcodes.ASM5, methodVisitor);

    _owner = owner;
    _jumpLabels = jumpLabels;
    _lineLabels = lineLabels;
    _switchLabels = switchLabels;

    int variableCount = 0;

    if ((Opcodes.ACC_STATIC & methodNode.access) == 0) {
      variableCount++;
    }

    for (Type type : Type.getArgumentTypes(methodNode.desc)) {
      variableCount += type.getSize();
    }

    _variableCount = variableCount;
  }
  protected void injectGetByIndex(
      ClassWriter classWriter, String targetClassName, List<Field> fields) {
    MethodVisitor methodVisitor =
        classWriter.visitMethod(
            ACC_PUBLIC,
            "get",
            "(Ljava/lang/Object;I)Ljava/lang/Object;",
            null,
            new String[] {getInternalName(ILLEGAL_ACCESS_EXCEPTION.getCanonicalName())});

    Boxer boxer = new Boxer(methodVisitor);

    methodVisitor.visitCode();
    methodVisitor.visitVarInsn(ILOAD, 2);

    int maxStack = 6;

    Label[] labels = new Label[fields.size()];
    Label errorLabel = new Label();

    for (int i = 0; i < fields.size(); i++) {
      labels[i] = new Label();
    }

    methodVisitor.visitTableSwitchInsn(0, labels.length - 1, errorLabel, labels);

    if (!fields.isEmpty()) {
      maxStack--;

      for (int i = 0; i < fields.size(); i++) {
        Field field = fields.get(i);
        Class<?> type = field.getType();
        String fieldDescriptor = Type.getDescriptor(type);

        methodVisitor.visitLabel(labels[i]);

        if (i == 0) methodVisitor.visitFrame(F_APPEND, 1, new Object[] {targetClassName}, 0, null);
        else methodVisitor.visitFrame(F_SAME, 0, null, 0, null);

        if (isPublic(field)) {
          methodVisitor.visitVarInsn(ALOAD, 1);
          methodVisitor.visitTypeInsn(CHECKCAST, targetClassName);
          methodVisitor.visitFieldInsn(GETFIELD, targetClassName, field.getName(), fieldDescriptor);

          boxer.box(Type.getType(type));
        } else {
          injectReflectiveGetter(methodVisitor);
        }

        methodVisitor.visitInsn(ARETURN);
      }

      methodVisitor.visitLabel(errorLabel);
      methodVisitor.visitFrame(F_SAME, 0, null, 0, null);
    }

    injectException(methodVisitor, IllegalAccessException.class);
    methodVisitor.visitMaxs(maxStack, 3);
    methodVisitor.visitEnd();
  }
  /** Returns the reference/primitive class to store the */
  private static String findReferenceDesc(String desc) {
    Type type = Type.getType(desc);

    switch (type.getSort()) {
      case Type.ARRAY:
        return "Lorg/multiverse/transactional/refs/BasicRef;";
      case Type.BOOLEAN:
        return "Lorg/multiverse/transactional/refs/BooleanRef;";
      case Type.BYTE:
        return "Lorg/multiverse/transactional/refs/ByteRef;";
      case Type.CHAR:
        return "Lorg/multiverse/transactional/refs/CharRef;";
      case Type.DOUBLE:
        return "Lorg/multiverse/transactional/refs/DoubleRef;";
      case Type.FLOAT:
        return "Lorg/multiverse/transactional/refs/FloatRef;";
      case Type.INT:
        return "Lorg/multiverse/transactional/refs/IntRef;";
      case Type.LONG:
        return "Lorg/multiverse/transactional/refs/LongRef;";
      case Type.SHORT:
        return "Lorg/multiverse/transactional/refs/ShortRef;";
      case Type.OBJECT:
        return "Lorg/multiverse/transactional/refs/BasicRef;";
      default:
        throw new IllegalStateException("Unhandeled sort: " + type.getSort());
    }
  }
 public Param(String typeDesc) {
   loadInstruction = Opcodes.ALOAD;
   storeInstruction = Opcodes.ASTORE;
   typeId = TypeIdMap.TYPEID_OBJECT;
   t = Type.getType(typeDesc);
   assert t.getDescriptor().equals(typeDesc);
 }
 /**
  * Creates a new local variable of the given type.
  *
  * @param type the type of the local variable to be created.
  * @return the identifier of the newly created local variable.
  */
 public int newLocal(final Type type) {
   Object t;
   switch (type.getSort()) {
     case Type.BOOLEAN:
     case Type.CHAR:
     case Type.BYTE:
     case Type.SHORT:
     case Type.INT:
       t = Opcodes.INTEGER;
       break;
     case Type.FLOAT:
       t = Opcodes.FLOAT;
       break;
     case Type.LONG:
       t = Opcodes.LONG;
       break;
     case Type.DOUBLE:
       t = Opcodes.DOUBLE;
       break;
     case Type.ARRAY:
       t = type.getDescriptor();
       break;
       // case Type.OBJECT:
     default:
       t = type.getInternalName();
       break;
   }
   int local = newLocalMapping(type);
   setLocalType(local, type);
   setFrameLocal(local, t);
   return local;
 }
Example #9
0
  private static byte[] visitEnd() {
    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, RubyIDClassName, null, "java/lang/Object", null);
    Method staticBlock = Method.getMethod("void <clinit> ()V");
    GeneratorAdapter staticBlockMg =
        new GeneratorAdapter(Opcodes.ACC_STATIC, staticBlock, null, null, cw);

    for (Map.Entry<String, String> e : idMap.entrySet()) {
      cw.visitField(
          Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC,
          e.getValue(),
          Types.RUBY_ID_TYPE.getDescriptor(),
          null,
          null);

      staticBlockMg.push(e.getKey());
      staticBlockMg.invokeStatic(
          Type.getType(RubyID.class),
          Method.getMethod("com.xruby.runtime.lang.RubyID intern(String)"));
      staticBlockMg.putStatic(
          Type.getType("L" + RubyIDClassName + ";"), e.getValue(), Types.RUBY_ID_TYPE);
    }

    staticBlockMg.returnValue();
    staticBlockMg.endMethod();
    cw.visitEnd();

    return cw.toByteArray();
  }
Example #10
0
  @Override
  public final void visit(String name, Object value) {
    if (value == null) throw new Error();

    Type type;
    if (value.getClass().equals(String.class)) {
      type = Type.getType(String.class);
    } else if (value.getClass().equals(Boolean.class)) {
      type = Type.BOOLEAN_TYPE;
    } else if (value.getClass().equals(Integer.class)) {
      type = Type.INT_TYPE;
    } else if (value.getClass().equals(Long.class)) {
      type = Type.LONG_TYPE;
    } else if (value.getClass().equals(Type.class)) {
      type = Type.getType(Class.class);
    } else {
      throw new Error("name=" + name + " value=" + value + " " + value.getClass());
    }

    if (name == null) {
      anon(type, value);
    } else {
      add(name, new AnnotationValue(type, value));
    }
  }
Example #11
0
  private void generateAccessor(
      ClassWriter cw,
      Class<?> parentType,
      String internalName,
      Property<Class<?>, Method> property) {
    Method accessor = property.getAccessor();

    MethodVisitor mv =
        cw.visitMethod(
            ACC_PUBLIC, accessor.getName(), Type.getMethodDescriptor(accessor), null, null);
    mv.visitCode();
    mv.visitVarInsn(ALOAD, 0);
    mv.visitFieldInsn(
        GETFIELD,
        internalName,
        property.getName(),
        Type.getDescriptor(property.getLeastSpecificType()));

    if (!property.isLeastSpecificType()) {
      mv.visitTypeInsn(CHECKCAST, Type.getInternalName(property.getType()));
    }
    mv.visitInsn(Type.getType(property.getType()).getOpcode(IRETURN));
    mv.visitMaxs(0, 0);
    mv.visitEnd();
  }
Example #12
0
 private static AbstractInsnNode getDefault(Type type) {
   if (type.equals(Type.BOOLEAN_TYPE)) {
     return new LdcInsnNode(0);
   } else if (type.equals(Type.INT_TYPE)) {
     return new LdcInsnNode(0);
   } else if (type.equals(Type.BYTE_TYPE)) {
     return new LdcInsnNode(0);
   } else if (type.equals(Type.CHAR_TYPE)) {
     return new LdcInsnNode(0);
   } else if (type.equals(Type.DOUBLE_TYPE)) {
     return new LdcInsnNode(0.0);
   } else if (type.equals(Type.FLOAT_TYPE)) {
     return new LdcInsnNode(0.0F);
   } else if (type.equals(Type.INT_TYPE)) {
     return new LdcInsnNode(0);
   } else if (type.equals(Type.LONG_TYPE)) {
     return new LdcInsnNode(0L);
   } else if (type.equals(Type.SHORT_TYPE)) {
     return new LdcInsnNode(0);
   } else if (type.equals(Type.VOID_TYPE)) {
     return new LabelNode();
   } else {
     return new InsnNode(Opcodes.ACONST_NULL);
   }
 }
  public JvmObjectConstant(Object constant) {
    super(
        constant == null
            ? null
            : constant instanceof Integer
                ? Type.INT_TYPE
                : constant instanceof Long
                    ? Type.LONG_TYPE
                    : constant instanceof Float
                        ? Type.FLOAT_TYPE
                        : constant instanceof Double
                            ? Type.DOUBLE_TYPE
                            : constant instanceof Byte
                                ? Type.BYTE_TYPE
                                : constant instanceof Short
                                    ? Type.SHORT_TYPE
                                    : constant instanceof Character
                                        ? Type.CHAR_TYPE
                                        : constant instanceof String
                                            ? Type.getType(String.class)
                                            : constant instanceof Type
                                                ? Type.getType(Class.class)
                                                : null);

    this.constant = constant;
  }
      public void handleMethod(
          String className,
          String methodName,
          int access,
          String desc,
          String signature,
          String[] exceptions,
          String annotation,
          List<Value> values) {
        System.err.println(
            "Sample annotated method : classname="
                + className
                + " methodName="
                + methodName
                + " access="
                + access
                + " desc="
                + desc
                + " signature="
                + signature);

        org.objectweb.asm.Type retType = org.objectweb.asm.Type.getReturnType(desc);
        System.err.println("REturn type = " + retType);
        org.objectweb.asm.Type[] params = org.objectweb.asm.Type.getArgumentTypes(desc);
        if (params == null) System.err.println("No params");
        else System.err.println(params.length + " params");

        if (exceptions == null) System.err.println("No exceptions");
        else System.err.println(exceptions.length + " exceptions");

        assertEquals("org.eclipse.jetty.annotations.ClassA", className);
        assertTrue(methods.contains(methodName));
        assertEquals("org.eclipse.jetty.annotations.Sample", annotation);
      }
Example #15
0
 private void addMethodDesc(final String desc) {
   addType(Type.getReturnType(desc));
   Type[] types = Type.getArgumentTypes(desc);
   for (int i = 0; i < types.length; i++) {
     addType(types[i]);
   }
 }
  private int firePeacefulRegenEventAndStoreEventBefore(
      MethodNode method, AbstractInsnNode injectPoint, LabelNode endLabel) {
    // create  variable
    LabelNode peacefulRegenEventStart = new LabelNode();
    LocalVariableNode peacefulRegenEvent =
        new LocalVariableNode(
            "peacefulRegenEvent",
            Type.getDescriptor(HealthRegenEvent.PeacefulRegen.class),
            null,
            peacefulRegenEventStart,
            endLabel,
            method.maxLocals);
    method.maxLocals += 1;
    method.localVariables.add(peacefulRegenEvent);

    InsnList toInject = new InsnList();

    // HealthRegenEvent.PeacefulRegen peacefulRegenEvent = Hooks.firePeacefulRegenEvent(this);
    toInject.add(new VarInsnNode(ALOAD, 0));
    toInject.add(
        new MethodInsnNode(
            INVOKESTATIC,
            Type.getInternalName(Hooks.class),
            "firePeacefulRegenEvent",
            "(Lnet/minecraft/entity/player/EntityPlayer;)Lsqueek/applecore/api/hunger/HealthRegenEvent$PeacefulRegen;",
            false));
    toInject.add(new VarInsnNode(ASTORE, peacefulRegenEvent.index));
    toInject.add(peacefulRegenEventStart);

    method.instructions.insertBefore(injectPoint, toInject);

    return peacefulRegenEvent.index;
  }
  private void writeConstructor(
      ClassVisitor visitor,
      Type generatedType,
      Type superclassType,
      StructSchema<?> delegateSchema) {
    String constructorDescriptor;
    Type delegateType;
    if (delegateSchema == null) {
      delegateType = null;
      constructorDescriptor = NO_DELEGATE_CONSTRUCTOR_DESCRIPTOR;
    } else {
      delegateType = Type.getType(delegateSchema.getType().getConcreteClass());
      constructorDescriptor =
          Type.getMethodDescriptor(
              Type.VOID_TYPE, MODEL_ELEMENT_STATE_TYPE, TYPE_CONVERTER_TYPE, delegateType);
    }
    MethodVisitor constructorVisitor =
        declareMethod(visitor, CONSTRUCTOR_NAME, constructorDescriptor, CONCRETE_SIGNATURE);

    invokeSuperConstructor(constructorVisitor, superclassType);
    assignStateField(constructorVisitor, generatedType);
    assignTypeConverterField(constructorVisitor, generatedType);
    if (delegateType != null) {
      assignDelegateField(constructorVisitor, generatedType, delegateType);
    }
    setCanCallSettersField(constructorVisitor, generatedType, true);
    finishVisitingMethod(constructorVisitor);
  }
 /**
  * Find the annotations to add to the given method and remove from the set of things to annotate
  *
  * @param className name of class we're adding annotation to
  * @param methodName name of method we're adding annotation to
  * @param methodDesc descriptor of method
  * @return set on annotations to add to method or null if none
  */
 static Set<Class<? extends Annotation>> findAnnotationsForMethod(
     String className, String methodName, String methodDesc) {
   for (AnnotatedElement elem : thingsToAnnotate.keySet()) {
     if (elem instanceof Method) {
       Method m = (Method) elem;
       if (m.getDeclaringClass().getName().equals(className)
           && m.getName().equals(methodName)
           && Type.getMethodDescriptor(m).equals(methodDesc)) {
         annotatedElements.add(m);
         return thingsToAnnotate.get(m);
       }
     } else if (elem instanceof Constructor) {
       Constructor m = (Constructor) elem;
       if (m.getDeclaringClass().getName().equals(className)
           && Type.getConstructorDescriptor(m).equals(methodDesc)) {
         annotatedElements.add(m);
         return thingsToAnnotate.get(m);
       }
     }
   }
   ElementTriple triple = new ElementTriple(className, methodName, methodDesc);
   Set<Class<? extends Annotation>> set = thingsToAnnotate2.get(triple);
   if (set != null) {
     annotatedElements2.add(triple);
   }
   return set;
 }
Example #19
0
 public static Class<?> getClassForType(Type type) {
   checkArgNotNull(type, "type");
   switch (type.getSort()) {
     case Type.BOOLEAN:
       return boolean.class;
     case Type.BYTE:
       return byte.class;
     case Type.CHAR:
       return char.class;
     case Type.DOUBLE:
       return double.class;
     case Type.FLOAT:
       return float.class;
     case Type.INT:
       return int.class;
     case Type.LONG:
       return long.class;
     case Type.SHORT:
       return short.class;
     case Type.VOID:
       return void.class;
     case Type.OBJECT:
     case Type.ARRAY:
       return getClassForInternalName(type.getInternalName());
   }
   throw new IllegalStateException(); // should be unreachable
 }
Example #20
0
  public DirectedGraph<Node, Edge> convert() {
    DirectedGraph<Node, Edge> graph = new SimpleDirectedGraph<Node, Edge>(Edge.factory);

    // Add vertices

    for (Type t : hierarchy) graph.addVertex(Node.get(t));

    // Add edges

    for (Type t : hierarchy) {
      for (Type i : hierarchy.getInterfaces(t)) {
        graph.addVertex(Node.get(i));
        graph.addEdge(Node.get(t), Node.get(i));
      }

      Type sc = hierarchy.getSuperclass(t);

      if (sc == null) {
        assert t.equals(OBJECT) : t;
        continue;
      }

      graph.addVertex(Node.get(sc));
      graph.addEdge(Node.get(t), Node.get(sc));
    }

    // Check for cycles

    if (new CycleDetector<Node, Edge>(graph).detectCycles())
      throw new CyclicHierarchyException(graph.toString());

    return graph;
  }
    private ClassBuilderImpl(Class<T> type) {
      this.type = type;

      visitor = new ClassWriter(ClassWriter.COMPUTE_MAXS);
      typeName = type.getName() + "_Decorated";
      generatedType = Type.getType("L" + typeName.replaceAll("\\.", "/") + ";");
      superclassType = Type.getType(type);
    }
Example #22
0
 @Override
 public final void visitEnum(String name, String desc, String value) {
   if (name == null) {
     anon(Type.getType(desc), value);
     return;
   }
   add(name, new AnnotationValue(Type.getType(desc), value));
 }
 private Set<String> mapGetDescriptor(AnnotationWithClassValuesDescriptor annotation) {
   Set<String> result = new HashSet<String>();
   for (Object o : annotation.properties.getArrayValues("annotations")) {
     Type type = (Type) o;
     result.add(type.getDescriptor());
   }
   return result;
 }
 public MethodVisitor visitMethod(
     int access, String name, String desc, String signature, String[] exceptions) {
   Type[] args = Type.getArgumentTypes(desc);
   Type returnType = Type.getReturnType(desc);
   int startParameter = getStartParameterIndex(name);
   MethodVisitor v = cv.visitMethod(access, name, desc, signature, exceptions);
   return new MyMethodAdapter(this, v, args, returnType, access, startParameter, name);
 }
 private void boxType(MethodVisitor methodVisitor, Class<?> primitiveType) {
   Class<?> boxedType = BOXED_TYPES.get(primitiveType);
   methodVisitor.visitMethodInsn(
       INVOKESTATIC,
       Type.getInternalName(boxedType),
       "valueOf",
       "(" + Type.getDescriptor(primitiveType) + ")" + Type.getDescriptor(boxedType),
       false);
 }
 private void invokeSuperConstructor(MethodVisitor constructorVisitor, Type superclassType) {
   putThisOnStack(constructorVisitor);
   constructorVisitor.visitMethodInsn(
       INVOKESPECIAL,
       superclassType.getInternalName(),
       CONSTRUCTOR_NAME,
       Type.getMethodDescriptor(Type.VOID_TYPE),
       false);
 }
 private void assignStateField(MethodVisitor constructorVisitor, Type generatedType) {
   putThisOnStack(constructorVisitor);
   putFirstMethodArgumentOnStack(constructorVisitor);
   constructorVisitor.visitFieldInsn(
       PUTFIELD,
       generatedType.getInternalName(),
       STATE_FIELD_NAME,
       MODEL_ELEMENT_STATE_TYPE.getDescriptor());
 }
 private void assignTypeConverterField(MethodVisitor constructorVisitor, Type generatedType) {
   putThisOnStack(constructorVisitor);
   putSecondMethodArgumentOnStack(constructorVisitor);
   constructorVisitor.visitFieldInsn(
       PUTFIELD,
       generatedType.getInternalName(),
       TYPE_CONVERTER_FIELD_NAME,
       TYPE_CONVERTER_TYPE.getDescriptor());
 }
Example #29
0
 @Override
 public void visitLdcInsn(Object cst) {
   if (cst instanceof Type) {
     Type type = (Type) cst;
     AsmClass usedClass = asmClassProvider.getClass(type.getInternalName(), DETAIL_LEVEL.NOTHING);
     method.addEdge(new AsmEdge(method, usedClass, SourceCodeEdgeUsage.USES, lineNumber));
   }
   emptyMethod = false;
 }
    private static byte[] generate(String name, Class<?> type, Class<?> parameter) {
      name = name.replace('.', '/');

      String typeName = Type.getInternalName(type);
      String typeDesc = Type.getDescriptor(type);
      String parameterName = Type.getInternalName(parameter);
      String parameterDesc = Type.getDescriptor(parameter);

      String constructSignature = '(' + parameterDesc + ')' + typeDesc;

      ClassWriter cw = new ClassWriter(0);
      MethodVisitor mv;

      cw.visit(V1_6, ACC_PUBLIC + ACC_FINAL + ACC_SUPER, name, null, BASE_CLASS, null);

      {
        mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(Ljava/lang/Class;)V", null, null);
        mv.visitCode();
        mv.visitVarInsn(ALOAD, 0);
        mv.visitVarInsn(ALOAD, 1);
        mv.visitMethodInsn(INVOKESPECIAL, BASE_CLASS, "<init>", "(Ljava/lang/Class;)V", false);
        mv.visitInsn(RETURN);
        mv.visitMaxs(2, 2);
        mv.visitEnd();
      }
      {
        mv = cw.visitMethod(ACC_PUBLIC, "construct", constructSignature, null, null);
        mv.visitCode();
        mv.visitTypeInsn(NEW, typeName);
        mv.visitInsn(DUP);
        mv.visitVarInsn(ALOAD, 1);
        mv.visitMethodInsn(INVOKESPECIAL, typeName, "<init>", '(' + parameterDesc + ")V", false);
        mv.visitInsn(ARETURN);
        mv.visitMaxs(3, 2);
        mv.visitEnd();
      }
      {
        mv =
            cw.visitMethod(
                ACC_PUBLIC + ACC_BRIDGE + ACC_SYNTHETIC,
                "construct",
                "(Ljava/lang/Object;)Ljava/lang/Object;",
                null,
                null);
        mv.visitCode();
        mv.visitVarInsn(ALOAD, 0);
        mv.visitVarInsn(ALOAD, 1);
        mv.visitTypeInsn(CHECKCAST, parameterName);
        mv.visitMethodInsn(INVOKEVIRTUAL, name, "construct", constructSignature, false);
        mv.visitInsn(ARETURN);
        mv.visitMaxs(2, 2);
        mv.visitEnd();
      }
      cw.visitEnd();

      return cw.toByteArray();
    }