this.eventEmitter = eventEmitter;
    }

    @Override
    public Provider<JavaCompiler> compilerFor(Action<? super JavaToolchainSpec> config) {
        return compilerFor(configureToolchainSpec(config));
    }

    @Override
    public Provider<JavaCompiler> compilerFor(JavaToolchainSpec spec) {
        return queryService.findMatchingToolchain(spec)

plugins {
    id 'myproject.java-conventions'
    id 'java-library'
}

// tag::customToolchain[]
tasks.withType(JavaCompile).configureEach {
    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(8)
    }
}

task('testsOn17', type: Test) {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

     */
    Provider<JavaCompiler> compilerFor(Action<? super JavaToolchainSpec> config);

    /**
     * Obtain a {@link JavaCompiler} matching the {@link JavaToolchainSpec}.
     *
     * @param spec The {@code JavaToolchainSpec}
     * @return A {@code Provider<JavaCompiler>}
     */
    Provider<JavaCompiler> compilerFor(JavaToolchainSpec spec);

    /**

plugins {
    id("myproject.java-conventions")
    `java-library`
}

// tag::customToolchain[]
tasks.withType<JavaCompile>().configureEach {
    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(8)
    }
}

tasks.register<Test>("testsOn17") {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

// tag::java-home[]

tasks.anotherSampleTask {
    javaHome = launcher.map { it.metadata.installationPath }
}
// end::java-home[]


// tag::java-compiler[]
val compiler = javaToolchains.compilerFor {
    languageVersion = JavaLanguageVersion.of(11)
}

tasks.yetAnotherSampleTask {
    javaCompilerExecutable = compiler.map { it.executablePath }
}

// tag::java-home[]

tasks.named('anotherSampleTask') {
    javaHome = launcher.map { it.metadata.installationPath }
}
// end::java-home[]


// tag::java-compiler[]
def compiler = javaToolchains.compilerFor {
    languageVersion = JavaLanguageVersion.of(11)
}

tasks.named('yetAnotherSampleTask') {
    javaCompilerExecutable = compiler.map { it.executablePath }
}

            .provider(() -> JavaCompileExecutableUtils.getExecutableOverrideToolchainSpec(this, objectFactory))
            .flatMap(javaToolchainService::compilerFor)
            .orElse(javaToolchainService.compilerFor(it -> {}));
        javaCompiler = objectFactory.property(JavaCompiler.class).convention(javaCompilerConvention);
        javaCompiler.finalizeValueOnRead();

                ${taskSource != null ? "sourceCompatibility = '$taskSource'" : ""}
                ${taskRelease != null ? "options.release = $taskRelease" : ""}
                ${taskToolchain != null ? "javaCompiler = javaToolchains.compilerFor { languageVersion = JavaLanguageVersion.of($taskToolchain) }" : ""}
            }

            compileCustomJava.doLast {
                logger.lifecycle("task.sourceCompatibility = '\$sourceCompatibility'")

        buildFile << """
            apply plugin: "application"

            compileJava {
                javaCompiler = javaToolchains.compilerFor {
                    languageVersion = JavaLanguageVersion.of(${compileWithVersion.majorVersion})
                }
            }

            application {
                mainClass = "App"
            }

        buildFile << """
            compileJava {
                javaCompiler = javaToolchains.compilerFor {
                    languageVersion = JavaLanguageVersion.of(${jdkMetadata.languageVersion.majorVersion})
                }
            }

            compileTestJava {
                javaCompiler = javaToolchains.compilerFor {
                    languageVersion = JavaLanguageVersion.of(${jdkMetadata.languageVersion.majorVersion})