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

            }
        """

        when:
        executer.expectDeprecationWarning('(l) Legacy or deprecated configuration. Those are variants created for backwards compatibility which are both resolvable and consumable.')
        run ':resolvableConfigurations', '--all'

        then:
        result.groupedOutput.task(":resolvableConfigurations").assertOutputContains("""--------------------------------------------------

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

        buildKotlinFile << """
            ${mavenCentralRepository(GradleDsl.KOTLIN)}

            configurations {
                dependencyScope("myLibs")

                resolvable("resolveMe") {
                    extendsFrom(configurations.getByName("myLibs"))
                }
            }

            dependencies {

     * {@inheritDoc}
     *
     * @implNote 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.
     */
    @Override
    public boolean contains(File file) {
        warnOnInvalidInternalAPIUsage("contains(File)", ProperMethodUsage.RESOLVABLE);
        return getIntrinsicFiles().contains(file);
    }

    @Override

        }
    }

    @Override
    public NamedDomainObjectProvider<ResolvableConfiguration> resolvable(String name) {
        assertMutable("resolvable(String)");
        return registerResolvableConfiguration(name, Actions.doNothing());
    }

    @Override
    public NamedDomainObjectProvider<ResolvableConfiguration> resolvable(String name, Action<? super ResolvableConfiguration> action) {

        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