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

            configurations {
                dependencyScope("myLibs")

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

            dependencies {

        }
    }

    @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) {

    }

    def "attribute combinations and capabilities on legacy resolvable configurations can match without a warning"() {
        given:
        buildFile << """
            plugins {
                id 'java'
            }

            configurations {
                sample1 {
                    // Configurations that are both resolvable and consumable are legacy and should not be used

        resolve.prepare()
        resolve
    }

    @ToBeFixedForConfigurationCache(because = "resolves configuration at execution time")
    def "can declare a configuration which extends from a resolvable configuration which uses consistency"() {
        withRuntimeClasspathAsReference()
        def foo = mavenHttpRepo.module('org', 'foo', '1.0').publish()
        def bar = mavenHttpRepo.module('org', 'bar', '1.0').publish()

        buildFile.text = """
            repositories {
                maven { url '${mavenRepo.uri}' }
            }

            configurations {
                dependencyScope("conf")
                resolvable("res") {
                    extendsFrom conf
                }
            }

            configurations.conf.dependencies.addLater(provider(() -> project.dependencies.create("org:foo:1.0")))

        ])
        directories*.source == ["Maven Toolchains", "Maven Toolchains"]

        where:
        useProperty << [true, false]
    }

    def "supplies multiple paths for multiple toolchains with resolvable environment variable"(boolean useProperty) {
        given:
        def toolchain = '''<toolchains>
                                <toolchain>
                                <type>jdk</type>

    public Set<File> resolve(boolean transitive) {

        DeprecationLogger.deprecate("Directly resolving the files of project dependency '" + getIdentityPath() + "'")
            .withAdvice("Add the dependency to a resolvable configuration and resolve the configuration.")
            .willBecomeAnErrorInGradle9()
            .withUpgradeGuideSection(8, "deprecate_self_resolving_dependency")
            .nagUser();

            // Treat both these cases as an unresolvable include directive
            expression = new SimpleExpression(expression.getAsSourceText(), IncludeType.OTHER);
        }
        expression = expression.asMacroExpansion();
        if (expression.getType() != IncludeType.OTHER || !expression.getValue().isEmpty()) {
            // Either a resolvable expression or a non-empty unresolvable expression, collect. Ignore includes with no value

                // need these resolution rules.
                id("org.jetbrains.kotlin.jvm") version "1.9.20"
            }

            configurations {
                dependencyScope("deps")
                resolvable("res") {
                    extendsFrom(deps)
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.LIBRARY))

In Gradle terminology, this is called a <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,resolvable configuration>>, which is defined this way:

.Declaring a resolvable configuration on the consumer
====
include::sample[dir="snippets/dependencyManagement/modelingFeatures-crossProjectPublications-simple/kotlin",files="consumer/build.gradle.kts[tags=resolvable-configuration]"]