private org.gradle.language.base.internal.compile.Compiler<ScalaJavaJointCompileSpec> compiler;

    @Nested
    @Override
    public ScalaCompileOptions getScalaCompileOptions() {
        return (ScalaCompileOptions) super.getScalaCompileOptions();
    }

    /**
     * Returns the classpath to use to load the Scala compiler.
     */
    @Classpath
    public FileCollection getScalaClasspath() {

        spec.getCompileOptions().setCompilerArgs(CollectionUtils.toStringList(spec.getCompileOptions().getCompilerArgs()));
    }

    private void logSourceFiles(ScalaJavaJointCompileSpec spec) {
        if (!spec.getScalaCompileOptions().isListFiles()) {
            return;
        }

        StringBuilder builder = new StringBuilder();
        builder.append("Source files to be compiled:");
        for (File file : spec.getSourceFiles()) {

import org.gradle.api.internal.tasks.compile.JvmLanguageCompileSpec;

import java.io.File;
import java.util.Map;

public interface ScalaCompileSpec extends JvmLanguageCompileSpec {
    MinimalScalaCompileOptions getScalaCompileOptions();

    Iterable<File> getScalaCompilerPlugins();

    void setScalaCompilerPlugins(Iterable<File> plugins);

    File getClassfileBackupDir();

    void setClassfileBackupDir(File classfileBackupDir);

        this.javaExecutable = javaExecutable;
    }

    @Override
    public File getJavaExecutable() {
        return javaExecutable;
    }

    @Override
    public MinimalScalaCompileOptions getScalaCompileOptions() {
        return options;
    }

    @Override
    public File getAnalysisFile() {
        return analysisFile;
    }

    @Override
    public void setAnalysisFile(File analysisFile) {

        File analysisFile = spec.getAnalysisFile();
        Optional<AnalysisStore> analysisStore;
        Optional<ClassFileManagerType> classFileManagerType;
        if (spec.getScalaCompileOptions().isForce()) {
            analysisStore = Optional.empty();
            classFileManagerType = IncOptions.defaultClassFileManagerType();
        } else {

public class ZincScalaCompilerArgumentsGenerator {
    public List<String> generate(ScalaCompileSpec spec) {
        List<String> result = new ArrayList<>();

        MinimalScalaCompileOptions options = spec.getScalaCompileOptions();
        addFlag("-deprecation", options.isDeprecation(), result);
        addFlag("-unchecked", options.isUnchecked(), result);
        addConcatenatedOption("-g:", options.getDebugLevel(), result);

    }

    /**
     * Returns the Scala compilation options.
     */
    @Nested
    public BaseScalaCompileOptions getScalaCompileOptions() {
        return scalaCompileOptions;
    }

    /**
     * Returns the Java compilation options.
     */
    @Nested
    @Override
    public CompileOptions getOptions() {

    protected DaemonForkOptions toDaemonForkOptions(T spec) {
        MinimalJavaCompilerDaemonForkOptions javaOptions = spec.getCompileOptions().getForkOptions();
        MinimalScalaCompileOptions compileOptions = spec.getScalaCompileOptions();
        MinimalScalaCompilerDaemonForkOptions forkOptions = compileOptions.getForkOptions();

        // cannot compute at task execution time because we need association with source set
        IncrementalCompileOptions incrementalOptions = scalaCompile.getScalaCompileOptions().getIncrementalOptions();
        incrementalOptions.getAnalysisFile().set(
            project.getLayout().getBuildDirectory().file("tmp/scala/compilerAnalysis/" + scalaCompile.getName() + ".analysis")
        );

Method <org.gradle.api.tasks.scala.ScalaCompile.getScalaCompileOptions()> does not have raw return type assignable to org.gradle.api.provider.Provider in (ScalaCompile.java:0)
Method <org.gradle.api.tasks.scala.ScalaCompile.getScalaCompileOptions()> does not have raw return type assignable to org.gradle.api.provider.Provider in (ScalaCompile.java:0)