* @return {@code true} if so; {@code false} otherwise
     */
    static boolean isDeclarableByExtension(ConfigurationInternal configuration) {
        if (configuration.isCanBeDeclared()) {
            return true;
        } else {
            return configuration.getExtendsFrom().stream()
                    .map(ConfigurationInternal.class::cast)
                    .anyMatch(ci -> ci.isDeclarableByExtension());
        }
    }

        ConfigurationInternal configurationInternal = (ConfigurationInternal) configuration;
        Set<TaskProvider<COMPILE>> compileTasks = Cast.uncheckedCast(configurationToCompileTasks.computeIfAbsent(configurationInternal, key -> new HashSet<>()));
        compileTasks.add(compileTask);

    }

    ConfigurationInternal consumable(String name, List<ConfigurationInternal> extendsFrom = []) {
        project.configurations.consumable(name) { conf ->
            extendsFrom.each { conf.extendsFrom(it) }
        }.get() as ConfigurationInternal
    }

    ConfigurationInternal resolvable(String name, List<ConfigurationInternal> extendsFrom = []) {

/**
 * Builds {@link LocalConfigurationMetadata} instances from {@link ConfigurationInternal}s, while
 * caching intermediary dependency and exclude state.
 */
@ServiceScope(Scope.Global.class)
public interface LocalConfigurationMetadataBuilder {

    LocalConfigurationGraphResolveMetadata create(
        ConfigurationInternal configuration,
        ConfigurationsProvider configurationsProvider,

    }

    @Override
    public Set<? extends ConfigurationInternal> getAll() {
        Set<? extends ConfigurationInternal> set = Cast.uncheckedCast(this);
        return ImmutableSet.copyOf(set);
    }

    @Override
    public void visitAll(Consumer<ConfigurationInternal> visitor) {
        for (Configuration configuration : this) {
            visitor.accept((ConfigurationInternal) configuration);
        }
    }

    private final Describable displayName;
    private final ConfigurationInternal clientConfiguration;

    public DefaultDependencyConstraintSet(Describable displayName, ConfigurationInternal clientConfiguration, DomainObjectSet<DependencyConstraint> backingSet) {
        super(backingSet);
        this.displayName = displayName;

import java.util.Set;
import java.util.function.Consumer;

public class ConfigurationVariantMapping {
    private final ConfigurationInternal outgoingConfiguration;
    private Action<? super ConfigurationVariantDetails> action;
    private final ObjectFactory objectFactory;

    public ConfigurationVariantMapping(ConfigurationInternal outgoingConfiguration, Action<? super ConfigurationVariantDetails> action, ObjectFactory objectFactory) {

     */
    public void complete(ConfigurationInternal.InternalState requestedState) {
        for (ResolvedProjectConfiguration projectResult : resolvedProjectConfigurations) {
            ProjectState targetState = projectStateRegistry.stateFor(projectResult.projectIdentity);

import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.attributes.Category;
import org.gradle.api.internal.artifacts.configurations.ConfigurationInternal;
import org.gradle.api.internal.artifacts.configurations.Configurations;
import org.gradle.api.internal.artifacts.configurations.ConfigurationsProvider;

        otherRoot.rootComponent.getConfiguration('conf').is(variant)

        where:
        mutationType << [MutationValidator.MutationType.STRATEGY]
    }

    private ConfigurationInternal resolvable() {
        Mock(ConfigurationInternal) {
            isCanBeResolved() >> true
            getAttributes() >> ImmutableAttributes.EMPTY
        }
    }