classes.push('alreadyRendered');
            }
            if (dependency.hasConflict) {
                classes.push('hasConflict');
            }
            if (!dependency.resolvable) {
                classes.push('unresolvable');
            }
            if (classes.length > 0) {
                node.attr['class'] = classes.join(' ');
            }

        ])
        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>

import gradlebuild.configureAsRuntimeJarClasspath

plugins {
    java
}

val agentsClasspath = configurations.dependencyScope("agentsClasspath")
val resolveAgentsClasspath = configurations.resolvable("resolveAgentsClasspath") {
    extendsFrom(agentsClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

val startScripts = tasks.register<GradleStartScriptGenerator>("startScripts") {

            "This will fail with an error in Gradle 9.0. Be sure to mark configurations meant for resolution as canBeConsumed=false or use the 'resolvable(String)' configuration factory method to create them. " +
            "Consult the upgrading guide for further information: https://docs.gradle.org/current/userguide/upgrading_version_8.html#depending_on_root_configuration")

        If you are unable to do so, please ensure you have collected the relevant debugging information manually and attached below;
        issue without enough information will not be resolvable.
  - type: checkboxes
    id: area
    attributes:
      label: Affected product area
      options:
      - label: "Ambient"
      - label: "Docs"
      - label: "Dual Stack"
      - label: "Installation"

    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();

 * corresponding source sets and any domain objects which are created by the {@link BasePlugin} on the source sets' behalf.
 * This includes their resolvable configurations and dependency scopes, as well as any associated tasks.
 *
 * TODO: We should strip almost all logic from this class. It should be a simple container for features and should provide

    /**
     * A cache of the defined dependencies for dependency configurations. This tracks the cached internal
     * dependency representations for these types so when constructing leaf configuration metadata
     * (resolvable and consumable), these conversions do not need to be executed multiple times.
     */
    class DependencyCache {
        private final Map<String, DefaultLocalConfigurationMetadataBuilder.DependencyState> cache = new HashMap<>();

    /**
     * Get the resolvable configuration containing the resolved runtime dependencies
     * for this feature. This configuration does not contain the artifacts from the
     * feature's compilation itself.
     *
     * @return The {@code runtimeClasspath} configuration.
     */
    Configuration getRuntimeClasspathConfiguration();

    /**

        given:
        mavenRepo.module("org", "foo").publish()
        buildFile << """
            configurations {
                dependencyScope("deps")
                resolvable("res")  {
                    extendsFrom(deps)
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }