compileOnly(project(":internal-instrumentation-api"))
    compileOnly(libs.asm)
    compileOnly(libs.asmUtil)
    compileOnly(libs.asmTree)
    annotationProcessor(project(":internal-instrumentation-processor"))
    annotationProcessor(platform(project(":distributions-dependencies")))
}

tasks.named<JavaCompile>("compileJava") {

    api(project(":internal-instrumentation-api"))
    implementation(project(":base-asm"))
    compileOnly(libs.asm)
    compileOnly(libs.asmUtil)
    compileOnly(libs.asmTree)
    annotationProcessor(project(":internal-instrumentation-processor"))
    annotationProcessor(platform(project(":distributions-dependencies")))
}

tasks.withType<JavaCompile>().configureEach {

        file('a/build.gradle') << '''
            configurations {
                annotationProcessor
            }
            dependencies {
                annotationProcessor project(':b')
            }
            compileJava {
                options.annotationProcessorPath = configurations.annotationProcessor
            }
        '''

        file('a/src/main/java/A.java') << '''

            </tr>
            <tr>
                <td>compileOnly</td>
            </tr>
            <tr>
                <td>runtimeOnly</td>
            </tr>
            <tr>
                <td>annotationProcessor</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

org.springframework:spring-core:5.0.5.RELEASE=compileClasspath, runtimeClasspath
org.springframework:spring-jcl:5.0.5.RELEASE=compileClasspath, runtimeClasspath

}

repositories {
    mavenCentral()
}

// tag::annotation-processing[]
dependencies {
    // The dagger compiler and its transitive dependencies will only be found on annotation processing classpath
    annotationProcessor("com.google.dagger:dagger-compiler:2.44")

    // And we still need the Dagger library on the compile classpath itself
    implementation("com.google.dagger:dagger:2.44")
}

 *     <li><code>runtimeOnly</code> dependencies are not available at compilation and are used only at runtime.</li>
 *     <li><code>annotationProcessor</code> dependencies are used only at compilation for the annotation processor classpath</li>
 * </ul>
 *

configurations {
    compileClasspath {
        resolutionStrategy.activateDependencyLocking()
    }
// end::locking-single[]
    runtimeClasspath {
        resolutionStrategy.activateDependencyLocking()
    }
    annotationProcessor {
        resolutionStrategy.activateDependencyLocking()
    }
// tag::locking-single[]
}
// end::locking-single[]

dependencies {
    implementation 'org.springframework:spring-beans:[5.0,6.0)'
}

            </tr>
            <tr>
                <td>annotationProcessorGeneratedSourcesDirectory</td>

plugins {
    id "java"
}

dependencies {
    compileOnly project(":library")
    annotationProcessor project(":processor")
}

compileJava {
    options.incremental = true