domainObjectCollectionFactory,
                calculatedValueFactory,
                this,
                taskDependencyFactory,
                role
        );
        instance.addMutationValidator(rootComponentMetadataBuilder.getValidator());
        return instance;
    }

    /**
     * Creates a new locked resolvable configuration instance.
     */

import org.gradle.api.artifacts.DependencyConstraint;

public interface DependencyConstraintInternal extends DependencyConstraint {
    void setForce(boolean force);

    boolean isForce();

    void addMutationValidator(Action<? super DependencyConstraint> action);

    DependencyConstraint copy();

        clientConfiguration.maybeEmitDeclarationDeprecation();
        if (dependencyConstraint instanceof DependencyConstraintInternal) {
            ((DependencyConstraintInternal) dependencyConstraint).addMutationValidator(constraint ->
                ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES)
            );
        }

public abstract class AbstractDependencyConstraint implements DependencyConstraintInternal {
    private ImmutableActionSet<DependencyConstraint> onMutate = ImmutableActionSet.empty();

    @Override
    public void addMutationValidator(Action<? super DependencyConstraint> action) {
        this.onMutate = onMutate.add(action);
    }

    protected void validateMutation() {
        onMutate.execute(this);
    }

        assertConfigurationIsDeclarable();
        clientConfiguration.maybeEmitDeclarationDeprecation();
        if (o instanceof AbstractModuleDependency) {
            ((AbstractModuleDependency) o).addMutationValidator(mutationValidator);
        }
        return super.add(o);
    }

    private void assertConfigurationIsDeclarable() {
        if (!clientConfiguration.isCanBeDeclared()) {

        if (config != null) {
            config.execute(mutable);
        }

        if (mutable instanceof AbstractModuleDependency) {
            ((AbstractModuleDependency) mutable).addMutationValidator(dep -> {
                if (((PropertyInternal<?>) getDependencies()).isFinalized()) {
                    DeprecationLogger.deprecateAction("Mutating dependency " + dep + " after it has been finalized")

     * After execution, all actions are de-registered, so execution will only occur once.
     */
    void runDependencyActions();

    void markAsObserved(InternalState requestedState);

    void addMutationValidator(MutationValidator validator);

    void removeMutationValidator(MutationValidator validator);

    /**
     * Visits the variants of this configuration.
     */
    void collectVariants(VariantVisitor visitor);

    }

    private void setAttributes(AttributeContainerInternal attributes) {
        this.attributes = attributes;
    }

    @SuppressWarnings("unchecked")
    public void addMutationValidator(Action<? super ModuleDependency> action) {
        this.onMutate = onMutate.add(action);
    }

    protected void validateMutation() {
        onMutate.execute(this);
    }

                    inheritedDependencyConstraints.addCollection(configuration.getAllDependencyConstraints());
                }
                ((ConfigurationInternal) configuration).addMutationValidator(parentMutationValidator);
            }
        }
        return this;
    }

    @Override
    public boolean isTransitive() {
        return transitive;
    }

    @Override