}

    def "cannot attach @Inject annotation to non getter method"() {
        when:
        generator.generate(NonGetterInjectBean)

        then:
        def e = thrown(ClassGenerationException)
        e.cause.message == "Cannot use @Inject annotation on method NonGetterInjectBean.thing() as it is not a property getter."
    }

        get() = withValidityAssertion { descriptor.isExtension }

    override val getter: KaPropertyGetterSymbol
        get() = withValidityAssertion {
            val getter = descriptor.getter ?: return KaFe10DescDefaultPropertyGetterSymbol(descriptor, analysisContext)
            return KaFe10DescPropertyGetterSymbol(getter, analysisContext)
        }

    override val javaGetterSymbol: KaFunctionSymbol

                }
            }

            extensions.create("thing", Thing, "a", 12)
        """

        expect:
        succeeds()
    }

    def "can inject service using getter"() {
        buildFile """
            class Thing {
                Thing(String a) {
                }

                @Inject
                ObjectFactory getObjects() { }
            }

import org.gradle.workers.WorkerExecutor;

// tag::download[]
public abstract class Download extends DefaultTask {
    // Use an abstract getter method
    @Inject
    protected abstract ObjectFactory getObjectFactory();

    // Alternatively, use a getter method with a dummy implementation
    @Inject
    protected WorkerExecutor getWorkerExecutor() {
        // Method body is ignored

        get() = withValidityAssertion { descriptor.isExtension }

    override val getter: KaPropertyGetterSymbol
        get() = withValidityAssertion {
            val getter = descriptor.getter ?: return KaFe10DescDefaultPropertyGetterSymbol(descriptor, analysisContext)
            return KaFe10DescPropertyGetterSymbol(getter, analysisContext)
        }

    override val javaGetterSymbol: KaFunctionSymbol

}

type DefaultPolicyGetter struct {
	Getter rest.Getter
}

func (g *DefaultPolicyGetter) GetValidatingAdmissionPolicy(ctx context.Context, name string) (*admissionregistration.ValidatingAdmissionPolicy, error) {
	p, err := g.Getter.Get(ctx, name, &metav1.GetOptions{})
	if err != nil {
		return nil, err
	}

package main

import "os"

type S struct { i int }
func (p *S) Get() int { return p.i }

type Empty interface {
}

type Getter interface {
	Get() int;
}

func f1(p Empty) {
	switch x := p.(type) {
	default: println("failed to match interface", x); os.Exit(1);
	case Getter: break;
	}

}

func main() {
	var s S;
	f1(&s);

 * </ul>
 *
 *  Implementations can receive parameters by using annotated abstract getter methods.
 *  <ul>
 *      <li>An abstract getter annotated with {@link InputArtifact} will receive the input artifact location, which is the file or directory that the transform should be applied to.</li>
 *      <li>An abstract getter with {@link InputArtifactDependencies} will receive the dependencies of its input artifact.</li>

}

func NewLegacyValidator(lookup bool, getter ServiceAccountTokenGetter, secretsWriter typedv1core.SecretsGetter) (Validator, error) {
	if lookup && getter == nil {
		return nil, errors.New("ServiceAccountTokenGetter must be provided")
	}
	if lookup && secretsWriter == nil {
		return nil, errors.New("SecretsWriter must be provided")
	}
	return &legacyValidator{
		lookup:        lookup,
		getter:        getter,
		secretsWriter: secretsWriter,

 *
 * <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>Gradle will attempt to instantiate a nested bean on abstract getter methods annotated with this annotation.