* An ignored field.
     */
    String ignoreMe1;

    /**
     * Another ignored field.
     */
    final long ignoreMe2 = 9;

    /**
     * Not a setter.
     */
    public void setIgnoreMe1() {
    }

    /**
     * Not a setter.
     */
    public void setIgnoreMe2(String a, int b) {
    }

    /**
     * A write-only property.
     */
    public void setWriteOnly(JavaInterface value) {

                return null
            }

            if (descriptor.hasJvmFieldAnnotation()) return descriptor.name

            val setter = descriptor.setter ?: return SpecialNames.NO_NAME_PROVIDED
            return Name.identifier(DescriptorUtils.getJvmName(setter) ?: JvmAbi.setterName(descriptor.name.asString()))
        }

        this.setter = setter;
        this.mapper = mapper;
        this.revMapper = revMapper;
    }

    @Override
    public T get(int index) {
        return mapper.apply(getter.get().get(index));
    }

    @Override
    public int size() {
        return getter.get().size();
    }

    @Override
    public boolean add(T t) {
        Objects.requireNonNull(t);
        if (setter != null) {

            PropertySetter setter = mutateUsingReturnValue(method);
            return AbstractOptionElement.of(optionName, option, setter, optionValueNotationParserFactory);
        }
        if (HasMultipleValues.class.isAssignableFrom(method.getReturnType())) {
            assertCanUseMethodReturnType(optionName, method);
            PropertySetter setter = mutateUsingReturnValue(method);

    private final PropertySetter setter;
    private final NotationParser<CharSequence, ?> notationParser;

    public SingleValueOptionElement(String optionName, Option option, Class<?> optionType, PropertySetter setter, OptionValueNotationParserFactory notationParserFactory) {
        super(optionName, option, String.class, setter.getDeclaringClass());
        this.setter = setter;

        }

    override val setter: KaPropertySetterSymbol?
        get() = withValidityAssertion {
            if (!psi.isVar) {
                return null
            }

            val setter = psi.setter ?: return KaFe10PsiDefaultPropertySetterSymbol(psi, analysisContext)
            return KaFe10PsiPropertySetterSymbol(setter, analysisContext)
        }

            apply type: RulePlugin
        '''

        then:
        fails "accessGenerativeName"

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

    def "non-abstract setters implemented as default interface methods are not allowed"() {
        when:
        file('buildSrc/src/main/java/Rules.java') << '''
            import org.gradle.api.*;

// license that can be found in the LICENSE file.

package main

func main() {
	check[string]()
}

func check[T any]() {
	var result setter[T]
	switch result.(type) {
	case fooA[T]:
	case fooB[T]:
	}
}

type setter[T any] interface {
	Set(T)
}

type fooA[T any] struct{}

func (fooA[T]) Set(T) {}

type fooB[T any] struct{}

        "normal setter"       | "call site" | "setTestString(String)"                       | { it.testString = "value" }          | false
        "boolean setter"      | "call site" | "setTestFlag(boolean)"                        | { it.testFlag = true }               | false

    @get:Deprecated("Deprecated getter")
    @set:Deprecated("Deprecated setter")
    var deprecatedProperty: Int = 0
        get() = field
        set(value) {
            field = value
        }

    @Deprecated("Deprecated function")
    fun deprecatedFunction() {

    }

    @get:Deprecated("Deprecated getter")
    @set:Deprecated("Deprecated setter")
    var deprecatedAccessors: Int = 1
        get() = field