* @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,

     */
    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
        }
    }

package org.gradle.internal.component.local.model;

import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.internal.artifacts.configurations.ConfigurationInternal;
import org.gradle.api.internal.artifacts.configurations.ConfigurationsProvider;
import org.gradle.api.internal.artifacts.configurations.VariantIdentityUniquenessVerifier;

                return configuration.isCanBeDeclared();
            }

            @Override
            boolean isDeprecated(ConfigurationInternal configuration) {
                return configuration.isDeprecatedForDeclarationAgainst();
            }
        };

        abstract boolean isAllowed(ConfigurationInternal configuration);

import org.gradle.api.artifacts.FileCollectionDependency
import org.gradle.api.artifacts.ModuleDependency
import org.gradle.api.artifacts.component.ComponentIdentifier
import org.gradle.api.internal.artifacts.configurations.ConfigurationInternal
import org.gradle.api.internal.artifacts.configurations.DetachedConfigurationsProvider
import org.gradle.api.internal.attributes.AttributeContainerInternal