// we don't need to lock each element, because they never get updated
	owner.dependentsLock.RLock()
	dependents := make([]*node, 0, len(owner.dependents))
	for dependent := range owner.dependents {
		dependents = append(dependents, dependent)
	}
	owner.dependentsLock.RUnlock()

	err := gc.orphanDependents(logger, owner.identity, dependents)
	if err != nil {

import org.gradle.platform.base.internal.dependents.DependentBinariesResolver;
import org.gradle.work.DisableCachingByDefault;

import javax.inject.Inject;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import static org.gradle.api.reporting.dependents.internal.DependentComponentsUtils.getAllComponents;
import static org.gradle.api.reporting.dependents.internal.DependentComponentsUtils.getAllTestSuites;

        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)
        }
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Types responsible for generating dependents components reports.
 */

import org.gradle.platform.base.internal.BinarySpecInternal;
import org.gradle.platform.base.internal.ComponentSpecInternal;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolutionResult;
import org.gradle.platform.base.internal.dependents.DependentBinariesResolver;
import org.gradle.reporting.ReportRenderer;

import javax.annotation.Nullable;
import java.util.LinkedHashSet;

            if (dependencies == null) {
                dependencies = new HashSet<>();
            }
            dependencies.add(node);
            if (node.dependents == null) {
                node.dependents = new HashSet<>();
            }
            node.dependents.add(this);
        }
        if (executedRules == null) {
            executedRules = new ArrayList<>();
        }

    - path: hack/lib/golang.sh
      match: minimum_go_version=go([0-9]+\.[0-9]+)

  - name: "registry.k8s.io/kube-cross: dependents"
    version: v1.31.0-go1.22.4-bullseye.0
    refPaths:
    - path: build/build-image/cross/VERSION

  # Base images
  - name: "registry.k8s.io/debian-base: dependents"
    version: bookworm-v1.0.3
    refPaths:
    - path: cluster/images/etcd/Makefile

        return Collections.unmodifiableSet(dependents);
    }

    public DefaultResolvedComponentResult addDependency(DependencyResult dependency) {
        this.dependencies.add(dependency);
        return this;
    }

    public DefaultResolvedComponentResult addDependent(ResolvedDependencyResult dependent) {
        this.dependents.add(dependent);
        return this;
    }

    @Override

    }

    def "knows when class is dependent to all if that class is added first"() {
        accumulator.addClass("b", hash, "reason",  [], [] as Set, IntSets.EMPTY_SET)
        accumulator.addClass("a", hash, null, [], ["b"], IntSets.EMPTY_SET)

        expect:
        accumulator.dependentsMap.b.dependencyToAll
    }

    def "knows when class is dependent to all even if that class is added last"() {

        DependentsSet dependents = current.findDependentsOfClasspathChanges(previous);
        if (dependents.isDependencyToAll()) {
            spec.setFullRebuildCause(dependents.getDescription());
            return;
        }
        spec.addClassesToCompile(dependents.getPrivateDependentClasses());
        spec.addClassesToCompile(dependents.getAccessibleDependentClasses());