this.delegate = delegate;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Class<?> realReturnType = method.getReturnType();
            Class<?> boxedReturnType = realReturnType;
            if (!realReturnType.equals(void.class) && realReturnType.isPrimitive()) {

            throw new Failure("Expected @" + ParameterKind.Receiver.class.getSimpleName() + " first parameter in @" + CallableKind.AfterConstructor.class.getSimpleName());
        }
        if (!Type.getReturnType(implementationDescriptor).equals(Type.VOID_TYPE)) {
            throw new Failure("@" + CallableKind.AfterConstructor.class.getSimpleName() + " handlers can only return void");
        }

                CallableInfo intercepted = request.getInterceptedCallable();
                Type returnType = intercepted.getReturnType().getType();
                Type[] parameterTypes = intercepted.getParameters().stream()
                    .map(ParameterInfo::getParameterType)
                    .toArray(Type[]::new);

        return new WeaklyTypeReferencingMethod<T, R>(target, returnType, method);
    }

    public ModelType<T> getDeclaringType() {
        return declaringType;
    }

    public ModelType<R> getReturnType() {
        return returnType;
    }

    public String getName() {
        return name;
    }

    public int getModifiers() {
        return modifiers;
    }

                problems.add("More than one method is annotated with @" + Mutate.class.getName());
            }

            for (Method ruleMethod : mutateMethods) {
                if (ruleMethod.getReturnType() != Void.TYPE) {
                    problems.add(ruleMethod, "A rule method must return void");
                }
                Type[] parameterTypes = ruleMethod.getGenericParameterTypes();

    List<Method> result = Lists.newArrayList();
    for (Method method : testClass.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers())
          && method.getReturnType() == void.class
          && method.getParameterTypes().length == 0
          && method.getName().startsWith("test")) {
        result.add(method);
      }
    }
    return ImmutableList.copyOf(result);
  }

    private static boolean isOldBooleanGetterOfUpgradedProperty(JApiMethod jApiMethod, Map<AccessorKey, ReplacedAccessor> upgradedMethods) {
        return isOldMethod(jApiMethod, upgradedMethods, BOOLEAN_GETTER_REGEX) && jApiMethod.getReturnType().getOldReturnType().equals("boolean");
    }

    private static boolean isOldMethod(JApiMethod jApiMethod, Map<AccessorKey, ReplacedAccessor> upgradedMethods, Pattern pattern) {

            }
            return super.getNativeParameterTypes();
        }

        @Override
        public Class<?> getReturnType() {
            if (original != null) {
                return original.getReturnType();
            }
            return Object.class;
        }

        @Override
        public CachedClass getDeclaringClass() {

        OptionValues optionValues = method.getAnnotation(OptionValues.class);
        if (optionValues == null) {
            return null;
        }
        if (Collection.class.isAssignableFrom(method.getReturnType())
            && method.getParameterTypes().length == 0
            && !Modifier.isStatic(method.getModifiers())) {
            return JavaMethod.of(Collection.class, method);
        } else {

            result.addStatement("$T.$L($L)", implementationOwner, implementationName, interceptorArgs);
            result.addStatement("return result");
        } else if (request.getInterceptedCallable().getReturnType().getType().equals(Type.VOID_TYPE)) {
            result.addStatement("$T.$L($L)", implementationOwner, implementationName, argsCode);
            result.addStatement("return null");
        } else {