* limitations under the License.
 */

package org.gradle.api.provider;

/**
 * Marker interface for parameter objects to {@link ValueSource}s.
 *
 * <p>
 * Parameter types should be interfaces, only declaring getters for {@link org.gradle.api.provider.Property}-like objects.
 * </p>
 * <pre class='autoTested'>
 * public interface MyParameters extends ValueSourceParameters {
 *     Property&lt;String&gt; getStringParameter();
 * }

import org.gradle.work.DisableCachingByDefault;

import java.io.File;

import static org.gradle.internal.instrumentation.api.annotations.ReplacedAccessor.AccessorType.GETTER;
import static org.gradle.internal.instrumentation.api.annotations.ReplacedAccessor.AccessorType.SETTER;
import static org.gradle.internal.instrumentation.api.annotations.ReplacesEagerProperty.BinaryCompatibility.ACCESSORS_KEPT;

/**

     */
    List<Method> getAllMethods();

    /**
     * Returns the non-private instance methods of this class that are not property getter or setter methods.
     * Includes inherited methods.
     */
    Collection<Method> getInstanceMethods();

    /**
     * Returns all instance fields of this class. Includes inherited fields.
     */

        then:
        registry.realize("foo", NonNamedThing).name == null
    }

    @Managed
    static abstract class NonNamedThingNoSetter {
        abstract String getName()
    }

    def "name requires setter if not named"() {
        given:
        registry.registerWithInitializer("bar", NonNamedThingNoSetter, nodeInitializerRegistry)

        when:
        registry.realize("bar", NonNamedThingNoSetter)

        then:

        if (property.delegate == null) return emptyList()
        val getValueSymbol = (property.getter?.singleStatementOfType<FirReturnExpression>()?.result as? FirFunctionCall)?.getCalleeSymbol()
        val setValueSymbol = (property.setter?.singleStatementOfType<FirReturnExpression>()?.result as? FirFunctionCall)?.getCalleeSymbol()
        return listOfNotNull(

	// Sort keys for deterministic ordering
	for _, k := range slices.Sort(maps.Keys(conditions)) {
		cond := conditions[k]
		setter := kstatus.UpdateConditionIfChanged
		if cond.setOnce != "" {
			setter = func(conditions []metav1.Condition, condition metav1.Condition) []metav1.Condition {
				return kstatus.CreateCondition(conditions, condition, cond.setOnce)
			}
		}

package org.gradle.api.flow;

import org.gradle.api.Incubating;

/**
 * Marker interface for {@link FlowAction dataflow action} parameters.
 *
 * <p>
 * Parameter types should be interfaces, only declaring getters for {@link org.gradle.api.provider.Property}-like objects.
 * Example:
 * </p>
 * <pre>
 * public interface MyFlowParameters extends FlowParameters {
 *    Property&lt;String&gt; getString();

                        (methodShouldNotBeAnnotatedMessage {type('com.moowork.gradle.node.npm.NpmSetupTask').kind('setter').method('setArgs').annotation('Internal').includeLink()}): ERROR,
                        (missingAnnotationMessage { type('com.moowork.gradle.node.yarn.YarnSetupTask').property('args').missingInputOrOutput().includeLink() }): ERROR,

        }
    };

    private static final DescribedPredicate<JavaClass> injected_by_getter = new DescribedPredicate<JavaClass>("injected into getters via @Inject") {
        @Override
        public boolean test(JavaClass javaClass) {
            return javaClass
                .getMethodsWithReturnTypeOfSelf()
                .stream()

        analyseForTest(context) { declaration ->
            val propertySymbol = (declaration as KtProperty).getVariableSymbol() as KaPropertySymbol
            val setterSymbol = propertySymbol.setter!!
            val setterParameterSymbol = setterSymbol.valueParameters.single()
            testServices.assertions.assertEquals(propertySymbol, setterSymbol.getContainingSymbol())