dependencies {
    implementation(localGroovy())
}

// tag::groovy-compilation-avoidance[]
val astTransformation by configurations.creating
dependencies {
    astTransformation(project(":ast-transformation"))
}
tasks.withType<GroovyCompile>().configureEach {
    astTransformationClasspath.from(astTransformation)
}

            @org.codehaus.groovy.transform.GroovyASTTransformationClass("MyASTTransformation")
            public @interface MyAnnotation {}
        """
    }

    def 'always recompile if compilation avoidance is not enabled'() {
        given:
        settingsFile.text = settingsFile.text.readLines().findAll { !it.contains("enableFeaturePreview") }.join('\n')
        buildFile << """
            project(':b') {

        then:
        configurationCache.assertStateStored()
        outputContains("Groovy compilation avoidance is an incubating feature")

        when:
        configurationCacheRun("compileGroovy", "--rerun-tasks")

        then:
        configurationCache.assertStateLoaded()
        outputContains("Groovy compilation avoidance is an incubating feature")
    }

dependencies {
    implementation localGroovy()
}

// tag::groovy-compilation-avoidance[]
configurations { astTransformation }
dependencies {
    astTransformation(project(":ast-transformation"))
}
tasks.withType(GroovyCompile).configureEach {
    astTransformationClasspath.from(configurations.astTransformation)
}

        configureProjectAndExpectCompileAvoidanceWarnings().assertBuildScriptCompiled().assertOutputContains("foo")
            .assertContainsCompileAvoidanceWarning("buildSrc.jar: class com/example/FooKt: inline fun foo(): compile avoidance is not supported with public inline functions")

        givenKotlinScriptInBuildSrcContains(
            "Foo",
            """
            inline fun foo() {
                println("bar")
            }

rootProject.name = 'compilation-avoidance'
include("ast-transformation")
include("ast-transformation-consumer")

rootProject.name = "compilation-avoidance"
include("ast-transformation")
include("ast-transformation-consumer")

    private
    val compileAvoidanceWarnings = output.lines()
        .filter { it.startsWith("Cannot use Kotlin build script compile avoidance with") }
        // filter out avoidance warnings for versioned jars - those come from Kotlin/libraries that don't change when code under test changes
        .filterNot { it.contains(Regex("\\d.jar: ")) }

    init {

[[annotation_processors]]
=== Annotation processors

Compile avoidance works out of the box.
There is one caveat though: when using annotation processors, Gradle uses the annotation processor classpath as an input.

class TaskAvoidancePerformanceTest extends AbstractCrossBuildPerformanceTest {

    def "help with lazy and eager tasks"() {
        given:
        runner.testGroup = "configuration avoidance"
        runner.buildSpec {
            displayName("lazy")
            invocation {
                tasksToRun("help")
            }
        }
        runner.baseline {
            displayName("eager")