return new Accessors(owningClass, propertyName, getters, superclassSetters);
                }
            }
            return null;
        }

        private Accessors(JavaClass owningClass, String propertyName, Set<JavaMethod> getters, Set<JavaMethod> setters) {
            this.getters = getters;
            this.setters = setters;
            this.owningClass = owningClass;

                setters.put(property, method.getParameterTypes()[0]);
            } else {
                throwParameterValidationError(clazz, String.format("Method %s is neither a setter nor a getter.", method.getName()));
            }
        }

        if (setters.size() != getters.size()) {
            throwParameterValidationError(clazz, "It contains a different number of getters and setters.");
        }

        return setters.getValues();
    }

    @Nullable
    @Override
    public Field getBackingField() {
        return field;
    }

    void addGetter(Method method) {
        getters.add(method);
    }

    void addSetter(Method method) {
        setters.add(method);
    }

    void field(Field field) {
        if (!getters.isEmpty()) {
            this.field = field;

            apply type: RulePlugin
        '''

        then:
        fails 'tasks'

        and:
        failure.assertHasCause("Calling setters of a managed type on itself is not allowed")
    }

    def "calling setters of super class from non-abstract getters is not allowed"() {
        when:
        defineCallsSetterInNonAbstractGetterClass()
        buildFile << '''
            @Managed

        when:
        ToolingParameterProxy.validateParameter(InvalidParameter2)

        then:
        IllegalArgumentException e = thrown()
        e.message == "org.gradle.tooling.internal.consumer.connection.ToolingParameterProxyTest\$InvalidParameter2 is not a valid parameter type. Method setValue is neither a setter nor a getter."
    }

    def "returns parameter invalid when setter and getter have different types"() {

import org.jetbrains.kotlin.analysis.api.symbols.KaValueParameterSymbol
import org.jetbrains.kotlin.analysis.api.types.KaSubstitutor

/**
 * A signature of a function-like symbol. This includes functions, getters, setters, lambdas, etc.
 */
public abstract class KaFunctionLikeSignature<out S : KaFunctionLikeSymbol> : KaCallableSignature<S>() {
    /**
     * The use-site-substituted value parameters.
     */

// tag::tar[]
tasks.register<Tar>("tar") {
    from("src/dist")
    into("libs") {
        from(configurations.runtimeClasspath)
    }
}
// end::tar[]

// TODO why can't we use properties instead of setters here?
// when using them, we get "Cannot access 'preserveFileTimestamps': it is private in 'AbstractArchiveTask'"
// tag::reproducible[]
tasks.withType<AbstractArchiveTask>().configureEach {
    isPreserveFileTimestamps = false

    }

    private static String getMessage(String propertyName) {
        return String.format(
            "unmanaged property '%s' cannot be read only, unmanaged properties must have setters",
            propertyName);
    }

to the float64 argument f. More flexibility is provided with explicit
setters, for instance:

	var z1 Int
	z1.SetUint64(123)                 // z1 := 123
	z2 := new(Rat).SetFloat64(1.25)   // z2 := 5/4
	z3 := new(Float).SetInt(z1)       // z3 := 123.0

Setters, numeric operations and predicates are represented as methods of
the form:

	func (z *T) SetV(v V) *T          // z = v

import java.lang.annotation.*;

/**
 * <p>Marks a property as specifying an output directory for a task.</p>
 *
 * <p>This annotation should be attached to the getter method in Java or the property in Groovy.
 * Annotations on setters or just the field in Java are ignored.</p>
 *
 * <p>The directory will be created before the task is executed if it does not exist already.</p>
 *