import org.gradle.workers.internal.DefaultWorkResult;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ApiCompilerResult extends DefaultWorkResult {

    private final AnnotationProcessingResult annotationProcessingResult = new AnnotationProcessingResult();

            Map<String, Set<String>> previousSourceClassesMapping = previousCompilerApiData == null ? null : previousCompilerApiData.getSourceToClassMapping();
            if (result instanceof ApiCompilerResult) {
                ApiCompilerResult jdkJavaResult = (ApiCompilerResult) result;
                ConstantToDependentsMapping newConstantsToDependentsMapping = jdkJavaResult.getConstantsAnalysisResult()
                    .getConstantToDependentsMapping()

public class CompilationFailedException extends RuntimeException implements CompilationFailedIndicator {

    private final ApiCompilerResult compilerPartialResult;

    public CompilationFailedException() {
        this((ApiCompilerResult) null);
    }

    public CompilationFailedException(@Nullable ApiCompilerResult compilerPartialResult) {
        super("Compilation failed; see the compiler error output for details.");

    }

    @Override
    public WorkResult execute(JavaCompileSpec spec) {
        LOGGER.info("Compiling with JDK Java compiler API.");

        ApiCompilerResult result = new ApiCompilerResult();
        JavaCompiler.CompilationTask task;
        try {
            task = createCompileTask(spec, result);
        } catch (RuntimeException ex) {

                            if (javaCompilerResult instanceof ApiCompilerResult) {
                                copyJavaCompilerResult((ApiCompilerResult) javaCompilerResult);
                            }
                        } catch (CompilationFailedException e) {
                            Optional<ApiCompilerResult> partialResult = e.getCompilerPartialResult();

                return result;
            }

            private Result toBuildOperationResult(WorkResult result) {
                if (result instanceof ApiCompilerResult) {
                    AnnotationProcessingResult annotationProcessingResult = ((ApiCompilerResult) result).getAnnotationProcessingResult();
                    List<AnnotationProcessorDetails> details = new ArrayList<AnnotationProcessorDetails>();

    private void rollback(List<StashedFile> stashResult, @Nullable ApiCompilerResult compilerResult) {
        if (compilerResult != null) {
            deleteGeneratedFiles(compilerResult);
            rollbackOverwrittenFiles(compilerResult);
        }
        rollbackStashedFiles(stashResult);
    }

    private void deleteGeneratedFiles(ApiCompilerResult compilerResult) {

    private final File headerOutputDir;
    private final File classBackupDir;
    private final ApiCompilerResult result;
    private final AtomicLong uniqueIndex;
    private final boolean shouldBackupFiles;

    public CompilationClassBackupService(JavaCompileSpec spec, ApiCompilerResult result) {
        this.classesToCompile = spec.getClassesToCompile();
        this.destinationDir = spec.getDestinationDir();

 */

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

import com.google.common.collect.Iterables;
import org.gradle.api.internal.ClassPathRegistry;
import org.gradle.api.internal.tasks.compile.ApiCompilerResult;
import org.gradle.api.internal.tasks.compile.BaseForkOptionsConverter;
import org.gradle.api.internal.tasks.compile.GroovyJavaJointCompileSpec;

        listAllFiles(annotationGeneratedSourcesDir) == ["com/example/A.java", "com/example/B.java", "com/example/B.txt"]
    }

    ApiCompilerResult simulateGeneratingClassesAndResources(File destinationDir, File annotationGeneratedSourcesDir, File overwrittenFile) {
        def compilerResult = new ApiCompilerResult()
        compilerResult.annotationProcessingResult.generatedAggregatingTypes.addAll(["com.example.A"])