[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

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/compilerRunner/GradleCliCommonizer.kt

@@ -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)
+    return configurations.findResolvable(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME)
-        ?: project.configurations.create(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME)
+        ?: project.configurations.createResolvable(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME)
-            .markResolvable()
             .run {
                 attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
                 attributes.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinLegacyCompatibilityMetadataArtifact.kt

@@ -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 {
+    target.project.configurations.createConsumable(COMMON_MAIN_ELEMENTS_CONFIGURATION_NAME).apply {
-        isCanBeConsumed = true
-        isCanBeResolved = false
         usesPlatformOf(target)
 
         attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.producerApiUsage(target))

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinNativeHostSpecificMetadataArtifact.kt

@@ -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 ->
+    target.project.configurations.createConsumable(target.hostSpecificMetadataElementsConfigurationName).also { configuration ->
-        configuration.isCanBeConsumed = true
-        configuration.isCanBeResolved = false
-
         configuration.extendsFrom(*apiElements.extendsFrom.toTypedArray())
 
         target.project.launchInStage(AfterFinaliseDsl) {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/Kapt3KotlinGradleSubplugin.kt

@@ -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 }
+            project.configurations.findResolvable(configurationName)?.let { return it }
-            val aptConfiguration = project.configurations.create(configurationName).apply {
+            val aptConfiguration = project.configurations.createResolvable(configurationName).apply {
-                // Should not be available for consumption from other projects during variant-aware dependency resolution:
-                isCanBeConsumed = false
                 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)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinLegacyMultiplatformPlugin.kt

@@ -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 implementConfig = project.configurations.createDependencyScope(IMPLEMENT_CONFIG_NAME)
-        val expectedByConfig = project.configurations.create(EXPECTED_BY_CONFIG_NAME)
+        val expectedByConfig = project.configurations.createDependencyScope(EXPECTED_BY_CONFIG_NAME)
 
         implementConfig.dependencies.whenObjectAdded {
             if (!implementConfigurationIsUsed) {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt

@@ -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)
+            .maybeCreateResolvable(COMPILER_CLASSPATH_CONFIGURATION_NAME)
-            .markResolvable()
             .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)
+            .maybeCreateResolvable(BUILD_TOOLS_API_CLASSPATH_CONFIGURATION_NAME)
-            .markResolvable()
             .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)
         }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdeBinaryDependencyResolver.kt

@@ -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()
+        val platformLikeCompileDependenciesConfiguration = project.configurations.detachedResolvable()
-        platformLikeCompileDependenciesConfiguration.markResolvable()
         platformLikeCompileDependenciesConfiguration.attributes.setupPlatformResolutionAttributes(sourceSet)
         platformLikeCompileDependenciesConfiguration.dependencies.addAll(sourceSet.resolvableMetadataConfiguration.allDependencies)
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinSoftwareComponent.kt

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

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/compilationImpl/factory/KotlinCompilationDependencyConfigurationsFactories.kt

@@ -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 {
+    val implementationConfiguration = target.project.configurations
-        extendsFrom(apiConfiguration)
+        .maybeCreateDependencyScope(implementationConfigurationName).apply {
-        deprecatedCompileConfiguration?.let { extendsFrom(it) }
+            extendsFrom(apiConfiguration)
-        isVisible = false
+            deprecatedCompileConfiguration?.let { extendsFrom(it) }
-        isCanBeConsumed = false
+            isVisible = false
-        isCanBeResolved = false
+            description = "Implementation only dependencies for $compilationCoordinates."
-        description = "Implementation only dependencies for $compilationCoordinates."
+        }
-    }
 
-    val compileOnlyConfiguration = target.project.configurations.maybeCreate(compileOnlyConfigurationName).apply {
+    val compileOnlyConfiguration = target.project.configurations
-        isCanBeConsumed = false
+        .maybeCreateDependencyScope(compileOnlyConfigurationName).apply {
-        setupAsLocalTargetSpecificConfigurationIfSupported(target)
+            setupAsLocalTargetSpecificConfigurationIfSupported(target)
-        attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
+            attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
-        isVisible = false
+            isVisible = false
-        isCanBeResolved = false
+            description = "Compile only dependencies for $compilationCoordinates."
-        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 {
+    val compileDependencyConfiguration = target.project.configurations
-        extendsFrom(compileOnlyConfiguration, implementationConfiguration)
+        .maybeCreateResolvable(compileClasspathConfigurationName).apply {
-        usesPlatformOf(target)
+            extendsFrom(compileOnlyConfiguration, implementationConfiguration)
-        isVisible = false
+            usesPlatformOf(target)
-        isCanBeConsumed = false
+            isVisible = false
-        attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerApiUsage(target))
+            attributes.attribute(Usage.USAGE_ATTRIBUTE, KotlinUsages.consumerApiUsage(target))
-        if (target.platformType != KotlinPlatformType.androidJvm) {
+            if (target.platformType != KotlinPlatformType.androidJvm) {
-            attributes.attribute(Category.CATEGORY_ATTRIBUTE, target.project.categoryByName(Category.LIBRARY))
+                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 {
+        if (withHostSpecificMetadata) target.project.configurations.maybeCreateResolvable(hostSpecificMetadataConfigurationName).apply {
-            markResolvable()
             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"
     }
 

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinTarget.kt

@@ -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 apiElementsConfiguration = project.configurations
-    val runtimeElementsConfiguration = project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "runtimeElements"))
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "apiElements"))
-    val sourcesElementsConfiguration = project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "sourcesElements"))
+    val runtimeElementsConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "runtimeElements"))
+    val sourcesElementsConfiguration = project.configurations
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "sourcesElements"))
 
-    val apiElementsPublishedConfiguration =
+    val apiElementsPublishedConfiguration = project.configurations
-        project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "apiElements-published"))
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "apiElements-published"))
 
-    val runtimeElementsPublishedConfiguration =
+    val runtimeElementsPublishedConfiguration = project.configurations
-        project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "runtimeElements-published"))
+        .maybeCreateConsumable(lowerCamelCaseName(descriptor.targetName, "runtimeElements-published"))
 
-    val sourcesElementsPublishedConfiguration =
+    val sourcesElementsPublishedConfiguration = project.configurations
-        project.configurations.maybeCreate(lowerCamelCaseName(descriptor.targetName, "sourcesElements-published"))
+        .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()

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/resolvableMetadataConfiguration.kt

@@ -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)
+    val configuration = project.configurations.maybeCreateResolvable(resolvableMetadataConfigurationName)
-    configuration.markResolvable()
 
     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 ->
+    get(): Configuration = configurations.findResolvable("allSourceSetsCompileDependenciesMetadata")
-        configuration.markResolvable()
+        ?: configurations.createResolvable("allSourceSetsCompileDependenciesMetadata").also { configuration ->
-        configuration.usesPlatformOf(multiplatformExtension.metadata())
+            configuration.usesPlatformOf(multiplatformExtension.metadata())
-        configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.usageByName(KotlinUsages.KOTLIN_METADATA))
+            configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.usageByName(KotlinUsages.KOTLIN_METADATA))
-        configuration.attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
+            configuration.attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.categoryByName(Category.LIBRARY))
 
-        kotlinExtension.sourceSets.all { sourceSet ->
+            kotlinExtension.sourceSets.all { sourceSet ->
-            configuration.extendsFrom(configurations.getByName(sourceSet.apiConfigurationName))
+                configuration.extendsFrom(configurations.getByName(sourceSet.apiConfigurationName))
-            configuration.extendsFrom(configurations.getByName(sourceSet.implementationConfigurationName))
+                configuration.extendsFrom(configurations.getByName(sourceSet.implementationConfigurationName))
-            configuration.extendsFrom(configurations.getByName(sourceSet.compileOnlyConfigurationName))
+                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 {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/KotlinSourceSetFactory.kt

@@ -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)) {
-                if (!configurationName.endsWith(METADATA_CONFIGURATION_NAME_SUFFIX)) {
+                maybeCreateDependencyScope(configurationName)
-                    isCanBeResolved = false
+            } else {
-                }
+                maybeCreateResolvable(configurationName)
-                isCanBeConsumed = false
             }
         }
     }
@@ -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) {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/scripting/internal/ScriptingGradleSubplugin.kt

@@ -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 {
+    project.configurations.maybeCreateResolvable(discoveryResultsConfigurationName).apply {
-        isCanBeConsumed = false
-        isCanBeResolved = true
         attributes.attribute(artifactType, scriptFilesExtensions)
         extendsFrom(discoveryConfiguration)
     }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/CreateTargetConfigurationsSideEffect.kt

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

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/android/KotlinAndroidTarget.kt

@@ -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 {
+            project.configurations.maybeCreateDependencyScope(archivesConfigurationName)
-                isCanBeConsumed = false
-                isCanBeResolved = false
-            }
             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)
+        val apiElementsConfiguration = project.configurations.findConsumable(apiElementsConfigurationName)
-        return project.configurations.create(sourcesElementsConfigurationName).apply {
+            ?: 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)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/KotlinJsPlugin.kt

@@ -71,7 +71,7 @@ open class KotlinJsPlugin: Plugin<Project> {
                     API,
                     RUNTIME_ONLY
                 ).forEach { baseConfigurationName ->
-                    configurations.maybeCreate(
+                    configurations.maybeCreateDependencyScope(
                         lowerCamelCaseName(
                             baseCompilationName,
                             baseConfigurationName

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/nodejs/NodeJsRootPlugin.kt

@@ -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 }
             }
         }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/resolver/KotlinCompilationNpmResolver.kt

@@ -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.*
-import org.jetbrains.kotlin.gradle.utils.`is`
+import org.jetbrains.kotlin.gradle.utils.createResolvable
-import org.jetbrains.kotlin.gradle.utils.topRealPath
 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
     }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/yarn/YarnPlugin.kt

@@ -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))
+                this.project.configurations.detachedResolvable(this.project.dependencies.create(it.ivyDependency))
-                    .markResolvable()
                     .also { conf -> conf.isTransitive = false }
             }
         }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinJvmWithJavaTargetPreset.kt

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

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/ConfigureFrameworkExportSideEffect.kt

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

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/NativeBinaries.kt

@@ -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
         }
 
     /**

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/NativeCompilerDownloader.kt

@@ -148,8 +148,7 @@ class NativeCompilerDownloader(
             )
         }
 
-        val configuration = project.configurations.detachedConfiguration(compilerDependency)
+        val configuration = project.configurations.detachedResolvable(compilerDependency)
-            .markResolvable()
         logger.lifecycle("\nPlease wait while Kotlin/Native compiler $compilerVersion is being installed.")
 
         if (!kotlinProperties.nativeDownloadFromMaven) {

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/configureBinaryFrameworks.kt

@@ -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 = {
+    val frameworkConfiguration = configurations.findConsumable(binaryFramework.binaryFrameworkConfigurationName)
-        it.markConsumable()
+        ?: configurations.createConsumable(binaryFramework.binaryFrameworkConfigurationName).also {
-        it.applyBinaryFrameworkGroupAttributes(project, binaryFramework.frameworkGroupDescription, listOf(binaryFramework.target))
+            it.applyBinaryFrameworkGroupAttributes(project, binaryFramework.frameworkGroupDescription, listOf(binaryFramework.target))
-        project.launchInStage(KotlinPluginLifecycle.Stage.FinaliseDsl) {
+            project.launchInStage(KotlinPluginLifecycle.Stage.FinaliseDsl) {
-            copyAttributes(binaryFramework.attributes, it.attributes)
+                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 = {
+    val fatFrameworkConfiguration = project.configurations.maybeCreateConsumable(fatFrameworkConfigurationName).also {
-        it.markConsumable()
         it.applyBinaryFrameworkGroupAttributes(project, groupDescription, targets = frameworks.map(Framework::target))
-    })
+    }
 
     addFrameworkArtifact(fatFrameworkConfiguration, fatFrameworkTask.map { it.fatFramework })
 }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/CInteropCommonizerConfigurations.kt

@@ -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.createConsumable
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+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 ->
+    return configurations.createConsumable(configurationName).also { configuration ->
-        configuration.markConsumable()
         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)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/CInteropConfigurations.kt

@@ -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 }
+    configurations.findConsumable(configurationName)?.let { return it }
-
-    return configurations.create(configurationName).apply {
-        isCanBeResolved = false
-        isCanBeConsumed = true
 
+    return configurations.createConsumable(configurationName).apply {
         /* Deferring attributes to wait for target.attributes to be configured by user */
         launchInStage(AfterFinaliseDsl) {
             usesPlatformOf(target)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/artifact/KotlinArtifact.kt

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

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/configuration/KaptConfig.kt

@@ -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.findResolvable(Kapt3GradleSubplugin.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME)
-            ?: project.configurations.create(Kapt3GradleSubplugin.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME).apply {
+            ?: 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(

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/tasks/configuration/KotlinCompileConfig.kt

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

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/configurations.kt

@@ -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 {
+internal fun ConfigurationContainer.createResolvable(name: String): Configuration = create(name).apply {
-    this.isCanBeConsumed = true
+    isCanBeConsumed = false
-    this.isCanBeResolved = false
 }
 
-internal fun Configuration.markResolvable(): Configuration = apply {
+internal fun ConfigurationContainer.findResolvable(name: String): Configuration? = findByName(name)?.apply {
-    this.isCanBeConsumed = false
+    if (isCanBeResolved && isCanBeConsumed) {
-    this.isCanBeResolved = true
+        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)

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/CInteropCommonizerArtifactTypeAttributeTest.kt

@@ -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.createConsumable
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+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 ->
+        project.configurations.createConsumable("testElements").also { configuration ->
-            configuration.markConsumable()
             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 ->
+        val resolvable = project.configurations.createResolvable("testDependencies").also { configuration ->
-            configuration.markResolvable()
             configuration.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.objects.named("test"))
             configuration.attributes.attribute(
                 CInteropCommonizerArtifactTypeAttribute.attribute, CInteropCommonizerArtifactTypeAttribute.KLIB

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/CInteropCommonizerConfigurationTests.kt

@@ -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.createConsumable
-import org.jetbrains.kotlin.gradle.utils.markResolvable
+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 ->
+        val consumable = project.configurations.createConsumable("testElements").also { configuration ->
-            configuration.markConsumable()
             configuration.attributes.attribute(
                 CommonizerTargetAttribute.attribute,
                 CommonizerTarget(
@@ -48,8 +47,7 @@ class CInteropCommonizerConfigurationTests {
             )
         }
 
-        val resolvable = project.configurations.create("testDependencies") { configuration ->
+        val resolvable = project.configurations.createResolvable("testDependencies").also { configuration ->
-            configuration.markResolvable()
             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 ->
+        project.configurations.createConsumable("testConsumableAll").also { configuration ->
-            configuration.markConsumable()
             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 ->
+        val consumableSpecific = project.configurations.createConsumable("testConsumableSpecific").also { configuration ->
-            configuration.markConsumable()
             configuration.attributes.attribute(
                 CommonizerTargetAttribute.attribute,
                 CommonizerTarget(
@@ -103,8 +99,7 @@ class CInteropCommonizerConfigurationTests {
             )
         }
 
-        val resolvable = project.configurations.create("testDependencies") { configuration ->
+        val resolvable = project.configurations.createResolvable("testDependencies").also { configuration ->
-            configuration.markResolvable()
             configuration.attributes.attribute(
                 CommonizerTargetAttribute.attribute,
                 CommonizerTarget(