private Map<DependencySubstitutionApplicator.SubstitutionResult, DependencyState> substitutionResultMap;

    DependencyState(DependencyMetadata dependency, ComponentSelectorConverter componentSelectorConverter) {
        this(dependency, dependency.getSelector(), Collections.emptyList(), componentSelectorConverter);
    }

        for (ModuleIdentifier module : upcomingNoLongerPendingConstraints) {
            Collection<DependencyState> dependencyStates = potentiallyActivatedConstraints.get(module);
            if (!dependencyStates.isEmpty()) {
                for (DependencyState dependencyState : dependencyStates) {
                    dependencyState = maybeSubstitute(dependencyState, resolveState.getDependencySubstitutionApplicator());

        return forced || (versionConstraint != null && versionConstraint.isStrict());
    }

    public void update(DependencyState dependencyState) {
        if (dependencyState != this.dependencyState) {
            if (!forced && dependencyState.isForced()) {
                forced = true;
                if (dependencyState.getDependency() instanceof LenientPlatformDependencyMetadata) {
                    softForced = true;

        root.maybeCollectStrictVersions(constraintsSet, edge(root).dependencyState)
        root.maybeCollectStrictVersions(constraintsSet, edge(root, false).dependencyState)
        root.maybeCollectStrictVersions(constraintsSet, edge(root).dependencyState)
        root.maybeCollectStrictVersions(constraintsSet, edge(root, false).dependencyState)
        root.storeOwnStrictVersions(constraintsSet)

        DependencyState dependencyState = new DependencyState(new LenientPlatformDependencyMetadata(resolveState, from, toSelector, toComponent, owner, force || hasStrongOpinion(from), transitive), resolveState.getComponentSelectorConverter());
        dependencyState = NodeState.maybeSubstitute(dependencyState, resolveState.getDependencySubstitutionApplicator());

    final TaskStateInternal dependencyState = Mock()
    final TaskExecutionGraph taskExecutionGraph = Mock()
    final SkipTaskWithNoActionsExecuter executor = new SkipTaskWithNoActionsExecuter(taskExecutionGraph, target)

    def setup() {
        _ * taskExecutionGraph.getDependencies(task) >> ([dependency] as Set)
        _ * dependency.state >> dependencyState
    }

        this.resolveState = resolveState;
    }

    @Override
    public PendingState maybeAddAsPendingDependency(NodeState node, DependencyState dependencyState) {
        ModuleIdentifier key = dependencyState.getModuleIdentifier();
        boolean isConstraint = dependencyState.getDependency().isConstraint();
        if (!isConstraint) {
            if (markNotPending(key)) {

    private boolean unattached;
    private boolean used;

    EdgeState(NodeState from, DependencyState dependencyState, ExcludeSpec transitiveExclusions, ResolveState resolveState) {
        this.from = from;
        this.dependencyState = dependencyState;
        this.dependencyMetadata = dependencyState.getDependency();
        // The accumulated exclusions that apply to this edge based on the path from the root

            this.pending = pending;
        }

        boolean isPending() {
            return this.pending;
        }
    }

    PendingState maybeAddAsPendingDependency(NodeState node, DependencyState dependencyState);

    boolean markNotPending(ModuleIdentifier id);

    void complete();

        private final Map<String, DefaultLocalConfigurationMetadataBuilder.DependencyState> cache = new HashMap<>();

        public DefaultLocalConfigurationMetadataBuilder.DependencyState computeIfAbsent(
            ConfigurationInternal configuration,
            Function<ConfigurationInternal, DependencyState> factory
        ) {
            DependencyState state = cache.get(configuration.getName());
            if (state == null) {