for (Method method : type.getDeclaredMethods()) {
            classDetails.method(method);

            if (Modifier.isPrivate(method.getModifiers()) || Modifier.isStatic(method.getModifiers())) {
                continue;
            }

            PropertyAccessorType accessorType = PropertyAccessorType.of(method);

import org.gradle.internal.Factory;
import org.gradle.model.internal.method.WeaklyTypeReferencingMethod;

import java.lang.reflect.Modifier;

class DefaultModelRuleInvoker<I, R> implements ModelRuleInvoker<R> {
    private final WeaklyTypeReferencingMethod<I, R> method;
    private final Factory<? extends I> factory;

    DefaultModelRuleInvoker(WeaklyTypeReferencingMethod<I, R> method, Factory<? extends I> factory) {
        this.method = method;

    }

    /**
     * Do not use this method, it will always return {@code false}.
     * @deprecated This class is scheduled for removal in a future version, this method <strong>should not be used</strong>.
     */
    @Input
    @Deprecated
    public boolean isUploadDescriptor() {
        return false;
    }

    /**
     * Do not use this method, it does nothing.

        problems.add(field, problem);
    }

    @Override
    public void add(Method method, String problem) {
        problems.add(method, problem);
    }

    @Override
    public void add(Method method, String role, String problem) {
        problems.add(method, role, problem);
    }

    @Override
    public void add(Constructor<?> constructor, String problem) {

            assertHasAccepted(
                "Method com.example.Task.getSourceCompatibility(): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method return type has changed", "Method is now abstract"),
                "Method com.example.Task.setSourceCompatibility(java.lang.String): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method has been removed")
            )
        }
    }

                    break;
            }
        }
        if (method == null) {
            return;
        }

        throw new IllegalStateException(format(method));
    }

    private String format(String method) {
        return String.format("Cannot call %s on %s after task has started execution.", method, task);
    }

                .collect(toList());

        List<Method> factoryMethods = Arrays.stream(cls.getDeclaredMethods())
                .filter(method -> method.getReturnType() == cls && Modifier.isStatic(method.getModifiers()))
                .collect(toList());
        List<Method> injectFactoryMethods = factoryMethods.stream()
                .filter(method -> method.isAnnotationPresent(Inject.class))
                .collect(toList());

     * @param method
     *            メソッド。{@literal null}であってはいけません
     */
    public MethodDescImpl(final BeanDesc beanDesc, final Method method) {
        assertArgumentNotNull("beanDesc", beanDesc);
        assertArgumentNotNull("method", method);

        this.beanDesc = beanDesc;
        this.method = method;
        methodName = method.getName();

    def "serializes a method invocation with parameters"() {
        def method = String.class.getMethod("substring", Integer.TYPE, Integer.TYPE)
        def invocation = new MethodInvocation(method, [1, 2] as Object[])

        when:
        def serialized = serialize(invocation)
        def result = deserialize(serialized)

        then:
        result.method == method
        result.arguments == [1, 2] as Object[]

    final Method method;

    MethodInvokable(Method method) {
      super(method);
      this.method = method;
    }

    @Override
    @CheckForNull
    final Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[] args)
        throws InvocationTargetException, IllegalAccessException {
      return method.invoke(receiver, args);
    }

    @Override