spec.setGroovyCompileOptions(new MinimalGroovyCompileOptions(groovyCompileOptions));
        spec.getCompileOptions().setSupportsCompilerApi(true);
        if (getOptions().isIncremental()) {
            validateIncrementalCompilationOptions(sourceRoots, spec.annotationProcessingConfigured());
            spec.getCompileOptions().setPreviousCompilationDataFile(getPreviousCompilationData());
        }

    }

    @Override
    public WorkResult execute(T spec) {
        ImmutableSet.Builder<File> outputDirs = ImmutableSet.builderWithExpectedSize(3);
        MinimalJavaCompileOptions compileOptions = spec.getCompileOptions();
        addDirectoryIfNotNull(outputDirs, spec.getDestinationDir());
        addDirectoryIfNotNull(outputDirs, compileOptions.getAnnotationProcessorGeneratedSourcesDirectory());

namespace {
using XlaDeviceCompiler =
    DeviceCompiler<xla::LocalExecutable, xla::LocalClient>;
using PjRtDeviceCompiler =
    DeviceCompiler<xla::PjRtLoadedExecutable, xla::PjRtClient>;

XlaCompiler::CompileOptions GetCompileOptions(bool for_pjrt = false) {
  XlaCompiler::CompileOptions compile_options;
  compile_options.is_entry_computation = true;
  // Optimization: where possible, have the computation return a naked array

    public void setGroovyClasspath(List<File> groovyClasspath) {
        this.groovyClasspath = groovyClasspath;
    }

    @Override
    public boolean incrementalCompilationEnabled() {
        return getCompileOptions().getPreviousCompilationDataFile() != null;
    }

        Map<String, AnnotationProcessorDeclaration> declarations = annotationProcessorDetector.detectProcessors(spec.getAnnotationProcessorPath());
        List<String> compilerArgs = spec.getCompileOptions().getCompilerArgs();
        int processorIndex = compilerArgs.lastIndexOf("-processor");
        if (processorIndex == -1) {
            return Sets.newLinkedHashSet(declarations.values());
        }

        this.delegate = delegate;
    }

    @Override
    public WorkResult execute(T spec) {
        WorkResult result = delegate.execute(spec);
        String mainClass = spec.getCompileOptions().getJavaModuleMainClass();
        if (mainClass != null) {
            File moduleInfo = new File(spec.getDestinationDir(), "module-info.class");
            if (moduleInfo.exists()) {

                            sourcepathBuilder.add(stubDir);
                            if (spec.getCompileOptions().getSourcepath() != null) {
                                sourcepathBuilder.addAll(spec.getCompileOptions().getSourcepath());
                            }
                            spec.getCompileOptions().setSourcepath(sourcepathBuilder.build());
                        }

    private List<File> sourceRoots;
    private Set<String> classesToCompile = Collections.emptySet();
    private File backupDestinationDir;

    @Override
    public MinimalJavaCompileOptions getCompileOptions() {
        return compileOptions;
    }

    @Nullable
    @Override
    public File getClassBackupDir() {
        return backupDestinationDir;
    }

    @Override

        this.classesToCompile = spec.getClassesToCompile();
        this.destinationDir = spec.getDestinationDir();
        this.headerOutputDir = spec.getCompileOptions().getHeaderOutputDirectory();
        this.classBackupDir = spec.getClassBackupDir();
        this.shouldBackupFiles = classBackupDir != null;
        this.result = result;
        this.uniqueIndex = new AtomicLong();

            return rebuildAllCompiler.execute(spec);
        }
        File previousCompilationDataFile = Objects.requireNonNull(spec.getCompileOptions().getPreviousCompilationDataFile());
        if (!previousCompilationDataFile.exists()) {
            LOG.info("Full recompilation is required because no previous compilation result is available.");