KT-MR-5666 Minor fixes, refactorings & formatting

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinProjectExtension.kt

@@ -13,6 +13,7 @@ import org.gradle.api.internal.plugins.DslObject
 import org.gradle.jvm.toolchain.JavaToolchainSpec
 import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinAndroidTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJsSingleTargetPreset
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
@@ -120,7 +121,7 @@ open class KotlinProjectExtension @Inject constructor(project: Project) : Kotlin
         }
 
     internal val kpmModelContainer by lazy {
-        if (PropertiesProvider(project).experimentalKpmModelMapping) {
+        if (project.kotlinPropertiesProvider.experimentalKpmModelMapping) {
             DefaultKpmGradleProjectModelContainer.create(project)
         } else error("Model mapping is not enabled.")
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/KotlinDependenciesManagement.kt

@@ -101,11 +101,11 @@ internal fun configureStdlibDefaultDependency(project: Project) = with(project)
 
     val scopesToHandleConfigurations = listOf(KotlinDependencyScope.API_SCOPE, KotlinDependencyScope.IMPLEMENTATION_SCOPE)
 
-    val ext = topLevelExtension
+    val extension = topLevelExtension
     when {
         project.hasKpmModel -> addStdlibToKpmProject(project)
-        ext is KotlinProjectExtension -> {
+        extension is KotlinProjectExtension -> {
-            ext.sourceSets.all { kotlinSourceSet ->
+            extension.sourceSets.all { kotlinSourceSet ->
                 scopesToHandleConfigurations.forEach { scope ->
                     val scopeConfiguration = project.sourceSetDependencyConfigurationByScope(kotlinSourceSet, scope)
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/GradlePlugin.kt

@@ -82,8 +82,7 @@ abstract class KotlinPm20GradlePlugin @Inject constructor(
 fun rootPublicationComponentName(module: KotlinGradleModule) =
     module.disambiguateName("root")
 
-open class KotlinPm20ProjectExtension(project: Project) :
+open class KotlinPm20ProjectExtension(project: Project) : KotlinTopLevelExtension(project) {
-    KotlinTopLevelExtension(project) {
 
     internal val kpmModelContainer = DefaultKpmGradleProjectModelContainer.create(project)
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinCompilationData.kt

@@ -37,7 +37,7 @@ interface KotlinVariantCompilationDataInternal<T : KotlinCommonOptions> : Kotlin
                 project.filesProvider {
                     val friendVariants = resolveFriendVariants()
                     val friendModuleClassifiers = friendVariants.map { it.containingModule.moduleClassifier }.toSet()
-                    val artifactView = owner.compileDependenciesConfiguration
+                    owner.compileDependenciesConfiguration
                         .incoming.artifactView { view ->
                             view.componentFilter { id ->
                                 // FIXME rewrite using the proper module resolution after those changes are merged
@@ -45,11 +45,10 @@ interface KotlinVariantCompilationDataInternal<T : KotlinCommonOptions> : Kotlin
                                 asProject?.build?.isCurrentBuild == true &&
                                         asProject.projectPath == owner.project.path
                             }
-                        }.artifacts
+                        }.artifacts.filter {
-                    artifactView.filter {
+                            // FIXME rewrite using the proper module resolution after those changes are merged
-                        // FIXME rewrite using the proper module resolution after those changes are merged
+                            moduleClassifiersFromCapabilities(it.variant.capabilities).any { it in friendModuleClassifiers }
-                        moduleClassifiersFromCapabilities(it.variant.capabilities).any { it in friendModuleClassifiers }
+                        }.map { it.file }
-                    }.map { it.file }
                 }
             )
         }
@@ -72,17 +71,16 @@ interface KotlinVariantCompilationDataInternal<T : KotlinCommonOptions> : Kotlin
                 ?: error("Failed to resolve dependencies of ${owner.containingModule}"))
                 .allDependencyModules
                 .filterIsInstance<KotlinGradleModule>()
-                .filter {
+                .filter { dependencyModule ->
                     // the module comes from the same Gradle project // todo: extend to other friends once supported
-                    it.project == owner.containingModule.project &&
+                    dependencyModule.project == owner.containingModule.project
-                            // also, important to check that the owner variant really requests this module:
-                            variantResolver.getChosenVariant(owner, it) is VariantResolution.VariantMatch
                 }
 
-        val friendVariants = friendModules.map {
+        return friendModules
-            (variantResolver.getChosenVariant(owner, it) as VariantResolution.VariantMatch).chosenVariant
+            .map { friendModule -> variantResolver.getChosenVariant(owner, friendModule) }
-        }
+            // also, important to check that the owner variant really requests this module:
-        return friendVariants.filterIsInstance<KotlinGradleVariant>()
+            .filterIsInstance<VariantResolution.VariantMatch>()
+            .mapNotNull { variantMatch -> variantMatch.chosenVariant as? KotlinGradleVariant }
     }
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinGradleFragment.kt

@@ -90,8 +90,8 @@ open class KotlinGradleFragmentInternal @Inject constructor(
     //       out of the consumer's metadata compilations compile classpath; however, Native variants must expose implementation as API
     //       anyway, so for now all fragments follow that behavior
     override val declaredModuleDependencies: Iterable<KotlinModuleDependency>
-        get() = listOf(apiConfiguration, implementationConfiguration).flatMapTo(mutableSetOf()) {
+        get() = listOf(apiConfiguration, implementationConfiguration).flatMapTo(mutableSetOf()) { exportConfiguration ->
-            it.allDependencies.map { it.toModuleDependency(project) }
+            exportConfiguration.allDependencies.map { dependency -> dependency.toModuleDependency(project) }
         }
 
     override val kotlinSourceRoots: SourceDirectorySet =

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KotlinJvmVariant.kt

@@ -51,7 +51,7 @@ internal fun KotlinGradleVariant.ownModuleName(): String {
     return filterModuleName("$baseName$suffix")
 }
 
-class KotlinMappedJvmCompilationFactory(
+internal class KotlinMappedJvmCompilationFactory(
     target: KotlinJvmTarget
 ) : KotlinJvmCompilationFactory(target) {
     override fun create(name: String): KotlinJvmCompilation {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/KpmAwareTargetConfigurator.kt

@@ -28,7 +28,7 @@ internal open class KpmAwareTargetConfigurator<T : KotlinTarget>(
     private fun setupMavenPublicationDsl(target: T) {
         if (target is AbstractKotlinTarget) {
             target.compilations.all { compilation ->
-                val compilationDetails = (compilation as? AbstractKotlinCompilation)?.compilationDetails as? VariantMappedCompilationDetails
+                val compilationDetails = (compilation as? AbstractKotlinCompilation)?.compilationDetails
                 if (compilationDetails is VariantMappedCompilationDetails<*> && compilationDetails.variant.containingModule.isMain) {
                     val variant = compilationDetails.variant
                     if (variant is SingleMavenPublishedModuleHolder) {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/LegacyMappedVariant.kt

@@ -40,15 +40,19 @@ internal open class LegacyMappedVariant(
 
     override val platformType: KotlinPlatformType
         get() = compilation.platformType
+
     override val compileDependenciesConfiguration: Configuration
         get() = project.configurations.getByName(compilation.compileDependencyConfigurationName)
+
     override var compileDependencyFiles: FileCollection
         get() = compilation.compileDependencyFiles
         set(value) {
             compilation.compileDependencyFiles = value
         }
+
     override val compilationOutputs: KotlinCompilationOutput
         get() = compilation.output
+
     override val sourceArchiveTaskName: String
         get() = defaultSourceArtifactTaskName // TODO: no such task yet
 
@@ -180,12 +184,11 @@ internal fun mapTargetCompilationsToKpmVariants(target: AbstractKotlinTarget, pu
         module.fragments.add(variant)
     }
 
-    val whenPublicationShouldRegister: (() -> Unit) -> Unit = when (publicationRegistration) {
+    fun whenPublicationShouldRegister(action: () -> Unit) =
-        PublicationRegistrationMode.IMMEDIATE -> ::run
+        when (publicationRegistration) {
-        PublicationRegistrationMode.AFTER_EVALUATE -> {
+            PublicationRegistrationMode.IMMEDIATE -> action()
-            { target.project.whenEvaluated { it() } }
+            PublicationRegistrationMode.AFTER_EVALUATE -> target.project.whenEvaluated { action() }
         }
-    }
 
     whenPublicationShouldRegister {
         val mainModule = target.project.kpmModules.getByName(KotlinGradleModule.MAIN_MODULE_NAME)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/pm20/fragmentsMetadataCompilation.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.gradle.tasks.registerTask
 import org.jetbrains.kotlin.gradle.tasks.withType
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
 import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
+import org.jetbrains.kotlin.gradle.utils.filesProvider
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.library.KLIB_FILE_EXTENSION
 import org.jetbrains.kotlin.project.model.KotlinModuleFragment
@@ -152,14 +153,12 @@ private fun configureMetadataJarTask(
     }
     module.fragments.all { fragment ->
         allMetadataJar.configure { jar ->
-            val metadataOutput = project.files(Callable {
+            val metadataOutput = project.filesProvider {
                 val compilationData = registry.getForFragmentOrNull(fragment)
-                compilationData?.run {
+                    .takeIf { !fragment.isNativeHostSpecific() }
-                    if (!fragment.isNativeHostSpecific())
+                    ?: return@filesProvider emptyList<Any>()
-                        project.filesWithUnpackedArchives(compilationData.output.allOutputs, setOf(KLIB_FILE_EXTENSION))
+                project.filesWithUnpackedArchives(compilationData.output.allOutputs, setOf(KLIB_FILE_EXTENSION))
-                    else emptyList<Any>()
+            }
-                } ?: emptyList<Any>()
-            })
             jar.from(metadataOutput) { spec ->
                 spec.into(fragment.fragmentName)
             }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/metadata/KpmMetadataTargetConfigurator.kt

@@ -27,16 +27,13 @@ internal class KpmMetadataTargetConfigurator(private val metadataTargetConfigura
     override fun configureCompilationDefaults(target: KotlinMetadataTarget) {
         super.configureCompilationDefaults(target)
 
-        // we still want to configure the legacy "main" compilation
+        val mainCompilation = target.compilations.create(KotlinCompilation.MAIN_COMPILATION_NAME)
-        run {
+        defineConfigurationsForCompilation(mainCompilation)
-            val mainCompilation = target.compilations.create(KotlinCompilation.MAIN_COMPILATION_NAME)
+        createLifecycleTask(mainCompilation)
-            defineConfigurationsForCompilation(mainCompilation)
+        metadataTargetConfigurator
-            createLifecycleTask(mainCompilation)
+            .buildCompilationProcessor(mainCompilation)
-            metadataTargetConfigurator
+            .run()
-                .buildCompilationProcessor(mainCompilation)
+        mainCompilation.compileKotlinTaskProvider.configure { it.enabled = false }
-                .run()
-            mainCompilation.compileKotlinTaskProvider.configure { it.enabled = false }
-        }
     }
 
     private fun configureTargetWithKpm(target: KotlinMetadataTarget) {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/utils/stringUtils.kt

@@ -24,7 +24,7 @@ internal fun dashSeparatedName(vararg nameParts: String?): String {
 }
 
 internal fun dashSeparatedLowercaseName(nameParts: Iterable<String?>) =
-    dashSeparatedName(*nameParts.toList().toTypedArray())
+    dashSeparatedLowercaseName(*nameParts.toList().toTypedArray())
 
 internal fun dashSeparatedLowercaseName(vararg nameParts: String?): String {
     val nonEmptyParts = nameParts.mapNotNull { it?.takeIf(String::isNotEmpty)?.toLowerCase(Locale.ENGLISH) }