return classesToConstants.build();
    }

    private void addDependency(Map<String, Set<String>> dependentsMap, String dependency, String dependent) {
        Set<String> dependents = rememberClass(dependentsMap, dependency);
        dependents.add(dependent);
    }

    public void fullRebuildNeeded(String fullRebuildCause) {
        this.fullRebuildCause = fullRebuildCause;
    }

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

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

        dependents.forEach(dependent -> addAccessibleDependent(constantOrigin, dependent));
        return this;
    }

    public ConstantToDependentsMappingBuilder addPrivateDependents(String constantOrigin, Collection<String> dependents) {
        dependents.forEach(dependent -> addPrivateDependent(constantOrigin, dependent));
        return this;
    }

        List<NativeBinarySpecInternal> dependents = state.getDependents(target);
        for (NativeBinarySpecInternal dependent : dependents) {
            List<DependentBinariesResolvedResult> children = doBuildResolvedResult(dependent, state, stack);
            result.add(new DefaultDependentBinariesResolvedResult(dependent.getId(), dependent.getProjectScopedName(), dependent.isBuildable(), isTestSuite(dependent), children));
        }

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

// Note that a dependent with multiple ownerReferences for the target uid can end up in both lists.
func partitionDependents(dependents []*node, matchOwnerIdentity objectReference) (matching, nonmatching []*node) {
	ownerIsNamespaced := len(matchOwnerIdentity.Namespace) > 0
	for i := range dependents {
		dep := dependents[i]
		foundMatch := false
		foundMismatch := false

    for (module in modules) {
        for (dependency in getDependencies(module)) {
            // `module` should not be part of its own dependents, per the contract of `KotlinModuleDependentsProvider`.
            if (dependency == module) continue

            val dependents = computeIfAbsent(dependency) { mutableSetOf() }
            dependents.add(module)
        }
    }

 * limitations under the License.
 */

package org.gradle.api.reporting.dependents

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class DependentComponentsReportIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        settingsFile << "rootProject.name = 'test'"
    }

    def "help displays dependents report task options"() {
        when:

        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"() {

 * limitations under the License.
 */

package org.gradle.platform.base.internal.dependents;

import org.gradle.api.artifacts.component.LibraryBinaryIdentifier;

import java.util.List;

/**
 * A dependent binary and its dependents, node of a dependent binaries resolution result.
 */
public interface DependentBinariesResolvedResult {

    LibraryBinaryIdentifier getId();