public static void generateResolvable(
      ClassLoader classLoader,
      String resolvableName,
      Class ownerClass,
      Method nonProxiedMethod,
      Type[] genericArguments,
      boolean isStatic,
      TransformGenerator[] tg) {
    Type ownerType = Type.getType(ownerClass);

    ClassGenerator w = new ClassGenerator(ACC_SUPER, resolvableName, OBJECT_TYPE, RESOLVABLE_TYPE);

    Type resolvableType = w.getThisType();

    if (tg != null) {
      int index = 0;
      for (TransformGenerator generator : tg) {
        generator.generateFields(resolvableType, index, w);
        index += generator.getFieldCount();
      }
    }

    Type[] arguments = nonProxiedMethod.getArgumentTypes();
    if (!isStatic) {
      w.defineField(ACC_PRIVATE | ACC_FINAL, OWNER_FIELD_NAME, ownerType);
    }
    Type[] stored = new Type[arguments.length];
    for (int i = 0; i < arguments.length; i++) {
      Type arg = genericArguments[i];
      if (tg != null) {
        stored[i] = Type.getType(tg[i].getTransformedType(toClass(classLoader, arg)));
      } else {
        stored[i] = arg;
      }
      w.defineField(ACC_PRIVATE | ACC_FINAL, "arg" + i, stored[i]);
    }

    Type[] ctorArguments = isStatic ? arguments : CodegenHelper.insertFirst(arguments, ownerType);
    MxConstructorGenerator ctor = w.defineConstructor(ACC_PUBLIC, ctorArguments);
    generateResolvableCtor(
        ownerType, resolvableType, arguments, genericArguments, ctor, isStatic, tg, stored);

    MxGeneratorAdapter getValue = w.defineMethod(ACC_PUBLIC, GET_VALUE_METHOD);
    generateGetValue(
        ownerClass,
        ownerType,
        nonProxiedMethod,
        isStatic,
        resolvableType,
        arguments,
        getValue,
        tg,
        stored);

    w.toClass(classLoader);
  }
  private static void generateGetValue(
      Class owner,
      Type ownerType,
      Method method,
      boolean isStatic,
      Type resolvableType,
      Type[] arguments,
      MxGeneratorAdapter getValue,
      TransformGenerator[] tg,
      Type[] stored) {
    getValue.visitCode();

    if (!isStatic) {
      getValue.loadThis();
      getValue.getField(resolvableType, OWNER_FIELD_NAME, ownerType);
    }
    int index = 0;
    for (int i = 0; i < arguments.length; i++) {
      getValue.loadThis();
      getValue.getField(resolvableType, "arg" + i, stored[i]);
      if (tg != null) {
        tg[i].generateBackward(resolvableType, index, getValue);
        index += tg[i].getFieldCount();
      }
    }

    getValue.visitMethodInsn(
        isStatic ? INVOKESTATIC : owner.isInterface() ? INVOKEINTERFACE : INVOKEVIRTUAL,
        ownerType.getInternalName(),
        method.getName(),
        method.getDescriptor());
    getValue.returnValue();
    getValue.endMethod();
  }
 @Override
 public void generateForward(Type thisType, int fieldIndex, GeneratorAdapter method) {
   if (thisType.getSize() == 2) {
     method.pop2();
   } else {
     method.pop();
   }
 }
 public static void generateResolvable(Class ownerClass, int id, Method method, boolean isStatic) {
   Method nonProxiedMethod = new Method(getNonProxiedMethodName(method), method.getDescriptor());
   generateResolvable(
       ownerClass.getClassLoader(),
       getResolvableName(id, Type.getType(ownerClass)),
       ownerClass,
       nonProxiedMethod,
       nonProxiedMethod.getArgumentTypes(),
       isStatic,
       getKeyTransformers(ownerClass, method));
 }
  private static void generateResolvableCtor(
      Type ownerType,
      Type resolvableType,
      Type[] arguments,
      Type[] genericArguments,
      MxConstructorGenerator ctor,
      boolean isStatic,
      TransformGenerator[] tg,
      Type[] stored) {
    ctor.callSuper();

    if (tg != null) {
      int contextLocal = ctor.newLocal(CACHE_CONTEXT_TYPE);

      ctor.invokeStatic(
          Type.getType(CacheFactory.class),
          new Method("getDefaultContext", CACHE_CONTEXT_TYPE, EMPTY_TYPES));
      ctor.storeLocal(contextLocal);

      int index = 0;
      for (TransformGenerator generator : tg) {
        generator.generateAcquire(resolvableType, index, ctor, contextLocal);
        index += generator.getFieldCount();
      }
    }

    if (!isStatic) {
      ctor.loadThis();
      ctor.loadArg(0);
      ctor.putField(resolvableType, OWNER_FIELD_NAME, ownerType);
    }
    int index = 0;
    for (int i = 0; i < arguments.length; i++) {
      ctor.loadThis();
      ctor.loadArg(isStatic ? i : i + 1);
      if (!genericArguments[i].equals(arguments[i])) {
        ctor.checkCast(genericArguments[i]);
      }
      if (tg != null) {
        tg[i].generateForward(resolvableType, index, ctor);
        index += tg[i].getFieldCount();
      }
      ctor.putField(resolvableType, "arg" + i, stored[i]);
    }
    ctor.returnValue();
    ctor.endMethod();
  }
 public static String getResolvableName(int id, Type ownerType) {
   return ownerType.getInternalName() + "$Resolvable" + id;
 }