should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateMigratingUnlocked(String,\ ConfigurationRole)\ or\ should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateResolvableDependencyScopeUnlocked(String),\ because\ Resolvable\ +\ dependency\ scope\ configurations\ should\ be\ avoided\ and\ we\ are\ migrating\ away\ from\ maybeCreate\ methods=configuration-factory-methods.txt...

                "\tDeclarable - this configuration can have dependencies added to it\n" +

                // 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]"]

            }
            return;
        }

        // Not resolvable. Discard the body when the expression is not resolvable
        macroFunctions.add(new UnresolvableMacroFunction(macroName, paramNames.size()));
    }

        ResolutionNode resolvedNode = getConflictResolver().resolveConflict(actualNode1, actualNode2);

        assertNotNull(resolvedNode, "Expected resolvable");
        assertEquals(expectedNode, resolvedNode, "Resolution node");
    }

    protected Artifact createArtifact(String id, String version) throws InvalidVersionSpecificationException {

     * By applying this functionality to all configurations, this method would no longer be required.
     *
     * @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
    <T> T callAndResetResolutionState(Factory<T> factory);

    }

    def "mainSourceElements can be consumed by another task via Dependency Management"() {
        buildFile << """
            plugins {
                id 'java'
            }

            // A resolvable configuration to collect source data
            def sourceElementsConfig = configurations.create("sourceElements") {
                visible = true
                assert canBeResolved
                canBeConsumed = false

                        config.getDependencies().add(project.getDependencies().create(project));
                    });

                    NamedDomainObjectProvider<Configuration> resolvable = configurations.register("resolvable", config -> {
                        config.setCanBeConsumed(false);
                        config.setCanBeResolved(true);
                        config.extendsFrom(dependencyScope.get());

By default, `resolvableConfigurations` prints information about all purely resolvable configurations.
These are configurations that are marked resolvable but *not* marked consumable.
Though some resolvable configurations are also marked consumable, these are legacy configurations that should *not* have dependencies added in build scripts.