assertThat(compilation).generatedSourceFile("${GENERATED_CLASSES_PACKAGE_NAME}.Task_Adapter")
    }

    def "should fail if @ReplacesEagerProperty is not a simple getter"() {
        given:
        def givenSource = source """
            package org.gradle.test;

            import org.gradle.api.provider.Property;

import java.lang.annotation.Target;

/**
 * <p>Marks a property as specifying a file or directory that a task destroys.
 * The file or directory belongs to another task.</p>
 *
 * <p>This annotation should be attached to the getter method or the field for the property.</p>
 *
 * <p>This will cause the task to have exclusive access to this file or directory while running.  This means

        when:
        def unpackedValue = getter(property, getter, someOtherValue())

        then:
        unpackedValue == someValue()
        1 * sideEffect.execute(someValue())
        0 * _

        where:
        setter  | getter
        "set"   | "get"
        "set"   | "getOrNull"
        "set"   | "getOrElse"

            return Collections.singletonList(new InvalidRequest(String.format("Method '%s.%s' annotated with @ReplacesEagerProperty should be a simple getter: name should start with 'get' and method should not have any parameters.", method.getEnclosingElement(), method)));
        }

        try {
            AnnotationMirror annotationMirror = annotation.get();

import java.util.LinkedList;
import java.util.List;

import static org.gradle.internal.concurrent.CompositeStoppable.stoppable;
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;

	// Ignored if Namespaces is non-empty. Defaults to 1.
	NamespaceCount int

	// Namespaces is the user-provided list of echo namespaces. If empty, NamespaceCount
	// namespaces will be generated.
	Namespaces []namespace.Getter

	// NoExternalNamespace if true, no external namespace will be generated and no external echo
	// instance will be deployed. Ignored if ExternalNamespace is non-nil.
	NoExternalNamespace bool

        0 * _

        when:
        unpackedValue = getter(property, getter, ["yet another key": "yet another value"])
        then:
        unpackedValue == expectedUnpackedValue
        1 * sideEffect1.execute("some value")
        then: // ensure ordering
        1 * sideEffect2.execute("other value")
        0 * _

        where:
        getter      | _
        "get"       | _
        "getOrNull" | _

        else -> false
    }


val KCallable<*>.annotationsWithGetters: List<Annotation>
    get() = this.annotations + if (this is KProperty) this.getter.annotations else emptyList()


fun KType.toDataTypeRefOrError() =
    toDataTypeRef() ?: error("failed to convert type $this to data type")


private
fun KType.toDataTypeRef(): DataTypeRef? = when {

        failure.assertHasCause("Cannot have abstract method Thing.getProp().")
    }

    def "services are injected into instances using constructor or getter"() {
        buildFile """
            class Thing1 {
                final Property<String> name

                @javax.inject.Inject

        return new NamedMemberScope(CallType.METHOD, methodName);
    }

    /**
     * The returned scope includes reads of all properties named {@code propertyName}.
     * This scope doesn't include calls to the getter method corresponding to this property,
     * use additional explicit {@link #methodsNamed(String)} scope to intercept that.
     *
     * @param propertyName the name of the property to intercept reads of