private final List<Task> tasks;

    private final boolean aggregating;

    public TaskSegment(boolean aggregating) {
        this.aggregating = aggregating;
        tasks = new ArrayList<>();
    }

    public TaskSegment(boolean aggregating, Task... tasks) {
        this.aggregating = aggregating;
        this.tasks = new ArrayList<>(Arrays.asList(tasks));
    }

    @Override

        private final Set<String> resolve;

        private boolean aggregating;

        private final int hashCode;

        public CacheKey(
                MavenProject project,
                List<RemoteRepository> repositories,
                Collection<String> scopesToCollect,
                Collection<String> scopesToResolve,
                boolean aggregating,
                RepositorySystemSession session) {

/**
 * The strategy used for aggregating annotation processors.
 * @see AggregatingProcessor
 */
class AggregatingProcessingStrategy extends IncrementalProcessingStrategy {

    AggregatingProcessingStrategy(AnnotationProcessorResult result) {
        super(result);
        result.setType(AGGREGATING);
    }

    @Override

        given:
        def jar = tmpDir.file("classes.jar")
        jar << JarUtils.jarWithContents(
            (PROCESSOR_DECLARATION): "InJar",
            (INCREMENTAL_PROCESSOR_DECLARATION): "InJar,AGGREGATING,Foo,Bar,Baz"
        )
        def dir = tmpDir.file("classes")
        dir.file(PROCESSOR_DECLARATION) << "InDir"
        dir.file(INCREMENTAL_PROCESSOR_DECLARATION) << "InDir,ISOLATING,Foo,Bar,Baz"

        boolean aggregating = false;

        Set<Artifact> reactorArtifacts = new HashSet<>(3);
        for (MavenProject reactorProject : session.getProjects()) {
            reactorProject.setArtifactFilter(artifact -> true);
            resolver.resolveProjectDependencies(
                    reactorProject, scopesToCollect, scopesToResolve, session, aggregating, reactorArtifacts);

            MavenSession session,
            boolean aggregating,
            Set<Artifact> projectArtifacts)
            throws LifecycleExecutionException {

        Set<Artifact> resolvedArtifacts = resolveProjectArtifacts(
                project, scopesToCollect, scopesToResolve, session, aggregating, projectArtifacts);

        !file("build/classes/java/main/A.txt").exists()
    }

    def "an isolating processor is also a valid aggregating processor"() {
        given:
        withProcessor(new HelperProcessorFixture().withDeclaredType(IncrementalAnnotationProcessorType.AGGREGATING))
        java "@Helper class A {}"

        expect:
        succeeds "compileJava"
    }

    }

    // tag::options-of-dynamic-processor[]
    @Override
    public Set<String> getSupportedOptions() {
        return Collections.singleton("org.gradle.annotation.processing.aggregating");
    }
    // end::options-of-dynamic-processor[]

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

import javax.annotation.processing.ProcessingEnvironment
import javax.annotation.processing.Processor

import static org.gradle.api.internal.tasks.compile.incremental.processing.IncrementalAnnotationProcessorType.AGGREGATING
import static org.gradle.api.internal.tasks.compile.incremental.processing.IncrementalAnnotationProcessorType.ISOLATING

        for (String task : tasks) {
            if (aggr.equals(task)) {
                boolean aggregating = true;

                if (currentSegment == null || currentSegment.isAggregating() != aggregating) {
                    currentSegment = new TaskSegment(aggregating);
                    taskSegments.add(currentSegment);
                }