Consumable - this configuration can be selected by another project as a dependency
	Resolvable - this configuration can be resolved by this project to a set of files
	Declarable - this configuration can have dependencies added to it
Yet Gradle expected to create it with the usage(s):
	Resolvable - this configuration can be resolved by this project to a set of files

/**
 * Returns a [KaClassLikeSymbol] for this [KaType] if the type represents a uniquely resolvable class/object/type alias.
 */
public val KaType.symbol: KaClassLikeSymbol?
    get() = (this as? KaNonErrorClassType)?.symbol

/**
 * Returns a [KtClassLikeSymbol] for this [KtType] if the type represents a uniquely resolvable class/object/type alias.
 */
@Deprecated("Use 'symbol' instead.", ReplaceWith("this.symbol"))

     *
     * @param configuration a resolvable configuration where to pick resolved version numbers
     */
    void fromResolutionOf(Configuration configuration);


    /**
     * Declares that this variant should use versions from the resolution
     * of the configuration provided as an argument.
     *
     * @param configurationName a resolvable configuration name where to pick resolved version numbers
     */

        return extendedConfigurations;
    }

    public boolean isPurelyConsumable() {
        return Type.CONSUMABLE == type;
    }

    public boolean isPurelyResolvable() {
        return Type.RESOLVABLE == type;
    }

    public boolean isLegacy() {
        return Type.LEGACY == type;
    }

    public boolean hasIncubatingAttributes() {

/**
 * A {@code SelfResolvingDependency} is a {@link Dependency} which is able to resolve itself, independent of a
 * repository.
 *
 * @deprecated Dependencies should not be resolved outside a resolvable configuration. To resolve this dependency,
 * add it to a resolvable configuration and resolve that configuration.
 */
@Deprecated
@HasInternalProtocol
public interface SelfResolvingDependency extends Dependency, Buildable {
    /**

        return getReportedConfigurationDirection() + " " + getReportedTypeAlias();
    }

    @Override
    public String getReportedConfigurationDirection() {
        return "resolvable";
    }

    @Override
    public boolean isIncludeCapabilities() {
        return false;
    }

    @Override
    public boolean isIncludeArtifacts() {
        return false;
    }

import org.gradle.work.DisableCachingByDefault;

/**
 * A task which reports the configurations of a project which can be resolved on the command line.
 *
 * This is useful for determining which attributes are associated with the resolvable
 * configurations being used to resolve a project's dependencies.  The output can help predict which variant of
 * each dependency will be resolved.
 *
 * @since 7.5
 */
@Incubating

// tag::test-report[]
// A resolvable configuration to collect test reports data
plugins {
    id 'reporting-base'
}

configurations {
    testReportData {
        canBeConsumed = false
        attributes {
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))
            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, 'test-report-data'))
        }
    }
}

dependencies {

        """

        when:
        fails 'help'

        then:
        failure.hasErrorOutput("Archives can not be added to the `compile` configuration.")
    }

    def "fail if a non-resolvable configuration is resolved"() {
        given:
        buildFile << """
            task resolve {
                dependsOn configurations.compileOnly
                doLast {

     * superconfigurations.
     */
    Set<ExcludeRule> getAllExcludeRules();

    /**
     * @implSpec Usage: This method should only be called on resolvable configurations and should throw an exception if
     * called on a configuration that does not permit this usage.
     */
    @Nullable
    ConfigurationInternal getConsistentResolutionSource();

    /**