delegate.detachedConfiguration(*dependencies)

    override fun resolvable(name: String): NamedDomainObjectProvider<ResolvableConfiguration> =
        delegate.resolvable(name)

    override fun resolvable(name: String, action: Action<in ResolvableConfiguration>): NamedDomainObjectProvider<ResolvableConfiguration> =
        delegate.resolvable(name, action)

    /**
     * Creates a resolvable + dependency scope configuration which can change roles.
     *
     * @deprecated Whether concept of a resolvable + dependency scope configuration should exist
     * is still under debate. However, in general, we should try to split up configurations which
     * have this role into separate resolvable and dependency scope configurations.
     */
    @Deprecated

        ConfigurationRoles.CONSUMABLE                   || [UsageDescriber.CONSUMABLE]
        ConfigurationRoles.RESOLVABLE                   || [UsageDescriber.RESOLVABLE]
        ConfigurationRoles.RESOLVABLE_DEPENDENCY_SCOPE  || [UsageDescriber.RESOLVABLE, UsageDescriber.DECLARABLE_AGAINST]

    private static final String CONSUMABLE = "Consumable - this configuration can be selected by another project as a dependency";
    private static final String RESOLVABLE = "Resolvable - this configuration can be resolved by this project to a set of files";
    private static final String DECLARABLE_AGAINST = "Declarable - this configuration can have dependencies added to it";

    private final boolean consumable;
    private final boolean resolvable;
    private final boolean declarable;
    private final boolean consumptionDeprecated;
    private final boolean resolutionDeprecated;
    private final boolean declarationDeprecated;

    public DefaultConfigurationRole(
        String name,
        boolean consumable,
        boolean resolvable,
        boolean declarable,
        boolean consumptionDeprecated,

    /**
     * Registers a {@link ResolvableConfiguration} with an immutable role. Resolvable configurations
     * are meant to resolve dependency graphs and their artifacts.
     *
     * @param name The name of the configuration to register.
     *
     * @return A provider which creates a new resolvable configuration.
     *

plugins {
    id 'java-library'
}

// tag::resolvable-configuration[]
configurations {
    instrumentedClasspath {
        canBeConsumed = false
    }
}
// end::resolvable-configuration[]

// tag::explicit-configuration-dependency[]
dependencies {
    instrumentedClasspath(project(path: ":producer", configuration: 'instrumentedJars'))
}
// end::explicit-configuration-dependency[]

tasks.register("resolveInstrumentedClasses") {

plugins {
    `java-library`
}

// tag::resolvable-configuration[]
val instrumentedClasspath by configurations.creating {
    isCanBeConsumed = false
}
// end::resolvable-configuration[]

// tag::explicit-configuration-dependency[]
dependencies {
    instrumentedClasspath(project(mapOf(
        "path" to ":producer",
        "configuration" to "instrumentedJars")))
}
// end::explicit-configuration-dependency[]

    /**
     * A resolvable dependency scope that will become a resolvable configuration in the next major version.
     */
    @SuppressWarnings("deprecation")
    public static final ConfigurationRole RESOLVABLE_DEPENDENCY_SCOPE_TO_RESOLVABLE = difference(ConfigurationRoles.RESOLVABLE_DEPENDENCY_SCOPE, ConfigurationRoles.RESOLVABLE);

    /**

        componentIdentifierFactory.createComponentIdentifier(_) >> {
            new DefaultModuleComponentIdentifier(mid, '1.0')
        }
        configurationsProvider.findByName('conf') >> resolvable()
        configurationsProvider.findByName('conf-2') >> resolvable()

        def root = builder.toRootComponent('conf')

        when:
        def sameConf = builder.toRootComponent('conf')

        then: