c := &node{
		identity:           n.identity,
		dependents:         make(map[*node]struct{}, len(n.dependents)),
		deletingDependents: n.deletingDependents,
		beingDeleted:       n.beingDeleted,
		virtual:            n.virtual,
		owners:             make([]metav1.OwnerReference, 0, len(n.owners)),
	}
	for dep := range n.dependents {
		c.dependents[dep] = struct{}{}
	}
	for _, owner := range n.owners {

            DependentsSet dependents = findDirectDependents(current);
            if (dependents.isDependencyToAll()) {
                return dependents;
            }
            dependentResources.addAll(dependents.getDependentResources());
            privateDependents.addAll(dependents.getPrivateDependentClasses());
            remaining.addAll(dependents.getAccessibleDependentClasses());
        }

    public static DependentsSet dependentClasses(Set<String> privateDependentClasses, Set<String> accessibleDependentClasses) {
        return dependents(privateDependentClasses, accessibleDependentClasses, Collections.emptySet());
    }

    public static DependentsSet dependents(Set<String> privateDependentClasses, Set<String> accessibleDependentClasses, Set<GeneratedResource> dependentResources) {

import org.gradle.platform.base.internal.BinaryNamingScheme;
import org.gradle.platform.base.internal.BinarySpecInternal;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolvedResult;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolver;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;

public class NativeComponents {

        def pullTaskOperation = pullFromCacheResults.operation("Task :cacheable")
        def pullOperations = pullTaskOperation.descendants {
            it.descriptor.displayName ==~ /Load entry .+ from (local|remote) build cache/
        }
        def unpackOperations = pullTaskOperation.descendants {
            it.descriptor.displayName ==~ /Unpack build cache entry .+/
        }
        if (hasLocalBuildCacheOperations()) {

        this.accessibleDependentDelegate = accessibleDependentConsumer;
        this.privateDependentDelegate = privateDependentConsumer;
    }

    /**
     * Consume "accessible" dependents of a constant. Accessible dependents in this context
     * are dependents that have a constant calculated from constant from origin.
     *
     * Example of accessible dependent:
     * class A {

            .filter(constantOrigin -> !changedClasses.contains(constantOrigin))
            .forEach(constantOrigin -> {
                DependentsSet dependents = oldMapping.getConstantDependentsForClass(constantOrigin);
                Set<String> accessibleDependents = new HashSet<>(dependents.getAccessibleDependentClasses());
                accessibleDependents.removeIf(changedClasses::contains);

        new ClassSetAnalysis(
            new ClassSetAnalysisData(Maps.transformValues(dependents) { hash }, dependents, classToConstants, fullRebuildCause),
            new AnnotationProcessingData([:], aggregatedTypes.getAllDependentClasses(), dependentsOnAll.getAllDependentClasses(), [:], dependentsOnAll.dependentResources, null),
            compilerApiData
        )
    }

        def a2 = first(c.dependencies).selected

        a2.is(a)

        first(b.dependents).is(first(a.dependencies))
        first(c.dependents).is(first(b.dependencies))
        first(a.dependents).is(first(c.dependencies))

        first(b.dependents).from.is(a)
        first(c.dependents).from.is(b)
        first(a.dependents).from.is(c)
    }

    def "accumulates and avoids duplicate dependencies"() {

    private void blackList(String id) {
        if (!blackList.contains(id)) {
            blackList.add(id);

            List<String> dependents = sorter.getDependents(id);

            if (dependents != null && !dependents.isEmpty()) {
                for (String dependentId : dependents) {
                    if (!buildSuccessesByProject.containsKey(dependentId)