*/
    public static <T, R> JavaMethod<T, R> of(Class<R> returnType, Method method) throws NoSuchMethodException {
        return new JavaMethod<T, R>(returnType, method);
    }

    public JavaMethod(Class<T> target, Class<R> returnType, String name, boolean allowStatic, Class<?>... paramTypes) {
        this(returnType, findMethod(target, name, allowStatic, paramTypes));
    }

            }
        }
        return option;
    }

    private static List<JavaMethod<Object, Collection>> loadValueMethodForOption(Class<?> declaredClass) {
        List<JavaMethod<Object, Collection>> methods = new ArrayList<JavaMethod<Object, Collection>>();
        for (Class<?> type = declaredClass; type != Object.class && type != null; type = type.getSuperclass()) {

    }

    static ArchCondition<JavaMethod> useJavaxAnnotationNullable() {
        return new ArchCondition<JavaMethod>("use javax.annotation.Nullable") {
            @Override
            public void check(JavaMethod method, ConditionEvents events) {
                // Check if method return type is annotated with the wrong Nullable

        };
    }

    private static Map<String, List<Accessor>> findAccessors(Set<JavaMethod> methods) {
        return methods.stream().map(Accessor::from).filter(Objects::nonNull).collect(groupingBy(Accessor::getPropertyName));
    }

    private static class Accessor {
        private final PropertyAccessorType accessorType;
        private final JavaMethod method;
        private final boolean isGetter;

        @Nullable

        expect:
        JavaMethod.ofStatic(myProperties.class, Void, "setStaticProperty", String.class).isStatic()
        JavaMethod.ofStatic(myProperties.class, String, "getStaticProperty").isStatic()
        !JavaMethod.of(myProperties.class, String, "getMyProperty").isStatic()
    }

    def "call failing methods reflectively"() {
        when:
        JavaMethod.of(myProperties.class, Void, "throwsException").invoke(myProperties)

        then:

import org.gradle.internal.reflect.JavaMethod;

import javax.annotation.Nullable;
import java.lang.reflect.Method;

class ReflectionBasedServiceMethod extends AbstractServiceMethod {
    private final JavaMethod<Object, Object> javaMethod;

    ReflectionBasedServiceMethod(Method target) {
        super(target);
        javaMethod = JavaMethod.of(Object.class, target);
    }

    @Override

        }

        @Override
        public void check(JavaMethod javaMethod, ConditionEvents events) {
            boolean hasSetter = hasSetter(javaMethod);
            Class<?> expectedReturnType = hasSetter ? mutableType : immutableType;
            boolean satisfied = javaMethod.getRawReturnType().isAssignableTo(expectedReturnType);

        }
    }

    protected Object invokeMethod(Object object, Method method, Object... parameterValues) {
        final JavaMethod<Object, Object> javaMethod = JavaMethod.of(Object.class, method);
        return javaMethod.invoke(object, parameterValues);
    }

    @Override
    public String getOptionName() {
        return optionName;
    }

    @Override

            if (inputDirectory != null) {
                JavaMethod.of(backedObject, Void.class, "setInputDirectory", String.class).invoke(backedObject, inputDirectory.getAbsolutePath());
                JavaMethod.of(backedObject, Void.class, "setForceRelativeOutput", boolean.class).invoke(backedObject, true);
            }

import org.gradle.api.provider.HasMultipleValues;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.options.Option;
import org.gradle.internal.Cast;
import org.gradle.internal.reflect.JavaMethod;
import org.gradle.model.internal.type.ModelType;

import java.io.File;
import java.lang.reflect.Method;
import java.lang.reflect.Type;

public class MethodOptionElement {