*/
    public void setCompiler(org.gradle.language.base.internal.compile.Compiler<ScalaJavaJointCompileSpec> compiler) {
        this.compiler = compiler;
    }

    @Override
    protected org.gradle.language.base.internal.compile.Compiler<ScalaJavaJointCompileSpec> getCompiler(ScalaJavaJointCompileSpec spec) {
        assertScalaClasspathIsNonEmpty();
        if (compiler == null) {

        PlatformToolProvider toolProvider = toolChain.select(targetPlatform);
        Compiler<? extends NativeCompileSpec> compiler = toolProvider.newCompiler(createCompileSpec().getClass());
        if (!(compiler instanceof VersionAwareCompiler)) {
            return null;
        }
        return ((VersionAwareCompiler) compiler).getVersion();
    }

 */
public class CleaningJavaCompiler<T extends JavaCompileSpec> implements Compiler<T> {
    private final Compiler<T> compiler;
    private final TaskOutputsInternal taskOutputs;
    private final Deleter deleter;

    public CleaningJavaCompiler(Compiler<T> compiler, TaskOutputsInternal taskOutputs, Deleter deleter) {
        this.compiler = compiler;
        this.taskOutputs = taskOutputs;

        expect:
        def compiler = factory.create(TestForkingJavaCompileSpec)
        compiler instanceof ModuleApplicationNameWritingCompiler
        compiler.delegate instanceof AnnotationProcessorDiscoveringCompiler
        compiler.delegate.delegate instanceof NormalizingJavaCompiler
        compiler.delegate.delegate.delegate instanceof DaemonJavaCompiler

        }
        return javaHomeBasedJavaCompilerFactory;
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T extends CompileSpec> Compiler<T> create(Class<T> type) {
        Compiler<T> result = createTargetCompiler(type);

 */

package org.gradle.language.base.internal.compile;

import org.gradle.api.tasks.WorkResult;
import org.gradle.language.base.compile.CompilerVersion;

public class VersionAwareCompiler<T extends CompileSpec> implements Compiler<T> {

    private final CompilerVersion compilerVersion;
    private final Compiler<T> compiler;

    public VersionAwareCompiler(Compiler<T> compiler, CompilerVersion version) {

/**
 * A Java {@link Compiler} which does some normalization of the compile configuration and behaviour before delegating to some other compiler.
 */
public class NormalizingJavaCompiler implements Compiler<JavaCompileSpec> {
    private static final Logger LOGGER = Logging.getLogger(NormalizingJavaCompiler.class);
    private final Compiler<JavaCompileSpec> delegate;

public class IncrementalSwiftCompiler implements Compiler<SwiftCompileSpec> {
    private final Compiler<SwiftCompileSpec> compiler;
    private final TaskOutputsInternal outputs;
    private final CompilerOutputFileNamingSchemeFactory compilerOutputFileNamingSchemeFactory;
    private final Deleter deleter;

    public IncrementalSwiftCompiler(
        Compiler<SwiftCompileSpec> compiler,
        TaskOutputsInternal outputs,

import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.util.internal.CollectionUtils;

import java.io.File;
import java.util.List;

/**
 * A Scala {@link Compiler} which does some normalization of the compile configuration and behaviour before delegating to some other compiler.
 */
public class NormalizingScalaCompiler implements Compiler<ScalaJavaJointCompileSpec> {

 */

package org.gradle.api.internal.tasks.compile

import org.gradle.api.InvalidUserDataException
import org.gradle.api.internal.tasks.compile.incremental.processing.IncrementalAnnotationProcessorType
import org.gradle.api.internal.tasks.compile.processing.AnnotationProcessorDeclaration
import org.gradle.api.internal.tasks.compile.processing.AnnotationProcessorDetector
import org.gradle.api.tasks.compile.CompileOptions