[Commonizer] Prefer using CommonizerTarget instead of KonanTarget

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cli/nativeTasks.kt

@@ -59,15 +59,17 @@ internal class NativeKlibCommonize(options: Collection<Option<*>>) : Task(option
         val statsType = getOptional<StatsType, StatsTypeOptionType> { it == "log-stats" } ?: StatsType.NONE
 
         val konanTargets = outputCommonizerTarget.konanTargets
+        val commonizerTargets = konanTargets.map(::CommonizerTarget)
+
         val logger = CliLoggerAdapter(2)
         val libraryLoader = DefaultNativeLibraryLoader(logger)
-        val statsCollector = StatsCollector(statsType, konanTargets.toList())
+        val statsCollector = StatsCollector(statsType, commonizerTargets)
         val repository = FilesRepository(targetLibraries.toSet(), libraryLoader)
 
         val resultsConsumer = buildResultsConsumer {
             this add ModuleSerializer(destination, HierarchicalCommonizerOutputLayout)
             this add CopyUnconsumedModulesAsIsConsumer(
-                repository, destination, konanTargets, NativeDistributionCommonizerOutputLayout, logger.toProgressLogger()
+                repository, destination, commonizerTargets.toSet(), NativeDistributionCommonizerOutputLayout, logger.toProgressLogger()
             )
             this add LoggingResultsConsumer(outputCommonizerTarget, logger.toProgressLogger())
         }
@@ -75,10 +77,10 @@ internal class NativeKlibCommonize(options: Collection<Option<*>>) : Task(option
         LibraryCommonizer(
             konanDistribution = distribution,
             repository = repository,
-            dependencies = KonanDistributionRepository(distribution, konanTargets, libraryLoader) +
+            dependencies = KonanDistributionRepository(distribution, commonizerTargets.toSet(), libraryLoader) +
                     FilesRepository(dependencyLibraries.toSet(), libraryLoader),
             libraryLoader = libraryLoader,
-            targets = konanTargets.toList(),
+            targets = commonizerTargets,
             resultsConsumer = resultsConsumer,
             statsCollector = statsCollector,
             logger = logger
@@ -94,7 +96,8 @@ internal class NativeDistributionCommonize(options: Collection<Option<*>>) : Tas
     override fun execute(logPrefix: String) {
         val distribution = KonanDistribution(getMandatory<File, NativeDistributionOptionType>())
         val destination = getMandatory<File, OutputOptionType>()
-        val targets = getMandatory<List<KonanTarget>, NativeTargetsOptionType>()
+        val konanTargets = getMandatory<List<KonanTarget>, NativeTargetsOptionType>()
+        val commonizerTargets = konanTargets.map(::CommonizerTarget)
 
         val copyStdlib = getOptional<Boolean, BooleanOptionType> { it == "copy-stdlib" } ?: false
         val copyEndorsedLibs = getOptional<Boolean, BooleanOptionType> { it == "copy-endorsed-libs" } ?: false
@@ -102,21 +105,21 @@ internal class NativeDistributionCommonize(options: Collection<Option<*>>) : Tas
 
         val logger = CliLoggerAdapter(2)
         val libraryLoader = DefaultNativeLibraryLoader(logger)
-        val repository = KonanDistributionRepository(distribution, targets.toSet(), libraryLoader)
+        val repository = KonanDistributionRepository(distribution, commonizerTargets.toSet(), libraryLoader)
-        val statsCollector = StatsCollector(statsType, targets)
+        val statsCollector = StatsCollector(statsType, commonizerTargets)
 
         val resultsConsumer = buildResultsConsumer {
             this add ModuleSerializer(destination, NativeDistributionCommonizerOutputLayout)
             this add CopyUnconsumedModulesAsIsConsumer(
-                repository, destination, targets.toSet(), NativeDistributionCommonizerOutputLayout, logger.toProgressLogger()
+                repository, destination, commonizerTargets.toSet(), NativeDistributionCommonizerOutputLayout, logger.toProgressLogger()
             )
             if (copyStdlib) this add CopyStdlibResultsConsumer(distribution, destination, logger.toProgressLogger())
             if (copyEndorsedLibs) this add CopyEndorsedLibrairesResultsConsumer(distribution, destination, logger.toProgressLogger())
-            this add LoggingResultsConsumer(SharedCommonizerTarget(targets), logger.toProgressLogger())
+            this add LoggingResultsConsumer(SharedCommonizerTarget(commonizerTargets.toSet()), logger.toProgressLogger())
         }
 
-        val targetNames = targets.joinToString { "[${it.name}]" }
+        val targetNames = commonizerTargets.joinToString { it.prettyName }
-        val descriptionSuffix = estimateLibrariesCount(repository, targets).let { " ($it items)" }
+        val descriptionSuffix = estimateLibrariesCount(repository, commonizerTargets).let { " ($it items)" }
         val description = "${logPrefix}Preparing commonized Kotlin/Native libraries for targets $targetNames$descriptionSuffix"
         println(description)
 
@@ -125,7 +128,7 @@ internal class NativeDistributionCommonize(options: Collection<Option<*>>) : Tas
             konanDistribution = distribution,
             dependencies = EmptyRepository,
             libraryLoader = libraryLoader,
-            targets = targets,
+            targets = commonizerTargets,
             resultsConsumer = resultsConsumer,
             statsCollector = statsCollector,
             logger = logger
@@ -135,8 +138,8 @@ internal class NativeDistributionCommonize(options: Collection<Option<*>>) : Tas
     }
 
     companion object {
-        private fun estimateLibrariesCount(repository: Repository, targets: List<KonanTarget>): Int {
+        private fun estimateLibrariesCount(repository: Repository, targets: List<LeafCommonizerTarget>): Int {
-            return targets.flatMap { repository.getLibraries(LeafCommonizerTarget(it)) }.count()
+            return targets.flatMap { repository.getLibraries(it) }.count()
         }
     }
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/konan/CopyUnconsumedModulesAsIsConsumer.kt

@@ -7,23 +7,22 @@ package org.jetbrains.kotlin.descriptors.commonizer.konan
 
 import org.jetbrains.kotlin.descriptors.commonizer.*
 import org.jetbrains.kotlin.descriptors.commonizer.repository.Repository
-import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.util.Logger
 import java.io.File
 
 internal class CopyUnconsumedModulesAsIsConsumer(
     private val repository: Repository,
     private val destination: File,
-    private val targets: Set<KonanTarget>,
+    private val targets: Set<LeafCommonizerTarget>,
     private val outputLayout: CommonizerOutputLayout,
     private val logger: Logger? = null
 ) : ResultsConsumer {
 
-    private val consumedTargets = mutableSetOf<KonanTarget>()
+    private val consumedTargets = mutableSetOf<LeafCommonizerTarget>()
 
     override fun targetConsumed(target: CommonizerTarget) {
         if (target is LeafCommonizerTarget) {
-            consumedTargets.add(target.konanTarget)
+            consumedTargets += target
         }
     }
 
@@ -34,15 +33,14 @@ internal class CopyUnconsumedModulesAsIsConsumer(
         }
     }
 
-    private fun copyTargetAsIs(target: KonanTarget) {
+    private fun copyTargetAsIs(target: LeafCommonizerTarget) {
-        val commonizerTarget = CommonizerTarget(target)
+        val libraries = repository.getLibraries(target)
-        val libraries = repository.getLibraries(commonizerTarget)
+        val librariesDestination = outputLayout.getTargetDirectory(destination, target)
-        val librariesDestination = outputLayout.getTargetDirectory(destination, commonizerTarget)
         librariesDestination.mkdirs() // always create an empty directory even if there is nothing to copy
         libraries.map { it.library.libraryFile.absolutePath }.map(::File).forEach { libraryFile ->
             libraryFile.copyRecursively(destination.resolve(libraryFile.name))
         }
 
-        logger?.log("Copied ${libraries.size} libraries for ${commonizerTarget.prettyName}")
+        logger?.log("Copied ${libraries.size} libraries for ${target.prettyName}")
     }
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/konan/LibraryCommonizer.kt

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.descriptors.commonizer.repository.Repository
 import org.jetbrains.kotlin.descriptors.commonizer.stats.StatsCollector
 import org.jetbrains.kotlin.descriptors.commonizer.utils.ResettableClockMark
 import org.jetbrains.kotlin.konan.library.*
-import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.util.Logger
 
@@ -22,7 +21,7 @@ internal class LibraryCommonizer internal constructor(
     private val repository: Repository,
     private val dependencies: Repository,
     private val libraryLoader: NativeLibraryLoader,
-    private val targets: List<KonanTarget>,
+    private val targets: List<LeafCommonizerTarget>,
     private val resultsConsumer: ResultsConsumer,
     private val statsCollector: StatsCollector?,
     private val logger: Logger
@@ -41,7 +40,7 @@ internal class LibraryCommonizer internal constructor(
     private fun loadLibraries(): AllNativeLibraries {
         val stdlib = libraryLoader(konanDistribution.stdlib)
 
-        val librariesByTargets = targets.map(::LeafCommonizerTarget).associateWith { target ->
+        val librariesByTargets = targets.associateWith { target ->
             NativeLibrariesToCommonize(repository.getLibraries(target).toList())
         }
 

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/repository/KonanDistributionRepository.kt

@@ -10,16 +10,15 @@ import org.jetbrains.kotlin.descriptors.commonizer.LeafCommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.NativeLibraryLoader
 import org.jetbrains.kotlin.descriptors.commonizer.konan.NativeLibrary
 import org.jetbrains.kotlin.descriptors.commonizer.platformLibsDir
-import org.jetbrains.kotlin.konan.target.KonanTarget
 
 internal class KonanDistributionRepository(
     konanDistribution: KonanDistribution,
-    targets: Set<KonanTarget>,
+    targets: Set<LeafCommonizerTarget>,
     libraryLoader: NativeLibraryLoader,
 ) : Repository {
 
     private val librariesByTarget: Map<LeafCommonizerTarget, Lazy<Set<NativeLibrary>>> =
-        targets.map(::LeafCommonizerTarget).associateWith { target ->
+        targets.associateWith { target ->
             lazy {
                 konanDistribution.platformLibsDir
                     .resolve(target.name)

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/stats/AggregatedStatsCollector.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.stats
 
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.stats.RawStatsCollector.CommonDeclarationStatus.*
-import org.jetbrains.kotlin.konan.target.KonanTarget
 
 class AggregatedStatsCollector(
-    targets: List<KonanTarget>
+    targets: List<CommonizerTarget>
 ) : StatsCollector {
     private val wrappedCollector = RawStatsCollector(targets)
 

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/stats/RawStatsCollector.kt

@@ -7,10 +7,11 @@ package org.jetbrains.kotlin.descriptors.commonizer.stats
 
 import com.intellij.util.containers.FactoryMap
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
+import org.jetbrains.kotlin.descriptors.commonizer.identityString
 import org.jetbrains.kotlin.descriptors.commonizer.stats.StatsCollector.StatsKey
 import org.jetbrains.kotlin.descriptors.commonizer.stats.StatsOutput.StatsHeader
 import org.jetbrains.kotlin.descriptors.commonizer.stats.StatsOutput.StatsRow
-import org.jetbrains.kotlin.konan.target.KonanTarget
 import java.util.*
 import kotlin.collections.ArrayList
 
@@ -56,9 +57,9 @@ platform/SystemConfiguration/SCDynamicStoreRefVar||||TYPE_ALIAS|-|O|O
 platform/SystemConfiguration/SCVLANInterfaceRef||||TYPE_ALIAS|-|O|O
 
  */
-class RawStatsCollector(private val targets: List<KonanTarget>) : StatsCollector {
+class RawStatsCollector(private val targets: List<CommonizerTarget>) : StatsCollector {
     private inline val dimension get() = targets.size + 1
-    private inline val targetNames get() = targets.map { it.name }
+    private inline val targetNames get() = targets.map { it.identityString }
 
     private inline val indexOfCommon get() = targets.size
     private inline val platformDeclarationsCount get() = targets.size

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/stats/StatsCollector.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.stats
 
-import org.jetbrains.kotlin.konan.target.KonanTarget
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 
-fun StatsCollector(type: StatsType, targets: List<KonanTarget>): StatsCollector? {
+fun StatsCollector(type: StatsType, targets: List<CommonizerTarget>): StatsCollector? {
     return when (type) {
         StatsType.RAW -> RawStatsCollector(targets)
         StatsType.AGGREGATED -> AggregatedStatsCollector(targets)