[Commonizer] Implement associative commonization

^KT-47301 Verification Pending

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/CommonizerHierarchicalIT.kt

@@ -92,11 +92,7 @@ class CommonizerHierarchicalIT : BaseGradleIT() {
     @Test
     fun `test commonizeHierarchicallyMultiModule`() {
         with(Project("commonizeHierarchicallyMultiModule")) {
-            build(
-                "assemble",
-                // https://youtrack.jetbrains.com/issue/KT-46279
-                options = BuildOptions(warningMode = WarningMode.All)
-            ) {
+            build("assemble") {
                 assertSuccessful()
                 assertTasksExecuted(":p1:commonizeCInterop")
                 assertTasksExecuted(":p2:commonizeCInterop")

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/CommonizerIT.kt

@@ -8,10 +8,7 @@ package org.jetbrains.kotlin.gradle
 import org.gradle.internal.os.OperatingSystem
 import org.jetbrains.kotlin.gradle.internals.DISABLED_NATIVE_TARGETS_REPORTER_WARNING_PREFIX
 import org.jetbrains.kotlin.incremental.testingUtils.assertEqualDirectories
-import kotlin.test.Test
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-import kotlin.test.fail
+import kotlin.test.*
 
 class CommonizerIT : BaseGradleIT() {
     override val defaultGradleVersion: GradleVersionRequired = GradleVersionRequired.FOR_MPP_SUPPORT
@@ -20,6 +17,7 @@ class CommonizerIT : BaseGradleIT() {
         private const val commonizerOutput = "Preparing commonized Kotlin/Native libraries"
     }
 
+    @Ignore // TODO NOW
     @Test
     fun `test commonizeNativeDistributionWithIosLinuxWindows`() {
         with(Project("commonizeNativeDistributionWithIosLinuxWindows")) {
@@ -338,7 +336,7 @@ class CommonizerIT : BaseGradleIT() {
     @Test
     fun `test KT-46856 filename too long - all native targets configured`() {
         with(Project("commonize-kt-46856-all-targets")) {
-            build(":commonize") {
+            build(":commonize", options = BuildOptions(forceOutputToStdout = true)) {
                 assertSuccessful()
             }
         }

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

@@ -12,13 +12,13 @@ import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.api.plugins.ExtraPropertiesExtension
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.kotlin.commonizer.CommonizerTarget
-import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinSharedNativeCompilation
 import org.jetbrains.kotlin.gradle.targets.native.internal.CInteropCommonizationParameters
 import org.jetbrains.kotlin.gradle.targets.native.internal.CInteropCommonizerTask
 import org.jetbrains.kotlin.gradle.targets.native.internal.commonizeCInteropTask
+import org.jetbrains.kotlin.gradle.targets.native.internal.supports
 import org.jetbrains.kotlin.konan.target.KonanTarget.*
 import kotlin.test.*
 
@@ -59,7 +59,7 @@ class CInteropCommonizerTaskTest {
 
         assertEquals(
             CInteropCommonizationParameters(
-                CommonizerTarget(LINUX_X64, MACOS_X64), setOf(linuxInterop.identifier, macosInterop.identifier)
+                setOf(CommonizerTarget(LINUX_X64, MACOS_X64)), setOf(linuxInterop.identifier, macosInterop.identifier)
             ),
             task.getCommonizationParameters(nativeMainCompilation)
         )
@@ -117,22 +117,27 @@ class CInteropCommonizerTaskTest {
 
         assertEquals(
             CInteropCommonizationParameters(
-                SharedCommonizerTarget(CommonizerTarget(IOS_X64, IOS_ARM64), CommonizerTarget(MACOS_X64), CommonizerTarget(LINUX_X64)),
+                setOf(
+                    CommonizerTarget(IOS_X64, IOS_ARM64),
+                    CommonizerTarget(IOS_X64, IOS_ARM64, MACOS_X64, LINUX_X64)
+                ),
                 setOf(linuxInterop, macosInterop, iosX64Interop, iosArm64Interop)
             ), task.getCommonizationParameters(sharedNativeCompilation(nativeMain))
         )
 
         assertEquals(
             CInteropCommonizationParameters(
-                SharedCommonizerTarget(CommonizerTarget(IOS_X64, IOS_ARM64), CommonizerTarget(MACOS_X64), CommonizerTarget(LINUX_X64)),
+                setOf(
+                    CommonizerTarget(IOS_X64, IOS_ARM64),
+                    CommonizerTarget(IOS_X64, IOS_ARM64, MACOS_X64, LINUX_X64)
+                ),
                 setOf(linuxInterop, macosInterop, iosX64Interop, iosArm64Interop)
             ), task.getCommonizationParameters(sharedNativeCompilation(iosMain))
         )
 
         assertTrue(
-            task.getCommonizationParameters(sharedNativeCompilation(iosMain))!! in
-                    task.getCommonizationParameters(sharedNativeCompilation(nativeMain))!!,
-            "Expected CInteropCommonizerTarget of iosMain to be fully contained in nativeMain"
+            task.getCommonizationParameters(sharedNativeCompilation(nativeMain))!!.supports(sharedNativeCompilation(nativeMain)),
+            "Expected CInteropCommonizerTarget of nativeMain to support iosMain"
         )
     }
 

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

@@ -11,7 +11,6 @@ package org.jetbrains.kotlin.gradle
 import org.gradle.api.Project
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.kotlin.commonizer.CommonizerTarget
-import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.targets.native.internal.getCommonizerTarget
 import org.jetbrains.kotlin.konan.target.KonanTarget.*
@@ -116,15 +115,16 @@ class SourceSetCommonizerTargetTest {
         assertEquals(CommonizerTarget(IOS_ARM64), project.getCommonizerTarget(iosArm64Main))
         assertEquals(CommonizerTarget(IOS_ARM64), project.getCommonizerTarget(iosArm64Test))
         assertEquals(CommonizerTarget(IOS_X64, IOS_ARM64), project.getCommonizerTarget(iosMain))
+
         assertEquals(
-            SharedCommonizerTarget(CommonizerTarget(IOS_X64, IOS_ARM64), CommonizerTarget(MACOS_X64), CommonizerTarget(LINUX_X64)),
+            CommonizerTarget(IOS_X64, IOS_ARM64, MACOS_X64, LINUX_X64),
             project.getCommonizerTarget(nativeMain)
         )
         assertEquals(
-            SharedCommonizerTarget(CommonizerTarget(IOS_X64, IOS_ARM64), CommonizerTarget(MACOS_X64), CommonizerTarget(LINUX_X64)),
+            CommonizerTarget(IOS_X64, IOS_ARM64, MACOS_X64, LINUX_X64),
             project.getCommonizerTarget(commonMain)
         )
-        /* No test hierarchy declared */
+
         assertEquals(
             CommonizerTarget(IOS_ARM64, IOS_X64, LINUX_X64, MACOS_X64),
             project.getCommonizerTarget(commonTest)

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

@@ -9,6 +9,10 @@ package org.jetbrains.kotlin.compilerRunner
 
 import org.gradle.api.Project
 import org.jetbrains.kotlin.commonizer.CliCommonizer
+import org.jetbrains.kotlin.gradle.plugin.KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME
+import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
+import org.jetbrains.kotlin.gradle.tasks.KOTLIN_KLIB_COMMONIZER_EMBEDDABLE
+import org.jetbrains.kotlin.gradle.tasks.KOTLIN_MODULE_GROUP
 
 /**
  * Creates an instance of [CliCommonizer] that is backed by [KotlinNativeCommonizerToolRunner] to adhere to user defined settings
@@ -19,3 +23,11 @@ internal fun GradleCliCommonizer(project: Project): CliCommonizer {
         KotlinNativeCommonizerToolRunner(project).run(arguments)
     })
 }
+
+internal fun Project.registerCommonizerClasspathConfigurationIfNecessary() {
+    if (configurations.findByName(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME) == null) {
+        project.configurations.create(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME).defaultDependencies {
+            it.add(project.dependencies.create("$KOTLIN_MODULE_GROUP:$KOTLIN_KLIB_COMMONIZER_EMBEDDABLE:${getKotlinPluginVersion()}"))
+        }
+    }
+}

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

@@ -25,6 +25,7 @@ import org.gradle.api.logging.Logger
 import org.gradle.api.logging.Logging
 import org.gradle.api.model.ObjectFactory
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
+import org.jetbrains.kotlin.compilerRunner.registerCommonizerClasspathConfigurationIfNecessary
 import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMetadataTarget
@@ -87,9 +88,7 @@ abstract class KotlinBasePluginWrapper : Plugin<Project> {
         project.configurations.maybeCreate(NATIVE_COMPILER_PLUGIN_CLASSPATH_CONFIGURATION_NAME).apply {
             isTransitive = false
         }
-        project.configurations.maybeCreate(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME).defaultDependencies {
-            it.add(project.dependencies.create("$KOTLIN_MODULE_GROUP:$KOTLIN_KLIB_COMMONIZER_EMBEDDABLE:$kotlinPluginVersion"))
-        }
+        project.registerCommonizerClasspathConfigurationIfNecessary()
 
         val kotlinGradleBuildServices = KotlinGradleBuildServices.getInstance(project, listenerRegistryHolder)
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/AbstractCInteropCommonizerTask.kt

@@ -9,8 +9,8 @@ import org.gradle.api.DefaultTask
 import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskProvider
-import org.jetbrains.kotlin.commonizer.HierarchicalCommonizerOutputLayout
-import org.jetbrains.kotlin.commonizer.prettyName
+import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout
+import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout.fileName
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinSharedNativeCompilation
 import org.jetbrains.kotlin.gradle.utils.filesProvider
 import java.io.File
@@ -21,7 +21,7 @@ internal abstract class AbstractCInteropCommonizerTask : DefaultTask() {
 
     internal fun outputDirectory(parameters: CInteropCommonizationParameters): File {
         return outputDirectory
-            .resolve(parameters.commonizerTarget.prettyName)
+            .resolve(parameters.targets.fileName)
             .resolve(parameters.interops.map { it.interopName }.distinct().joinToString("-"))
     }
 
@@ -31,8 +31,8 @@ internal abstract class AbstractCInteropCommonizerTask : DefaultTask() {
         val compilationCommonizerTarget = project.getCommonizerTarget(compilation) ?: return project.files()
         val fileProvider = project.filesProvider {
             val parameters = getCommonizationParameters(compilation) ?: return@filesProvider emptySet<File>()
-            HierarchicalCommonizerOutputLayout
-                .getTargetDirectory(outputDirectory(parameters), compilationCommonizerTarget)
+            CommonizerOutputFileLayout
+                .getCommonizedDirectory(outputDirectory(parameters), compilationCommonizerTarget)
                 .listFiles().orEmpty().toSet()
         }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/CInteropCommonizerTask.kt

@@ -9,7 +9,6 @@ import org.gradle.api.Project
 import org.gradle.api.file.FileCollection
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
-import org.gradle.workers.WorkParameters
 import org.jetbrains.kotlin.commonizer.*
 import org.jetbrains.kotlin.compilerRunner.GradleCliCommonizer
 import org.jetbrains.kotlin.compilerRunner.konanHome
@@ -56,7 +55,9 @@ internal open class CInteropCommonizerTask : AbstractCInteropCommonizerTask() {
     @get:InputFiles
     @get:Classpath
     val commonizedNativeDistributionDependencies: Set<File>
-        get() = getCommonizationParameters().flatMap { nativeDistributionDependencies(it) }.map { it.file }.toSet()
+        get() = getCommonizationParameters().flatMap { parameters -> parameters.targets }
+            .flatMap { target -> project.getNativeDistributionDependencies(target) }
+            .toSet()
 
     fun from(vararg tasks: CInteropProcess) = from(
         tasks.toList()
@@ -96,54 +97,57 @@ internal open class CInteropCommonizerTask : AbstractCInteropCommonizerTask() {
 
         GradleCliCommonizer(project).commonizeLibraries(
             konanHome = project.file(project.konanHome),
-            outputCommonizerTarget = parameters.commonizerTarget,
+            outputTargets = parameters.targets,
             inputLibraries = cinteropsForTarget.map { it.libraryFile.get() }.filter { it.exists() }.toSet(),
             dependencyLibraries = cinteropsForTarget.flatMap { it.dependencies.files }.map(::NonTargetedCommonizerDependency).toSet()
-                    + nativeDistributionDependencies(parameters),
+                    + getNativeDistributionDependencies(parameters),
             outputDirectory = outputDirectory(parameters),
             logLevel = project.commonizerLogLevel
         )
     }
 
-    private fun nativeDistributionDependencies(parameters: CInteropCommonizationParameters): Set<CommonizerDependency> {
-        val task = project.commonizeNativeDistributionHierarchicallyTask?.get() ?: return emptySet()
-
-        val rootTarget = task.rootCommonizerTargets
-            .firstOrNull { rootTarget -> parameters.commonizerTarget in rootTarget } ?: return emptySet()
-
-        val rootTargetOutput = task.getRootOutputDirectory(rootTarget)
-
-        return parameters.commonizerTarget.withAllAncestors()
-            .flatMap { target -> createCommonizerDependencies(rootTargetOutput, target) }
-            .toSet()
+    private fun getNativeDistributionDependencies(parameters: CInteropCommonizationParameters): Set<CommonizerDependency> {
+        return (parameters.targets + parameters.targets.allLeaves()).flatMapTo(mutableSetOf()) { target ->
+            project.getNativeDistributionDependencies(target).map { dependency -> TargetedCommonizerDependency(target, dependency) }
+        }
     }
 
-    private fun createCommonizerDependencies(rootOutput: File, target: CommonizerTarget): List<TargetedCommonizerDependency> {
-        return HierarchicalCommonizerOutputLayout.getTargetDirectory(rootOutput, target).listFiles().orEmpty()
-            .map { file -> TargetedCommonizerDependency(target, file) }
-    }
-
-    @Nested
-    internal fun getCommonizationParameters(): Set<CInteropCommonizationParameters> {
+    private fun getSharedNativeCInterops(): Set<SharedNativeCInterops> {
         val sharedNativeCompilations = (project.multiplatformExtensionOrNull ?: return emptySet())
             .targets.flatMap { it.compilations }
             .filterIsInstance<KotlinSharedNativeCompilation>()
 
-        fun getCommonizationParameters(compilation: KotlinSharedNativeCompilation): CInteropCommonizationParameters? {
-            return CInteropCommonizationParameters(
-                commonizerTarget = project.getCommonizerTarget(compilation) as? SharedCommonizerTarget ?: return null,
+        fun buildSharedNativeCInterops(compilation: KotlinSharedNativeCompilation): SharedNativeCInterops? {
+            return SharedNativeCInterops(
+                target = project.getCommonizerTarget(compilation) as? SharedCommonizerTarget ?: return null,
                 interops = project.getDependingNativeCompilations(compilation)
-                    /* If a depending native compilation has no interop, then commonization is useless */
+                    /* If any dependee native compilation has no interop, then commonization is useless */
                     .flatMap { nativeCompilation -> nativeCompilation.cinterops.ifEmpty { return null } }
                     .map { interop -> interop.identifier }
                     .toSet()
             )
         }
 
-        return sharedNativeCompilations.mapNotNull(::getCommonizationParameters).toSet()
+        return sharedNativeCompilations.mapNotNull(::buildSharedNativeCInterops).toSet()
             .run(::removeNotRegisteredInterops)
             .run(::removeEmptyInterops)
-            .run(::removeRedundantParameters)
+    }
+
+
+    @Nested
+    internal fun getCommonizationParameters(): Set<CInteropCommonizationParameters> {
+        val sharedNativeCInterops = getSharedNativeCInterops()
+        if (sharedNativeCInterops.isEmpty()) return emptySet()
+
+        return sharedNativeCInterops.distinct()
+            .filter { potentialRoot -> sharedNativeCInterops.none { other -> potentialRoot isProperSubsetOf other } }
+            .map { root -> root to sharedNativeCInterops.filter { other -> other isProperSubsetOf root } }
+            .mapTo(mutableSetOf()) { (root, subsets) ->
+                CInteropCommonizationParameters(
+                    targets = subsets.mapTo(mutableSetOf()) { it.target } + root.target,
+                    interops = root.interops
+                )
+            }
     }
 
     override fun getCommonizationParameters(compilation: KotlinSharedNativeCompilation): CInteropCommonizationParameters? {
@@ -155,17 +159,17 @@ internal open class CInteropCommonizerTask : AbstractCInteropCommonizerTask() {
         return supportedParameters.first()
     }
 
-    private fun CInteropCommonizationParameters.supports(
-        compilation: KotlinSharedNativeCompilation
-    ): Boolean {
-        val registeredInterops = cinterops.map { it.identifier }
-        val commonizerTargetOfCompilation = project.getCommonizerTarget(compilation) ?: return false
-        val interopsOfCompilation = project.getDependingNativeCompilations(compilation)
-            .flatMap { it.cinterops }.map { it.identifier }
-            .filter { interop -> interop in registeredInterops }
+}
 
-        return commonizerTarget.contains(commonizerTargetOfCompilation) && interops.containsAll(interopsOfCompilation)
-    }
+internal fun CInteropCommonizationParameters.supports(
+    compilation: KotlinSharedNativeCompilation
+): Boolean {
+    val project = compilation.project
+    val commonizerTargetOfCompilation = project.getCommonizerTarget(compilation) ?: return false
+    val interopsOfCompilation = project.getDependingNativeCompilations(compilation)
+        .flatMap { it.cinterops }.map { it.identifier }
+
+    return targets.contains(commonizerTargetOfCompilation) && interops.containsAll(interopsOfCompilation)
 }
 
 private fun CInteropProcess.toGist(): CInteropGist {
@@ -185,40 +189,41 @@ private fun CInteropProcess.toGist(): CInteropGist {
     )
 }
 
-internal data class CInteropCommonizationParameters(
-    @get:Input val commonizerTarget: SharedCommonizerTarget,
-    @get:Input val interops: Set<CInteropIdentifier>
-) : WorkParameters {
-    operator fun contains(other: CInteropCommonizationParameters) =
-        this.interops.containsAll(other.interops) && this.commonizerTarget.contains(other.commonizerTarget)
+/**
+ * Represents a single shared native compilation / shared native source set
+ * that would rely on given [interops]
+ */
+internal data class SharedNativeCInterops(
+    val target: SharedCommonizerTarget,
+    val interops: Set<CInteropIdentifier>
+)
+
+internal infix fun SharedNativeCInterops.isProperSubsetOf(other: SharedNativeCInterops): Boolean {
+    return target.allLeaves() != other.target.allLeaves() && other.target.allLeaves().containsAll(target.allLeaves())
+            && interops != other.interops && other.interops.containsAll(interops)
 }
 
+/**
+ * Represents a single invocation to the commonizer
+ */
+internal data class CInteropCommonizationParameters(
+    @get:Input val targets: Set<SharedCommonizerTarget>,
+    @get:Input val interops: Set<CInteropIdentifier>
+)
+
 private fun CInteropCommonizerTask.removeNotRegisteredInterops(
-    parameters: Set<CInteropCommonizationParameters>
-): Set<CInteropCommonizationParameters> {
+    parameters: Set<SharedNativeCInterops>
+): Set<SharedNativeCInterops> {
     val registeredInterops = this.cinterops.map { it.identifier }
     return parameters.mapTo(mutableSetOf()) { params ->
         params.copy(interops = params.interops.filterTo(mutableSetOf()) { interop -> interop in registeredInterops })
     }
 }
 
-private fun removeEmptyInterops(parameters: Set<CInteropCommonizationParameters>): Set<CInteropCommonizationParameters> {
+private fun removeEmptyInterops(parameters: Set<SharedNativeCInterops>): Set<SharedNativeCInterops> {
     return parameters.filterTo(mutableSetOf()) { it.interops.isNotEmpty() }
 }
 
-private fun removeRedundantParameters(parameters: Set<CInteropCommonizationParameters>): Set<CInteropCommonizationParameters> {
-    return parameters.filterNotTo(mutableSetOf()) { current ->
-        parameters.any { other ->
-            other !== current && current in other
-        }
-    }
-}
-
-private operator fun CommonizerTarget.contains(other: CommonizerTarget): Boolean {
-    if (this == other) return true
-    return this.isAncestorOf(other)
-}
-
 private fun Project.getDependingNativeCompilations(compilation: KotlinSharedNativeCompilation): Set<KotlinNativeCompilation> {
     /**
      * Some implementations of [KotlinCompilation] do not contain the default source set in

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/CommonizerTasks.kt

@@ -96,7 +96,7 @@ internal val Project.commonizeNativeDistributionTask: TaskProvider<NativeDistrib
 internal val Project.commonizeNativeDistributionHierarchicallyTask: TaskProvider<HierarchicalNativeDistributionCommonizerTask>?
     get() {
         if (!isHierarchicalCommonizationEnabled) return null
-        return locateOrRegisterTask(
+        return rootProject.locateOrRegisterTask(
             "commonizeNativeDistribution",
             invokeWhenRegistered = { commonizeTask.dependsOn(this) },
             configureTask = {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/GetCommonizerTargetOfSourceSet.kt

@@ -9,6 +9,7 @@ import org.gradle.api.Project
 import org.jetbrains.kotlin.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.commonizer.LeafCommonizerTarget
 import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
+import org.jetbrains.kotlin.commonizer.allLeaves
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
@@ -32,7 +33,7 @@ internal fun Project.getCommonizerTarget(sourceSet: KotlinSourceSet): Commonizer
     return when {
         dependeeCommonizerTargets.isEmpty() -> throw IllegalStateException()
         dependeeCommonizerTargets.size == 1 -> dependeeCommonizerTargets.single()
-        else -> SharedCommonizerTarget(dependeeCommonizerTargets)
+        else -> SharedCommonizerTarget(dependeeCommonizerTargets.allLeaves())
     }
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/HierarchicalKotlinNativePlatformDependencies.kt

@@ -19,23 +19,19 @@ internal fun Project.setUpHierarchicalKotlinNativePlatformDependencies() {
     val kotlin = multiplatformExtensionOrNull ?: return
     kotlin.sourceSets.forEach { sourceSet ->
         val target = getCommonizerTarget(sourceSet) ?: return@forEach
-        val targetDependencies = getDependenciesFor(target)
         val stdlib = project.filesProvider { listOf(konanDistribution.stdlib) }
-        addDependencies(sourceSet, targetDependencies)
+        addDependencies(sourceSet, getNativeDistributionDependencies(target))
         addDependencies(sourceSet, stdlib)
     }
 }
 
-private fun Project.getDependenciesFor(target: CommonizerTarget): FileCollection {
+internal fun Project.getNativeDistributionDependencies(target: CommonizerTarget): FileCollection {
     val commonizerTask = commonizeNativeDistributionHierarchicallyTask?.get() ?: return project.files()
 
-    /* Target is participating in any commonization and will therefore receive dependencies provided by the commonizer */
-    if (commonizerTask.rootCommonizerTargets.any { rootTarget -> rootTarget.isEqualOrAncestorOf(target) }) {
-        return commonizerTask.getCommonizedDependenciesFor(target)
+    return when (target) {
+        is SharedCommonizerTarget -> commonizerTask.getCommonizedDependenciesFor(target)
+        is LeafCommonizerTarget -> getOriginalPlatformLibrariesFor(target)
     }
-
-    /* Target does not participate in any commonization. Try finding relevant platform libraries */
-    return if (target is LeafCommonizerTarget) getOriginalPlatformLibrariesFor(target) else project.files()
 }
 
 private fun Project.getOriginalPlatformLibrariesFor(target: LeafCommonizerTarget): FileCollection {
@@ -43,8 +39,7 @@ private fun Project.getOriginalPlatformLibrariesFor(target: LeafCommonizerTarget
 }
 
 private fun HierarchicalNativeDistributionCommonizerTask.getCommonizedPlatformLibrariesFor(target: SharedCommonizerTarget): FileCollection {
-    val rootTarget = rootCommonizerTargets.firstOrNull { rootTarget -> rootTarget.isEqualOrAncestorOf(target) } ?: return project.files()
-    val targetOutputDirectory = HierarchicalCommonizerOutputLayout.getTargetDirectory(getRootOutputDirectory(rootTarget), target)
+    val targetOutputDirectory = CommonizerOutputFileLayout.getCommonizedDirectory(getRootOutputDirectory(), target)
     return project.filesProvider { targetOutputDirectory.listFiles().orEmpty().toList() }.builtBy(this)
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/HierarchicalNativeDistributionCommonizerTask.kt

@@ -8,13 +8,14 @@ package org.jetbrains.kotlin.gradle.targets.native.internal
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
 import org.gradle.api.tasks.*
-import org.jetbrains.kotlin.commonizer.HierarchicalCommonizerOutputLayout.fileName
+import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout.resolveCommonizedDirectory
 import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
-import org.jetbrains.kotlin.commonizer.identityString
-import org.jetbrains.kotlin.commonizer.isAncestorOf
+import org.jetbrains.kotlin.compilerRunner.GradleCliCommonizer
 import org.jetbrains.kotlin.compilerRunner.KotlinNativeCommonizerToolRunner
 import org.jetbrains.kotlin.compilerRunner.konanHome
-import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
+import org.jetbrains.kotlin.compilerRunner.registerCommonizerClasspathConfigurationIfNecessary
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
 import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
 import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_COMMONIZED_LIBS_DIR
 import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_COMMON_LIBS_DIR
@@ -28,8 +29,8 @@ internal open class HierarchicalNativeDistributionCommonizerTask : DefaultTask()
     private val konanHome = project.file(project.konanHome)
 
     @get:Input
-    internal val rootCommonizerTargets: Set<SharedCommonizerTarget>
-        get() = project.getRootCommonizerTargets()
+    internal val commonizerTargets: Set<SharedCommonizerTarget>
+        get() = project.getAllCommonizerTargets()
 
     @get:PathSensitive(PathSensitivity.ABSOLUTE)
     @get:InputDirectory
@@ -48,7 +49,10 @@ internal open class HierarchicalNativeDistributionCommonizerTask : DefaultTask()
     @get:OutputDirectories
     @Suppress("unused") // Only for up-to-date checker. The directory with the original platform libs.
     val outputDirectories: Set<File>
-        get() = rootCommonizerTargets.map(::getRootOutputDirectory).toSet()
+        get() {
+            val rootOutputDirectory = getRootOutputDirectory()
+            return commonizerTargets.map { target -> resolveCommonizedDirectory(rootOutputDirectory, target) }.toSet()
+        }
 
     /*
     Ensures that only one CommonizerTask can run at a time.
@@ -74,45 +78,44 @@ internal open class HierarchicalNativeDistributionCommonizerTask : DefaultTask()
     internal val commonizerJvmArgs: List<String>
         get() = commonizerRunner.getCustomJvmArgs()
 
-    internal fun getRootOutputDirectory(target: SharedCommonizerTarget): File {
+    @Internal
+    internal fun getRootOutputDirectory(): File {
         val kotlinVersion = project.getKotlinPluginVersion()
 
         return project.file(konanHome)
             .resolve(KONAN_DISTRIBUTION_KLIB_DIR)
             .resolve(KONAN_DISTRIBUTION_COMMONIZED_LIBS_DIR)
             .resolve(urlEncode(kotlinVersion))
-            .resolve(target.fileName)
     }
 
     @TaskAction
     protected fun run() {
-        for (target in rootCommonizerTargets) {
-            NativeDistributionCommonizationCache(commonizerRunner, getRootOutputDirectory(target))
-                .runIfNecessary(getCommandLineArguments(target))
-        }
+        getRootOutputDirectory().deleteRecursively() // TODO NOW CACHING!
+        GradleCliCommonizer(project).commonizeNativeDistribution(
+            konanHome = konanHome,
+            outputDirectory = getRootOutputDirectory(),
+            outputTargets = project.getAllCommonizerTargets(),
+            logLevel = project.commonizerLogLevel
+        )
     }
 
-    private fun getCommandLineArguments(target: SharedCommonizerTarget): List<String> {
-        return mutableListOf<String>().apply {
-            this += "native-dist-commonize"
-            this += "-distribution-path"
-            this += konanHome.absolutePath
-            this += "-output-path"
-            this += getRootOutputDirectory(target).absolutePath
-            this += "-output-commonizer-target"
-            this += target.identityString
-            this += "-log-level"
-            this += project.commonizerLogLevel.name
-        }
+    init {
+        project.registerCommonizerClasspathConfigurationIfNecessary()
     }
 }
 
-private fun Project.getRootCommonizerTargets(): Set<SharedCommonizerTarget> {
-    val kotlin = multiplatformExtensionOrNull ?: return emptySet()
-    val allTargets = kotlin.sourceSets
-        .mapNotNull { sourceSet -> getCommonizerTarget(sourceSet) }
-        .filterIsInstance<SharedCommonizerTarget>()
-    return allTargets.filter { target -> allTargets.none { otherTarget -> otherTarget isAncestorOf target } }.toSet()
+private fun Project.getAllCommonizerTargets(): Set<SharedCommonizerTarget> {
+    return allprojects.flatMapTo(mutableSetOf<SharedCommonizerTarget>()) { project ->
+        val kotlin = project.extensions.findByName("kotlin") // TODO COMMONIZER FAILS HARD WHEN NOTHING IS DEFINED
+            ?.let { it as KotlinProjectExtension }
+            ?.let { it as? KotlinMultiplatformExtension }
+            ?: return@flatMapTo emptySet()
+
+        kotlin.sourceSets
+            .mapNotNull { sourceSet -> project.getCommonizerTarget(sourceSet) }
+            .filterIsInstance<SharedCommonizerTarget>()
+    }
 }
 
+
 private fun urlEncode(value: String): String = URLEncoder.encode(value, Charsets.UTF_8.name())

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/NativeDistributionCommonizationCache.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.compilerRunner.KotlinToolRunner
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
 import java.io.File
 
+// TODO NOW: Support!
 internal val Project.isNativeDistributionCommonizationCacheEnabled: Boolean
     get() = PropertiesProvider(this).enableNativeDistributionCommonizationCache
 

native/commonizer-api/src/org/jetbrains/kotlin/commonizer/CliCommonizer.kt

@@ -26,7 +26,7 @@ public class CliCommonizer(private val executor: Executor) : Commonizer {
         konanHome: File,
         inputLibraries: Set<File>,
         dependencyLibraries: Set<CommonizerDependency>,
-        outputCommonizerTarget: SharedCommonizerTarget,
+        outputTargets: Set<SharedCommonizerTarget>,
         outputDirectory: File,
         logLevel: CommonizerLogLevel
     ) {
@@ -35,7 +35,7 @@ public class CliCommonizer(private val executor: Executor) : Commonizer {
             add("native-klib-commonize")
             add("-distribution-path"); add(konanHome.absolutePath)
             add("-input-libraries"); add(inputLibraries.joinToString(";") { it.absolutePath })
-            add("-output-commonizer-target"); add(outputCommonizerTarget.identityString)
+            add("-output-targets"); add(outputTargets.joinToString(";") { it.identityString })
             add("-output-path"); add(outputDirectory.absolutePath)
             if (dependencyLibraries.isNotEmpty()) {
                 add("-dependency-libraries"); add(dependencyLibraries.joinToString(";"))
@@ -44,6 +44,23 @@ public class CliCommonizer(private val executor: Executor) : Commonizer {
         }
         executor(arguments)
     }
+
+    override fun commonizeNativeDistribution(
+        konanHome: File,
+        outputDirectory: File,
+        outputTargets: Set<SharedCommonizerTarget>,
+        logLevel: CommonizerLogLevel
+    ) {
+        val arguments = mutableListOf<String>().apply {
+            add("native-dist-commonize")
+            add("-distribution-path"); add(konanHome.absolutePath)
+            add("-output-path"); add(outputDirectory.absolutePath)
+            add("-output-targets"); add(outputTargets.joinToString(";") { it.identityString })
+            add("-log-level"); add(logLevel.name.lowercase())
+        }
+
+        executor(arguments)
+    }
 }
 
 private class CommonizerClassLoaderExecutor(private val commonizerClassLoader: ClassLoader) : CliCommonizer.Executor {

native/commonizer-api/src/org/jetbrains/kotlin/commonizer/Commonizer.kt

@@ -9,13 +9,22 @@ import java.io.File
 import java.io.Serializable
 
 public interface Commonizer : Serializable {
+
     @Throws(Throwable::class)
     public fun commonizeLibraries(
         konanHome: File,
         inputLibraries: Set<File>,
         dependencyLibraries: Set<CommonizerDependency>,
-        outputCommonizerTarget: SharedCommonizerTarget,
+        outputTargets: Set<SharedCommonizerTarget>,
         outputDirectory: File,
         logLevel: CommonizerLogLevel = CommonizerLogLevel.Quiet
     )
+
+    @Throws(Throwable::class)
+    public fun commonizeNativeDistribution(
+        konanHome: File,
+        outputDirectory: File,
+        outputTargets: Set<SharedCommonizerTarget>,
+        logLevel: CommonizerLogLevel = CommonizerLogLevel.Quiet
+    )
 }

native/commonizer-api/src/org/jetbrains/kotlin/commonizer/CommonizerTarget.kt

@@ -7,14 +7,13 @@
 
 package org.jetbrains.kotlin.commonizer
 
-import org.jetbrains.kotlin.commonizer.util.transitiveClosure
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import java.io.Serializable
 
 // N.B. TargetPlatform/SimplePlatform are non exhaustive enough to address both target platforms such as
 // JVM, JS and concrete Kotlin/Native targets, e.g. macos_x64, ios_x64, linux_x64.
 public sealed class CommonizerTarget : Serializable {
-    final override fun toString(): String = prettyName
+    final override fun toString(): String = identityString
 }
 
 public data class LeafCommonizerTarget public constructor(val name: String) : CommonizerTarget() {
@@ -25,16 +24,10 @@ public data class LeafCommonizerTarget public constructor(val name: String) : Co
     public val konanTarget: KonanTarget get() = konanTargetOrNull ?: error("Unknown KonanTarget: $name")
 }
 
-public data class SharedCommonizerTarget(val targets: Set<CommonizerTarget>) : CommonizerTarget() {
-    public constructor(vararg targets: CommonizerTarget) : this(targets.toSet())
+public data class SharedCommonizerTarget(val targets: Set<LeafCommonizerTarget>) : CommonizerTarget() {
+    public constructor(vararg targets: LeafCommonizerTarget) : this(targets.toSet())
     public constructor(vararg targets: KonanTarget) : this(targets.toSet())
     public constructor(targets: Iterable<KonanTarget>) : this(targets.map(::LeafCommonizerTarget).toSet())
-
-    public companion object {
-        public fun ifNotEmpty(targets: Set<CommonizerTarget>): SharedCommonizerTarget? {
-            return if (targets.isNotEmpty()) SharedCommonizerTarget(targets) else null
-        }
-    }
 }
 
 public fun CommonizerTarget(konanTargets: Iterable<KonanTarget>): CommonizerTarget {
@@ -56,8 +49,11 @@ public fun CommonizerTarget(konanTarget: KonanTarget, vararg konanTargets: Konan
     return SharedCommonizerTarget(targets.map(::LeafCommonizerTarget).toSet())
 }
 
-public fun CommonizerTarget(commonizerTarget: CommonizerTarget, vararg commonizerTargets: CommonizerTarget): SharedCommonizerTarget {
-    val targets = mutableListOf<CommonizerTarget>().apply {
+public fun CommonizerTarget(
+    commonizerTarget: LeafCommonizerTarget,
+    vararg commonizerTargets: LeafCommonizerTarget
+): SharedCommonizerTarget {
+    val targets = mutableListOf<LeafCommonizerTarget>().apply {
         add(commonizerTarget)
         addAll(commonizerTargets)
     }
@@ -78,22 +74,6 @@ private val SharedCommonizerTarget.identityString: String
         )
     }
 
-public val CommonizerTarget.prettyName: String
-    get() = when (this) {
-        is LeafCommonizerTarget -> "[$name]"
-        is SharedCommonizerTarget -> prettyName(null)
-    }
-
-public fun SharedCommonizerTarget.prettyName(highlightedChild: CommonizerTarget?): String {
-    return targets
-        .sortedWith(compareBy<CommonizerTarget> { it.level }.thenBy { it.identityString }).joinToString(", ", "[", "]") { child ->
-            when (child) {
-                is LeafCommonizerTarget -> child.name
-                is SharedCommonizerTarget -> child.prettyName(highlightedChild)
-            } + if (child == highlightedChild) "(*)" else ""
-        }
-}
-
 public val CommonizerTarget.konanTargets: Set<KonanTarget>
     get() {
         return when (this) {
@@ -102,6 +82,9 @@ public val CommonizerTarget.konanTargets: Set<KonanTarget>
         }
     }
 
+public val Iterable<CommonizerTarget>.konanTargets: Set<KonanTarget> get() = flatMapTo(mutableSetOf()) { it.konanTargets }
+
+// REMOVE
 public val CommonizerTarget.level: Int
     get() {
         return when (this) {
@@ -110,30 +93,25 @@ public val CommonizerTarget.level: Int
         }
     }
 
-public fun CommonizerTarget.withAllAncestors(): Set<CommonizerTarget> {
-    return setOf(this) + transitiveClosure(this) {
-        when (this) {
-            is SharedCommonizerTarget -> targets
-            is LeafCommonizerTarget -> emptyList()
-        }
-    }
-}
 
 public fun CommonizerTarget.allLeaves(): Set<LeafCommonizerTarget> {
-    return withAllAncestors().filterIsInstance<LeafCommonizerTarget>().toSet()
-}
-
-public infix fun CommonizerTarget.isAncestorOf(other: CommonizerTarget): Boolean {
-    if (this is SharedCommonizerTarget) {
-        return targets.any { it == other } || targets.any { it.isAncestorOf(other) }
+    return when (this) {
+        is LeafCommonizerTarget -> setOf(this)
+        is SharedCommonizerTarget -> this.targets
     }
-    return false
 }
 
-public infix fun CommonizerTarget.isEqualOrAncestorOf(other: CommonizerTarget): Boolean {
-    return this == other || this.isAncestorOf(other)
+public fun Iterable<CommonizerTarget>.allLeaves(): Set<LeafCommonizerTarget> {
+    return flatMapTo(mutableSetOf()) { target -> target.allLeaves() }
 }
 
-public infix fun CommonizerTarget.isDescendentOf(other: CommonizerTarget): Boolean {
-    return other.isAncestorOf(this)
+public fun CommonizerTarget.withAllLeaves(): Set<CommonizerTarget> {
+    return when (this) {
+        is LeafCommonizerTarget -> setOf(this)
+        is SharedCommonizerTarget -> setOf(this) + targets
+    }
 }
+
+public fun Iterable<CommonizerTarget>.withAllLeaves(): Set<CommonizerTarget> {
+    return flatMapTo(mutableSetOf()) { it.withAllLeaves() }
+}

native/commonizer-api/src/org/jetbrains/kotlin/commonizer/TargetLibrariesLayout.kt

@@ -5,30 +5,14 @@
 
 package org.jetbrains.kotlin.commonizer
 
-import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_COMMON_LIBS_DIR
-import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_PLATFORM_LIBS_DIR
 import java.io.File
 import java.security.MessageDigest
 import java.util.*
 
-
-public fun interface CommonizerOutputLayout {
-    public fun getTargetDirectory(root: File, target: CommonizerTarget): File
-}
-
-public object NativeDistributionCommonizerOutputLayout : CommonizerOutputLayout {
-    override fun getTargetDirectory(root: File, target: CommonizerTarget): File {
-        return when (target) {
-            is LeafCommonizerTarget -> root.resolve(KONAN_DISTRIBUTION_PLATFORM_LIBS_DIR).resolve(target.name)
-            is SharedCommonizerTarget -> root.resolve(KONAN_DISTRIBUTION_COMMON_LIBS_DIR)
-        }
-    }
-}
-
-public object HierarchicalCommonizerOutputLayout : CommonizerOutputLayout {
+public object CommonizerOutputFileLayout {
     internal const val maxFileNameLength = 150
 
-    override fun getTargetDirectory(root: File, target: CommonizerTarget): File {
+    public fun getCommonizedDirectory(root: File, target: CommonizerTarget): File {
         return root.resolve(target.fileName)
     }
 
@@ -42,11 +26,18 @@ public object HierarchicalCommonizerOutputLayout : CommonizerOutputLayout {
             }
         }
 
+    public val Set<CommonizerTarget>.fileName: String
+        get() = this.joinToString(";") { it.identityString }.base64Hash
+
+
     private val CommonizerTarget.identityStringHash: String
+        get() = identityString.base64Hash
+
+    private val String.base64Hash: String
         get() {
             val sha = MessageDigest.getInstance("SHA-1")
             val base64 = Base64.getUrlEncoder()
-            return base64.encode(sha.digest(identityString.encodeToByteArray())).decodeToString()
+            return base64.encode(sha.digest(this.encodeToByteArray())).decodeToString()
         }
 }
 

native/commonizer-api/src/org/jetbrains/kotlin/commonizer/parseCommonizerTarget.kt

@@ -192,8 +192,9 @@ private sealed class IdentityStringSyntaxNode {
 private fun buildCommonizerTarget(node: IdentityStringSyntaxNode): CommonizerTarget {
     return when (node) {
         is LeafTargetSyntaxNode -> LeafCommonizerTarget(node.token.value)
+        // Previous nested ((a, b), c) notation is still valid and will be flattened to (a, b, c)
         is SharedTargetSyntaxNode -> SharedCommonizerTarget(
-            node.children.map { child -> buildCommonizerTarget(child) }.toSet()
+            node.children.flatMap { child -> buildCommonizerTarget(child).allLeaves() }.toSet()
         )
     }
 }

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CliCommonizerTest.kt

@@ -23,7 +23,7 @@ class CliCommonizerTest {
             konanHome = konanHome,
             inputLibraries = emptySet(),
             dependencyLibraries = emptySet(),
-            outputCommonizerTarget = CommonizerTarget(KonanTarget.LINUX_X64, KonanTarget.MACOS_X64),
+            outputTargets = setOf(CommonizerTarget(KonanTarget.LINUX_X64, KonanTarget.MACOS_X64)),
             outputDirectory = temporaryOutputDirectory.root
         )
     }

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CommonizeLibcurlTest.kt

@@ -34,24 +34,13 @@ class CommonizeLibcurlTest {
                     KonanDistribution(konanHome).platformLibsDir.resolve(LINUX_ARM64.name).listFiles().orEmpty()
                         .map { TargetedCommonizerDependency(LeafCommonizerTarget(LINUX_ARM64), it) }
                         .toSet(),
-            outputCommonizerTarget = CommonizerTarget(LINUX_ARM64, LINUX_X64),
-            outputDirectory = temporaryOutputDirectory.root
+            outputTargets = setOf(CommonizerTarget(LINUX_ARM64, LINUX_X64)),
+            outputDirectory = temporaryOutputDirectory.root,
+            logLevel = CommonizerLogLevel.Info
         )
 
-        val x64OutputDirectory = temporaryOutputDirectory.root.resolve(CommonizerTarget(LINUX_X64).identityString)
-        val arm64OutputDirectory = temporaryOutputDirectory.root.resolve(CommonizerTarget(LINUX_ARM64).identityString)
         val commonOutputDirectory = temporaryOutputDirectory.root.resolve(CommonizerTarget(LINUX_X64, LINUX_ARM64).identityString)
 
-        assertTrue(
-            x64OutputDirectory.exists(),
-            "Missing output directory for x64 target"
-        )
-
-        assertTrue(
-            arm64OutputDirectory.exists(),
-            "Missing output directory for arm64 target"
-        )
-
         assertTrue(
             commonOutputDirectory.exists(),
             "Missing output directory for commonized x64&arm64 target"
@@ -64,18 +53,8 @@ class CommonizeLibcurlTest {
             )
         }
 
-        assertContainsKnmFiles(x64OutputDirectory)
-        assertContainsKnmFiles(arm64OutputDirectory)
         assertContainsKnmFiles(commonOutputDirectory)
-
-
-        assertContainsManifestWithContent(x64OutputDirectory, "native_targets=linux_x64")
-        assertContainsManifestWithContent(arm64OutputDirectory, "native_targets=linux_arm64")
         assertContainsManifestWithContent(commonOutputDirectory, "native_targets=linux_arm64 linux_x64")
-
-        assertContainsManifestWithContent(x64OutputDirectory, "commonizer_target=linux_x64")
-        assertContainsManifestWithContent(arm64OutputDirectory, "commonizer_target=linux_arm64")
-
         assertContainsManifestWithContent(commonOutputDirectory, "commonizer_native_targets=linux_arm64 linux_x64")
         assertContainsManifestWithContent(
             commonOutputDirectory, "commonizer_target=${CommonizerTarget(LINUX_X64, LINUX_ARM64).identityString}"
@@ -98,22 +77,14 @@ class CommonizeLibcurlTest {
                     KonanDistribution(konanHome).platformLibsDir.resolve(LINUX_ARM64.name).listFiles().orEmpty()
                         .map { TargetedCommonizerDependency(LeafCommonizerTarget(LINUX_ARM64), it) }
                         .toSet(),
-            outputCommonizerTarget = CommonizerTarget(LINUX_ARM64, LINUX_X64, MACOS_X64),
+            outputTargets = setOf(CommonizerTarget(LINUX_ARM64, LINUX_X64, MACOS_X64)),
             outputDirectory = temporaryOutputDirectory.root
         )
 
-        val x64OutputDirectory = temporaryOutputDirectory.root.resolve(CommonizerTarget(LINUX_X64).identityString)
-        val arm64OutputDirectory = temporaryOutputDirectory.root.resolve(CommonizerTarget(LINUX_ARM64).identityString)
         val commonOutputDirectory = temporaryOutputDirectory.root
             .resolve(CommonizerTarget(LINUX_X64, LINUX_ARM64, MACOS_X64).identityString)
 
-        assertContainsManifestWithContent(x64OutputDirectory, "native_targets=linux_x64")
-        assertContainsManifestWithContent(arm64OutputDirectory, "native_targets=linux_arm64")
         assertContainsManifestWithContent(commonOutputDirectory, "native_targets=linux_arm64 linux_x64")
-
-        assertContainsManifestWithContent(x64OutputDirectory, "commonizer_target=linux_x64")
-        assertContainsManifestWithContent(arm64OutputDirectory, "commonizer_target=linux_arm64")
-
         assertContainsManifestWithContent(commonOutputDirectory, "commonizer_native_targets=linux_arm64 linux_x64 macos_x64")
         assertContainsManifestWithContent(
             commonOutputDirectory, "commonizer_target=${CommonizerTarget(LINUX_X64, LINUX_ARM64, MACOS_X64).identityString}"

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CommonizeNativeDistributionTest.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.commonizer
+
+import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout.getCommonizedDirectory
+import org.jetbrains.kotlin.commonizer.utils.konanHome
+import org.jetbrains.kotlin.konan.target.KonanTarget.*
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import kotlin.test.assertTrue
+
+
+class CommonizeNativeDistributionTest {
+
+    @get:Rule
+    val temporaryOutputDirectory = TemporaryFolder()
+
+    @Test
+    fun commonizeLinuxPlatforms() {
+        val linuxTarget1 = CommonizerTarget(LINUX_X64, LINUX_ARM64)
+        val linuxTarget2 = CommonizerTarget(LINUX_X64, LINUX_ARM64, LINUX_ARM32_HFP)
+
+        CliCommonizer(this::class.java.classLoader).commonizeNativeDistribution(
+            konanHome = konanHome,
+            outputTargets = setOf(linuxTarget1, linuxTarget2),
+            outputDirectory = temporaryOutputDirectory.root,
+            logLevel = CommonizerLogLevel.Info
+        )
+
+        assertTrue(
+            getCommonizedDirectory(temporaryOutputDirectory.root, linuxTarget1).isDirectory,
+            "Expected directory for $linuxTarget1"
+        )
+
+        assertTrue(
+            getCommonizedDirectory(temporaryOutputDirectory.root, linuxTarget2).isDirectory,
+            "Expected directory for $linuxTarget2"
+        )
+    }
+}

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CommonizerDependencyTest.kt

@@ -14,8 +14,8 @@ class CommonizerDependencyTest {
     @Test
     fun `sample identityString`() {
         assertEquals(
-            "((a, b), c)::${File("/").canonicalPath}hello.txt",
-            TargetedCommonizerDependency(parseCommonizerTarget("((a,b), c)"), File("/hello.txt")).identityString
+            "(a, b, c)::${File("/").canonicalPath}hello.txt",
+            TargetedCommonizerDependency(parseCommonizerTarget("(a, b, c)"), File("/hello.txt")).identityString
         )
     }
 

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CommonizerTargetFileNameTest.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.commonizer
 
-import org.jetbrains.kotlin.commonizer.HierarchicalCommonizerOutputLayout.fileName
-import org.jetbrains.kotlin.commonizer.HierarchicalCommonizerOutputLayout.maxFileNameLength
+import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout.fileName
+import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout.maxFileNameLength
 import org.junit.Rule
 import org.junit.rules.TemporaryFolder
 import kotlin.test.Test

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CommonizerTargetIdentityStringTest.kt

@@ -33,60 +33,14 @@ class CommonizerTargetIdentityStringTest {
     }
 
     @Test
-    fun `hierarchical commonizer targets`() {
-        val hierarchy = SharedCommonizerTarget(
-            CommonizerTarget(LINUX_X64, MACOS_X64),
-            CommonizerTarget(IOS_ARM64, IOS_X64)
-        )
-        assertEquals(setOf(LINUX_X64, MACOS_X64, IOS_ARM64, IOS_X64), hierarchy.konanTargets)
-        assertEquals(hierarchy, parseCommonizerTarget(hierarchy.identityString))
-    }
-
-    @Test
-    fun `multilevel hierarchical commonizer targets`() {
-        val hierarchy = SharedCommonizerTarget(
-            SharedCommonizerTarget(
-                SharedCommonizerTarget(
-                    SharedCommonizerTarget(
-                        CommonizerTarget(LINUX_X64, MACOS_X64),
-                        CommonizerTarget(IOS_X64, IOS_ARM64)
-                    ),
-                    CommonizerTarget(LINUX_ARM32_HFP)
-                ),
-                CommonizerTarget(LINUX_MIPSEL32)
-            ),
-            CommonizerTarget(WATCHOS_X86, WATCHOS_ARM64)
-        )
-
-        assertEquals(hierarchy, parseCommonizerTarget(hierarchy.identityString))
-    }
-
-    @Test
-    fun `parsing CommonizerTarget`() {
+    fun `parsing CommonizerTarget with 1 5 20 notation`() {
         val target = parseCommonizerTarget("(x, (x, y, (a, b), (b, c)))")
-        assertEquals(
-            SharedCommonizerTarget(
-                LeafCommonizerTarget("x"),
-                SharedCommonizerTarget(
-                    LeafCommonizerTarget("x"),
-                    LeafCommonizerTarget("y"),
-                    SharedCommonizerTarget(
-                        LeafCommonizerTarget("a"),
-                        LeafCommonizerTarget("b"),
-                    ),
-                    SharedCommonizerTarget(
-                        LeafCommonizerTarget("b"),
-                        LeafCommonizerTarget("c")
-                    )
-                )
-            ),
-            target
-        )
+        assertEquals(SharedCommonizerTarget(setOf("x", "y", "a", "b", "c").map(::LeafCommonizerTarget).toSet()), target)
     }
 
     @Test
     fun `empty shared target`() {
-        assertEquals(SharedCommonizerTarget(emptySet<CommonizerTarget>()), parseCommonizerTarget("()"))
+        assertEquals(SharedCommonizerTarget(emptySet<LeafCommonizerTarget>()), parseCommonizerTarget("()"))
     }
 
     @Test(expected = IllegalArgumentException::class)

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CommonizerTargetPrettyNameTest.kt

@@ -1,90 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.commonizer
-
-import org.junit.Test
-import kotlin.test.assertEquals
-
-class CommonizerTargetPrettyNameTest {
-
-    @Test
-    fun leafTargetNames() {
-        listOf(
-            Triple("foo", "[foo]", FOO),
-            Triple("bar", "[bar]", BAR),
-            Triple("baz_123", "[baz_123]", BAZ),
-        ).forEach { (name, prettyName, target: LeafCommonizerTarget) ->
-            assertEquals(name, target.name)
-            assertEquals(prettyName, target.prettyName)
-        }
-    }
-
-    @Test
-    fun sharedTargetNames() {
-        listOf(
-            "[foo]" to SharedTarget(FOO),
-            "[bar, foo]" to SharedTarget(FOO, BAR),
-            "[bar, baz_123, foo]" to SharedTarget(FOO, BAR, BAZ),
-            "[bar, baz_123, foo, [bar, foo]]" to SharedTarget(FOO, BAR, BAZ, SharedTarget(FOO, BAR))
-        ).forEach { (prettyName, target: SharedCommonizerTarget) ->
-            assertEquals(prettyName, target.prettyName)
-        }
-    }
-
-    @Test
-    fun prettyCommonizedName() {
-        val sharedTarget = SharedTarget(FOO, BAR, BAZ)
-        listOf(
-            "[bar, baz_123, foo(*)]" to FOO,
-            "[bar(*), baz_123, foo]" to BAR,
-            "[bar, baz_123(*), foo]" to BAZ,
-            "[bar, baz_123, foo]" to sharedTarget,
-        ).forEach { (prettyCommonizerName, target: CommonizerTarget) ->
-            assertEquals(prettyCommonizerName, sharedTarget.prettyName(target))
-        }
-    }
-
-    @Test
-    fun prettyNestedName() {
-        val target = parseCommonizerTarget("(a, b, (c, (d, e)))") as SharedCommonizerTarget
-
-        assertEquals(
-            "[a, b, [c, [d, e]]]", target.prettyName
-        )
-
-        assertEquals(
-            "[a, b, [c, [d, e(*)]]]", target.prettyName(LeafCommonizerTarget("e"))
-        )
-
-        assertEquals(
-            "[a, b, [c, [d, e](*)]]", target.prettyName(parseCommonizerTarget("(d, e)"))
-        )
-
-        assertEquals(
-            "[a, b, [c, [d, e]](*)]", target.prettyName(parseCommonizerTarget("(c, (d, e))"))
-        )
-
-        assertEquals(
-            "[a, b(*), [c, [d, e]]]", target.prettyName(LeafCommonizerTarget("b"))
-        )
-    }
-
-    @Test
-    fun sharedTargetNoInnerTargets() {
-        assertEquals(
-            "[]", SharedCommonizerTarget(emptySet<CommonizerTarget>()).prettyName
-        )
-    }
-
-    private companion object {
-        val FOO = LeafCommonizerTarget("foo")
-        val BAR = LeafCommonizerTarget("bar")
-        val BAZ = LeafCommonizerTarget("baz_123")
-
-        @Suppress("TestFunctionName")
-        fun SharedTarget(vararg targets: CommonizerTarget) = SharedCommonizerTarget(linkedSetOf(*targets))
-    }
-}

native/commonizer-api/test/org/jetbrains/kotlin/commonizer/CommonizerTargetUtilsTest.kt

@@ -7,53 +7,9 @@ package org.jetbrains.kotlin.commonizer
 
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
 
 class CommonizerTargetUtilsTest {
 
-    @Test
-    fun `isAncestorOf isDescendentOf`() {
-        val child = LeafCommonizerTarget("a")
-        val parent = SharedCommonizerTarget(LeafCommonizerTarget("a"))
-
-        assertTrue(child isDescendentOf parent, "Expected child isDescendent of parent")
-        assertTrue(parent isAncestorOf child, "Expected parent isAncestor of child")
-        assertFalse(child isDescendentOf child, "Expected same target not being descendent of itself")
-        assertFalse(parent isDescendentOf parent, "Expected same target not being descendent of itself")
-        assertFalse(LeafCommonizerTarget("b") isDescendentOf parent, "Expected orphan target not being descendent of parent")
-
-        val hierarchicalParent = SharedCommonizerTarget(parent, parseCommonizerTarget("((c, d), e)"))
-        assertTrue(child isDescendentOf hierarchicalParent, "Expected child being descendent of hierarchical parent")
-        assertTrue(hierarchicalParent isAncestorOf child, "Expected hierarchicalParent being ancestor of child")
-        assertTrue(parseCommonizerTarget("(c, d)") isDescendentOf hierarchicalParent)
-        assertTrue(LeafCommonizerTarget("e") isDescendentOf hierarchicalParent)
-    }
-
-    @Test
-    fun withAllAncestors() {
-        val target = parseCommonizerTarget("((a, b), (c, d), (e, (f, g)))")
-
-        assertEquals(
-            setOf(
-                target,
-                parseCommonizerTarget("(a, b)"),
-                parseCommonizerTarget("(c, d)"),
-                parseCommonizerTarget("(e, (f, g))"),
-                parseCommonizerTarget("(f, g)"),
-                LeafCommonizerTarget("a"),
-                LeafCommonizerTarget("b"),
-                LeafCommonizerTarget("c"),
-                LeafCommonizerTarget("d"),
-                LeafCommonizerTarget("e"),
-                LeafCommonizerTarget("f"),
-                LeafCommonizerTarget("g")
-            ),
-            target.withAllAncestors(),
-            "Expected all targets present"
-        )
-    }
-
     @Test
     fun allLeaves() {
         val target = parseCommonizerTarget("((a, b), (c, d), (e, (f, g)))")
@@ -76,5 +32,18 @@ class CommonizerTargetUtilsTest {
             "Expected LeafCommonizerTarget returns itself in 'allLeaves'"
         )
     }
+
+    @Test
+    fun `withAllLeaves LeafCommonizerTarget`() {
+        assertEquals(setOf(LeafCommonizerTarget("a")), LeafCommonizerTarget("a").withAllLeaves())
+    }
+
+    @Test
+    fun `withAllLeaves SharedCommonizerTarget`() {
+        assertEquals(
+            setOf(parseCommonizerTarget("(a, b)"), LeafCommonizerTarget("a"), LeafCommonizerTarget("b")),
+            parseCommonizerTarget("(a, b)").withAllLeaves()
+        )
+    }
 }
 

native/commonizer/src/org/jetbrains/kotlin/commonizer/CommonizerParameters.kt

@@ -9,27 +9,22 @@ import org.jetbrains.kotlin.commonizer.konan.NativeManifestDataProvider
 import org.jetbrains.kotlin.commonizer.mergedtree.CirFictitiousFunctionClassifiers
 import org.jetbrains.kotlin.commonizer.mergedtree.CirProvidedClassifiers
 import org.jetbrains.kotlin.commonizer.stats.StatsCollector
-import org.jetbrains.kotlin.commonizer.utils.ProgressLogger
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.util.Logger
 
 data class CommonizerParameters(
-    val outputTarget: SharedCommonizerTarget,
+    val outputTargets: Set<SharedCommonizerTarget>,
     val manifestProvider: TargetDependent<NativeManifestDataProvider>,
     val dependenciesProvider: TargetDependent<ModulesProvider?>,
     val targetProviders: TargetDependent<TargetProvider?>,
     val resultsConsumer: ResultsConsumer,
+    val storageManager: StorageManager = LockBasedStorageManager.NO_LOCKS,
     val statsCollector: StatsCollector? = null,
-    val logger: ProgressLogger? = null,
+    val logger: Logger? = null,
 )
 
 internal fun CommonizerParameters.dependencyClassifiers(target: CommonizerTarget): CirProvidedClassifiers {
-    val modules = outputTarget.withAllAncestors()
-        .sortedBy { it.level }
-        .filter { it == target || it isAncestorOf target }
-        .mapNotNull { compatibleTarget -> dependenciesProvider[compatibleTarget] }
-
-    return modules.fold<ModulesProvider, CirProvidedClassifiers>(CirFictitiousFunctionClassifiers) { classifiers, module ->
-        CirProvidedClassifiers.of(classifiers, CirProvidedClassifiers.by(module))
-    }
+    val modulesProvider = dependenciesProvider[target]
+    return CirProvidedClassifiers.of(CirFictitiousFunctionClassifiers, CirProvidedClassifiers.by(modulesProvider))
 }
-
-internal fun CommonizerParameters.with(logger: ProgressLogger?) = copy(logger = logger)

native/commonizer/src/org/jetbrains/kotlin/commonizer/CommonizerQueue.kt

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.commonizer
+
+import org.jetbrains.kotlin.commonizer.mergedtree.CirRootNode
+import org.jetbrains.kotlin.commonizer.tree.CirTreeRoot
+import org.jetbrains.kotlin.commonizer.tree.assembleCirTree
+import org.jetbrains.kotlin.storage.NullableLazyValue
+import org.jetbrains.kotlin.storage.StorageManager
+
+private typealias OutputCommonizerTarget = SharedCommonizerTarget
+private typealias InputCommonizerTarget = CommonizerTarget
+
+internal fun CommonizerQueue(parameters: CommonizerParameters): CommonizerQueue {
+    return CommonizerQueue(
+        storageManager = parameters.storageManager,
+        outputTargets = parameters.outputTargets,
+        deserializers = parameters.targetProviders.mapTargets { target ->
+            CommonizerQueue.Deserializer { deserializeTarget(parameters, target) }
+        },
+        commonizer = { inputs, output -> commonizeTarget(parameters, inputs, output) },
+        serializer = { declarations, outputTarget -> serializeTarget(parameters, declarations, outputTarget) },
+        inputTargetsSelector = DefaultInputTargetsSelector
+    )
+}
+
+internal class CommonizerQueue(
+    private val storageManager: StorageManager,
+    private val outputTargets: Set<OutputCommonizerTarget>,
+    private val deserializers: TargetDependent<Deserializer>,
+    private val commonizer: Commonizer,
+    private val serializer: Serializer,
+    private val inputTargetsSelector: InputTargetsSelector
+) {
+
+    fun interface Deserializer {
+        operator fun invoke(): CirTreeRoot?
+    }
+
+    fun interface Commonizer {
+        operator fun invoke(inputs: TargetDependent<CirTreeRoot?>, output: SharedCommonizerTarget): CirRootNode?
+    }
+
+    fun interface Serializer {
+        operator fun invoke(declarations: CirRootNode, outputTarget: OutputCommonizerTarget)
+    }
+
+    /**
+     * Targets that can just be deserialized and do not need to be commonized.
+     * All leaf targets are expected to be provided.
+     * Previously commonized targets can also be provided
+     */
+    private val deserializedTargets: MutableMap<InputCommonizerTarget, NullableLazyValue<CirTreeRoot>> =
+        deserializers.toMap().mapValuesTo(mutableMapOf()) { (_, deserializer) ->
+            storageManager.createNullableLazyValue { deserializer() }
+        }
+
+    /**
+     * Targets that created using commonization.
+     * The roots are lazy and will be removed as no further pending target requires it's input
+     */
+    private val commonizedTargets: MutableMap<OutputCommonizerTarget, NullableLazyValue<CirTreeRoot>> = mutableMapOf()
+
+    /**
+     * Represents dependency relationships between input and output targets.
+     * Dependencies will be removed if the target was commonized.
+     */
+    private val targetDependencies: MutableMap<OutputCommonizerTarget, Set<InputCommonizerTarget>> = mutableMapOf()
+
+    val retainedDeserializedTargets: Set<InputCommonizerTarget> get() = deserializedTargets.keys
+
+    val retainedCommonizedTargets: Set<OutputCommonizerTarget> get() = commonizedTargets.keys
+
+    val retainedTargetDependencies: Map<OutputCommonizerTarget, Set<InputCommonizerTarget>> get() = targetDependencies.toMap()
+
+    val pendingOutputTargets: Set<CommonizerTarget> get() = targetDependencies.keys
+
+    /**
+     * Runs all tasks/targets in this queue
+     */
+    fun invokeAll() {
+        outputTargets.forEach { outputTarget -> invokeTarget(outputTarget) }
+        assert(deserializedTargets.isEmpty()) { "Expected 'deserializedTargets' to be empty. Found ${deserializedTargets.keys}" }
+        assert(commonizedTargets.isEmpty()) { "Expected 'commonizedTargets' to be empty. Found ${commonizedTargets.keys}" }
+        assert(targetDependencies.isEmpty()) { "Expected 'targetDependencies' to be empty. Found $targetDependencies" }
+    }
+
+    fun invokeTarget(outputTarget: OutputCommonizerTarget) {
+        commonizedTargets[outputTarget]?.invoke()
+    }
+
+    private fun enqueue(outputTarget: OutputCommonizerTarget) {
+        registerTargetDependencies(outputTarget)
+
+        commonizedTargets[outputTarget] = storageManager.createNullableLazyValue {
+            commonize(outputTarget)
+        }
+    }
+
+    private fun commonize(target: SharedCommonizerTarget): CirTreeRoot? {
+        val inputTargets = targetDependencies.getValue(target)
+
+        val inputDeclarations = EagerTargetDependent(inputTargets) { inputTarget ->
+            (deserializedTargets[inputTarget] ?: commonizedTargets[inputTarget]
+            ?: throw IllegalStateException("Missing inputTarget $inputTarget")).invoke()
+        }
+
+        return commonizer(inputDeclarations, target)
+            .also { removeTargetDependencies(target) }
+            ?.also { commonizedDeclarations -> serializer(commonizedDeclarations, target) }
+            ?.assembleCirTree()
+
+    }
+
+    private fun registerTargetDependencies(outputTarget: OutputCommonizerTarget) {
+        targetDependencies[outputTarget] = inputTargetsSelector(outputTargets + deserializers.targets, outputTarget)
+    }
+
+    private fun removeTargetDependencies(target: OutputCommonizerTarget) {
+        targetDependencies.remove(target) ?: return
+        val referencedDependencyTargets = targetDependencies.values.flatten().toSet()
+
+        // Release all commonized targets that are not pending anymore (are already invoked)
+        //  and that are not listed as input target dependency for any further commonization
+        //  Release all commonized targets that no one intends to use any further.
+        commonizedTargets.keys
+            .filter { it !in referencedDependencyTargets && it !in pendingOutputTargets }
+            .forEach(commonizedTargets::remove)
+
+        // Release all deserialized targets that are not referenced as any further dependency anymore.
+        //  Release all deserialized targets that no one intends to use any further
+        deserializedTargets.keys
+            .filter { it !in referencedDependencyTargets }
+            .forEach(deserializedTargets::remove)
+    }
+
+    init {
+        outputTargets.forEach(this::enqueue)
+    }
+}

native/commonizer/src/org/jetbrains/kotlin/commonizer/InputTargetsSelector.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.commonizer
+
+import org.jetbrains.kotlin.commonizer.utils.isProperSubsetOf
+import org.jetbrains.kotlin.commonizer.utils.isSubsetOf
+
+internal fun interface InputTargetsSelector {
+    operator fun invoke(inputTargets: Set<CommonizerTarget>, outputTarget: SharedCommonizerTarget): Set<CommonizerTarget>
+}
+
+internal operator fun InputTargetsSelector.invoke(
+    parameters: CommonizerParameters,
+    outputTarget: SharedCommonizerTarget
+): Set<CommonizerTarget> {
+    return invoke(parameters.outputTargets + parameters.targetProviders.targets, outputTarget)
+}
+
+internal object DefaultInputTargetsSelector : InputTargetsSelector {
+    override fun invoke(inputTargets: Set<CommonizerTarget>, outputTarget: SharedCommonizerTarget): Set<CommonizerTarget> {
+
+        val subsetInputTargets = inputTargets
+            .filter { inputTarget -> inputTarget != outputTarget && inputTarget.allLeaves() isSubsetOf outputTarget.allLeaves() }
+            .sortedBy { it.allLeaves().size }
+
+        val disjointSubsetInputTargets = subsetInputTargets
+            .filter { inputTarget ->
+                subsetInputTargets.none { potentialSuperSet -> inputTarget.allLeaves() isProperSubsetOf potentialSuperSet.allLeaves() }
+            }
+
+        return outputTarget.allLeaves().fold(setOf()) { selectedInputTargets, outputLeafTarget ->
+            if (outputLeafTarget in selectedInputTargets.allLeaves()) return@fold selectedInputTargets
+            selectedInputTargets + (disjointSubsetInputTargets.firstOrNull { inputTarget -> outputLeafTarget in inputTarget.allLeaves() }
+                ?: failedSelectingInputTargets(inputTargets, outputTarget))
+        }
+    }
+}
+
+private fun failedSelectingInputTargets(inputTargets: Set<CommonizerTarget>, outputTarget: SharedCommonizerTarget): Nothing {
+    throw IllegalArgumentException(
+        "Failed selecting input targets for $outputTarget\n" +
+                "inputTargets=$inputTargets\n" +
+                "missing leaf targets: ${outputTarget.allLeaves() - inputTargets.allLeaves()}"
+    )
+}

native/commonizer/src/org/jetbrains/kotlin/commonizer/cli/OutputCommonizerTargetsOptionType.kt

@@ -8,16 +8,16 @@ package org.jetbrains.kotlin.commonizer.cli
 import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
 import org.jetbrains.kotlin.commonizer.parseCommonizerTarget
 
-internal object OutputCommonizerTargetOptionType : OptionType<SharedCommonizerTarget>(
-    alias = "output-commonizer-target",
-    description = "Shared commonizer target representing the commonized output hierarchy",
-    mandatory = false
+internal object OutputCommonizerTargetsOptionType : OptionType<Set<SharedCommonizerTarget>>(
+    alias = "output-targets",
+    description = "Shared commonizer target representing the commonized output hierarchy", // TODO NOW
+    mandatory = true
 ) {
-    override fun parse(rawValue: String, onError: (reason: String) -> Nothing): Option<SharedCommonizerTarget> {
+    override fun parse(rawValue: String, onError: (reason: String) -> Nothing): Option<Set<SharedCommonizerTarget>> {
         return try {
-            Option(this, parseCommonizerTarget(rawValue) as SharedCommonizerTarget)
+            Option(this, rawValue.split(";").map(::parseCommonizerTarget).map { it as SharedCommonizerTarget }.toSet())
         } catch (t: Throwable) {
-            onError("Failed parsing output-commonizer-target ($rawValue): ${t.message}")
+            onError("Failed parsing output-target ($rawValue): ${t.message}")
         }
     }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/cli/TaskType.kt

@@ -18,7 +18,7 @@ internal enum class TaskType(
             NativeDistributionOptionType,
             OutputOptionType,
             NativeTargetsOptionType,
-            OutputCommonizerTargetOptionType,
+            OutputCommonizerTargetsOptionType,
             BooleanOptionType(
                 "copy-stdlib",
                 "Boolean (default false);\nwhether to copy Kotlin/Native endorsed libraries to the destination",
@@ -52,7 +52,7 @@ internal enum class TaskType(
             OutputOptionType,
             InputLibrariesOptionType,
             DependencyLibrariesOptionType,
-            OutputCommonizerTargetOptionType,
+            OutputCommonizerTargetsOptionType,
             LogLevelOptionType
         ),
         ::NativeKlibCommonize

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

@@ -3,18 +3,19 @@
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
+@file:Suppress("DuplicatedCode")
+
 package org.jetbrains.kotlin.commonizer.cli
 
 import org.jetbrains.kotlin.commonizer.*
-import org.jetbrains.kotlin.commonizer.konan.*
+import org.jetbrains.kotlin.commonizer.konan.LibraryCommonizer
+import org.jetbrains.kotlin.commonizer.konan.ModuleSerializer
 import org.jetbrains.kotlin.commonizer.repository.*
 import org.jetbrains.kotlin.commonizer.stats.FileStatsOutput
 import org.jetbrains.kotlin.commonizer.stats.StatsCollector
 import org.jetbrains.kotlin.commonizer.stats.StatsType
-import org.jetbrains.kotlin.commonizer.utils.ProgressLogger
 import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_KLIB_DIR
 import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_PLATFORM_LIBS_DIR
-import org.jetbrains.kotlin.konan.target.KonanTarget
 import java.io.File
 
 internal class NativeDistributionListTargets(options: Collection<Option<*>>) : Task(options) {
@@ -48,35 +49,31 @@ internal class NativeKlibCommonize(options: Collection<Option<*>>) : Task(option
         val destination = getMandatory<File, OutputOptionType>()
         val targetLibraries = getMandatory<List<File>, InputLibrariesOptionType>()
         val dependencyLibraries = getOptional<List<CommonizerDependency>, DependencyLibrariesOptionType>().orEmpty()
-        val outputCommonizerTarget = compatGetOutputTarget()
+        val outputTargets = getMandatory<Set<SharedCommonizerTarget>, OutputCommonizerTargetsOptionType>()
         val statsType = getOptional<StatsType, StatsTypeOptionType> { it == "log-stats" } ?: StatsType.NONE
         val logLevel = getOptional<CommonizerLogLevel, LogLevelOptionType>() ?: CommonizerLogLevel.Quiet
 
 
-        val konanTargets = outputCommonizerTarget.konanTargets
+        val konanTargets = outputTargets.konanTargets
         val commonizerTargets = konanTargets.map(::CommonizerTarget)
 
-        val logger = ProgressLogger(CliLoggerAdapter(logLevel, 2))
+        val logger = CliLoggerAdapter(logLevel, 2)
         val libraryLoader = DefaultNativeLibraryLoader(logger)
         val statsCollector = StatsCollector(statsType, commonizerTargets)
         val repository = FilesRepository(targetLibraries.toSet(), libraryLoader)
 
         val resultsConsumer = buildResultsConsumer {
-            this add ModuleSerializer(destination, HierarchicalCommonizerOutputLayout)
-            this add CopyUnconsumedModulesAsIsConsumer(
-                repository, destination, commonizerTargets.toSet(), NativeDistributionCommonizerOutputLayout
-            )
-            this add LoggingResultsConsumer(outputCommonizerTarget)
+            this add ModuleSerializer(destination)
         }
 
         LibraryCommonizer(
-            outputTarget = outputCommonizerTarget,
+            outputTargets = outputTargets,
             repository = repository,
             dependencies = StdlibRepository(distribution, libraryLoader) +
                     CommonizerDependencyRepository(dependencyLibraries.toSet(), libraryLoader),
             resultsConsumer = resultsConsumer,
             statsCollector = statsCollector,
-            progressLogger = logger
+            logger = logger
         ).run()
 
         statsCollector?.writeTo(FileStatsOutput(destination, statsType.name.lowercase()))
@@ -90,40 +87,30 @@ internal class NativeDistributionCommonize(options: Collection<Option<*>>) : Tas
         val distribution = KonanDistribution(getMandatory<File, NativeDistributionOptionType>())
         val destination = getMandatory<File, OutputOptionType>()
 
-        val outputTarget = compatGetOutputTarget()
-        val outputLayout = if (getOptional<SharedCommonizerTarget, OutputCommonizerTargetOptionType>() != null)
-            HierarchicalCommonizerOutputLayout
-        else NativeDistributionCommonizerOutputLayout
+        val outputTargets = getMandatory<Set<SharedCommonizerTarget>, OutputCommonizerTargetsOptionType>()
 
-
-        val copyStdlib = getOptional<Boolean, BooleanOptionType> { it == "copy-stdlib" } ?: false
-        val copyEndorsedLibs = getOptional<Boolean, BooleanOptionType> { it == "copy-endorsed-libs" } ?: false
         val statsType = getOptional<StatsType, StatsTypeOptionType> { it == "log-stats" } ?: StatsType.NONE
         val logLevel = getOptional<CommonizerLogLevel, LogLevelOptionType>() ?: CommonizerLogLevel.Quiet
 
-        val logger = ProgressLogger(CliLoggerAdapter(logLevel, 2))
+        val logger = CliLoggerAdapter(logLevel, 2)
         val libraryLoader = DefaultNativeLibraryLoader(logger)
-        val repository = KonanDistributionRepository(distribution, outputTarget.konanTargets, libraryLoader)
-        val statsCollector = StatsCollector(statsType, outputTarget.withAllAncestors().toList())
+        val repository = KonanDistributionRepository(distribution, outputTargets.konanTargets, libraryLoader)
+        val statsCollector = StatsCollector(statsType, outputTargets.allLeaves().toList())
 
         val resultsConsumer = buildResultsConsumer {
-            this add ModuleSerializer(destination, outputLayout)
-            this add CopyUnconsumedModulesAsIsConsumer(repository, destination, outputTarget.allLeaves(), outputLayout)
-            if (copyStdlib) this add CopyStdlibResultsConsumer(distribution, destination)
-            if (copyEndorsedLibs) this add CopyEndorsedLibrairesResultsConsumer(distribution, destination)
-            this add LoggingResultsConsumer(outputTarget)
+            this add ModuleSerializer(destination)
         }
 
-        val descriptionSuffix = estimateLibrariesCount(repository, outputTarget.allLeaves()).let { " ($it items)" }
-        logger.log("${logPrefix}Preparing commonized Kotlin/Native libraries for $outputTarget$descriptionSuffix")
+        val descriptionSuffix = estimateLibrariesCount(repository, outputTargets.allLeaves()).let { " ($it items)" }
+        logger.log("${logPrefix}Preparing commonized Kotlin/Native libraries for ${outputTargets.allLeaves()}$descriptionSuffix")
 
         LibraryCommonizer(
-            outputTarget = outputTarget,
+            outputTargets = outputTargets,
             repository = repository,
             dependencies = StdlibRepository(distribution, libraryLoader),
             resultsConsumer = resultsConsumer,
             statsCollector = statsCollector,
-            progressLogger = logger
+            logger = logger
         ).run()
 
         statsCollector?.writeTo(FileStatsOutput(destination, statsType.name.lowercase()))
@@ -136,10 +123,4 @@ internal class NativeDistributionCommonize(options: Collection<Option<*>>) : Tas
     }
 }
 
-private fun Task.compatGetOutputTarget(): SharedCommonizerTarget {
-    getOptional<SharedCommonizerTarget, OutputCommonizerTargetOptionType>()?.let { return it }
-    val konanTargets = getOptional<List<KonanTarget>, NativeTargetsOptionType>() ?: throw IllegalArgumentException(
-        "Missing ${OutputCommonizerTargetOptionType.alias} or deprecated ${NativeTargetsOptionType.alias} option was specified"
-    )
-    return SharedCommonizerTarget(konanTargets)
-}
+

native/commonizer/src/org/jetbrains/kotlin/commonizer/commonModuleNames.kt

@@ -9,7 +9,7 @@ package org.jetbrains.kotlin.commonizer
  * @return Set of module names that is available across all children targets
  */
 internal fun CommonizerParameters.commonModuleNames(target: CommonizerTarget): Set<String> {
-    val supportedTargets = target.withAllAncestors().mapNotNull(targetProviders::getOrNull)
+    val supportedTargets = target.withAllLeaves().mapNotNull(targetProviders::getOrNull)
     if (supportedTargets.isEmpty()) return emptySet() // Nothing to do
 
     val allModuleNames: List<Set<String>> = supportedTargets.toList().map { targetProvider ->
@@ -23,8 +23,8 @@ internal fun CommonizerParameters.commonModuleNames(target: CommonizerTarget): S
  * @return Set of module names that this [targetProvider] shares with *at least* one other target
  */
 internal fun CommonizerParameters.commonModuleNames(targetProvider: TargetProvider): Set<String> {
-    return outputTarget.withAllAncestors()
-        .filter { target -> target isAncestorOf targetProvider.target }
+    return outputTargets
+        .filter { target -> (target.allLeaves() intersect targetProvider.target.allLeaves()).isNotEmpty() }
         .map { target -> commonModuleNames(target) }
         .fold(emptySet()) { acc, names -> acc + names }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/core/RootCommonizer.kt

@@ -6,22 +6,24 @@
 package org.jetbrains.kotlin.commonizer.core
 
 import org.jetbrains.kotlin.commonizer.CommonizerTarget
+import org.jetbrains.kotlin.commonizer.LeafCommonizerTarget
 import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
+import org.jetbrains.kotlin.commonizer.allLeaves
 import org.jetbrains.kotlin.commonizer.cir.CirRoot
 
 class RootCommonizer : AbstractStandardCommonizer<CirRoot, CirRoot>() {
-    private val targets = mutableSetOf<CommonizerTarget>()
+    private val targets = mutableSetOf<LeafCommonizerTarget>()
 
     override fun commonizationResult() = CirRoot.create(
         target = SharedCommonizerTarget(targets)
     )
 
     override fun initialize(first: CirRoot) {
-        targets += first.target
+        targets += first.target.allLeaves()
     }
 
     override fun doCommonizeWith(next: CirRoot): Boolean {
-        targets += next.target
+        targets += next.target.allLeaves()
         return true
     }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/facade.kt

@@ -6,126 +6,79 @@
 package org.jetbrains.kotlin.commonizer
 
 import kotlinx.metadata.klib.ChunkedKlibModuleFragmentWriteStrategy
-import org.jetbrains.kotlin.commonizer.ResultsConsumer.ModuleResult
-import org.jetbrains.kotlin.commonizer.ResultsConsumer.ModuleResult.Missing
 import org.jetbrains.kotlin.commonizer.ResultsConsumer.Status
 import org.jetbrains.kotlin.commonizer.core.CommonizationVisitor
 import org.jetbrains.kotlin.commonizer.mergedtree.CirCommonizedClassifierNodes
 import org.jetbrains.kotlin.commonizer.mergedtree.CirKnownClassifiers
 import org.jetbrains.kotlin.commonizer.mergedtree.CirNode.Companion.indexOfCommon
-import org.jetbrains.kotlin.commonizer.mergedtree.CirNode.Companion.targetIndices
 import org.jetbrains.kotlin.commonizer.mergedtree.CirRootNode
-import org.jetbrains.kotlin.commonizer.metadata.CirTreeSerializer.serializeSingleTarget
+import org.jetbrains.kotlin.commonizer.metadata.CirTreeSerializer
 import org.jetbrains.kotlin.commonizer.transformer.Checked.Companion.invoke
 import org.jetbrains.kotlin.commonizer.transformer.InlineTypeAliasCirNodeTransformer
 import org.jetbrains.kotlin.commonizer.tree.CirTreeRoot
-import org.jetbrains.kotlin.commonizer.tree.assembleCirTree
-import org.jetbrains.kotlin.commonizer.tree.deserializeCirTree
+import org.jetbrains.kotlin.commonizer.tree.defaultCirTreeRootDeserializer
 import org.jetbrains.kotlin.commonizer.tree.mergeCirTree
+import org.jetbrains.kotlin.commonizer.utils.progress
 import org.jetbrains.kotlin.library.SerializedMetadata
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import org.jetbrains.kotlin.storage.StorageManager
 
 fun runCommonization(parameters: CommonizerParameters) {
     if (!parameters.containsCommonModuleNames()) {
         parameters.resultsConsumer.allConsumed(parameters, Status.NOTHING_TO_DO)
         return
     }
-
-    val storageManager = LockBasedStorageManager("Declarations commonization")
-    commonize(parameters, storageManager, parameters.outputTarget)
+    CommonizerQueue(parameters).invokeAll()
     parameters.resultsConsumer.allConsumed(parameters, Status.DONE)
 }
 
-private fun commonize(
-    parameters: CommonizerParameters,
-    storageManager: StorageManager,
-    target: SharedCommonizerTarget,
-): CirRootNode? {
-    val cirTrees = getCirTree(parameters, storageManager, target)
-    parameters.logProgress("Built declaration tree for $target")
-
-    // build merged tree:
-    val classifiers = CirKnownClassifiers(
-        commonizedNodes = CirCommonizedClassifierNodes.default(),
-        commonDependencies = parameters.dependencyClassifiers(target)
-    )
-
-    val mergedTree = merge(storageManager, classifiers, cirTrees) ?: return null
-    InlineTypeAliasCirNodeTransformer(storageManager, classifiers).invoke(mergedTree)
-    mergedTree.accept(CommonizationVisitor(classifiers, mergedTree), Unit)
-    parameters.logProgress("Commonized declarations for $target")
-
-    serialize(parameters, mergedTree, target)
-
-    return mergedTree
-}
-
-private fun getCirTree(
-    parameters: CommonizerParameters, storageManager: StorageManager, target: SharedCommonizerTarget
-): TargetDependent<CirTreeRoot?> {
-    return EagerTargetDependent(target.targets) { childTarget ->
-        when (childTarget) {
-            is LeafCommonizerTarget -> deserialize(parameters, childTarget)
-            is SharedCommonizerTarget -> commonize(parameters.fork(), storageManager, childTarget)?.assembleCirTree().also {
-                parameters.logProgress("Commonized target $childTarget")
-            }
-        }
+internal fun deserializeTarget(parameters: CommonizerParameters, target: TargetProvider): CirTreeRoot {
+    return parameters.logger.progress(target.target, "Deserialized declarations") {
+        defaultCirTreeRootDeserializer(parameters, target)
     }
 }
 
-private fun deserialize(parameters: CommonizerParameters, target: CommonizerTarget): CirTreeRoot? {
+internal fun deserializeTarget(parameters: CommonizerParameters, target: CommonizerTarget): CirTreeRoot? {
     val targetProvider = parameters.targetProviders[target] ?: return null
-    return deserializeCirTree(parameters, targetProvider)
+    return deserializeTarget(parameters, targetProvider)
 }
 
-private fun merge(
-    storageManager: StorageManager, classifiers: CirKnownClassifiers, cirTrees: TargetDependent<CirTreeRoot?>,
+internal fun commonizeTarget(
+    parameters: CommonizerParameters,
+    inputs: TargetDependent<CirTreeRoot?>,
+    output: CommonizerTarget
 ): CirRootNode? {
-    val availableTrees = cirTrees.filterNonNull()
-    /* Nothing to merge */
-    if (availableTrees.size == 0) return null
+    parameters.logger.progress(output, "Commonized declarations from ${inputs.targets}") {
+        val availableTrees = inputs.filterNonNull()
+        /* Nothing to merge */
+        if (availableTrees.size == 0) return null
 
-    return mergeCirTree(storageManager, classifiers, availableTrees)
-}
+        val classifiers = CirKnownClassifiers(
+            commonizedNodes = CirCommonizedClassifierNodes.default(),
+            commonDependencies = parameters.dependencyClassifiers(output)
+        )
 
-private fun serialize(parameters: CommonizerParameters, mergedTree: CirRootNode, commonTarget: CommonizerTarget) {
-    for (targetIndex in mergedTree.targetIndices) {
-        val target = mergedTree.targetDeclarations[targetIndex]?.target ?: continue
-        serializeMissingModules(parameters, target)
-        if (target is LeafCommonizerTarget) {
-            serialize(parameters, mergedTree, target, targetIndex)
-        }
+        val mergedTree = mergeCirTree(parameters.storageManager, classifiers, availableTrees)
+        InlineTypeAliasCirNodeTransformer(parameters.storageManager, classifiers).invoke(mergedTree)
+        mergedTree.accept(CommonizationVisitor(classifiers, mergedTree), Unit)
+
+        return mergedTree
     }
-    serialize(parameters, mergedTree, commonTarget, mergedTree.indexOfCommon)
 }
 
-private fun serialize(parameters: CommonizerParameters, mergedTree: CirRootNode, target: CommonizerTarget, targetIndex: Int) {
-    serializeSingleTarget(mergedTree, targetIndex, parameters.statsCollector) { metadataModule ->
+internal fun serializeTarget(
+    parameters: CommonizerParameters,
+    commonized: CirRootNode,
+    outputTarget: SharedCommonizerTarget
+): Unit = parameters.logger.progress(outputTarget, "Serialized target") {
+    CirTreeSerializer.serializeSingleTarget(commonized, commonized.indexOfCommon, parameters.statsCollector) { metadataModule ->
         val libraryName = metadataModule.name
-        val serializedMetadata = with(metadataModule.write(KLIB_FRAGMENT_WRITE_STRATEGY)) {
+        val serializedMetadata = with(metadataModule.write(ChunkedKlibModuleFragmentWriteStrategy())) {
             SerializedMetadata(header, fragments, fragmentNames)
         }
-        val manifestData = parameters.manifestProvider[target].buildManifest(libraryName)
-        parameters.resultsConsumer.consume(parameters, target, ModuleResult.Commonized(libraryName, serializedMetadata, manifestData))
+        val manifestData = parameters.manifestProvider[outputTarget].buildManifest(libraryName)
+        parameters.resultsConsumer.consume(
+            parameters, outputTarget,
+            ResultsConsumer.ModuleResult.Commonized(libraryName, serializedMetadata, manifestData)
+        )
     }
-    parameters.resultsConsumer.targetConsumed(parameters, target)
+    parameters.resultsConsumer.targetConsumed(parameters, outputTarget)
 }
-
-private fun serializeMissingModules(parameters: CommonizerParameters, requestedTarget: CommonizerTarget) {
-    val targetProvider = parameters.targetProviders.getOrNull(requestedTarget) ?: return
-    val commonModuleNames = parameters.commonModuleNames(targetProvider)
-
-    targetProvider.modulesProvider.loadModuleInfos()
-        .filter { it.name !in commonModuleNames }
-        .forEach { missingModule ->
-            parameters.resultsConsumer.consume(parameters, requestedTarget, Missing(missingModule.originalLocation))
-        }
-}
-
-private fun CommonizerParameters.fork(): CommonizerParameters = with(logger?.fork())
-
-private fun CommonizerParameters.logProgress(message: String) = logger?.progress(message)
-
-private val KLIB_FRAGMENT_WRITE_STRATEGY = ChunkedKlibModuleFragmentWriteStrategy()
-

native/commonizer/src/org/jetbrains/kotlin/commonizer/konan/CopyLibrariesFromKonanDistributionResultsConsumer.kt

@@ -1,60 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-@file:Suppress("FunctionName")
-
-package org.jetbrains.kotlin.commonizer.konan
-
-import org.jetbrains.kotlin.commonizer.CommonizerParameters
-import org.jetbrains.kotlin.commonizer.KonanDistribution
-import org.jetbrains.kotlin.commonizer.ResultsConsumer
-import org.jetbrains.kotlin.commonizer.klibDir
-import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_COMMON_LIBS_DIR
-import org.jetbrains.kotlin.konan.library.KONAN_STDLIB_NAME
-import java.io.File
-
-internal fun CopyStdlibResultsConsumer(
-    konanDistribution: KonanDistribution,
-    destination: File
-): ResultsConsumer {
-    return CopyLibrariesFromKonanDistributionResultsConsumer(
-        konanDistribution,
-        destination,
-        invokeWhenCopied = { logger?.progress("Copied standard library") },
-        copyFileIf = { file -> file.endsWith(KONAN_STDLIB_NAME) }
-    )
-}
-
-internal fun CopyEndorsedLibrairesResultsConsumer(
-    konanDistribution: KonanDistribution,
-    destination: File,
-): ResultsConsumer {
-    return CopyLibrariesFromKonanDistributionResultsConsumer(
-        konanDistribution,
-        destination,
-        invokeWhenCopied = { logger?.progress("Copied endorsed libraries") },
-        copyFileIf = { file -> !file.endsWith(KONAN_STDLIB_NAME) }
-    )
-}
-
-private class CopyLibrariesFromKonanDistributionResultsConsumer(
-    private val konanDistribution: KonanDistribution,
-    private val destination: File,
-    private val invokeWhenCopied: CommonizerParameters.() -> Unit = {},
-    private val copyFileIf: (File) -> Boolean = { true }
-) : ResultsConsumer {
-    override fun allConsumed(parameters: CommonizerParameters, status: ResultsConsumer.Status) {
-        konanDistribution.klibDir
-            .resolve(KONAN_DISTRIBUTION_COMMON_LIBS_DIR)
-            .listFiles().orEmpty()
-            .filter { it.isDirectory }
-            .filterNot(copyFileIf)
-            .forEach { libraryOrigin ->
-                val libraryDestination = destination.resolve(KONAN_DISTRIBUTION_COMMON_LIBS_DIR).resolve(libraryOrigin.name)
-                libraryOrigin.copyRecursively(libraryDestination)
-            }
-        parameters.invokeWhenCopied()
-    }
-}

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

@@ -1,44 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.commonizer.konan
-
-import org.jetbrains.kotlin.commonizer.*
-import org.jetbrains.kotlin.commonizer.repository.Repository
-import java.io.File
-
-internal class CopyUnconsumedModulesAsIsConsumer(
-    private val repository: Repository,
-    private val destination: File,
-    private val targets: Set<LeafCommonizerTarget>,
-    private val outputLayout: CommonizerOutputLayout,
-) : ResultsConsumer {
-
-    private val consumedTargets = mutableSetOf<LeafCommonizerTarget>()
-
-    override fun targetConsumed(parameters: CommonizerParameters, target: CommonizerTarget) {
-        if (target is LeafCommonizerTarget) {
-            consumedTargets += target
-        }
-    }
-
-    override fun allConsumed(parameters: CommonizerParameters, status: ResultsConsumer.Status) {
-        when (status) {
-            ResultsConsumer.Status.NOTHING_TO_DO -> targets.forEach { target -> copyTargetAsIs(parameters, target) }
-            ResultsConsumer.Status.DONE -> targets.minus(consumedTargets).forEach { target -> copyTargetAsIs(parameters, target) }
-        }
-    }
-
-    private fun copyTargetAsIs(parameters: CommonizerParameters, target: LeafCommonizerTarget) {
-        val libraries = repository.getLibraries(target)
-        val librariesDestination = outputLayout.getTargetDirectory(destination, target)
-        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))
-        }
-
-        parameters.logger?.progress("Copied ${libraries.size} libraries for ${target.prettyName}")
-    }
-}

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

@@ -8,55 +8,61 @@ package org.jetbrains.kotlin.commonizer.konan
 import org.jetbrains.kotlin.commonizer.*
 import org.jetbrains.kotlin.commonizer.repository.Repository
 import org.jetbrains.kotlin.commonizer.stats.StatsCollector
-import org.jetbrains.kotlin.commonizer.utils.ProgressLogger
+import org.jetbrains.kotlin.commonizer.utils.progress
+import org.jetbrains.kotlin.util.Logger
 import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
 
 internal class LibraryCommonizer internal constructor(
-    private val outputTarget: SharedCommonizerTarget,
+    private val outputTargets: Set<SharedCommonizerTarget>,
     private val repository: Repository,
     private val dependencies: Repository,
     private val resultsConsumer: ResultsConsumer,
     private val statsCollector: StatsCollector?,
-    private val progressLogger: ProgressLogger
+    private val logger: Logger
 ) {
 
     fun run() {
-        checkPreconditions()
-        val allLibraries = loadLibraries()
-        commonizeAndSaveResults(allLibraries)
-        progressLogger.logTotal()
+        logger.progress("Commonized all targets") {
+            checkPreconditions()
+            val allLibraries = loadLibraries()
+            commonizeAndSaveResults(allLibraries)
+        }
     }
 
     private fun loadLibraries(): TargetDependent<NativeLibrariesToCommonize?> {
-        val libraries = EagerTargetDependent(outputTarget.allLeaves()) { target ->
-            repository.getLibraries(target).toList().ifNotEmpty { NativeLibrariesToCommonize(target, this) }
-        }
+        return logger.progress("Resolved all libraries for commonization") {
+            val libraries = EagerTargetDependent(outputTargets.allLeaves()) { target ->
+                repository.getLibraries(target).toList().ifNotEmpty { NativeLibrariesToCommonize(target, this) }
+            }
 
-        libraries.forEachWithTarget { target, librariesOrNull ->
-            if (librariesOrNull == null)
-                progressLogger.warning(
-                    "No libraries found for target ${target.prettyName}. This target will be excluded from commonization."
-                )
+            libraries.forEachWithTarget { target, librariesOrNull ->
+                if (librariesOrNull == null)
+                    logger.warning(
+                        "No libraries found for target ${target}. This target will be excluded from commonization."
+                    )
+            }
+            libraries
         }
-
-        progressLogger.progress("Resolved libraries to be commonized")
-        return libraries
     }
 
     private fun commonizeAndSaveResults(libraries: TargetDependent<NativeLibrariesToCommonize?>) {
-        val parameters = CommonizerParameters(
-            outputTarget = outputTarget,
-            targetProviders = libraries.map { target, targetLibraries -> createTargetProvider(target, targetLibraries) },
-            manifestProvider = createManifestProvider(libraries),
-            dependenciesProvider = createDependenciesProvider(),
-            resultsConsumer = resultsConsumer,
-            statsCollector = statsCollector,
-            logger = progressLogger
+        runCommonization(
+            CommonizerParameters(
+                outputTargets = outputTargets,
+                targetProviders = libraries.map { target, targetLibraries -> createTargetProvider(target, targetLibraries) },
+                manifestProvider = createManifestProvider(libraries),
+                dependenciesProvider = createDependenciesProvider(),
+                resultsConsumer = resultsConsumer,
+                statsCollector = statsCollector,
+                logger = logger
+            )
         )
-        runCommonization(parameters)
     }
 
-    private fun createTargetProvider(target: CommonizerTarget, libraries: NativeLibrariesToCommonize?): TargetProvider? {
+    private fun createTargetProvider(
+        target: CommonizerTarget,
+        libraries: NativeLibrariesToCommonize?
+    ): TargetProvider? {
         if (libraries == null) return null
         return TargetProvider(
             target = target,
@@ -65,7 +71,7 @@ internal class LibraryCommonizer internal constructor(
     }
 
     private fun createDependenciesProvider(): TargetDependent<ModulesProvider?> {
-        return TargetDependent(outputTarget.withAllAncestors()) { target ->
+        return TargetDependent(outputTargets + outputTargets.allLeaves()) { target ->
             DefaultModulesProvider.create(dependencies.getLibraries(target))
         }
     }
@@ -73,7 +79,7 @@ internal class LibraryCommonizer internal constructor(
     private fun createManifestProvider(
         libraries: TargetDependent<NativeLibrariesToCommonize?>
     ): TargetDependent<NativeManifestDataProvider> {
-        return TargetDependent(outputTarget.withAllAncestors()) { target ->
+        return TargetDependent(outputTargets) { target ->
             when (target) {
                 is LeafCommonizerTarget -> libraries[target] ?: error("Can't provide manifest for missing target $target")
                 is SharedCommonizerTarget -> NativeManifestDataProvider(
@@ -84,9 +90,11 @@ internal class LibraryCommonizer internal constructor(
     }
 
     private fun checkPreconditions() {
+        /* TODO
         when (outputTarget.allLeaves().size) {
             0 -> progressLogger.fatal("No targets specified")
             1 -> progressLogger.fatal("Too few targets specified: $outputTarget")
         }
+         */
     }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/konan/LoggingResultsConsumer.kt

@@ -1,16 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.commonizer.konan
-
-import org.jetbrains.kotlin.commonizer.*
-
-internal class LoggingResultsConsumer(
-    private val outputCommonizerTarget: SharedCommonizerTarget
-) : ResultsConsumer {
-    override fun targetConsumed(parameters: CommonizerParameters, target: CommonizerTarget) {
-        parameters.logger?.progress("Written libraries for ${outputCommonizerTarget.prettyName(target)}")
-    }
-}

native/commonizer/src/org/jetbrains/kotlin/commonizer/konan/ModuleSerializer.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.commonizer.konan
 
-import org.jetbrains.kotlin.commonizer.CommonizerOutputLayout
+import org.jetbrains.kotlin.commonizer.CommonizerOutputFileLayout
 import org.jetbrains.kotlin.commonizer.CommonizerParameters
 import org.jetbrains.kotlin.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.commonizer.ResultsConsumer
@@ -18,10 +18,9 @@ import java.io.File
 
 internal class ModuleSerializer(
     private val destination: File,
-    private val outputLayout: CommonizerOutputLayout,
 ) : ResultsConsumer {
     override fun consume(parameters: CommonizerParameters, target: CommonizerTarget, moduleResult: ResultsConsumer.ModuleResult) {
-        val librariesDestination = outputLayout.getTargetDirectory(destination, target)
+        val librariesDestination = CommonizerOutputFileLayout.getCommonizedDirectory(destination, target)
         when (moduleResult) {
             is ResultsConsumer.ModuleResult.Commonized -> {
                 val libraryDestination = librariesDestination.resolve(moduleResult.fileSystemCompatibleLibraryName)

native/commonizer/src/org/jetbrains/kotlin/commonizer/repository/StdlibRepository.kt

@@ -5,8 +5,11 @@
 
 package org.jetbrains.kotlin.commonizer.repository
 
-import org.jetbrains.kotlin.commonizer.*
+import org.jetbrains.kotlin.commonizer.CommonizerTarget
+import org.jetbrains.kotlin.commonizer.KonanDistribution
+import org.jetbrains.kotlin.commonizer.NativeLibraryLoader
 import org.jetbrains.kotlin.commonizer.konan.NativeLibrary
+import org.jetbrains.kotlin.commonizer.stdlib
 
 internal class StdlibRepository(
     private val konanDistribution: KonanDistribution,
@@ -18,6 +21,6 @@ internal class StdlibRepository(
     }
 
     override fun getLibraries(target: CommonizerTarget): Set<NativeLibrary> {
-        return if (target is SharedCommonizerTarget) setOf(stdlib) else emptySet()
+        return setOf(stdlib)
     }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializeCirTree.kt

@@ -6,8 +6,10 @@
 package org.jetbrains.kotlin.commonizer.tree
 
 import org.jetbrains.kotlin.commonizer.CommonizerParameters
+import org.jetbrains.kotlin.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.commonizer.TargetProvider
 import org.jetbrains.kotlin.commonizer.tree.deserializer.*
+import org.jetbrains.kotlin.commonizer.utils.progress
 
 internal val defaultCirTreeModuleDeserializer = CirTreeModuleDeserializer(
     packageDeserializer = CirTreePackageDeserializer(
@@ -25,8 +27,3 @@ internal val defaultCirTreeModuleDeserializer = CirTreeModuleDeserializer(
 internal val defaultCirTreeRootDeserializer = RootCirTreeDeserializer(
     defaultCirTreeModuleDeserializer
 )
-
-
-internal fun deserializeCirTree(parameters: CommonizerParameters, target: TargetProvider): CirTreeRoot {
-    return defaultCirTreeRootDeserializer(parameters, target)
-}

native/commonizer/src/org/jetbrains/kotlin/commonizer/utils/ProgressLogger.kt

@@ -5,36 +5,25 @@
 
 package org.jetbrains.kotlin.commonizer.utils
 
-import org.jetbrains.kotlin.commonizer.cli.CliLoggerAdapter
-import org.jetbrains.kotlin.commonizer.CommonizerLogLevel
+import org.jetbrains.kotlin.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.util.Logger
 
-class ProgressLogger(
-    private val wrapped: Logger = CliLoggerAdapter(CommonizerLogLevel.Info, 0),
-    private val indent: Int = 0,
-) : Logger by wrapped {
-    private val clockMark = ResettableClockMark()
-    private var finished = false
+private const val ansiReset = "\u001B[0m"
+private const val ansiTimeColor = "\u001B[36m"
+private const val ansiTargetColor = "\u001B[32m"
 
-    private val prefix = "  ".repeat(indent) + " * "
-
-    init {
-        clockMark.reset()
-        require(indent >= 0) { "Required indent >= 1" }
-    }
-
-    fun progress(message: String) {
-        check(!finished)
-        wrapped.log("$prefix$message in ${clockMark.elapsedSinceLast()}")
-    }
-
-    fun logTotal() {
-        check(!finished)
-        wrapped.log("TOTAL: ${clockMark.elapsedSinceStart()}")
-        finished = true
-    }
-
-    fun fork(): ProgressLogger {
-        return ProgressLogger(this, indent + 1)
+internal inline fun <T> Logger?.progress(message: String, action: () -> T): T {
+    val clock = ResettableClockMark()
+    clock.reset()
+    try {
+        return action()
+    } finally {
+        this?.log("$message ${ansiTimeColor}in ${clock.elapsedSinceLast()}$ansiReset")
     }
 }
+
+internal inline fun <T> Logger?.progress(
+    target: CommonizerTarget, message: String, action: () -> T
+): T {
+    return progress("[$ansiTargetColor$target$ansiReset]: $message", action)
+}

native/commonizer/src/org/jetbrains/kotlin/commonizer/utils/SetExtensions.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.commonizer.utils
+
+infix fun <T> Set<T>.isSubsetOf(other: Set<T>): Boolean {
+    if (this === other) return true
+    return other.containsAll(this)
+}
+
+infix fun <T> Set<T>.isProperSubsetOf(other: Set<T>): Boolean {
+    if (this == other) return false
+    return other.containsAll(this)
+}

native/commonizer/tests/org/jetbrains/kotlin/commonizer/AbstractCommonizationFromSourcesTest.kt

@@ -84,17 +84,6 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
             (results.modulesByTargets.getValue(sharedTarget).single() as ModuleResult.Commonized).metadata
 
         assertModulesAreEqual(sharedModuleAsExpected, sharedModuleByCommonizer, sharedTarget)
-
-        val leafTargets: Set<LeafCommonizerTarget> = analyzedModules.leafTargets
-        assertEquals(leafTargets, results.leafTargets)
-
-        for (leafTarget in leafTargets) {
-            val leafTargetModuleAsExpected: SerializedMetadata = analyzedModules.commonizedModules.getValue(leafTarget)
-            val leafTargetModuleByCommonizer: SerializedMetadata =
-                (results.modulesByTargets.getValue(leafTarget).single() as ModuleResult.Commonized).metadata
-
-            assertModulesAreEqual(leafTargetModuleAsExpected, leafTargetModuleByCommonizer, leafTarget)
-        }
     }
 }
 
@@ -208,9 +197,14 @@ private class AnalyzedModules(
         resultsConsumer: ResultsConsumer,
         manifestDataProvider: (CommonizerTarget) -> NativeManifestDataProvider = { MockNativeManifestDataProvider(it) }
     ) = CommonizerParameters(
-        outputTarget = SharedCommonizerTarget(leafTargets.toSet()),
-        manifestProvider = TargetDependent(sharedTarget.withAllAncestors(), manifestDataProvider),
-        dependenciesProvider = TargetDependent(sharedTarget.withAllAncestors()) { dependencyModules[it]?.let(MockModulesProvider::create) },
+        outputTargets = setOf(SharedCommonizerTarget(leafTargets.toSet())),
+        manifestProvider = TargetDependent(sharedTarget.withAllLeaves(), manifestDataProvider),
+        dependenciesProvider = TargetDependent(sharedTarget.withAllLeaves()) { target ->
+            dependencyModules
+                .filter { (registeredTarget, _) -> target in registeredTarget.withAllLeaves() }
+                .values.flatten()
+                .let(MockModulesProvider::create)
+        },
         targetProviders = TargetDependent(leafTargets) { leafTarget ->
             TargetProvider(
                 target = leafTarget,

native/commonizer/tests/org/jetbrains/kotlin/commonizer/AbstractInlineSourcesCommonizationTest.kt

@@ -25,7 +25,7 @@ data class HierarchicalCommonizationResult(
 abstract class AbstractInlineSourcesCommonizationTest : KtInlineSourceCommonizerTestCase() {
 
     data class Parameters(
-        val outputTarget: SharedCommonizerTarget,
+        val outputTargets: Set<SharedCommonizerTarget>,
         val dependencies: TargetDependent<List<InlineSourceBuilder.Module>>,
         val targets: List<Target>
     )
@@ -41,7 +41,7 @@ abstract class AbstractInlineSourcesCommonizationTest : KtInlineSourceCommonizer
 
     @InlineSourcesCommonizationTestDsl
     class ParametersBuilder(private val parentInlineSourceBuilder: InlineSourceBuilder) {
-        private var outputTarget: SharedCommonizerTarget? = null
+        private var outputTargets: MutableSet<SharedCommonizerTarget>? = null
 
         private val dependencies: MutableMap<CommonizerTarget, MutableList<InlineSourceBuilder.Module>> = LinkedHashMap()
 
@@ -52,8 +52,12 @@ abstract class AbstractInlineSourcesCommonizationTest : KtInlineSourceCommonizer
 
 
         @InlineSourcesCommonizationTestDsl
-        fun outputTarget(target: String) {
-            outputTarget = parseCommonizerTarget(target) as SharedCommonizerTarget
+        fun outputTarget(vararg targets: String) {
+            val outputTargets = outputTargets ?: mutableSetOf()
+            targets.forEach { target ->
+                outputTargets += parseCommonizerTarget(target) as SharedCommonizerTarget
+            }
+            this.outputTargets = outputTargets
         }
 
         @InlineSourcesCommonizationTestDsl
@@ -67,18 +71,20 @@ abstract class AbstractInlineSourcesCommonizationTest : KtInlineSourceCommonizer
         }
 
         @InlineSourcesCommonizationTestDsl
-        fun registerDependency(target: CommonizerTarget, builder: InlineSourceBuilder.ModuleBuilder.() -> Unit) {
-            val dependenciesList = dependencies.getOrPut(target) { mutableListOf() }
-            val dependency = inlineSourceBuilderFactory[target].createModule {
-                builder()
-                name = "${target.prettyName}-dependency-${dependenciesList.size}-$name"
+        fun registerDependency(vararg targets: CommonizerTarget, builder: InlineSourceBuilder.ModuleBuilder.() -> Unit) {
+            targets.forEach { target ->
+                val dependenciesList = dependencies.getOrPut(target) { mutableListOf() }
+                val dependency = inlineSourceBuilderFactory[target].createModule {
+                    builder()
+                    name = "$target-dependency-${dependenciesList.size}-$name"
+                }
+                dependenciesList.add(dependency)
             }
-            dependenciesList.add(dependency)
         }
 
         @InlineSourcesCommonizationTestDsl
-        fun registerDependency(target: String, builder: InlineSourceBuilder.ModuleBuilder.() -> Unit) {
-            registerDependency(parseCommonizerTarget(target), builder)
+        fun registerDependency(vararg targets: String, builder: InlineSourceBuilder.ModuleBuilder.() -> Unit) {
+            registerDependency(targets = targets.map(::parseCommonizerTarget).toTypedArray(), builder)
         }
 
         @InlineSourcesCommonizationTestDsl
@@ -96,7 +102,7 @@ abstract class AbstractInlineSourcesCommonizationTest : KtInlineSourceCommonizer
         }
 
         fun build(): Parameters = Parameters(
-            outputTarget = outputTarget ?: SharedCommonizerTarget(targets.map { it.target }.toSet()),
+            outputTargets = outputTargets ?: setOf(SharedCommonizerTarget(targets.map { it.target }.allLeaves())),
             dependencies = dependencies.toTargetDependent(),
             targets = targets.toList()
         )
@@ -111,7 +117,7 @@ abstract class AbstractInlineSourcesCommonizationTest : KtInlineSourceCommonizer
                 override fun createModule(builder: InlineSourceBuilder.ModuleBuilder.() -> Unit): InlineSourceBuilder.Module {
                     return inlineSourceBuilder.createModule {
                         dependencies.toMap()
-                            .filterKeys { dependencyTarget -> dependencyTarget.isEqualOrAncestorOf(target) }.values.flatten()
+                            .filterKeys { dependencyTarget -> target in dependencyTarget.withAllLeaves() }.values.flatten()
                             .forEach { dependencyModule -> dependency(dependencyModule) }
                         builder()
                     }
@@ -155,16 +161,16 @@ abstract class AbstractInlineSourcesCommonizationTest : KtInlineSourceCommonizer
         manifestDataProvider: (CommonizerTarget) -> NativeManifestDataProvider = { MockNativeManifestDataProvider(it) }
     ): CommonizerParameters {
         return CommonizerParameters(
-            outputTarget = outputTarget,
-            manifestProvider = TargetDependent(outputTarget.withAllAncestors(), manifestDataProvider),
-            dependenciesProvider = TargetDependent(outputTarget.withAllAncestors()) { target ->
+            outputTargets = outputTargets,
+            manifestProvider = TargetDependent(outputTargets, manifestDataProvider),
+            dependenciesProvider = TargetDependent(outputTargets.withAllLeaves()) { target ->
                 val explicitDependencies = dependencies.getOrNull(target).orEmpty().map { module -> createModuleDescriptor(module) }
-                val implicitDependencies = listOfNotNull(if (target == outputTarget) DefaultBuiltIns.Instance.builtInsModule else null)
+                val implicitDependencies = listOfNotNull(DefaultBuiltIns.Instance.builtInsModule)
                 val dependencies = explicitDependencies + implicitDependencies
                 if (dependencies.isEmpty()) null
                 else MockModulesProvider.create(dependencies)
             },
-            targetProviders = TargetDependent(outputTarget.allLeaves()) { commonizerTarget ->
+            targetProviders = TargetDependent(outputTargets.allLeaves()) { commonizerTarget ->
                 val target = targets.singleOrNull { it.target == commonizerTarget } ?: return@TargetDependent null
                 TargetProvider(
                     target = commonizerTarget,

native/commonizer/tests/org/jetbrains/kotlin/commonizer/CommonizerFacadeTest.kt

@@ -70,12 +70,12 @@ class CommonizerFacadeTest {
             manifestDataProvider: (CommonizerTarget) -> NativeManifestDataProvider = { MockNativeManifestDataProvider(it) }
         ): CommonizerParameters {
             val targetDependentModuleNames = mapKeys { (targetName, _) -> LeafCommonizerTarget(targetName) }.toTargetDependent()
-            val sharedTarget = SharedCommonizerTarget(targetDependentModuleNames.targets.toSet())
+            val sharedTarget = SharedCommonizerTarget(targetDependentModuleNames.targets.allLeaves())
 
             return CommonizerParameters(
-                outputTarget = sharedTarget,
-                dependenciesProvider = TargetDependent(sharedTarget.withAllAncestors()) { null },
-                manifestProvider = TargetDependent(sharedTarget.withAllAncestors(), manifestDataProvider),
+                outputTargets = setOf(sharedTarget),
+                dependenciesProvider = TargetDependent(sharedTarget.withAllLeaves()) { null },
+                manifestProvider = TargetDependent(sharedTarget.withAllLeaves(), manifestDataProvider),
                 targetProviders = targetDependentModuleNames.map { target, moduleNames ->
                     TargetProvider(
                         target = target,

native/commonizer/tests/org/jetbrains/kotlin/commonizer/CommonizerQueueTest.kt

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.commonizer
+
+import org.jetbrains.kotlin.commonizer.cir.CirRoot
+import org.jetbrains.kotlin.commonizer.mergedtree.CirRootNode
+import org.jetbrains.kotlin.commonizer.tree.CirTreeRoot
+import org.jetbrains.kotlin.commonizer.utils.CommonizedGroup
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.junit.Test
+import kotlin.test.assertEquals
+
+class CommonizerQueueTest {
+
+    @Test
+    fun `test retained targets`() {
+        val queue = CommonizerQueue(
+            storageManager = LockBasedStorageManager.NO_LOCKS,
+            outputTargets = setOf("(a, b)", "(a, b, c)").map(::parseCommonizerTarget).map { it as SharedCommonizerTarget }.toSet(),
+            deserializers = EagerTargetDependent(
+                setOf("a", "b", "c").map(::parseCommonizerTarget)
+            ) { CommonizerQueue.Deserializer { null } },
+            commonizer = { _, _ -> null },
+            serializer = { _, _ -> },
+            inputTargetsSelector = DefaultInputTargetsSelector
+        )
+
+        assertEquals(
+            setOf("a", "b", "c"), queue.retainedDeserializedTargets.map { it.identityString }.toSet(),
+            "Expected all targets a, b, c to be retained in the beginning"
+        )
+
+        assertEquals(
+            setOf("(a, b)", "(a, b, c)"), queue.retainedCommonizedTargets.map { it.identityString }.toSet(),
+            "Expected all output targets to be retained in the beginning"
+        )
+
+        assertEquals(
+            setOf("(a, b)", "(a, b, c)"), queue.retainedTargetDependencies.keys.map { it.identityString }.toSet(),
+            "Expected all output targets to declare its dependencies"
+        )
+
+        queue.invokeTarget(parseCommonizerTarget("(a, b)") as SharedCommonizerTarget)
+
+        assertEquals(
+            setOf("c"), queue.retainedDeserializedTargets.map { it.identityString }.toSet(),
+            "Expected only target 'c' to be retained after commonizing (a, b)"
+        )
+
+        assertEquals(
+            setOf("(a, b)", "(a, b, c)"), queue.retainedCommonizedTargets.map { it.identityString }.toSet(),
+            "Expected all output targets to be retained after commonizing (a, b)"
+        )
+
+        assertEquals(
+            setOf("(a, b, c)"), queue.retainedTargetDependencies.keys.map { it.identityString }.toSet(),
+            "Expected remaining targets to declare its dependencies"
+        )
+
+        assertEquals(queue.pendingOutputTargets, queue.retainedTargetDependencies.keys)
+
+        queue.invokeTarget(parseCommonizerTarget("(a, b, c)") as SharedCommonizerTarget)
+
+        assertEquals(
+            emptySet(), queue.retainedDeserializedTargets,
+            "Expected no retained deserialized targets"
+        )
+
+        assertEquals(
+            emptySet(), queue.retainedCommonizedTargets,
+            "Expected no retained commonized targets"
+        )
+
+        assertEquals(
+            emptySet(), queue.retainedTargetDependencies.keys,
+            "Expected no retained target dependencies"
+        )
+
+        assertEquals(queue.pendingOutputTargets, queue.retainedTargetDependencies.keys)
+
+        queue.invokeAll()
+    }
+
+    @Test
+    fun `test commonizer being called`() {
+        data class CommonizerInvocation(val inputs: TargetDependent<CirTreeRoot?>, val output: SharedCommonizerTarget)
+
+        val commonizerInvocations = mutableListOf<CommonizerInvocation>()
+        val storageManager = LockBasedStorageManager.NO_LOCKS
+        val providedTargets = setOf("a", "b", "c").map(::parseCommonizerTarget).toSet()
+        val abOutputTarget = parseCommonizerTarget("(a, b)") as SharedCommonizerTarget
+        val abcOutputTarget = parseCommonizerTarget("(a, b, c)") as SharedCommonizerTarget
+        val outputTargets = setOf(abOutputTarget, abcOutputTarget)
+
+        val queue = CommonizerQueue(
+            storageManager = storageManager,
+            outputTargets = outputTargets,
+            deserializers = EagerTargetDependent(providedTargets) { CommonizerQueue.Deserializer { null } },
+            commonizer = { inputs, output ->
+                commonizerInvocations.add(CommonizerInvocation(inputs, output))
+                CirRootNode(CommonizedGroup(0), storageManager.createNullableLazyValue { CirRoot.create(output) })
+            },
+            serializer = { _, _ -> },
+            inputTargetsSelector = DefaultInputTargetsSelector
+        )
+
+        queue.invokeAll()
+
+        assertEquals(
+            2, commonizerInvocations.size,
+            "Expected 2 commonizer invocations"
+        )
+
+        assertEquals(
+            outputTargets, commonizerInvocations.map { it.output }.toSet(),
+            "Expected specified output targets to be invoked"
+        )
+
+        val abInvocation = commonizerInvocations.single { it.output == abOutputTarget }
+        assertEquals(
+            DefaultInputTargetsSelector(providedTargets + outputTargets, abOutputTarget),
+            abInvocation.inputs.targets.toSet(),
+            "Expected commonizer being invoked with selected targets for abInvocation"
+        )
+
+        val abcInvocation = commonizerInvocations.single { it.output == abcOutputTarget }
+        assertEquals(
+            DefaultInputTargetsSelector(providedTargets + outputTargets, abcOutputTarget),
+            abcInvocation.inputs.targets.toSet(),
+            "Expected commonizer being invoked with selected targets for abcInvocation"
+        )
+    }
+}

native/commonizer/tests/org/jetbrains/kotlin/commonizer/DefaultInputTargetsSelectorTest.kt

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.commonizer
+
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertTrue
+
+class DefaultInputTargetsSelectorTest {
+
+    @Test
+    fun `missing leaf targets`() {
+        val inputTargets = setOf(LeafCommonizerTarget("a"), LeafCommonizerTarget("b"))
+
+        val exception = assertFailsWith<IllegalArgumentException> {
+            DefaultInputTargetsSelector(inputTargets, parseCommonizerTarget("(a, b, c)") as SharedCommonizerTarget)
+        }
+
+        assertTrue(
+            exception.message.orEmpty().contains(inputTargets.toString()),
+            "Expected error message to contain all input targets. Found ${exception.message}"
+        )
+
+        assertTrue(
+            exception.message.orEmpty().contains(parseCommonizerTarget("(a, b, c)").toString()),
+            "Expected error message to contain output target. Found ${exception.message}"
+        )
+    }
+
+    @Test
+    fun `sample 0`() {
+        val inputTargets = setOf(
+            LeafCommonizerTarget("a"),
+            LeafCommonizerTarget("b"),
+            LeafCommonizerTarget("c"),
+            LeafCommonizerTarget("d"),
+            SharedCommonizerTarget(LeafCommonizerTarget("c"), LeafCommonizerTarget("d"))
+        )
+
+        assertEquals(
+            setOf(LeafCommonizerTarget("a"), LeafCommonizerTarget("b")),
+            DefaultInputTargetsSelector(inputTargets, parseCommonizerTarget("(a, b)") as SharedCommonizerTarget)
+        )
+
+        assertEquals(
+            setOf(LeafCommonizerTarget("a"), LeafCommonizerTarget("b"), LeafCommonizerTarget("c")),
+            DefaultInputTargetsSelector(inputTargets, parseCommonizerTarget("(a, b, c)") as SharedCommonizerTarget)
+        )
+
+        assertEquals(
+            setOf(LeafCommonizerTarget("a"), LeafCommonizerTarget("b"), parseCommonizerTarget("(c, d)")),
+            DefaultInputTargetsSelector(inputTargets, parseCommonizerTarget("(a, b, c, d)") as SharedCommonizerTarget)
+        )
+    }
+
+    @Test
+    fun `sample 1`() {
+        val inputTargets = setOf(
+            parseCommonizerTarget("(a, b)"),
+            parseCommonizerTarget("(a, b, c)"),
+            parseCommonizerTarget("(a, b, c, d)"),
+            parseCommonizerTarget("(c, d)"),
+            parseCommonizerTarget("(c, d, e)"),
+            parseCommonizerTarget("f")
+        )
+
+        assertEquals(
+            setOf("(a, b, c, d)", "f").map(::parseCommonizerTarget).toSet(),
+            DefaultInputTargetsSelector(inputTargets, parseCommonizerTarget("(a, b, c, d, f)") as SharedCommonizerTarget)
+        )
+
+        assertEquals(
+            setOf("(a, b, c, d)", "(c, d, e)").map(::parseCommonizerTarget).toSet(),
+            DefaultInputTargetsSelector(inputTargets, parseCommonizerTarget("(a, b, c, d, e)") as SharedCommonizerTarget)
+        )
+
+        assertEquals(
+            setOf("(a, b, c, d)", "(c, d, e)", "f").map(::parseCommonizerTarget).toSet(),
+            DefaultInputTargetsSelector(inputTargets, parseCommonizerTarget("(a, b, c, d, e, f)") as SharedCommonizerTarget)
+        )
+    }
+
+    @Test
+    fun `empty outputTarget`() {
+        assertEquals(
+            emptySet(),
+            DefaultInputTargetsSelector(emptySet(), parseCommonizerTarget("()") as SharedCommonizerTarget)
+        )
+    }
+
+    @Test
+    fun `single leaf outputTarget`() {
+        assertEquals(
+            setOf(LeafCommonizerTarget("a")),
+            DefaultInputTargetsSelector(setOf(LeafCommonizerTarget("a")), parseCommonizerTarget("(a)") as SharedCommonizerTarget)
+        )
+    }
+
+    @Test
+    fun `exact output available`() {
+        assertEquals(
+            setOf(parseCommonizerTarget("(a, b)"), parseCommonizerTarget("(c, d)")),
+            DefaultInputTargetsSelector(
+                setOf("a", "b", "c", "d", "(a, b)", "(c, d)", "(a, b, c, d)").map(::parseCommonizerTarget).toSet(),
+                parseCommonizerTarget("(a, b, c, d)") as SharedCommonizerTarget
+            )
+        )
+    }
+}

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/FunctionReturnTypeCommonizationTest.kt

@@ -41,24 +41,6 @@ class FunctionReturnTypeCommonizationTest : AbstractInlineSourcesCommonizationTe
         result.assertCommonized(
             "(a,b)", ""
         )
-
-        result.assertCommonized(
-            "a", """
-            class A {
-                class B
-            }
-            fun x(): A.B = TODO()
-            """
-        )
-
-        result.assertCommonized(
-            "b", """
-            interface A {
-                class B
-            }
-            fun x(): A.B = TODO()
-            """
-        )
     }
 
 
@@ -98,23 +80,5 @@ class FunctionReturnTypeCommonizationTest : AbstractInlineSourcesCommonizationTe
                 expect fun x(): A.B
             """
         )
-
-        result.assertCommonized(
-            "a", """
-                interface A {
-                    class B
-                }
-                fun x(): A.B = TODO()
-            """
-        )
-
-        result.assertCommonized(
-            "b", """
-                interface A {
-                    class B
-                }
-                fun x(): A.B = TODO()
-            """
-        )
     }
 }

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalClassAndTypeAliasCommonizationTest.kt

@@ -18,13 +18,11 @@ class HierarchicalClassAndTypeAliasCommonizationTest : AbstractInlineSourcesComm
         }
 
         result.assertCommonized("(a, b)", "expect class X")
-        result.assertCommonized("a", "typealias X = Int")
-        result.assertCommonized("b", "class X")
     }
 
     fun `test commonization of typeAlias and class hierarchically`() {
         val result = commonize {
-            outputTarget("((a, b), (c, d))")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
             simpleSingleSourceTarget("a", "typealias X = Int")
             simpleSingleSourceTarget("b", "typealias X = Long")
             simpleSingleSourceTarget("c", "class X")

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalClassCommonizationTest.kt

@@ -12,7 +12,7 @@ class HierarchicalClassCommonizationTest : AbstractInlineSourcesCommonizationTes
 
     fun `test simple class`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d), e)")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)", "(a, b, c, d, e)")
             simpleSingleSourceTarget("a", "class X")
             simpleSingleSourceTarget("b", "class X")
             simpleSingleSourceTarget("c", "class X")
@@ -20,12 +20,6 @@ class HierarchicalClassCommonizationTest : AbstractInlineSourcesCommonizationTes
             simpleSingleSourceTarget("e", "class X")
         }
 
-        result.assertCommonized("a", "class X")
-        result.assertCommonized("b", "class X")
-        result.assertCommonized("c", "class X")
-        result.assertCommonized("d", "class X")
-        result.assertCommonized("e", "class X")
-
         result.assertCommonized("(a,b)", "expect class X expect constructor()")
         result.assertCommonized("(c,d)", "expect class X expect constructor()")
         result.assertCommonized("(a,b)", "expect class X expect constructor()")
@@ -34,7 +28,7 @@ class HierarchicalClassCommonizationTest : AbstractInlineSourcesCommonizationTes
 
     fun `test sample class`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d))")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
             simpleSingleSourceTarget(
                 "a", """
                    class X {
@@ -76,46 +70,6 @@ class HierarchicalClassCommonizationTest : AbstractInlineSourcesCommonizationTes
             )
         }
 
-        result.assertCommonized(
-            "a", """
-               class X {
-                    val a: Int = 42
-                    val ab: Int = 42
-                    val abcd: Int = 42
-               } 
-                """
-        )
-
-        result.assertCommonized(
-            "b", """
-               class X {
-                    val b: Int = 42
-                    val ab: Int = 42
-                    val abcd: Int = 42
-               } 
-                """
-        )
-
-        result.assertCommonized(
-            "c", """
-               class X {
-                    val c: Int = 42
-                    val cd: Int = 42
-                    val abcd: Int = 42
-               } 
-                """
-        )
-
-        result.assertCommonized(
-            "d", """
-               class X {
-                   val d: Int = 42
-                   val cd: Int = 42
-                   val abcd: Int = 42
-               } 
-                """
-        )
-
         result.assertCommonized(
             "(a,b)", """
                expect class X expect constructor() {

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalFunctionCommonizationTest.kt

@@ -12,7 +12,7 @@ class HierarchicalFunctionCommonizationTest : AbstractInlineSourcesCommonization
 
     fun `test simple function 1`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d))")
+            outputTarget("(a,b)", "(c,d)", "(a, b, c, d)")
             simpleSingleSourceTarget("a", "fun x(): Int = 42")
             simpleSingleSourceTarget("b", "fun x(): Int = 42")
             simpleSingleSourceTarget("c", "fun x(): Int = 42")
@@ -22,15 +22,11 @@ class HierarchicalFunctionCommonizationTest : AbstractInlineSourcesCommonization
         result.assertCommonized("((a,b), (c,d))", "expect fun x(): Int")
         result.assertCommonized("(a,b)", "expect fun x(): Int")
         result.assertCommonized("(c,d)", "expect fun x(): Int")
-        result.assertCommonized("a", "actual fun x(): Int = 42")
-        result.assertCommonized("b", "actual fun x(): Int = 42")
-        result.assertCommonized("c", "actual fun x(): Int = 42")
-        result.assertCommonized("d", "actual fun x(): Int = 42")
     }
 
     fun `test simple function 2`() {
         val result = commonize {
-            outputTarget("((a,b), c)")
+            outputTarget("(a, b)", "(a, b, c)")
             simpleSingleSourceTarget("a", "fun x(): Int = 42")
             simpleSingleSourceTarget("b", "fun x(): Int = 42")
             simpleSingleSourceTarget("c", "fun x(): Int = 42")
@@ -38,14 +34,11 @@ class HierarchicalFunctionCommonizationTest : AbstractInlineSourcesCommonization
 
         result.assertCommonized("((a,b), c)", "expect fun x(): Int")
         result.assertCommonized("(a,b)", "expect fun x(): Int")
-        result.assertCommonized("a", "fun x(): Int = 42")
-        result.assertCommonized("b", "fun x(): Int = 42")
-        result.assertCommonized("c", "fun x(): Int = 42")
     }
 
     fun `test function with returnType`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d))")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
             simpleSingleSourceTarget(
                 "a", """
                 interface ABCD
@@ -73,34 +66,6 @@ class HierarchicalFunctionCommonizationTest : AbstractInlineSourcesCommonization
             )
         }
 
-        result.assertCommonized(
-            "a", """
-            interface ABCD
-            fun x(): ABCD = TODO()
-            """
-        )
-
-        result.assertCommonized(
-            "b", """
-            interface ABCD
-            fun x(): ABCD = TODO()
-            """
-        )
-
-        result.assertCommonized(
-            "c", """
-            interface ABCD
-            fun x(): ABCD = TODO()
-            """
-        )
-
-        result.assertCommonized(
-            "d", """
-            interface ABCD
-            fun x(): ABCD = TODO()
-            """
-        )
-
         result.assertCommonized(
             "(a, b)", """
             expect interface ABCD
@@ -125,18 +90,14 @@ class HierarchicalFunctionCommonizationTest : AbstractInlineSourcesCommonization
 
     fun `test function with returnType from dependency 1`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d))")
-            registerDependency("((a,b), (c,d))") { source("interface ABCD") }
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
+            registerDependency("a", "b", "c", "d", "(a, b)", "(c, d)", "(a, b, c, d)") { source("interface ABCD") }
             simpleSingleSourceTarget("a", "fun x(): ABCD = TODO()")
             simpleSingleSourceTarget("b", "fun x(): ABCD = TODO()")
             simpleSingleSourceTarget("c", "fun x(): ABCD = TODO()")
             simpleSingleSourceTarget("d", "fun x(): ABCD = TODO()")
         }
 
-        result.assertCommonized("a", "fun x(): ABCD")
-        result.assertCommonized("b", "fun x(): ABCD")
-        result.assertCommonized("c", "fun x(): ABCD")
-        result.assertCommonized("d", "fun x(): ABCD")
         result.assertCommonized("(c, d)", "expect fun x(): ABCD")
         result.assertCommonized("(a, b)", "expect fun x(): ABCD")
         result.assertCommonized("((a,b), (c,d))", "expect fun x(): ABCD")
@@ -144,8 +105,9 @@ class HierarchicalFunctionCommonizationTest : AbstractInlineSourcesCommonization
 
     fun `test function with returnType from dependency 2`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d))")
-            registerDependency("(a,b)") { source("interface ABCD") }
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
+            registerDependency("a", "b", "c", "d") { source("interface ABCD") }
+            registerDependency("(a, b)") { source("interface ABCD") }
             registerDependency("(c,d)") { source("interface ABCD") }
             simpleSingleSourceTarget("a", "fun x(): ABCD = TODO()")
             simpleSingleSourceTarget("b", "fun x(): ABCD = TODO()")
@@ -153,28 +115,23 @@ class HierarchicalFunctionCommonizationTest : AbstractInlineSourcesCommonization
             simpleSingleSourceTarget("d", "fun x(): ABCD = TODO()")
         }
 
-        result.assertCommonized("a", "fun x(): ABCD")
-        result.assertCommonized("b", "fun x(): ABCD")
-        result.assertCommonized("c", "fun x(): ABCD")
-        result.assertCommonized("d", "fun x(): ABCD")
         result.assertCommonized("(c, d)", "expect fun x(): ABCD")
         result.assertCommonized("(a, b)", "expect fun x(): ABCD")
+
+        // ABCD is not given as dependency on (a, b, c, d) -> can't be commonized
         result.assertCommonized("((a,b), (c,d))", "")
     }
 
     fun `test function with returnType from dependency 3`() {
         val result = commonize {
-            outputTarget("((a,b), c)")
-            registerDependency("((a,b), c)") { source("interface ABCD") }
-            registerDependency("(a,b)") { source("interface ABCD") }
+            outputTarget("(a, b)", "(a, b, c)")
+            registerDependency("(a, b, c)") { source("interface ABCD") }
+            registerDependency("a", "b", "c", "(a, b)") { source("interface ABCD") }
             simpleSingleSourceTarget("a", "fun x(): ABCD = TODO()")
             simpleSingleSourceTarget("b", "fun x(): ABCD = TODO()")
             simpleSingleSourceTarget("c", "fun x(): ABCD = TODO()")
         }
 
-        result.assertCommonized("a", "fun x(): ABCD")
-        result.assertCommonized("b", "fun x(): ABCD")
-        result.assertCommonized("c", "fun x(): ABCD")
         result.assertCommonized("(a, b)", "expect fun x(): ABCD")
         result.assertCommonized("((a,b), c)", "expect fun x(): ABCD")
     }

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalModuleCommonizationTest.kt

@@ -17,7 +17,7 @@ class HierarchicalModuleCommonizationTest : AbstractInlineSourcesCommonizationTe
 
     fun `test common modules hierarchically`() {
         val result = commonize {
-            outputTarget("((a, b), c)")
+            outputTarget("(a, b)", "(a, b, c)")
 
             target("a") {
                 module {
@@ -67,20 +67,20 @@ class HierarchicalModuleCommonizationTest : AbstractInlineSourcesCommonizationTe
         }
 
 
-        result.assertCommonized("((a, b), c)") {
+        result.assertCommonized("(a, b, c)") {
             name = "foo"
             source("expect val foo: Int")
         }
 
         assertEquals(
-            1, result.results[parseCommonizerTarget("((a, b), c)")].orEmpty().size,
+            1, result.results[parseCommonizerTarget("(a, b, c)")].orEmpty().size,
             "Expected only a single module"
         )
     }
 
     fun `test module commonization with empty root not sharing any module`() {
         val result = commonize {
-            outputTarget("((a, b), c)")
+            outputTarget("(a, b)", "(a, b, c)")
 
             target("a") {
                 module {
@@ -110,14 +110,14 @@ class HierarchicalModuleCommonizationTest : AbstractInlineSourcesCommonizationTe
         }
 
         assertTrue(
-            result.results[parseCommonizerTarget("((a, b), c)")].orEmpty().isEmpty(),
-            "Expected empty result for ((a, b), c)"
+            result.results[parseCommonizerTarget("(a, b, c)")].orEmpty().isEmpty(),
+            "Expected empty result for (a, b, c)"
         )
     }
 
     fun `test no common modules`() {
         val result = commonize(Status.NOTHING_TO_DO) {
-            outputTarget("((a, b), c)")
+            outputTarget("(a, b)", "(a, b, c)")
 
             target("a") {
                 module {
@@ -146,7 +146,7 @@ class HierarchicalModuleCommonizationTest : AbstractInlineSourcesCommonizationTe
 
     fun `test propagation`() {
         val result = commonize {
-            outputTarget("(((a, b), c), d)")
+            outputTarget("(a, b)", "(a, b, c)", "(a, b, c, d)")
 
             target("a") {
                 module {
@@ -170,12 +170,12 @@ class HierarchicalModuleCommonizationTest : AbstractInlineSourcesCommonizationTe
             }
         }
 
-        result.assertCommonized("((a, b), c)") {
+        result.assertCommonized("(a, b, c)") {
             name = "foo"
             source("expect val foo: Int")
         }
 
-        result.assertCommonized("(((a, b), c), d)") {
+        result.assertCommonized("(a, b, c, d)") {
             name = "foo"
             source("expect val foo: Int")
         }
@@ -212,36 +212,9 @@ class HierarchicalModuleCommonizationTest : AbstractInlineSourcesCommonizationTe
 
         assertEquals(1, result.results[parseCommonizerTarget("(a, b)")]?.size, "Expected only one commonized module")
 
-
         result.assertCommonized("(a, b)") {
             name = "shared"
             source("expect class Shared expect constructor()")
         }
-
-        result.assertCommonized("a") {
-            name = "shared"
-            source("class Shared constructor()")
-        }
-
-        result.assertCommonized("b") {
-            name = "shared"
-            source("class Shared constructor()")
-        }
-
-        val targetAResults = result.results[parseCommonizerTarget("a")].orEmpty()
-        assertEquals(2, targetAResults.size, "Expected 'Missing' and 'Commonized' results for target a")
-        val targetAMissingModule = kotlin.test.assertNotNull(
-            targetAResults.filterIsInstance<Missing>().singleOrNull(),
-            "Expected 'Missing' result for target a"
-        )
-        assertEquals("onlyInA", targetAMissingModule.libraryName)
-
-        val targetBResults = result.results[parseCommonizerTarget("b")].orEmpty()
-        assertEquals(2, targetBResults.size, "Expected 'Missing' and 'Commonized' results for target b")
-        val targetBMissingModule = kotlin.test.assertNotNull(
-            targetBResults.filterIsInstance<Missing>().singleOrNull(),
-            "Expected 'Missing' result for target b"
-        )
-        assertEquals("onlyInB", targetBMissingModule.libraryName)
     }
 }

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalPackageCommonizationTest.kt

@@ -12,7 +12,7 @@ class HierarchicalPackageCommonizationTest : AbstractInlineSourcesCommonizationT
 
     fun `test package with dummy`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d))")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
 
             target("a") {
                 module {
@@ -107,90 +107,6 @@ class HierarchicalPackageCommonizationTest : AbstractInlineSourcesCommonizationT
             }
         }
 
-        result.assertCommonized("a") {
-            source(
-                """
-                package pkg.abcd
-                val dummy = "me"
-                """, "abcd.kt"
-            )
-            source(
-                """
-                package pkg.ab
-                val dummy = "me"
-                """, "ab.kt"
-            )
-            source(
-                """
-                package pkg.a
-                val dummy = "me"
-                """, "a.kt"
-            )
-        }
-
-        result.assertCommonized("b") {
-            source(
-                """
-                package pkg.abcd
-                val dummy = "me"
-                """, "abcd.kt"
-            )
-            source(
-                """
-                package pkg.ab
-                val dummy = "me"
-                """, "ab.kt"
-            )
-            source(
-                """
-                package pkg.b
-                val dummy = "me"
-                """, "b.kt"
-            )
-        }
-
-        result.assertCommonized("c") {
-            source(
-                """
-                package pkg.abcd
-                val dummy = "me"
-                """, "abcd.kt"
-            )
-            source(
-                """
-                package pkg.cd
-                val dummy = "me"
-                """, "cd.kt"
-            )
-            source(
-                """
-                package pkg.c
-                val dummy = "me"
-                """, "c.kt"
-            )
-        }
-
-        result.assertCommonized("d") {
-            source(
-                """
-                package pkg.abcd
-                val dummy = "me"
-                """, "abcd.kt"
-            )
-            source(
-                """
-                package pkg.cd
-                val dummy = "me"
-                """, "cd.kt"
-            )
-            source(
-                """
-                package pkg.d
-                val dummy = "me"
-                """, "d.kt"
-            )
-        }
-
         result.assertCommonized("(a,b)") {
             source(
                 """

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalPropertyCommonizationTest.kt

@@ -12,7 +12,7 @@ class HierarchicalPropertyCommonizationTest : AbstractInlineSourcesCommonization
 
     fun `test simple property`() {
         val result = commonize {
-            outputTarget("((a, b), (c, d))")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
             simpleSingleSourceTarget("a", "val x: Int = 42")
             simpleSingleSourceTarget("b", "val x: Int = 42")
             simpleSingleSourceTarget("c", "val x: Int = 42")
@@ -22,10 +22,6 @@ class HierarchicalPropertyCommonizationTest : AbstractInlineSourcesCommonization
         result.assertCommonized("((a,b), (c,d))", "expect val x: Int")
         result.assertCommonized("(a, b)", "expect val x: Int")
         result.assertCommonized("(c, d)", "expect val x: Int")
-        result.assertCommonized("a", "val x: Int = 42")
-        result.assertCommonized("b", "val x: Int = 42")
-        result.assertCommonized("c", "val x: Int = 42")
-        result.assertCommonized("d", "val x: Int = 42")
     }
 
     fun `test same typeAliased property`() {

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/HierarchicalTypeAliasCommonizationTest.kt

@@ -12,7 +12,7 @@ class HierarchicalTypeAliasCommonizationTest : AbstractInlineSourcesCommonizatio
 
     fun `test simple type alias`() {
         val result = commonize {
-            outputTarget("((a,b), (c,d))")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
             simpleSingleSourceTarget("a", "typealias X = Int")
             simpleSingleSourceTarget("b", "typealias X = Int")
             simpleSingleSourceTarget("c", "typealias X = Int")
@@ -22,12 +22,6 @@ class HierarchicalTypeAliasCommonizationTest : AbstractInlineSourcesCommonizatio
         result.assertCommonized("((a,b), (c,d))", "typealias X = Int")
         result.assertCommonized("(a,b)", "typealias X = Int")
         result.assertCommonized("(c, d)", "typealias X = Int")
-
-        /* Special case: For now, leaves should depend on commonized platform libraries */
-        result.assertCommonized("a", "")
-        result.assertCommonized("b", "")
-        result.assertCommonized("c", "")
-        result.assertCommonized("d", "")
     }
 
     /**
@@ -50,7 +44,7 @@ class HierarchicalTypeAliasCommonizationTest : AbstractInlineSourcesCommonizatio
 
     fun `test typealias to different classes`() {
         val result = commonize {
-            outputTarget("(((a,b), (c,d)), (e,f))")
+            outputTarget("(a, b)", "(c, d)", "(e, f)", "(a, b, c, d)", "(a, b, c, d, e, f)")
             simpleSingleSourceTarget(
                 "a", """
                 class AB
@@ -79,13 +73,6 @@ class HierarchicalTypeAliasCommonizationTest : AbstractInlineSourcesCommonizatio
             simpleSingleSourceTarget("f", """class x""")
         }
 
-        result.assertCommonized("a", """class AB""")
-        result.assertCommonized("b", """class AB""")
-        result.assertCommonized("c", """class CD""")
-        result.assertCommonized("d", """class CD""")
-        result.assertCommonized("e", """class x""")
-        result.assertCommonized("f", """class x""")
-
         result.assertCommonized(
             "(a,b)", """
                 expect class AB expect constructor()
@@ -111,7 +98,7 @@ class HierarchicalTypeAliasCommonizationTest : AbstractInlineSourcesCommonizatio
             "(e,f)", """expect class x expect constructor()"""
         )
 
-        result.assertCommonized("((a,b), (c,d))", """expect class x expect constructor()""")
-        result.assertCommonized("(((a,b), (c,d)), (e,f))", """expect class x expect constructor()""")
+        result.assertCommonized("(a, b, c, d)", """expect class x expect constructor()""")
+        result.assertCommonized("(a, b, c, d, e, f)", """expect class x expect constructor()""")
     }
 }

native/commonizer/tests/org/jetbrains/kotlin/commonizer/hierarchical/SingleTargetPropagationTest.kt

@@ -21,11 +21,10 @@ class SingleTargetPropagationTest : AbstractInlineSourcesCommonizationTest() {
     @Test
     fun `test single native target in hierarchy`() {
         val result = commonize {
-            outputTarget("((a, b), (c, d))")
+            outputTarget("(a, b)", "(c, d)", "(a, b, c, d)")
             simpleSingleSourceTarget("a", """class A""")
         }
 
-        result.assertCommonized("a", "class A")
         result.assertCommonized("(a,b)", "expect class A expect constructor()")
         result.assertCommonized("((a, b), (c, d))", "expect class A expect constructor()")
     }