get() = withValidityAssertion { descriptor.setter != null }

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

            val setter = descriptor.setter ?: return KaFe10DescDefaultPropertySetterSymbol(descriptor, analysisContext)
            KaFe10DescPropertySetterSymbol(setter, analysisContext)
        }

    override fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): WriteResolution {
        val setter = (findKotlinProperty(receiverClass, name) as? KMutableProperty<*>)?.let(::kotlinPropertySetter)
            ?: findKotlinFunctionSetter(receiverClass, name)
            ?: findJavaSetter(receiverClass, name)

        return setter?.let(::ResolvedWrite) ?: UnresolvedWrite
    }

    private

            addSetterForProperty(property, setter);
        }

        private void addSetterForProperty(PropertyMetadata property, Method setter) {
            // GENERATE public void <setter>(<type> value) { <field> == value }
            Type fieldType = getType(property.getType());

        get() = withValidityAssertion { analysisSession.symbolInfoProvider.getGetterDeprecation(this) }

    /**
     * Gets the deprecation status of the setter of this property symbol. Returns null if the setter it not deprecated or the property does
     * not have a setter.
     */
    public val KaPropertySymbol.setterDeprecationStatus: DeprecationInfo?

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

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

            error(methodShouldNotBeAnnotatedConfig { type('MyTask').kind('setter').method('setWriteOnly').annotation('Input') }, 'validation_problems', 'ignored_annotations_on_method'),

                    break;
                case SETTER:
                    if (!hasVoidReturnType(method.getMethod())) {
                        problems.add(method, "property accessor", "setter method must have void return type");
                    }
                    if (!takesSingleParameter(method.getMethod())) {
                        problems.add(method, "property accessor", "setter method must take exactly one parameter");

        PropertyAccessorType.of(DeviantBean.class.getMethod("isidore")) == PropertyAccessorType.IS_GETTER
        PropertyAccessorType.fromName('settings') == PropertyAccessorType.SETTER
        PropertyAccessorType.of(DeviantBean.class.getMethod("settings", String)) == PropertyAccessorType.SETTER
    }

    def "deviant bean properties are considered as such by Java"() {
        expect:

     * The parameter type must conform to the following rules:
     * <ul>
     *     <li>It must be an interface.</li>
     *     <li>It must contain only getter-like and setter-like methods.</li>
     *     <li>There must be one getter corresponding to exactly one setter, with matching value types.</li>
     * </ul>
     * <p>
     * For each getter-like method:
     * <ul>