MutationValidator.MutationType.DEPENDENCY_ATTRIBUTES,
            MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES,
            MutationValidator.MutationType.ARTIFACTS,
            MutationValidator.MutationType.USAGE,
            MutationValidator.MutationType.HIERARCHY
        ]
    }

    def "does not reevaluate component metadata when #mutationType change"() {

        private final ModelActionRole mutationType;
        private final RuleApplicationScope ruleApplicationScope;

        public ExtractedMutationRule(ModelActionRole mutationType, MethodRuleDefinition<?, S> ruleDefinition, RuleApplicationScope ruleApplicationScope) {
            super(ruleDefinition);
            this.mutationType = mutationType;
            this.ruleApplicationScope = ruleApplicationScope;
        }

         * prevented on resolved configurations.
         */
        DEPENDENCY_ATTRIBUTES("dependency attributes"),

        /**
         * The mutation of the attributes (other than coordinates) of a dependency constraint.
         * Theoretically these should be bundled under {@link MutationType#DEPENDENCIES}, but these mutations are not (yet)

 */
public abstract class RunnableMutationValidator implements MutationValidator, Runnable {
    private final MutationType typeAsRunnable;

    public RunnableMutationValidator(MutationType typeAsRunnable) {
        this.typeAsRunnable = typeAsRunnable;
    }

    @Override
    public void run() {
        validateMutation(typeAsRunnable);
    }

            return true;
        }
        return false;
    }

    private void preventIllegalParentMutation(MutationType type) {
        // TODO: We can remove this check once we turn `maybePreventMutation` into an error
        if (type == MutationType.DEPENDENCY_ATTRIBUTES || type == MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES) {
            return;
        }

        if (isFullyResoled(currentResolveState.get())) {

            ((DependencyConstraintInternal) dependencyConstraint).addMutationValidator(constraint ->
                ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES)
            );
        }
        return addInternalDependencyConstraint(dependencyConstraint);
    }

        @Nullable
        private LocalComponentGraphResolveState cachedValue;

        @Override
        public void validateMutation(MutationType type) {
            if (type != MutationType.STRATEGY) {
                LocalComponentGraphResolveState value = currentValue();
                if (value != null) {
                    value.reevaluate();
                }
            }

        }

        @Override
        public void execute(ModuleDependency moduleDependency) {
            ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_ATTRIBUTES);
        }
    }

        this.getEventRegister().registerLazyAddAction(x -> rootComponentMetadataBuilder.getValidator().validateMutation(MutationValidator.MutationType.HIERARCHY));
        this.whenObjectRemoved(x -> rootComponentMetadataBuilder.getValidator().validateMutation(MutationValidator.MutationType.HIERARCHY));
    }

    @Override
    @SuppressWarnings("deprecation")
    protected Configuration doCreate(String name) {

import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;

import static org.gradle.api.internal.artifacts.configurations.MutationValidator.MutationType.STRATEGY;

public class DefaultComponentSelectionRules implements ComponentSelectionRulesInternal {
    private static final String INVALID_SPEC_ERROR = "Could not add a component selection rule for module '%s'.";