[Gradle] Add role-based configuration method factories

Starting from Gradle 8.2 there is deprecation diagnostic that disallows changing configuration roles after creation. With Gradle 8.4 there is an Incubating API that introduces role factories for Configuration. For consistency reasons names that introduced in this commit match the names that Gradle introduces in 8.4 version. ^KT-60879
2023-11-10 12:54:43 +01:00
parent e94b247835
commit 2ab30d8880
32 changed files with 215 additions and 240 deletions
@@ -16,8 +16,9 @@ import org.jetbrains.kotlin.commonizer.CliCommonizer
 import org.jetbrains.kotlin.gradle.internal.KOTLIN_MODULE_GROUP
 import org.jetbrains.kotlin.gradle.plugin.KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME
 import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
-import org.jetbrains.kotlin.gradle.utils.markResolvable
 import org.jetbrains.kotlin.gradle.plugin.usageByName
+import org.jetbrains.kotlin.gradle.utils.createResolvable
+import org.jetbrains.kotlin.gradle.utils.findResolvable
 import org.jetbrains.kotlin.gradle.utils.named

 private const val KOTLIN_KLIB_COMMONIZER_EMBEDDABLE = "kotlin-klib-commonizer-embeddable"
@@ -29,9 +30,8 @@ internal fun GradleCliCommonizer(commonizerToolRunner: KotlinNativeCommonizerToo
 }

 internal fun Project.maybeCreateCommonizerClasspathConfiguration(): Configuration {
-    return configurations.findByName(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME)
-        ?: project.configurations.create(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME)
-            .markResolvable()
+    return configurations.findResolvable(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME)
+        ?: project.configurations.createResolvable(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME)
            .run {
                attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
                attributes.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.gradle.targets.metadata.COMMON_MAIN_ELEMENTS_CONFIGU
 import org.jetbrains.kotlin.gradle.targets.metadata.isCompatibilityMetadataVariantEnabled
 import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
 import org.jetbrains.kotlin.gradle.tasks.registerTask
+import org.jetbrains.kotlin.gradle.utils.createConsumable

 internal val KotlinLegacyCompatibilityMetadataArtifact = KotlinTargetArtifact { target, _, _ ->
    if (target !is KotlinMetadataTarget) return@KotlinTargetArtifact
@@ -35,9 +36,7 @@ internal val KotlinLegacyCompatibilityMetadataArtifact = KotlinTargetArtifact {
    }

    /* Create actual Gradle artifact */
-    target.project.configurations.create(COMMON_MAIN_ELEMENTS_CONFIGURATION_NAME).apply {
-        isCanBeConsumed = true
-        isCanBeResolved = false
+    target.project.configurations.createConsumable(COMMON_MAIN_ELEMENTS_CONFIGURATION_NAME).apply {
        usesPlatformOf(target)

        attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerApiUsage(target))
@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnab
 import org.jetbrains.kotlin.gradle.targets.native.internal.includeCommonizedCInteropMetadata
 import org.jetbrains.kotlin.gradle.tasks.locateOrRegisterTask
 import org.jetbrains.kotlin.gradle.utils.copyAttributes
+import org.jetbrains.kotlin.gradle.utils.createConsumable
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly

 internal val KotlinNativeHostSpecificMetadataArtifact = KotlinTargetArtifact { target, apiElements, _ ->
@@ -30,10 +31,7 @@ internal val KotlinNativeHostSpecificMetadataArtifact = KotlinTargetArtifact { t
    if (!target.project.isKotlinGranularMetadataEnabled) return@KotlinTargetArtifact
    val project = target.project

-    target.project.configurations.create(target.hostSpecificMetadataElementsConfigurationName) { configuration ->
-        configuration.isCanBeConsumed = true
-        configuration.isCanBeResolved = false
-
+    target.project.configurations.createConsumable(target.hostSpecificMetadataElementsConfigurationName).also { configuration ->
        configuration.extendsFrom(*apiElements.extendsFrom.toTypedArray())

        target.project.launchInStage(AfterFinaliseDsl) {
@@ -32,6 +32,8 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmAndroidCompilation
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaCompilation
 import org.jetbrains.kotlin.gradle.tasks.*
 import org.jetbrains.kotlin.gradle.tasks.configuration.*
+import org.jetbrains.kotlin.gradle.utils.createResolvable
+import org.jetbrains.kotlin.gradle.utils.findResolvable
 import org.jetbrains.kotlin.gradle.utils.whenEvaluated
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
 import java.io.ByteArrayOutputStream
@@ -142,10 +144,8 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
        fun createAptConfigurationIfNeeded(project: Project, sourceSetName: String): Configuration {
            val configurationName = getKaptConfigurationName(sourceSetName)

-            project.configurations.findByName(configurationName)?.let { return it }
-            val aptConfiguration = project.configurations.create(configurationName).apply {
-                // Should not be available for consumption from other projects during variant-aware dependency resolution:
-                isCanBeConsumed = false
+            project.configurations.findResolvable(configurationName)?.let { return it }
+            val aptConfiguration = project.configurations.createResolvable(configurationName).apply {
                attributes.attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage::class.java, Usage.JAVA_RUNTIME))
            }

@@ -368,11 +368,9 @@ class Kapt3GradleSubplugin @Inject internal constructor(private val registry: To
            kaptExtension
        )

-        val kaptClasspathConfiguration = project.configurations.create("kaptClasspath_$taskName")
+        val kaptClasspathConfiguration = project.configurations.createResolvable("kaptClasspath_$taskName")
            .setExtendsFrom(kaptClasspathConfigurations).also {
                it.isVisible = false
-                it.isCanBeConsumed = false
-                it.isCanBeResolved = true
            }
        taskConfigAction.configureTaskProvider { taskProvider ->
            taskProvider.dependsOn(generateStubsTask)
@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.gradle.plugin.diagnostics.KotlinToolingDiagnostics
 import org.jetbrains.kotlin.gradle.plugin.diagnostics.reportDiagnosticOncePerBuild
 import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
+import org.jetbrains.kotlin.gradle.utils.createDependencyScope
 import org.jetbrains.kotlin.gradle.utils.whenEvaluated

 abstract class KotlinPlatformPluginBase(protected val platformName: String) : Plugin<Project> {
@@ -53,8 +54,8 @@ open class KotlinPlatformImplementationPluginBase(platformName: String) : Kotlin
    override fun apply(project: Project) {
        warnAboutKotlin12xMppDeprecation(project)

-        val implementConfig = project.configurations.create(IMPLEMENT_CONFIG_NAME)
-        val expectedByConfig = project.configurations.create(EXPECTED_BY_CONFIG_NAME)
+        val implementConfig = project.configurations.createDependencyScope(IMPLEMENT_CONFIG_NAME)
+        val expectedByConfig = project.configurations.createDependencyScope(EXPECTED_BY_CONFIG_NAME)

        implementConfig.dependencies.whenObjectAdded {
            if (!implementConfigurationIsUsed) {
@@ -70,10 +70,8 @@ abstract class DefaultKotlinBasePlugin : KotlinBasePlugin {
        addKotlinCompilerConfiguration(project)


-        project.configurations.maybeCreate(PLUGIN_CLASSPATH_CONFIGURATION_NAME).apply {
+        project.configurations.maybeCreateResolvable(PLUGIN_CLASSPATH_CONFIGURATION_NAME).apply {
            isVisible = false
-            isCanBeConsumed = false
-            isCanBeResolved = true
            addGradlePluginMetadataAttributes(project)
        }

@@ -88,8 +86,7 @@ abstract class DefaultKotlinBasePlugin : KotlinBasePlugin {
    private fun addKotlinCompilerConfiguration(project: Project) {
        project
            .configurations
-            .maybeCreate(COMPILER_CLASSPATH_CONFIGURATION_NAME)
-            .markResolvable()
+            .maybeCreateResolvable(COMPILER_CLASSPATH_CONFIGURATION_NAME)
            .defaultDependencies {
                it.add(
                    project.dependencies.create("$KOTLIN_MODULE_GROUP:$KOTLIN_COMPILER_EMBEDDABLE:${project.getKotlinPluginVersion()}")
@@ -97,8 +94,7 @@ abstract class DefaultKotlinBasePlugin : KotlinBasePlugin {
            }
        project
            .configurations
-            .maybeCreate(BUILD_TOOLS_API_CLASSPATH_CONFIGURATION_NAME)
-            .markResolvable()
+            .maybeCreateResolvable(BUILD_TOOLS_API_CLASSPATH_CONFIGURATION_NAME)
            .defaultDependencies {
                it.add(
                    project.dependencies.create("$KOTLIN_MODULE_GROUP:$KOTLIN_BUILD_TOOLS_API_IMPL:${project.getKotlinPluginVersion()}")
@@ -227,9 +223,8 @@ abstract class KotlinBasePluginWrapper : DefaultKotlinBasePlugin() {
        project.logger.info("Using Kotlin Gradle Plugin $pluginVariant variant")
        checkGradleCompatibility()

-        project.configurations.maybeCreate(NATIVE_COMPILER_PLUGIN_CLASSPATH_CONFIGURATION_NAME).apply {
+        project.configurations.maybeCreateResolvable(NATIVE_COMPILER_PLUGIN_CLASSPATH_CONFIGURATION_NAME).apply {
            isVisible = false
-            isCanBeConsumed = false
            isTransitive = false
            addGradlePluginMetadataAttributes(project)
        }
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfiguration
 import org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.sources.InternalKotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.sources.internal
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+import org.jetbrains.kotlin.gradle.utils.detachedResolvable
 import org.jetbrains.kotlin.gradle.utils.relativeOrAbsolute
 import org.jetbrains.kotlin.tooling.core.mutableExtrasOf

@@ -244,8 +244,7 @@ class IdeBinaryDependencyResolver @JvmOverloads constructor(
        if (sourceSet !is DefaultKotlinSourceSet) return null
        val project = sourceSet.project

-        val platformLikeCompileDependenciesConfiguration = project.configurations.detachedConfiguration()
-        platformLikeCompileDependenciesConfiguration.markResolvable()
+        val platformLikeCompileDependenciesConfiguration = project.configurations.detachedResolvable()
        platformLikeCompileDependenciesConfiguration.attributes.setupPlatformResolutionAttributes(sourceSet)
        platformLikeCompileDependenciesConfiguration.dependencies.addAll(sourceSet.resolvableMetadataConfiguration.allDependencies)

@@ -34,7 +34,6 @@ import org.jetbrains.kotlin.gradle.targets.metadata.*
 import org.jetbrains.kotlin.gradle.utils.*
 import org.jetbrains.kotlin.gradle.utils.Future
 import org.jetbrains.kotlin.gradle.utils.future
-import org.jetbrains.kotlin.gradle.utils.markResolvable
 import org.jetbrains.kotlin.gradle.utils.setProperty
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly

@@ -207,7 +206,7 @@ class DefaultKotlinUsageContext(
         * attributes schema migration, or create proper, non-detached configurations for publishing that are separated from the
         * configurations used for project-to-project dependencies
         */
-        val result = project.configurations.detachedConfiguration().markResolvable().attributes
+        val result = project.configurations.detachedResolvable().attributes

        // Capture type parameter T:
        fun <T> copyAttribute(attribute: Attribute<T>, from: AttributeContainer, to: AttributeContainer) {
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.DefaultKotlinCompi
 import org.jetbrains.kotlin.gradle.plugin.mpp.compilationImpl.KotlinCompilationConfigurationsContainer
 import org.jetbrains.kotlin.gradle.plugin.mpp.javaSourceSets
 import org.jetbrains.kotlin.gradle.plugin.sources.METADATA_CONFIGURATION_NAME_SUFFIX
-import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
 import org.jetbrains.kotlin.gradle.utils.*

 internal sealed class DefaultKotlinCompilationDependencyConfigurationsFactory :
@@ -101,84 +100,72 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
    val compilationCoordinates = "${target.disambiguationClassifier}/$compilationName"

    /* Support deprecated configurations */
-    val deprecatedCompileConfiguration = target.project.configurations.findByName(
+    val deprecatedCompileConfiguration = target.project.configurations.findDependencyScope(
        ConfigurationNaming.Default(target, compilationName).name(COMPILE)
    )?.apply {
-        isCanBeConsumed = false
        setupAsLocalTargetSpecificConfigurationIfSupported(target)
        isVisible = false
-        isCanBeResolved = false
        description = "Dependencies for $compilation (deprecated, use '${implementationConfigurationName} ' instead)."
    }

-    val deprecatedRuntimeConfiguration = if (withRuntime) target.project.configurations.findByName(
+    val deprecatedRuntimeConfiguration = if (withRuntime) target.project.configurations.findDependencyScope(
        ConfigurationNaming.Default(target, compilationName).name(RUNTIME)
    )?.apply {
-        isCanBeConsumed = false
        setupAsLocalTargetSpecificConfigurationIfSupported(target)
        deprecatedCompileConfiguration?.let { extendsFrom(it) }
        isVisible = false
-        isCanBeResolved = false
        description =
            "Runtime dependencies for $compilation (deprecated, use '${runtimeOnlyConfigurationName} ' instead)."
    } else null

    /* Actual configurations */

-    val apiConfiguration = target.project.configurations.maybeCreate(apiConfigurationName).apply {
+    val apiConfiguration = target.project.configurations.maybeCreateDependencyScope(apiConfigurationName).apply {
        deprecatedCompileConfiguration?.let { extendsFrom(it) }

        isVisible = false
-        isCanBeConsumed = false
-        isCanBeResolved = false
        description = "API dependencies for $compilationCoordinates"
    }

-    val implementationConfiguration = target.project.configurations.maybeCreate(implementationConfigurationName).apply {
-        extendsFrom(apiConfiguration)
-        deprecatedCompileConfiguration?.let { extendsFrom(it) }
-        isVisible = false
-        isCanBeConsumed = false
-        isCanBeResolved = false
-        description = "Implementation only dependencies for $compilationCoordinates."
-    }
+    val implementationConfiguration = target.project.configurations
+        .maybeCreateDependencyScope(implementationConfigurationName).apply {
+            extendsFrom(apiConfiguration)
+            deprecatedCompileConfiguration?.let { extendsFrom(it) }
+            isVisible = false
+            description = "Implementation only dependencies for $compilationCoordinates."
+        }

-    val compileOnlyConfiguration = target.project.configurations.maybeCreate(compileOnlyConfigurationName).apply {
-        isCanBeConsumed = false
-        setupAsLocalTargetSpecificConfigurationIfSupported(target)
-        attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
-        isVisible = false
-        isCanBeResolved = false
-        description = "Compile only dependencies for $compilationCoordinates."
-    }
+    val compileOnlyConfiguration = target.project.configurations
+        .maybeCreateDependencyScope(compileOnlyConfigurationName).apply {
+            setupAsLocalTargetSpecificConfigurationIfSupported(target)
+            attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
+            isVisible = false
+            description = "Compile only dependencies for $compilationCoordinates."
+        }

-    val runtimeOnlyConfiguration = target.project.configurations.maybeCreate(runtimeOnlyConfigurationName).apply {
+    val runtimeOnlyConfiguration = target.project.configurations.maybeCreateDependencyScope(runtimeOnlyConfigurationName).apply {
        isVisible = false
-        isCanBeConsumed = false
-        isCanBeResolved = false
        description = "Runtime only dependencies for $compilationCoordinates."
    }

-    val compileDependencyConfiguration = target.project.configurations.maybeCreate(compileClasspathConfigurationName).apply {
-        extendsFrom(compileOnlyConfiguration, implementationConfiguration)
-        usesPlatformOf(target)
-        isVisible = false
-        isCanBeConsumed = false
-        attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerApiUsage(target))
-        if (target.platformType != KotlinPlatformType.androidJvm) {
-            attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
+    val compileDependencyConfiguration = target.project.configurations
+        .maybeCreateResolvable(compileClasspathConfigurationName).apply {
+            extendsFrom(compileOnlyConfiguration, implementationConfiguration)
+            usesPlatformOf(target)
+            isVisible = false
+            attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerApiUsage(target))
+            if (target.platformType != KotlinPlatformType.androidJvm) {
+                attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
+            }
+            description = "Compile classpath for $compilationCoordinates."
        }
-        description = "Compile classpath for $compilationCoordinates."
-    }

    val runtimeDependencyConfiguration =
-        if (withRuntime) target.project.configurations.maybeCreate(runtimeClasspathConfigurationName).apply {
+        if (withRuntime) target.project.configurations.maybeCreateResolvable(runtimeClasspathConfigurationName).apply {
            extendsFrom(runtimeOnlyConfiguration, implementationConfiguration)
            deprecatedRuntimeConfiguration?.let { extendsFrom(it) }
            usesPlatformOf(target)
            isVisible = false
-            isCanBeConsumed = false
-            isCanBeResolved = true
            attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(target))
            if (target.platformType != KotlinPlatformType.androidJvm) {
                attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
@@ -187,8 +174,7 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
        } else null

    val hostSpecificMetadataConfiguration =
-        if (withHostSpecificMetadata) target.project.configurations.maybeCreate(hostSpecificMetadataConfigurationName).apply {
-            markResolvable()
+        if (withHostSpecificMetadata) target.project.configurations.maybeCreateResolvable(hostSpecificMetadataConfigurationName).apply {
            isVisible = false
            description = "Host-specific Metadata dependencies for $compilationCoordinates"
            extendsFrom(compileDependencyConfiguration)
@@ -198,7 +184,7 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
            }
        } else null

-    val pluginConfiguration = target.project.configurations.maybeCreate(pluginConfigurationName).apply {
+    val pluginConfiguration = target.project.configurations.maybeCreateResolvable(pluginConfigurationName).apply {
        addGradlePluginMetadataAttributes(target.project)

        if (target.platformType == KotlinPlatformType.native) {
@@ -208,7 +194,6 @@ private fun KotlinCompilationDependencyConfigurationsContainer(
            extendsFrom(target.project.commonKotlinPluginClasspath)
        }
        isVisible = false
-        isCanBeConsumed = false
        description = "Kotlin compiler plugins for $compilation"
    }

@@ -23,8 +23,8 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
 import org.jetbrains.kotlin.gradle.plugin.mpp.configureSourcesPublicationAttributes
 import org.jetbrains.kotlin.gradle.plugin.usesPlatformOf
 import org.jetbrains.kotlin.gradle.tasks.locateOrRegisterTask
+import org.jetbrains.kotlin.gradle.utils.*
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
-import org.jetbrains.kotlin.gradle.utils.markConsumable
 import org.jetbrains.kotlin.gradle.utils.named
 import org.jetbrains.kotlin.gradle.utils.newInstance

@@ -39,18 +39,21 @@ import org.jetbrains.kotlin.gradle.utils.newInstance
 fun <T : DecoratedExternalKotlinTarget> KotlinMultiplatformExtension.createExternalKotlinTarget(
    descriptor: ExternalKotlinTargetDescriptor<T>,
 ): T {
-    val apiElementsConfiguration = project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "apiElements"))
-    val runtimeElementsConfiguration = project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "runtimeElements"))
-    val sourcesElementsConfiguration = project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "sourcesElements"))
+    val apiElementsConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "apiElements"))
+    val runtimeElementsConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "runtimeElements"))
+    val sourcesElementsConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "sourcesElements"))

-    val apiElementsPublishedConfiguration =
-        project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "apiElements-published"))
+    val apiElementsPublishedConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "apiElements-published"))

-    val runtimeElementsPublishedConfiguration =
-        project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "runtimeElements-published"))
+    val runtimeElementsPublishedConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "runtimeElements-published"))

-    val sourcesElementsPublishedConfiguration =
-        project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "sourcesElements-published"))
+    val sourcesElementsPublishedConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "sourcesElements-published"))

    val kotlinTargetComponent = ExternalKotlinTargetComponent(
        ExternalKotlinTargetComponent.TargetProvider.byTargetName(this, descriptor.targetName)
@@ -91,17 +94,6 @@ fun <T : DecoratedExternalKotlinTarget> KotlinMultiplatformExtension.createExter
    target.setupRuntimeElements(runtimeElementsPublishedConfiguration)
    target.setupSourcesElements(sourcesElementsConfiguration)
    target.setupSourcesElements(sourcesElementsPublishedConfiguration)
-    apiElementsConfiguration.markConsumable()
-    runtimeElementsConfiguration.markConsumable()
-    sourcesElementsConfiguration.markConsumable()
-
-    /* Those configurations can not be resolved but also not consumed (not suitable for project to project dependencies) */
-    apiElementsPublishedConfiguration.isCanBeConsumed = false
-    apiElementsPublishedConfiguration.isCanBeResolved = false
-    runtimeElementsPublishedConfiguration.isCanBeResolved = false
-    runtimeElementsPublishedConfiguration.isCanBeConsumed = false
-    sourcesElementsPublishedConfiguration.isCanBeConsumed = false
-    sourcesElementsPublishedConfiguration.isCanBeResolved = false

    val decorated = descriptor.targetFactory.create(DecoratedExternalKotlinTarget.Delegate(target))
    target.onCreated()
@@ -19,10 +19,8 @@ import org.jetbrains.kotlin.gradle.plugin.sources.disambiguateName
 import org.jetbrains.kotlin.gradle.plugin.usageByName
 import org.jetbrains.kotlin.gradle.plugin.usesPlatformOf
 import org.jetbrains.kotlin.gradle.utils.*
-import org.jetbrains.kotlin.gradle.utils.getOrCreate
 import org.jetbrains.kotlin.gradle.utils.listProperty
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
-import org.jetbrains.kotlin.gradle.utils.markResolvable

 /**
 * @see resolvableMetadataConfiguration
@@ -37,8 +35,7 @@ internal val InternalKotlinSourceSet.resolvableMetadataConfigurationName: String
 */
 internal val InternalKotlinSourceSet.resolvableMetadataConfiguration: Configuration by extrasStoredProperty {
    assert(resolvableMetadataConfigurationName !in project.configurations.names)
-    val configuration = project.configurations.maybeCreate(resolvableMetadataConfigurationName)
-    configuration.markResolvable()
+    val configuration = project.configurations.maybeCreateResolvable(resolvableMetadataConfigurationName)

    withDependsOnClosure.forAll { sourceSet ->
        configuration.extendsFrom(project.configurations.getByName(sourceSet.apiConfigurationName))
@@ -96,18 +93,18 @@ private fun InternalKotlinSourceSet.configureMetadataDependenciesConfigurations(
 * the [InternalKotlinSourceSet.resolvableMetadataConfiguration]
 */
 private val Project.allCompileMetadataConfiguration
-    get(): Configuration = configurations.getOrCreate("allSourceSetsCompileDependenciesMetadata", invokeWhenCreated = { configuration ->
-        configuration.markResolvable()
-        configuration.usesPlatformOf(multiplatformExtension.metadata())
-        configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.usageByName(KotlinUsages.KOTLIN_METADATA))
-        configuration.attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
+    get(): Configuration = configurations.findResolvable("allSourceSetsCompileDependenciesMetadata")
+        ?: configurations.createResolvable("allSourceSetsCompileDependenciesMetadata").also { configuration ->
+            configuration.usesPlatformOf(multiplatformExtension.metadata())
+            configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.usageByName(KotlinUsages.KOTLIN_METADATA))
+            configuration.attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))

-        kotlinExtension.sourceSets.all { sourceSet ->
-            configuration.extendsFrom(configurations.getByName(sourceSet.apiConfigurationName))
-            configuration.extendsFrom(configurations.getByName(sourceSet.implementationConfigurationName))
-            configuration.extendsFrom(configurations.getByName(sourceSet.compileOnlyConfigurationName))
+            kotlinExtension.sourceSets.all { sourceSet ->
+                configuration.extendsFrom(configurations.getByName(sourceSet.apiConfigurationName))
+                configuration.extendsFrom(configurations.getByName(sourceSet.implementationConfigurationName))
+                configuration.extendsFrom(configurations.getByName(sourceSet.compileOnlyConfigurationName))
+            }
        }
-    })

 private inline fun <reified T> Project.listProvider(noinline provider: () -> List<T>): Provider<List<T>> {
    return project.objects.listProperty<T>().apply {
@@ -12,7 +12,8 @@ import org.gradle.api.attributes.Usage
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
 import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
-import org.jetbrains.kotlin.gradle.utils.getOrCreate
+import org.jetbrains.kotlin.gradle.utils.maybeCreateDependencyScope
+import org.jetbrains.kotlin.gradle.utils.maybeCreateResolvable
 import java.io.File

 internal abstract class KotlinSourceSetFactory<T : KotlinSourceSet> internal constructor(
@@ -42,11 +43,10 @@ internal abstract class KotlinSourceSetFactory<T : KotlinSourceSet> internal con
            )
        }
        configurationNames.forEach { configurationName ->
-            maybeCreate(configurationName).apply {
-                if (!configurationName.endsWith(METADATA_CONFIGURATION_NAME_SUFFIX)) {
-                    isCanBeResolved = false
-                }
-                isCanBeConsumed = false
+            if (!configurationName.endsWith(METADATA_CONFIGURATION_NAME_SUFFIX)) {
+                maybeCreateDependencyScope(configurationName)
+            } else {
+                maybeCreateResolvable(configurationName)
            }
        }
    }
@@ -87,15 +87,14 @@ internal class DefaultKotlinSourceSetFactory(
        }

        dependencyConfigurationWithMetadata.forEach { (configurationName, metadataName) ->
-            project.configurations.getOrCreate(metadataName).apply {
+            project.configurations.maybeCreateResolvable(metadataName).apply {
                attributes.attribute(KotlinPlatformType.attribute, KotlinPlatformType.common)
                attributes.attribute(Usage.USAGE_ATTRIBUTE, project.usageByName(KotlinUsages.KOTLIN_API))
                attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
                isVisible = false
-                isCanBeConsumed = false

                if (configurationName != null) {
-                    extendsFrom(project.configurations.maybeCreate(configurationName))
+                    extendsFrom(project.configurations.maybeCreateDependencyScope(configurationName))
                }

                if (project.isKotlinGranularMetadataEnabled) {
@@ -31,6 +31,8 @@ import org.jetbrains.kotlin.gradle.plugin.internal.JavaSourceSetsAccessor
 import org.jetbrains.kotlin.gradle.plugin.mpp.AbstractKotlinNativeCompilation
 import org.jetbrains.kotlin.gradle.scripting.ScriptingExtension
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.utils.maybeCreateDependencyScope
+import org.jetbrains.kotlin.gradle.utils.maybeCreateResolvable
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly

 private const val SCRIPTING_LOG_PREFIX = "kotlin scripting plugin:"
@@ -41,9 +43,8 @@ class ScriptingGradleSubplugin : Plugin<Project> {
        const val MISCONFIGURATION_MESSAGE_SUFFIX = "the plugin is probably applied by a mistake"

        fun configureForSourceSet(project: Project, sourceSetName: String) {
-            val discoveryConfiguration = project.configurations.maybeCreate(getDiscoveryClasspathConfigurationName(sourceSetName)).apply {
+            val discoveryConfiguration = project.configurations.maybeCreateDependencyScope(getDiscoveryClasspathConfigurationName(sourceSetName)).apply {
                isVisible = false
-                isCanBeConsumed = false
                description = "Script filename extensions discovery classpath configuration"
            }
            project.logger.info("$SCRIPTING_LOG_PREFIX created the scripting discovery configuration: ${discoveryConfiguration.name}")
@@ -111,9 +112,7 @@ private fun configureDiscoveryTransformation(
    discoveryConfiguration: Configuration,
    discoveryResultsConfigurationName: String
 ) {
-    project.configurations.maybeCreate(discoveryResultsConfigurationName).apply {
-        isCanBeConsumed = false
-        isCanBeResolved = true
+    project.configurations.maybeCreateResolvable(discoveryResultsConfigurationName).apply {
        attributes.attribute(artifactType, scriptFilesExtensions)
        extendsFrom(discoveryConfiguration)
    }
@@ -15,6 +15,8 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.configureSourcesPublicationAttribu
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal
 import org.jetbrains.kotlin.gradle.plugin.mpp.isSourcesPublishableFuture
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
+import org.jetbrains.kotlin.gradle.utils.maybeCreateConsumable
+import org.jetbrains.kotlin.gradle.utils.maybeCreateDependencyScope

 internal val CreateTargetConfigurationsSideEffect = KotlinTargetSideEffect { target ->
    val project = target.project
@@ -24,21 +26,19 @@ internal val CreateTargetConfigurationsSideEffect = KotlinTargetSideEffect { tar
    val mainCompilation = target.compilations.maybeCreate(KotlinCompilation.MAIN_COMPILATION_NAME)

    val compileConfiguration = mainCompilation.internal.configurations.deprecatedCompileConfiguration
-    val implementationConfiguration = configurations.maybeCreate(mainCompilation.implementationConfigurationName)
+    val implementationConfiguration = configurations.maybeCreateDependencyScope(mainCompilation.implementationConfigurationName)

    val runtimeOnlyConfiguration = when (mainCompilation) {
-        is KotlinCompilationToRunnableFiles<*> -> configurations.maybeCreate(mainCompilation.runtimeOnlyConfigurationName)
+        is KotlinCompilationToRunnableFiles<*> -> configurations.maybeCreateDependencyScope(mainCompilation.runtimeOnlyConfigurationName)
        else -> null
    }

-    configurations.maybeCreate(target.apiElementsConfigurationName).apply {
+    configurations.maybeCreateConsumable(target.apiElementsConfigurationName).apply {
        description = "API elements for main."
        isVisible = false
-        isCanBeResolved = false
-        isCanBeConsumed = true
        attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerApiUsage(target))
        attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
-        extendsFrom(configurations.maybeCreate(mainCompilation.apiConfigurationName))
+        extendsFrom(configurations.maybeCreateDependencyScope(mainCompilation.apiConfigurationName))
        if (mainCompilation is KotlinCompilationToRunnableFiles) {
            val runtimeConfiguration = mainCompilation.internal.configurations.deprecatedRuntimeConfiguration
            runtimeConfiguration?.let { extendsFrom(it) }
@@ -47,11 +47,9 @@ internal val CreateTargetConfigurationsSideEffect = KotlinTargetSideEffect { tar
    }

    if (mainCompilation is KotlinCompilationToRunnableFiles<*>) {
-        configurations.maybeCreate(target.runtimeElementsConfigurationName).apply {
+        configurations.maybeCreateConsumable(target.runtimeElementsConfigurationName).apply {
            description = "Elements of runtime for main."
            isVisible = false
-            isCanBeConsumed = true
-            isCanBeResolved = false
            attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerRuntimeUsage(target))
            attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
            val runtimeConfiguration = mainCompilation.internal.configurations.deprecatedRuntimeConfiguration
@@ -63,11 +61,9 @@ internal val CreateTargetConfigurationsSideEffect = KotlinTargetSideEffect { tar
        }
    }

-    configurations.maybeCreate(target.sourcesElementsConfigurationName).apply {
+    configurations.maybeCreateConsumable(target.sourcesElementsConfigurationName).apply {
        description = "Source files of main compilation of ${target.name}."
        isVisible = false
-        isCanBeResolved = false
-        isCanBeConsumed = true
        configureSourcesPublicationAttributes(target)
        project.launch { isCanBeConsumed = target.internal.isSourcesPublishableFuture.await() }
    }
@@ -75,9 +71,9 @@ internal val CreateTargetConfigurationsSideEffect = KotlinTargetSideEffect { tar
    if (target !is KotlinMetadataTarget) {
        val testCompilation = target.compilations.getByName(KotlinCompilation.TEST_COMPILATION_NAME)
        val compileTestsConfiguration = testCompilation.internal.configurations.deprecatedCompileConfiguration
-        val testImplementationConfiguration = configurations.maybeCreate(testCompilation.implementationConfigurationName)
+        val testImplementationConfiguration = configurations.maybeCreateDependencyScope(testCompilation.implementationConfigurationName)
        val testRuntimeOnlyConfiguration = when (testCompilation) {
-            is KotlinCompilationToRunnableFiles<*> -> configurations.maybeCreate(testCompilation.runtimeOnlyConfigurationName)
+            is KotlinCompilationToRunnableFiles<*> -> configurations.maybeCreateDependencyScope(testCompilation.runtimeOnlyConfigurationName)
            else -> null
        }

@@ -93,13 +89,11 @@ internal val CreateTargetConfigurationsSideEffect = KotlinTargetSideEffect { tar
    }

    if (target is KotlinJsIrTarget && !target.isMpp!!) {
-        target.project.configurations.maybeCreate(
+        target.project.configurations.maybeCreateConsumable(
            target.commonFakeApiElementsConfigurationName
        ).apply {
            description = "Common Fake API elements for main."
            isVisible = false
-            isCanBeResolved = false
-            isCanBeConsumed = true
            attributes.attribute<Usage>(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerApiUsage(target))
            attributes.attribute(KotlinPlatformType.attribute, KotlinPlatformType.common)
        }
@@ -221,10 +221,7 @@ abstract class KotlinAndroidTarget @Inject constructor(
        val outputTaskOrProvider = getLibraryOutputTask(variant) ?: return emptySet()
        val artifact = run {
            val archivesConfigurationName = lowerCamelCaseName(targetName, variantName, "archives")
-            project.configurations.maybeCreate(archivesConfigurationName).apply {
-                isCanBeConsumed = false
-                isCanBeResolved = false
-            }
+            project.configurations.maybeCreateDependencyScope(archivesConfigurationName)
            project.artifacts.add(archivesConfigurationName, outputTaskOrProvider) { artifact ->
                artifact.classifier = artifactClassifier
            }
@@ -294,12 +291,11 @@ abstract class KotlinAndroidTarget @Inject constructor(
        val existingConfiguration = project.configurations.findByName(sourcesElementsConfigurationName)
        if (existingConfiguration != null) return existingConfiguration

-        val apiElementsConfiguration = project.configurations.getByName(apiElementsConfigurationName)
-        return project.configurations.create(sourcesElementsConfigurationName).apply {
+        val apiElementsConfiguration = project.configurations.findConsumable(apiElementsConfigurationName)
+            ?: error("Configuration $apiElementsConfigurationName was not found")
+        return project.configurations.createConsumable(sourcesElementsConfigurationName).apply {
            description = "Source files of Android ${variantName}."
            isVisible = false
-            isCanBeResolved = false
-            isCanBeConsumed = true

            copyAttributes(apiElementsConfiguration.attributes, attributes)
            configureSourcesPublicationAttributes(this@KotlinAndroidTarget)
@@ -71,7 +71,7 @@ open class KotlinJsPlugin: Plugin<Project> {
                    API,
                    RUNTIME_ONLY
                ).forEach { baseConfigurationName ->
-                    configurations.maybeCreate(
+                    configurations.maybeCreateDependencyScope(
                        lowerCamelCaseName(
                            baseCompilationName,
                            baseConfigurationName
@@ -50,7 +50,6 @@ open class NodeJsRootPlugin : Plugin<Project> {
            it.description = "Download and install a local node/npm version"
            it.configuration = project.provider {
                project.configurations.detachedConfiguration(project.dependencies.create(it.ivyDependency))
-                    .markResolvable()
                    .also { conf -> conf.isTransitive = false }
            }
        }
@@ -32,9 +32,8 @@ import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin.Companion.
 import org.jetbrains.kotlin.gradle.targets.js.npm.*
 import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinPackageJsonTask
 import org.jetbrains.kotlin.gradle.tasks.registerTask
-import org.jetbrains.kotlin.gradle.utils.CompositeProjectComponentArtifactMetadata
-import org.jetbrains.kotlin.gradle.utils.`is`
-import org.jetbrains.kotlin.gradle.utils.topRealPath
+import org.jetbrains.kotlin.gradle.utils.*
+import org.jetbrains.kotlin.gradle.utils.createResolvable
 import java.io.Serializable

 /**
@@ -133,15 +132,13 @@ class KotlinCompilationNpmResolver(
    }

    private fun createAggregatedConfiguration(): Configuration {
-        val all = project.configurations.create(compilation.npmAggregatedConfigurationName)
+        val all = project.configurations.createResolvable(compilation.npmAggregatedConfigurationName)

        all.usesPlatformOf(target)
        all.attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(target))
        all.attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
        all.attributes.attribute(publicPackageJsonAttribute, PUBLIC_PACKAGE_JSON_ATTR_VALUE)
        all.isVisible = false
-        all.isCanBeConsumed = false
-        all.isCanBeResolved = true
        all.description = "NPM configuration for $compilation."

        KotlinDependencyScope.values().forEach { scope ->
@@ -163,15 +160,13 @@ class KotlinCompilationNpmResolver(
    }

    private fun createPublicPackageJsonConfiguration(): Configuration {
-        val all = project.configurations.create(compilation.publicPackageJsonConfigurationName)
+        val all = project.configurations.createConsumable(compilation.publicPackageJsonConfigurationName)

        all.usesPlatformOf(target)
        all.attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerRuntimeUsage(target))
        all.attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
        all.attributes.attribute(publicPackageJsonAttribute, PUBLIC_PACKAGE_JSON_ATTR_VALUE)
        all.isVisible = false
-        all.isCanBeConsumed = true
-        all.isCanBeResolved = false

        return all
    }
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockCopyTask.Companion.ST
 import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockCopyTask.Companion.UPGRADE_YARN_LOCK
 import org.jetbrains.kotlin.gradle.tasks.CleanDataTask
 import org.jetbrains.kotlin.gradle.tasks.registerTask
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+import org.jetbrains.kotlin.gradle.utils.detachedResolvable
 import org.jetbrains.kotlin.gradle.utils.onlyIfCompat

 open class YarnPlugin : Plugin<Project> {
@@ -47,8 +47,7 @@ open class YarnPlugin : Plugin<Project> {
            it.description = "Download and install a local yarn version"

            it.configuration = provider {
-                this.project.configurations.detachedConfiguration(this.project.dependencies.create(it.ivyDependency))
-                    .markResolvable()
+                this.project.configurations.detachedResolvable(this.project.dependencies.create(it.ivyDependency))
                    .also { conf -> conf.isTransitive = false }
            }
        }
@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.gradle.plugin.diagnostics.reportDiagnostic
 import org.jetbrains.kotlin.gradle.targets.android.internal.InternalKotlinTargetPreset
 import org.jetbrains.kotlin.gradle.tasks.KotlinTasksProvider
 import org.jetbrains.kotlin.gradle.utils.configureExperimentalTryNext
+import org.jetbrains.kotlin.gradle.utils.maybeCreateResolvable

@DeprecatedTargetPresetApi
 class KotlinJvmWithJavaTargetPreset(
@@ -71,12 +72,12 @@ class KotlinJvmWithJavaTargetPreset(

            compileDependencyFiles = project.files(
                main.output.allOutputs,
-                project.configurations.maybeCreate(compileDependencyConfigurationName)
+                project.configurations.maybeCreateResolvable(compileDependencyConfigurationName)
            )
            runtimeDependencyFiles = project.files(
                output.allOutputs,
                main.output.allOutputs,
-                project.configurations.maybeCreate(runtimeDependencyConfigurationName)
+                project.configurations.maybeCreateResolvable(runtimeDependencyConfigurationName)
            )
        }

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
 import org.jetbrains.kotlin.gradle.plugin.usesPlatformOf
 import org.jetbrains.kotlin.gradle.targets.KotlinTargetSideEffect
+import org.jetbrains.kotlin.gradle.utils.maybeCreateResolvable

 internal val ConfigureFrameworkExportSideEffect = KotlinTargetSideEffect<KotlinNativeTarget> { target ->
    val project = target.project
@@ -30,11 +31,9 @@ internal val ConfigureFrameworkExportSideEffect = KotlinTargetSideEffect<KotlinN
    }

    target.binaries.withType(AbstractNativeLibrary::class.java).all { framework ->
-        project.configurations.maybeCreate(framework.exportConfigurationName).apply {
+        project.configurations.maybeCreateResolvable(framework.exportConfigurationName).apply {
            isVisible = false
            isTransitive = false
-            isCanBeConsumed = false
-            isCanBeResolved = true
            usesPlatformOf(target)
            attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerApiUsage(target))
            attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
@@ -20,6 +20,7 @@ import org.gradle.api.tasks.TaskProvider
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.tasks.KotlinNativeLink
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
+import org.jetbrains.kotlin.gradle.utils.maybeCreateResolvable
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toUpperCaseAsciiOnly
 import java.io.File
@@ -213,9 +214,9 @@ abstract class AbstractNativeLibrary(
     */
    @ExperimentalKotlinGradlePluginApi
    var transitiveExport: Boolean
-        get() = project.configurations.maybeCreate(exportConfigurationName).isTransitive
+        get() = project.configurations.maybeCreateResolvable(exportConfigurationName).isTransitive
        set(value) {
-            project.configurations.maybeCreate(exportConfigurationName).isTransitive = value
+            project.configurations.maybeCreateResolvable(exportConfigurationName).isTransitive = value
        }

    /**
@@ -148,8 +148,7 @@ class NativeCompilerDownloader(
            )
        }

-        val configuration = project.configurations.detachedConfiguration(compilerDependency)
-            .markResolvable()
+        val configuration = project.configurations.detachedResolvable(compilerDependency)
        logger.lifecycle("\nPlease wait while Kotlin/Native compiler $compilerVersion is being installed.")

        if (!kotlinProperties.nativeDownloadFromMaven) {
@@ -20,10 +20,9 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType
 import org.jetbrains.kotlin.gradle.tasks.FatFrameworkTask
 import org.jetbrains.kotlin.gradle.tasks.KotlinNativeLink
+import org.jetbrains.kotlin.gradle.utils.*
 import org.jetbrains.kotlin.gradle.utils.copyAttributes
-import org.jetbrains.kotlin.gradle.utils.getOrCreate
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
-import org.jetbrains.kotlin.gradle.utils.markConsumable
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 import java.io.File
@@ -47,13 +46,13 @@ private val Framework.frameworkGroupDescription
    )

 internal fun Project.createFrameworkArtifact(binaryFramework: Framework, linkTask: TaskProvider<KotlinNativeLink>) {
-    val frameworkConfiguration = configurations.getOrCreate(binaryFramework.binaryFrameworkConfigurationName, invokeWhenCreated = {
-        it.markConsumable()
-        it.applyBinaryFrameworkGroupAttributes(project, binaryFramework.frameworkGroupDescription, listOf(binaryFramework.target))
-        project.launchInStage(KotlinPluginLifecycle.Stage.FinaliseDsl) {
-            copyAttributes(binaryFramework.attributes, it.attributes)
+    val frameworkConfiguration = configurations.findConsumable(binaryFramework.binaryFrameworkConfigurationName)
+        ?: configurations.createConsumable(binaryFramework.binaryFrameworkConfigurationName).also {
+            it.applyBinaryFrameworkGroupAttributes(project, binaryFramework.frameworkGroupDescription, listOf(binaryFramework.target))
+            project.launchInStage(KotlinPluginLifecycle.Stage.FinaliseDsl) {
+                copyAttributes(binaryFramework.attributes, it.attributes)
+            }
        }
-    })

    // Can't use flatMap here because of https://github.com/gradle/gradle/issues/25645
    val linkTaskOutputProvider = linkTask.map { it.outputFile.get() }
@@ -125,10 +124,9 @@ private fun Project.createFatFramework(groupDescription: FrameworkGroupDescripti
        }
    }

-    val fatFrameworkConfiguration = project.configurations.getOrCreate(fatFrameworkConfigurationName, invokeWhenCreated = {
-        it.markConsumable()
+    val fatFrameworkConfiguration = project.configurations.maybeCreateConsumable(fatFrameworkConfigurationName).also {
        it.applyBinaryFrameworkGroupAttributes(project, groupDescription, targets = frameworks.map(Framework::target))
-    })
+    }

    addFrameworkArtifact(fatFrameworkConfiguration, fatFrameworkTask.map { it.fatFramework })
 }
@@ -21,8 +21,8 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfiguration
 import org.jetbrains.kotlin.gradle.plugin.sources.internal
 import org.jetbrains.kotlin.gradle.targets.metadata.awaitMetadataCompilationsCreated
 import org.jetbrains.kotlin.gradle.targets.metadata.findMetadataCompilation
-import org.jetbrains.kotlin.gradle.utils.markConsumable
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+import org.jetbrains.kotlin.gradle.utils.createConsumable
+import org.jetbrains.kotlin.gradle.utils.createResolvable
 import org.jetbrains.kotlin.tooling.core.UnsafeApi

 /* Elements configuration */
@@ -64,8 +64,7 @@ internal fun Project.locateOrCreateCommonizedCInteropApiElementsConfiguration(co
    val configurationName = commonizerTarget.identityString + "CInteropApiElements"
    configurations.findByName(configurationName)?.let { return it }

-    return configurations.create(configurationName) { configuration ->
-        configuration.markConsumable()
+    return configurations.createConsumable(configurationName).also { configuration ->
        setupBasicCommonizedCInteropConfigurationAttributes(configuration, commonizerTarget)

        launch {
@@ -102,9 +101,8 @@ internal suspend fun Project.locateOrCreateCommonizedCInteropDependencyConfigura
    val configurationName = sourceSet.name + "CInterop"
    configurations.findByName(configurationName)?.let { return it }

-    val configuration = configurations.create(configurationName) { configuration ->
+    val configuration = configurations.createResolvable(configurationName).also { configuration ->
        configuration.isVisible = false
-        configuration.markResolvable()

        // Extends from Metadata Configuration associated with given source set to ensure matching
        configuration.extendsFrom(sourceSet.internal.resolvableMetadataConfiguration)
@@ -21,8 +21,10 @@ import org.jetbrains.kotlin.gradle.plugin.usesPlatformOf
 import org.jetbrains.kotlin.gradle.targets.KotlinTargetSideEffect
 import org.jetbrains.kotlin.gradle.targets.native.internal.CInteropKlibLibraryElements.cinteropKlibLibraryElements
 import org.jetbrains.kotlin.gradle.tasks.CInteropProcess
+import org.jetbrains.kotlin.gradle.utils.*
 import org.jetbrains.kotlin.gradle.utils.copyAttributes
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+import org.jetbrains.kotlin.gradle.utils.createConsumable
+import org.jetbrains.kotlin.gradle.utils.findConsumable

 internal fun createCInteropApiElementsKlibArtifact(
    target: KotlinNativeTarget,
@@ -43,15 +45,14 @@ internal fun createCInteropApiElementsKlibArtifact(
 internal fun Project.locateOrCreateCInteropDependencyConfiguration(
    compilation: KotlinNativeCompilation,
 ): Configuration {
-    configurations.findByName(compilation.cInteropDependencyConfigurationName)?.let { return it }
+    configurations.findResolvable(compilation.cInteropDependencyConfigurationName)?.let { return it }

    val compileOnlyConfiguration = configurations.getByName(compilation.compileOnlyConfigurationName)
    val implementationConfiguration = configurations.getByName(compilation.implementationConfigurationName)

-    return configurations.create(compilation.cInteropDependencyConfigurationName).apply {
+    return configurations.createResolvable(compilation.cInteropDependencyConfigurationName).apply {
        extendsFrom(compileOnlyConfiguration, implementationConfiguration)
        isVisible = false
-        markResolvable()

        /* Deferring attributes to wait for compilation.attributes to be configured  by user*/
        launchInStage(AfterFinaliseDsl) {
@@ -74,12 +75,9 @@ internal val SetupCInteropApiElementsConfigurationSideEffect = KotlinTargetSideE

 internal fun Project.locateOrCreateCInteropApiElementsConfiguration(target: KotlinTarget): Configuration {
    val configurationName = cInteropApiElementsConfigurationName(target)
-    configurations.findByName(configurationName)?.let { return it }
-
-    return configurations.create(configurationName).apply {
-        isCanBeResolved = false
-        isCanBeConsumed = true
+    configurations.findConsumable(configurationName)?.let { return it }

+    return configurations.createConsumable(configurationName).apply {
        /* Deferring attributes to wait for target.attributes to be configured by user */
        launchInStage(AfterFinaliseDsl) {
            usesPlatformOf(target)
@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
 import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
+import org.jetbrains.kotlin.gradle.utils.maybeCreateResolvable
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.konan.target.presetName

@@ -72,10 +73,8 @@ abstract class KotlinNativeArtifactConfigImpl(artifactName: String) : KotlinArti

 internal fun Project.registerLibsDependencies(target: KonanTarget, artifactName: String, deps: Set<Any>): String {
    val librariesConfigurationName = lowerCamelCaseName(target.presetName, artifactName, "linkLibrary")
-    configurations.maybeCreate(librariesConfigurationName).apply {
+    configurations.maybeCreateResolvable(librariesConfigurationName).apply {
        isVisible = false
-        isCanBeConsumed = false
-        isCanBeResolved = true
        isTransitive = true
        attributes.attribute(KotlinPlatformType.attribute, KotlinPlatformType.native)
        attributes.attribute(KotlinNativeTarget.konanTargetAttribute, target.name)
@@ -87,10 +86,8 @@ internal fun Project.registerLibsDependencies(target: KonanTarget, artifactName:

 internal fun Project.registerExportDependencies(target: KonanTarget, artifactName: String, deps: Set<Any>): String {
    val exportConfigurationName = lowerCamelCaseName(target.presetName, artifactName, "linkExport")
-    configurations.maybeCreate(exportConfigurationName).apply {
+    configurations.maybeCreateResolvable(exportConfigurationName).apply {
        isVisible = false
-        isCanBeConsumed = false
-        isCanBeResolved = true
        isTransitive = false
        attributes.attribute(KotlinPlatformType.attribute, KotlinPlatformType.native)
        attributes.attribute(KotlinNativeTarget.konanTargetAttribute, target.name)
@@ -25,8 +25,10 @@ import org.jetbrains.kotlin.gradle.internal.kapt.incremental.StructureTransformA
 import org.jetbrains.kotlin.gradle.internal.kapt.incremental.StructureTransformLegacyAction
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.tasks.toCompilerPluginOptions
+import org.jetbrains.kotlin.gradle.utils.*
+import org.jetbrains.kotlin.gradle.utils.createDependencyScope
+import org.jetbrains.kotlin.gradle.utils.detachedResolvable
 import org.jetbrains.kotlin.gradle.utils.listProperty
-import org.jetbrains.kotlin.gradle.utils.markResolvable
 import java.io.File

 internal open class KaptConfig<TASK : KaptTask>(
@@ -91,7 +93,7 @@ internal open class KaptConfig<TASK : KaptTask>(
        return if (project.isIncrementalKapt()) {
            maybeRegisterTransform(project)

-            val classStructureConfiguration = project.configurations.detachedConfiguration().markResolvable()
+            val classStructureConfiguration = project.configurations.detachedResolvable()

            // Wrap the `kotlinCompile.classpath` into a file collection, so that, if the classpath is represented by a configuration,
            // the configuration is not extended (via extendsFrom, which normally happens when one configuration is _added_ into another)
@@ -196,8 +198,8 @@ internal class KaptWithoutKotlincConfig : KaptConfig<KaptWithoutKotlincTask> {
        kaptGenerateStubsTask: TaskProvider<KaptGenerateStubsTask>,
        ext: KaptExtension
    ) : super(project, kaptGenerateStubsTask, ext) {
-        project.configurations.findByName(Kapt3GradleSubplugin.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME)
-            ?: project.configurations.create(Kapt3GradleSubplugin.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME).apply {
+        project.configurations.findResolvable(Kapt3GradleSubplugin.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME)
+            ?: project.configurations.createResolvable(Kapt3GradleSubplugin.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME).apply {
                dependencies.addAllLater(project.listProperty {
                    val kaptDependency = "org.jetbrains.kotlin:kotlin-annotation-processing-gradle:${project.getKotlinPluginVersion()}"
                    listOf(
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaCompilation
 import org.jetbrains.kotlin.gradle.plugin.tcs
 import org.jetbrains.kotlin.gradle.tasks.DefaultKotlinJavaToolchain
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+import org.jetbrains.kotlin.gradle.utils.detachedResolvable
 import org.jetbrains.kotlin.gradle.utils.providerWithLazyConvention

 internal typealias KotlinCompileConfig = BaseKotlinCompileConfig<KotlinCompile>
@@ -48,9 +48,9 @@ internal open class BaseKotlinCompileConfig<TASK : KotlinCompile> : AbstractKotl
                registerTransformsOnce(project, jvmToolchain, runKotlinCompilerViaBuildToolsApi)
                // Note: Creating configurations should be done during build configuration, not task configuration, to avoid issues with
                // composite builds (e.g., https://issuetracker.google.com/183952598).
-                project.configurations.detachedConfiguration(
+                project.configurations.detachedResolvable(
                    project.dependencies.create(objectFactory.fileCollection().from(project.provider { taskProvider.get().libraries }))
-                ).markResolvable()
+                )
            } else null

            if (useClasspathSnapshot) {
@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.gradle.utils

 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ConfigurationContainer
+import org.gradle.api.artifacts.Dependency

 const val COMPILE_ONLY = "compileOnly"
 const val COMPILE = "compile"
@@ -15,12 +17,55 @@ const val RUNTIME_ONLY = "runtimeOnly"
 const val RUNTIME = "runtime"
 internal const val INTRANSITIVE = "intransitive"

-internal fun Configuration.markConsumable(): Configuration = apply {
-    this.isCanBeConsumed = true
-    this.isCanBeResolved = false
+internal fun ConfigurationContainer.createResolvable(name: String): Configuration = create(name).apply {
+    isCanBeConsumed = false
 }

-internal fun Configuration.markResolvable(): Configuration = apply {
-    this.isCanBeConsumed = false
-    this.isCanBeResolved = true
+internal fun ConfigurationContainer.findResolvable(name: String): Configuration? = findByName(name)?.apply {
+    if (isCanBeResolved && isCanBeConsumed) {
+        isCanBeConsumed = false
+    } else {
+        check(isCanBeResolved && !isCanBeConsumed) { "$this is not resolvable" }
+    }
 }
+
+internal fun ConfigurationContainer.maybeCreateResolvable(name: String): Configuration =
+    findResolvable(name) ?: createResolvable(name)
+
+internal fun ConfigurationContainer.detachedResolvable(vararg dependencies: Dependency) =
+    detachedConfiguration(*dependencies).apply {
+        isCanBeConsumed = false
+    }
+
+internal fun ConfigurationContainer.createConsumable(name: String): Configuration = create(name).apply {
+    isCanBeResolved = false
+}
+
+internal fun ConfigurationContainer.findConsumable(name: String): Configuration? = findByName(name)?.apply {
+    if (isCanBeResolved && isCanBeConsumed) {
+        isCanBeResolved = false
+    } else {
+        check(!isCanBeResolved && isCanBeConsumed) { "$this is not consumable" }
+    }
+}
+
+internal fun ConfigurationContainer.maybeCreateConsumable(name: String): Configuration =
+    findConsumable(name) ?: createConsumable(name)
+
+internal fun ConfigurationContainer.createDependencyScope(name: String) = create(name).apply {
+    isCanBeResolved = false
+    isCanBeConsumed = false
+}
+
+internal fun ConfigurationContainer.findDependencyScope(name: String): Configuration? = findByName(name)?.apply {
+    if (isCanBeResolved && isCanBeConsumed) {
+        isCanBeConsumed = false
+        isCanBeResolved = false
+    } else {
+        check(!isCanBeResolved) { "$this is not dependency scope configuration but resolvable one" }
+        check(!isCanBeConsumed) { "$this is not dependency scope configuration but consumable one" }
+    }
+}
+
+internal fun ConfigurationContainer.maybeCreateDependencyScope(name: String): Configuration =
+    findDependencyScope(name) ?: createDependencyScope(name)
@@ -11,8 +11,8 @@ import org.gradle.api.attributes.Usage
 import org.gradle.kotlin.dsl.dependencies
 import org.jetbrains.kotlin.gradle.targets.native.internal.CInteropCommonizerArtifactTypeAttribute
 import org.jetbrains.kotlin.gradle.util.buildProjectWithMPP
-import org.jetbrains.kotlin.gradle.utils.markConsumable
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+import org.jetbrains.kotlin.gradle.utils.createConsumable
+import org.jetbrains.kotlin.gradle.utils.createResolvable
 import org.jetbrains.kotlin.gradle.utils.named
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -33,8 +33,7 @@ class CInteropCommonizerArtifactTypeAttributeTest {
        )

        /* Create consumable elements configuration */
-        project.configurations.create("testElements") { configuration ->
-            configuration.markConsumable()
+        project.configurations.createConsumable("testElements").also { configuration ->
            configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.objects.named("test"))

            /* Add klibCollectionDir as artifact */
@@ -45,8 +44,7 @@ class CInteropCommonizerArtifactTypeAttributeTest {
        }

        /* Create resolvable configuration */
-        val resolvable = project.configurations.create("testDependencies") { configuration ->
-            configuration.markResolvable()
+        val resolvable = project.configurations.createResolvable("testDependencies").also { configuration ->
            configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.objects.named("test"))
            configuration.attributes.attribute(
                CInteropCommonizerArtifactTypeAttribute.attribute, CInteropCommonizerArtifactTypeAttribute.KLIB
@@ -21,8 +21,8 @@ import org.jetbrains.kotlin.gradle.plugin.await
 import org.jetbrains.kotlin.gradle.targets.native.internal.CommonizerTargetAttribute
 import org.jetbrains.kotlin.gradle.targets.native.internal.locateOrCreateCommonizedCInteropDependencyConfiguration
 import org.jetbrains.kotlin.gradle.util.*
-import org.jetbrains.kotlin.gradle.utils.markConsumable
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+import org.jetbrains.kotlin.gradle.utils.createConsumable
+import org.jetbrains.kotlin.gradle.utils.createResolvable
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.tooling.core.UnsafeApi
 import kotlin.test.Test
@@ -35,8 +35,7 @@ class CInteropCommonizerConfigurationTests {
    fun `test - compatibility rule - superset is compatible`() {
        val project = buildProjectWithMPP()

-        val consumable = project.configurations.create("testElements") { configuration ->
-            configuration.markConsumable()
+        val consumable = project.configurations.createConsumable("testElements").also { configuration ->
            configuration.attributes.attribute(
                CommonizerTargetAttribute.attribute,
                CommonizerTarget(
@@ -48,8 +47,7 @@ class CInteropCommonizerConfigurationTests {
            )
        }

-        val resolvable = project.configurations.create("testDependencies") { configuration ->
-            configuration.markResolvable()
+        val resolvable = project.configurations.createResolvable("testDependencies").also { configuration ->
            configuration.attributes.attribute(
                CommonizerTargetAttribute.attribute,
                CommonizerTarget(
@@ -74,8 +72,7 @@ class CInteropCommonizerConfigurationTests {
    fun `test - disambiguation rule - chooses most specific variant`() {
        val project = buildProjectWithMPP()

-        project.configurations.create("testConsumableAll") { configuration ->
-            configuration.markConsumable()
+        project.configurations.createConsumable("testConsumableAll").also { configuration ->
            configuration.attributes.attribute(
                CommonizerTargetAttribute.attribute,
                CommonizerTarget(
@@ -90,8 +87,7 @@ class CInteropCommonizerConfigurationTests {
        }

        /* More specific as it does not offer macos parts */
-        val consumableSpecific = project.configurations.create("testConsumableSpecific") { configuration ->
-            configuration.markConsumable()
+        val consumableSpecific = project.configurations.createConsumable("testConsumableSpecific").also { configuration ->
            configuration.attributes.attribute(
                CommonizerTargetAttribute.attribute,
                CommonizerTarget(
@@ -103,8 +99,7 @@ class CInteropCommonizerConfigurationTests {
            )
        }

-        val resolvable = project.configurations.create("testDependencies") { configuration ->
-            configuration.markResolvable()
+        val resolvable = project.configurations.createResolvable("testDependencies").also { configuration ->
            configuration.attributes.attribute(
                CommonizerTargetAttribute.attribute,
                CommonizerTarget(