}
    }

    private static class DependencyToAll extends DependentsSet {

        private final String reason;

        private DependencyToAll(String reason) {
            this.reason = Preconditions.checkNotNull(reason);
        }

        private DependencyToAll() {
            this(null);
        }

        @Override

        accumulator.addClass("c", hash, null, [], ["a"] as Set, IntSets.EMPTY_SET)

        expect:
        !accumulator.dependentsMap.a.dependencyToAll
        accumulator.dependentsMap.b.dependencyToAll
        !accumulator.dependentsMap.c.dependencyToAll
    }

    def "remembers if class declares non-private constants"() {
        // a -> b -> c

            assert read.dependents[it].accessibleDependentClasses == data.dependents[it].accessibleDependentClasses
            assert read.dependents[it].dependencyToAll == data.dependents[it].dependencyToAll
        }

        read.dependents["D"].dependencyToAll
        read.classesToConstants == [C: [1,2] as Set, D: [] as Set]
        read.fullRebuildCause == "Because"
    }

        deps.getAccessibleDependentClasses() == ["Bar", "FooBar", "BarFoo"] as Set
    }

    private static DependentsSet dependentSet(boolean dependencyToAll, Collection<String> privateClasses, Collection<String> accessibleClasses) {
        dependencyToAll ? DependentsSet.dependencyToAll("reason") : dependentClasses(privateClasses as Set, accessibleClasses as Set)
    }

        ClassSetAnalysis currentClasspath = getClasspath();
        ClassSetAnalysis previousClasspath = previous.getClasspath();
        if (previousClasspath == null) {
            return DependentsSet.dependencyToAll("classpath data of previous compilation is incomplete");
        }
        ClassSetAnalysis.ClassSetDiff classpathChanges = currentClasspath.findChangesSince(previousClasspath);

    public DependentsSet getChangedClassesSince(ClassSetAnalysisData other) {
        if (fullRebuildCause != null) {
            return DependentsSet.dependencyToAll(fullRebuildCause);
        }
        if (other.fullRebuildCause != null) {
            return DependentsSet.dependencyToAll(other.fullRebuildCause);
        }

        ImmutableSet.Builder<String> changed = ImmutableSet.builder();

        HierarchicalNameSerializer nameSerializer = hierarchicalNameSerializerSupplier.get();
        byte b = decoder.readByte();
        if (b == 0) {
            return DependentsSet.dependencyToAll(decoder.readString());
        }

        ImmutableSet.Builder<String> privateBuilder = ImmutableSet.builder();
        int count = decoder.readSmallInt();
        for (int i = 0; i < count; i++) {

            return DependentsSet.dependencyToAll(fullRebuildCause);
        }
        if (!compilerApiData.isSupportsConstantsMapping()) {
            for (Map.Entry<String, IntSet> changedConstantsOfClass : changedConstantsByClass.entrySet()) {
                if (!changedConstantsOfClass.getValue().isEmpty()) {

        }
        ImmutableMap.Builder<String, DependentsSet> builder = ImmutableMap.builder();
        for (Map.Entry<String, String> entry : dependenciesToAll.entrySet()) {
            builder.put(entry.getKey(), DependentsSet.dependencyToAll(entry.getValue()));
        }
        Set<String> collected = new HashSet<>();
        for (Map.Entry<String, Set<String>> entry : accessibleDependents.entrySet()) {
            if (collected.add(entry.getKey())) {

Class <org.gradle.api.internal.tasks.compile.incremental.compilerapi.deps.DependentsSet$DependencyToAll> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (DependentsSet.java:0)