[Commonizer] Implement support for hierarchical commonization

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

@@ -31,7 +31,7 @@ internal class KotlinNativeCommonizerToolRunner(project: Project) : KotlinToolRu
 
     override val defaultMaxHeapSize: String get() = "4G"
 
-    override val mustRunViaExec get() = true // because it's not enough the standard Gradle wrapper's heap size
+    override val mustRunViaExec get() = false // because it's not enough the standard Gradle wrapper's heap size
 
     override fun getCustomJvmArgs() = PropertiesProvider(project).commonizerJvmArgs?.split("\\s+".toRegex()).orEmpty()
 }

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

@@ -6,26 +6,19 @@
 package org.jetbrains.kotlin.commonizer
 
 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
 
 class CommonizerParameters(
+    val outputTarget: SharedCommonizerTarget,
+    val manifestProvider: TargetDependent<NativeManifestDataProvider>,
+    val dependenciesProvider: TargetDependent<ModulesProvider?>,
     val targetProviders: TargetDependent<TargetProvider>,
     val resultsConsumer: ResultsConsumer,
-    val commonManifestProvider: NativeManifestDataProvider,
-    val commonDependencyModulesProvider: ModulesProvider? = null,
     val statsCollector: StatsCollector? = null,
     val progressLogger: ((String) -> Unit)? = null
-) {
-    internal val commonTarget: SharedCommonizerTarget = SharedCommonizerTarget(targetProviders.targets.toSet())
-
-    internal val manifestDataProvider: TargetDependent<NativeManifestDataProvider>
-        get() = TargetDependent(setOf(SharedCommonizerTarget(targetProviders.targets.toSet())) + targetProviders.targets) { target ->
-            if (target == commonTarget) return@TargetDependent commonManifestProvider
-            this.targetProviders.firstOrNull { it.target == target }?.manifestProvider?.let { return@TargetDependent it }
-            throw IllegalStateException("Illegal target $target")
-        }
-
-}
+)
 
 fun CommonizerParameters.getCommonModuleNames(): Set<String> {
     if (targetProviders.size < 2) return emptySet() // too few targets
@@ -37,4 +30,10 @@ fun CommonizerParameters.getCommonModuleNames(): Set<String> {
     return allModuleNames.reduce { a, b -> a intersect b } // there are modules that are present in every target
 }
 
+internal fun CommonizerParameters.dependencyClassifiers(target: CommonizerTarget): CirProvidedClassifiers {
+    val modules = outputTarget.withAllAncestors()
+        .filter { it == target || it isAncestorOf target }
+        .mapNotNull { compatibleTarget -> dependenciesProvider[compatibleTarget] }
 
+    return CirProvidedClassifiers.of(modules.map { module -> CirProvidedClassifiers.by(module) } + CirFictitiousFunctionClassifiers)
+}

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

@@ -36,8 +36,8 @@ internal fun <T : Any> TargetDependent<T?>.filterNonNull(): TargetDependent<T> {
 
 internal fun <T> TargetDependent<T>.toMap(): Map<CommonizerTarget, T> {
     return mutableMapOf<CommonizerTarget, T>().apply {
-        for (key in keys) {
-            put(key, this@toMap[key])
+        for (target in targets) {
+            put(target, this@toMap[target])
         }
     }
 }
@@ -55,8 +55,8 @@ internal fun <T, R> TargetDependent<T>.mapTargets(mapper: (CommonizerTarget) ->
 }
 
 
-internal fun <T> TargetDependent(map: Map<CommonizerTarget, T>): TargetDependent<T> {
-    return MapBasedTargetDependent(map)
+internal fun <T> TargetDependent(map: Map<out CommonizerTarget, T>): TargetDependent<T> {
+    return MapBasedTargetDependent(map.toMap())
 }
 
 internal fun <T> TargetDependent(keys: Iterable<CommonizerTarget>, factory: (target: CommonizerTarget) -> T): TargetDependent<T> {

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

@@ -5,15 +5,12 @@
 
 package org.jetbrains.kotlin.commonizer
 
-import org.jetbrains.kotlin.commonizer.konan.NativeManifestDataProvider
 import org.jetbrains.kotlin.library.SerializedMetadata
 import java.io.File
 
 class TargetProvider(
     val target: CommonizerTarget,
-    val modulesProvider: ModulesProvider,
-    val dependencyModulesProvider: ModulesProvider?,
-    val manifestProvider: NativeManifestDataProvider
+    val modulesProvider: ModulesProvider
 )
 
 interface ModulesProvider {

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

@@ -68,7 +68,7 @@ internal class NativeKlibCommonize(options: Collection<Option<*>>) : Task(option
         }
 
         LibraryCommonizer(
-            commonTarget = outputCommonizerTarget,
+            outputTarget = outputCommonizerTarget,
             repository = repository,
             dependencies = StdlibRepository(distribution, libraryLoader) +
                     FilesRepository(dependencyLibraries.toSet(), libraryLoader),
@@ -119,7 +119,7 @@ internal class NativeDistributionCommonize(options: Collection<Option<*>>) : Tas
         println(description)
 
         LibraryCommonizer(
-            commonTarget = SharedCommonizerTarget(commonizerTargets.toSet()),
+            outputTarget = SharedCommonizerTarget(commonizerTargets.toSet()),
             repository = repository,
             dependencies = StdlibRepository(distribution, libraryLoader),
             resultsConsumer = resultsConsumer,

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

@@ -9,11 +9,16 @@ import kotlinx.metadata.klib.ChunkedKlibModuleFragmentWriteStrategy
 import org.jetbrains.kotlin.commonizer.ResultsConsumer.ModuleResult
 import org.jetbrains.kotlin.commonizer.ResultsConsumer.Status
 import org.jetbrains.kotlin.commonizer.core.CommonizationVisitor
-import org.jetbrains.kotlin.commonizer.mergedtree.*
-import org.jetbrains.kotlin.commonizer.mergedtree.CirNode.Companion.dimension
+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.indices
+import org.jetbrains.kotlin.commonizer.mergedtree.CirRootNode
 import org.jetbrains.kotlin.commonizer.metadata.CirTreeSerializer
-import org.jetbrains.kotlin.commonizer.tree.deserializer.deserialize
-import org.jetbrains.kotlin.commonizer.tree.merger.mergeCirTree
+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.mergeCirTree
 import org.jetbrains.kotlin.library.SerializedMetadata
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
@@ -25,37 +30,55 @@ fun runCommonization(parameters: CommonizerParameters) {
     }
 
     val storageManager = LockBasedStorageManager("Declarations commonization")
-
-    val mergedTree = mergeAndCommonize(storageManager, parameters)
-
-    // build resulting declarations:
-    for (targetIndex in 0 until mergedTree.dimension) {
-        serializeTarget(mergedTree, targetIndex, parameters)
-    }
-
+    serializeCommonDeclarations(commonize(parameters, storageManager, parameters.outputTarget), parameters)
     parameters.resultsConsumer.allConsumed(Status.DONE)
 }
 
-private fun mergeAndCommonize(storageManager: StorageManager, parameters: CommonizerParameters): CirRootNode {
+private fun commonize(
+    parameters: CommonizerParameters,
+    storageManager: StorageManager,
+    target: SharedCommonizerTarget,
+): CirRootNode {
+    val cirTrees = getCirTree(parameters, storageManager, target)
+    parameters.progressLogger?.invoke("Build cir tree for $target")
+
     // build merged tree:
     val classifiers = CirKnownClassifiers(
         commonizedNodes = CirCommonizedClassifierNodes.default(),
-        commonDependencies = CirProvidedClassifiers.of(
-            CirFictitiousFunctionClassifiers,
-            CirProvidedClassifiers.by(parameters.commonDependencyModulesProvider)
-        )
+        commonDependencies = parameters.dependencyClassifiers(target)
     )
 
-    val targetTrees = parameters.targetProviders.mapValue { target -> deserialize(parameters, target) }
-    parameters.progressLogger?.invoke("Deserialized targets")
-
-    val mergedTree = mergeCirTree(storageManager, classifiers, targetTrees)
+    val mergedTree = mergeCirTree(storageManager, classifiers, cirTrees)
     mergedTree.accept(CommonizationVisitor(classifiers, mergedTree), Unit)
-    parameters.progressLogger?.invoke("Commonized declarations")
+    parameters.progressLogger?.invoke("Commonized declarations for $target")
+
+    serializeTargetDeclarations(mergedTree, parameters)
+    parameters.progressLogger?.invoke("Commonized target $target")
 
     return mergedTree
 }
 
+private fun getCirTree(
+    parameters: CommonizerParameters, storageManager: StorageManager, target: SharedCommonizerTarget
+): TargetDependent<CirTreeRoot> {
+    return TargetDependent(target.targets) { childTarget ->
+        when (childTarget) {
+            is LeafCommonizerTarget -> deserializeCirTree(parameters, parameters.targetProviders[childTarget])
+            is SharedCommonizerTarget -> commonize(parameters, storageManager, childTarget).assembleCirTree()
+        }
+    }
+}
+
+private fun serializeTargetDeclarations(mergedTree: CirRootNode, parameters: CommonizerParameters) {
+    for (targetIndex in (mergedTree.indices - mergedTree.indexOfCommon)) {
+        serializeTarget(mergedTree, targetIndex, parameters)
+    }
+}
+
+private fun serializeCommonDeclarations(mergedTree: CirRootNode, parameters: CommonizerParameters) {
+    serializeTarget(mergedTree, mergedTree.indexOfCommon, parameters)
+}
+
 private fun serializeTarget(mergedTree: CirRootNode, targetIndex: Int, parameters: CommonizerParameters) {
     val target = mergedTree.getTarget(targetIndex)
 
@@ -64,7 +87,7 @@ private fun serializeTarget(mergedTree: CirRootNode, targetIndex: Int, parameter
         val serializedMetadata = with(metadataModule.write(KLIB_FRAGMENT_WRITE_STRATEGY)) {
             SerializedMetadata(header, fragments, fragmentNames)
         }
-        val manifestData = parameters.manifestDataProvider[target].getManifest(libraryName)
+        val manifestData = parameters.manifestProvider[target].getManifest(libraryName)
         parameters.resultsConsumer.consume(target, ModuleResult.Commonized(libraryName, serializedMetadata, manifestData))
     }
 

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

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.commonizer.stats.StatsCollector
 import org.jetbrains.kotlin.commonizer.utils.ProgressLogger
 
 internal class LibraryCommonizer internal constructor(
+    private val outputTarget: SharedCommonizerTarget,
     private val repository: Repository,
     private val dependencies: Repository,
-    private val commonTarget: SharedCommonizerTarget,
     private val resultsConsumer: ResultsConsumer,
     private val statsCollector: StatsCollector?,
     private val progressLogger: ProgressLogger
@@ -27,7 +27,7 @@ internal class LibraryCommonizer internal constructor(
     }
 
     private fun loadLibraries(): TargetDependent<NativeLibrariesToCommonize> {
-        val librariesByTargets = commonTarget.targets.associateWith { target ->
+        val librariesByTargets = outputTarget.allLeaves().associateWith { target ->
             NativeLibrariesToCommonize(repository.getLibraries(target).toList())
         }
 
@@ -42,11 +42,12 @@ internal class LibraryCommonizer internal constructor(
 
     private fun commonizeAndSaveResults(allLibraries: TargetDependent<NativeLibrariesToCommonize>) {
         val parameters = CommonizerParameters(
-            targetProviders = TargetDependent(commonTarget.targets) { target -> createTargetProvider(target, allLibraries[target]) }
+            outputTarget = outputTarget,
+            targetProviders = TargetDependent(outputTarget.allLeaves()) { target -> createTargetProvider(target, allLibraries[target]) }
                 .filterNonNull(),
+            manifestProvider = createManifestProvider(allLibraries),
+            dependenciesProvider = createDependenciesProvider(),
             resultsConsumer = resultsConsumer,
-            commonManifestProvider = CommonNativeManifestDataProvider(commonTarget.targets.map { allLibraries[it] }),
-            commonDependencyModulesProvider = DefaultModulesProvider.create(dependencies.getLibraries(commonTarget)),
             statsCollector = statsCollector,
             progressLogger = progressLogger::log
         )
@@ -57,16 +58,33 @@ internal class LibraryCommonizer internal constructor(
         if (libraries.libraries.isEmpty()) return null
         return TargetProvider(
             target = target,
-            modulesProvider = DefaultModulesProvider.create(libraries),
-            dependencyModulesProvider = DefaultModulesProvider.create(dependencies.getLibraries(target)),
-            manifestProvider = libraries,
+            modulesProvider = DefaultModulesProvider.create(libraries)
         )
     }
 
+    private fun createDependenciesProvider(): TargetDependent<ModulesProvider?> {
+        return TargetDependent(outputTarget.withAllAncestors()) { target ->
+            DefaultModulesProvider.create(dependencies.getLibraries(target))
+        }
+    }
+
+    private fun createManifestProvider(
+        libraries: TargetDependent<NativeLibrariesToCommonize>
+    ): TargetDependent<NativeManifestDataProvider> {
+        return TargetDependent(outputTarget.withAllAncestors()) { target ->
+            when (target) {
+                is LeafCommonizerTarget -> libraries[target]
+                is SharedCommonizerTarget -> CommonNativeManifestDataProvider(
+                    target.allLeaves().map { leafTarget -> libraries[leafTarget] }
+                )
+            }
+        }
+    }
+
     private fun checkPreconditions() {
-        when (commonTarget.targets.size) {
+        when (outputTarget.allLeaves().size) {
             0 -> progressLogger.fatal("No targets specified")
-            1 -> progressLogger.fatal("Too few targets specified: $commonTarget")
+            1 -> progressLogger.fatal("Too few targets specified: $outputTarget")
         }
     }
 }

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirClassNode.kt

@@ -7,11 +7,13 @@ package org.jetbrains.kotlin.commonizer.mergedtree
 
 import gnu.trove.THashMap
 import org.jetbrains.kotlin.commonizer.cir.CirClass
+import org.jetbrains.kotlin.commonizer.cir.CirEntityId
 import org.jetbrains.kotlin.commonizer.cir.CirName
 import org.jetbrains.kotlin.commonizer.utils.CommonizedGroup
 import org.jetbrains.kotlin.storage.NullableLazyValue
 
 class CirClassNode(
+    val id: CirEntityId,
     override val targetDeclarations: CommonizedGroup<CirClass>,
     override val commonDeclaration: NullableLazyValue<CirClass>,
 ) : CirClassifierNode<CirClass, CirClass>, CirNodeWithMembers<CirClass, CirClass> {

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirNode.kt

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.commonizer.mergedtree
 
-import org.jetbrains.kotlin.commonizer.cir.*
+import org.jetbrains.kotlin.commonizer.cir.CirClassifier
+import org.jetbrains.kotlin.commonizer.cir.CirDeclaration
+import org.jetbrains.kotlin.commonizer.cir.CirLiftedUpDeclaration
+import org.jetbrains.kotlin.commonizer.cir.CirName
 import org.jetbrains.kotlin.commonizer.utils.CommonizedGroup
 import org.jetbrains.kotlin.commonizer.utils.firstNonNull
 import org.jetbrains.kotlin.storage.NullableLazyValue
@@ -17,6 +20,8 @@ interface CirNode<T : CirDeclaration, R : CirDeclaration> {
     fun <T, R> accept(visitor: CirNodeVisitor<T, R>, data: T): R
 
     companion object {
+        inline val CirNode<*, *>.indices: IntRange get() = 0..targetDeclarations.size
+
         inline val CirNode<*, *>.indexOfCommon: Int
             get() = targetDeclarations.size
 

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirProvidedClassifiers.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.commonizer.mergedtree
 
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.commonizer.ModulesProvider
 import org.jetbrains.kotlin.commonizer.cir.CirEntityId
 import org.jetbrains.kotlin.commonizer.utils.isUnderKotlinNativeSyntheticPackages
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.types.Variance
 
 /** A set of classes and type aliases provided by libraries (either the libraries to commonize, or their dependency libraries)/ */
@@ -50,6 +50,10 @@ interface CirProvidedClassifiers {
             }
         }
 
+        fun of(delegates: Iterable<CirProvidedClassifiers?>): CirProvidedClassifiers {
+            return of(*delegates.filterNotNull().toTypedArray())
+        }
+
         fun by(modulesProvider: ModulesProvider?): CirProvidedClassifiers =
             if (modulesProvider != null) CirProvidedClassifiersByModules.load(modulesProvider) else EMPTY
     }

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/CirTypeAliasNode.kt

@@ -6,11 +6,13 @@
 package org.jetbrains.kotlin.commonizer.mergedtree
 
 import org.jetbrains.kotlin.commonizer.cir.CirClassifier
+import org.jetbrains.kotlin.commonizer.cir.CirEntityId
 import org.jetbrains.kotlin.commonizer.cir.CirTypeAlias
 import org.jetbrains.kotlin.commonizer.utils.CommonizedGroup
 import org.jetbrains.kotlin.storage.NullableLazyValue
 
 class CirTypeAliasNode(
+    val id: CirEntityId,
     override val targetDeclarations: CommonizedGroup<CirTypeAlias>,
     override val commonDeclaration: NullableLazyValue<CirClassifier>,
 ) : CirClassifierNode<CirTypeAlias, CirClassifier>, CirNodeWithLiftingUp<CirTypeAlias, CirClassifier> {

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/mergers/RootMerger.kt

@@ -30,8 +30,7 @@ internal class RootMerger(
             val typeResolver = CirTypeResolver.create(
                 providedClassifiers = CirProvidedClassifiers.of(
                     CirProvidedClassifiers.by(targetProvider.modulesProvider),
-                    CirProvidedClassifiers.by(targetProvider.dependencyModulesProvider),
-                    classifiers.commonDependencies
+                    parameters.dependencyClassifiers(targetProvider.target)
                 )
             )
             targetMerger.processTarget(

native/commonizer/src/org/jetbrains/kotlin/commonizer/mergedtree/nodeBuilders.kt

@@ -77,7 +77,7 @@ internal fun buildClassNode(
     commonizerProducer = { ClassCommonizer(classifiers) },
     recursionMarker = CirClassRecursionMarker,
     nodeProducer = { targetDeclarations, commonDeclaration ->
-        CirClassNode(targetDeclarations, commonDeclaration).also {
+        CirClassNode(classId, targetDeclarations, commonDeclaration).also {
             classifiers.commonizedNodes.addClassNode(classId, it)
         }
     }
@@ -105,7 +105,7 @@ internal fun buildTypeAliasNode(
     commonizerProducer = { TypeAliasCommonizer(classifiers) },
     recursionMarker = CirClassifierRecursionMarker,
     nodeProducer = { targetDeclarations, commonDeclaration ->
-        CirTypeAliasNode(targetDeclarations, commonDeclaration).also {
+        CirTypeAliasNode(typeAliasId, targetDeclarations, commonDeclaration).also {
             classifiers.commonizedNodes.addTypeAliasNode(typeAliasId, it)
         }
     }

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

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.commonizer.repository
 
 import org.jetbrains.kotlin.commonizer.CommonizerTarget
-import org.jetbrains.kotlin.commonizer.LeafCommonizerTarget
 import org.jetbrains.kotlin.commonizer.NativeLibraryLoader
 import org.jetbrains.kotlin.commonizer.konan.NativeLibrary
+import org.jetbrains.kotlin.commonizer.konanTargets
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import java.io.File
 
@@ -17,15 +17,15 @@ internal class FilesRepository(
     private val libraryLoader: NativeLibraryLoader
 ) : Repository {
 
-    private val librariesByTarget: Map<CommonizerTarget, Set<NativeLibrary>> by lazy {
+    private val librariesByTarget: Map<Set<KonanTarget>, Set<NativeLibrary>> by lazy {
         libraryFiles
             .map(libraryLoader::invoke)
-            .groupBy { library -> CommonizerTarget(library.manifestData.nativeTargets.map(::konanTargetOrThrow)) }
+            .groupBy { library -> library.manifestData.nativeTargets.map(::konanTargetOrThrow).toSet() }
             .mapValues { (_, list) -> list.toSet() }
     }
 
     override fun getLibraries(target: CommonizerTarget): Set<NativeLibrary> {
-        return librariesByTarget[target].orEmpty()
+        return librariesByTarget[target.konanTargets].orEmpty()
     }
 }
 

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

@@ -37,19 +37,23 @@ data class CirTreeFunction(
     val function: CirFunction
 )
 
+sealed interface CirTreeClassifier {
+    val id: CirEntityId
+}
+
 data class CirTreeTypeAlias(
-    val id: CirEntityId,
+    override val id: CirEntityId,
     val typeAlias: CirTypeAlias
-)
+) : CirTreeClassifier
 
 data class CirTreeClass(
-    val id: CirEntityId,
+    override val id: CirEntityId,
     val clazz: CirClass,
     val properties: List<CirTreeProperty>,
     val functions: List<CirTreeFunction>,
     val constructors: List<CirTreeClassConstructor>,
     val classes: List<CirTreeClass>,
-)
+) : CirTreeClassifier
 
 class CirTreeClassConstructor(
     val approximationKey: ConstructorApproximationKey,

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

@@ -0,0 +1,72 @@
+/*
+ * 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.tree
+
+import org.jetbrains.kotlin.commonizer.cir.CirTypeAlias
+import org.jetbrains.kotlin.commonizer.mergedtree.*
+
+internal fun CirRootNode.assembleCirTree(): CirTreeRoot {
+    return CirTreeRoot(
+        modules = modules.values.mapNotNull { it.assembleCirTree() }
+    )
+}
+
+internal fun CirModuleNode.assembleCirTree(): CirTreeModule? {
+    return CirTreeModule(
+        module = commonDeclaration() ?: return null,
+        packages = packages.values.mapNotNull { it.assembleCirTree() }
+    )
+}
+
+internal fun CirPackageNode.assembleCirTree(): CirTreePackage? {
+    return CirTreePackage(
+        pkg = commonDeclaration() ?: return null,
+        properties = properties.mapNotNull { (key, property) -> property.assembleCirTree(key) },
+        functions = functions.mapNotNull { (key, function) -> function.assembleCirTree(key) },
+        typeAliases = typeAliases.mapNotNull { (_, typeAlias) -> typeAlias.assembleCirTree() },
+        classes = classes.mapNotNull { (_, clazz) -> clazz.assembleCirTree() }
+    )
+}
+
+internal fun CirClassNode.assembleCirTree(): CirTreeClass? {
+    return CirTreeClass(
+        id = id,
+        clazz = commonDeclaration() ?: return null,
+        properties = properties.mapNotNull { (key, property) -> property.assembleCirTree(key) },
+        functions = functions.mapNotNull { (key, function) -> function.assembleCirTree(key) },
+        constructors = constructors.mapNotNull { (key, constructor) -> constructor.assembleCirTree(key) },
+        classes = classes.mapNotNull { (_, clazz) -> clazz.assembleCirTree() }
+    )
+}
+
+internal fun CirTypeAliasNode.assembleCirTree(): CirTreeTypeAlias? {
+    return CirTreeTypeAlias(
+        id = id,
+        typeAlias = commonDeclaration() as? CirTypeAlias ?: return null
+    )
+}
+
+internal fun CirPropertyNode.assembleCirTree(approximationKey: PropertyApproximationKey): CirTreeProperty? {
+    return CirTreeProperty(
+        approximationKey = approximationKey,
+        property = commonDeclaration() ?: return null,
+    )
+}
+
+internal fun CirFunctionNode.assembleCirTree(approximationKey: FunctionApproximationKey): CirTreeFunction? {
+    return CirTreeFunction(
+        approximationKey = approximationKey,
+        function = commonDeclaration() ?: return null,
+    )
+}
+
+internal fun CirClassConstructorNode.assembleCirTree(approximationKey: ConstructorApproximationKey): CirTreeClassConstructor? {
+    return CirTreeClassConstructor(
+        approximationKey = approximationKey,
+        constructor = commonDeclaration() ?: return null
+    )
+}
+

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

@@ -0,0 +1,32 @@
+/*
+ * 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.tree
+
+import org.jetbrains.kotlin.commonizer.CommonizerParameters
+import org.jetbrains.kotlin.commonizer.TargetProvider
+import org.jetbrains.kotlin.commonizer.tree.deserializer.*
+
+internal val defaultCirTreeModuleDeserializer = CirTreeModuleDeserializer(
+    packageDeserializer = CirTreePackageDeserializer(
+        propertyDeserializer = CirTreePropertyDeserializer,
+        functionDeserializer = CirTreeFunctionDeserializer,
+        typeAliasDeserializer = CirTreeTypeAliasDeserializer,
+        classDeserializer = CirTreeClassDeserializer(
+            propertyDeserializer = CirTreePropertyDeserializer,
+            functionDeserializer = CirTreeFunctionDeserializer,
+            constructorDeserializer = CirTreeClassConstructorDeserializer
+        )
+    )
+)
+
+internal val defaultCirTreeRootDeserializer = RootCirTreeDeserializer(
+    defaultCirTreeModuleDeserializer
+)
+
+
+internal fun deserializeCirTree(parameters: CommonizerParameters, target: TargetProvider): CirTreeRoot {
+    return defaultCirTreeRootDeserializer(parameters, target)
+}

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreeClassConstructorDeserializer.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.commonizer.metadata.CirDeserializers
 import org.jetbrains.kotlin.commonizer.metadata.CirTypeResolver
 import org.jetbrains.kotlin.commonizer.tree.CirTreeClassConstructor
 
-internal object ClassConstructorCirTreeDeserializer {
+internal object CirTreeClassConstructorDeserializer {
     operator fun invoke(
         constructor: KmConstructor, containingClass: CirContainingClass, typeResolver: CirTypeResolver
     ): CirTreeClassConstructor {

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreeClassDeserializer.kt

@@ -12,10 +12,10 @@ import org.jetbrains.kotlin.commonizer.metadata.CirDeserializers
 import org.jetbrains.kotlin.commonizer.metadata.CirTypeResolver
 import org.jetbrains.kotlin.commonizer.tree.CirTreeClass
 
-internal class ClassCirTreeDeserializer(
-    private val propertyDeserializer: PropertyCirTreeDeserializer,
-    private val functionDeserializer: FunctionCirTreeDeserializer,
-    private val constructorDeserializer: ClassConstructorCirTreeDeserializer,
+internal class CirTreeClassDeserializer(
+    private val propertyDeserializer: CirTreePropertyDeserializer,
+    private val functionDeserializer: CirTreeFunctionDeserializer,
+    private val constructorDeserializer: CirTreeClassConstructorDeserializer,
 ) {
     operator fun invoke(
         classEntry: ClassesToProcess.ClassEntry, classesToProcess: ClassesToProcess, typeResolver: CirTypeResolver

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreeFunctionDeserializer.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.commonizer.utils.isFakeOverride
 import org.jetbrains.kotlin.commonizer.utils.isKniBridgeFunction
 import org.jetbrains.kotlin.commonizer.utils.isTopLevelDeprecatedFunction
 
-object FunctionCirTreeDeserializer {
+object CirTreeFunctionDeserializer {
     operator fun invoke(function: KmFunction, containingClass: CirContainingClass?, typeResolver: CirTypeResolver): CirTreeFunction? {
         val functionTypeResolver = typeResolver.create(function.typeParameters)
         if (function.isFakeOverride()

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreeModuleDeserializer.kt

@@ -17,8 +17,8 @@ import org.jetbrains.kotlin.commonizer.tree.CirTreeModule
 import org.jetbrains.kotlin.commonizer.utils.foldToMap
 import org.jetbrains.kotlin.library.SerializedMetadata
 
-internal class ModuleCirTreeDeserializer(
-    private val packageDeserializer: PackageCirTreeDeserializer
+internal class CirTreeModuleDeserializer(
+    private val packageDeserializer: CirTreePackageDeserializer
 ) {
     operator fun invoke(metadata: SerializedMetadata, typeResolver: CirTypeResolver): CirTreeModule {
         val module = KlibModuleMetadata.read(SerializedMetadataLibraryProvider(metadata))

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreePackageDeserializer.kt

@@ -12,11 +12,11 @@ import org.jetbrains.kotlin.commonizer.mergedtree.mergers.ClassesToProcess
 import org.jetbrains.kotlin.commonizer.metadata.CirTypeResolver
 import org.jetbrains.kotlin.commonizer.tree.CirTreePackage
 
-internal class PackageCirTreeDeserializer(
-    private val propertyDeserializer: PropertyCirTreeDeserializer,
-    private val functionDeserializer: FunctionCirTreeDeserializer,
-    private val typeAliasDeserializer: TypeAliasCirTreeDeserializer,
-    private val classDeserializer: ClassCirTreeDeserializer,
+internal class CirTreePackageDeserializer(
+    private val propertyDeserializer: CirTreePropertyDeserializer,
+    private val functionDeserializer: CirTreeFunctionDeserializer,
+    private val typeAliasDeserializer: CirTreeTypeAliasDeserializer,
+    private val classDeserializer: CirTreeClassDeserializer,
 ) {
     operator fun invoke(
         packageName: CirPackageName,

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreePropertyDeserializer.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.commonizer.metadata.CirTypeResolver
 import org.jetbrains.kotlin.commonizer.tree.CirTreeProperty
 import org.jetbrains.kotlin.commonizer.utils.isFakeOverride
 
-object PropertyCirTreeDeserializer {
+object CirTreePropertyDeserializer {
     operator fun invoke(property: KmProperty, containingClass: CirContainingClass?, typeResolver: CirTypeResolver): CirTreeProperty? {
         if (property.isFakeOverride()) return null
         val propertyTypeResolver = typeResolver.create(property.typeParameters)

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreeTypeAliasDeserializer.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.commonizer.metadata.CirTypeResolver
 import org.jetbrains.kotlin.commonizer.tree.CirTreeTypeAlias
 
 
-internal object TypeAliasCirTreeDeserializer {
+internal object CirTreeTypeAliasDeserializer {
     operator fun invoke(typeAlias: KmTypeAlias, packageName: CirPackageName, typeResolver: CirTypeResolver): CirTreeTypeAlias {
         val typeAliasTypeResolver = typeResolver.create(typeAlias.typeParameters)
         val typeAliasName = CirName.create(typeAlias.name)

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/RootCirTreeDeserializer.kt

@@ -7,14 +7,14 @@ package org.jetbrains.kotlin.commonizer.tree.deserializer
 
 import org.jetbrains.kotlin.commonizer.CommonizerParameters
 import org.jetbrains.kotlin.commonizer.TargetProvider
+import org.jetbrains.kotlin.commonizer.dependencyClassifiers
 import org.jetbrains.kotlin.commonizer.getCommonModuleNames
-import org.jetbrains.kotlin.commonizer.mergedtree.CirFictitiousFunctionClassifiers
 import org.jetbrains.kotlin.commonizer.mergedtree.CirProvidedClassifiers
 import org.jetbrains.kotlin.commonizer.metadata.CirTypeResolver
 import org.jetbrains.kotlin.commonizer.tree.CirTreeRoot
 
 internal class RootCirTreeDeserializer(
-    private val moduleDeserializer: ModuleCirTreeDeserializer
+    private val moduleDeserializer: CirTreeModuleDeserializer
 ) {
     operator fun invoke(parameters: CommonizerParameters, targetProvider: TargetProvider): CirTreeRoot {
 
@@ -24,11 +24,7 @@ internal class RootCirTreeDeserializer(
         val typeResolver = CirTypeResolver.create(
             providedClassifiers = CirProvidedClassifiers.of(
                 CirProvidedClassifiers.by(targetProvider.modulesProvider),
-                CirProvidedClassifiers.by(targetProvider.dependencyModulesProvider),
-                CirProvidedClassifiers.of(
-                    CirFictitiousFunctionClassifiers,
-                    CirProvidedClassifiers.by(parameters.commonDependencyModulesProvider)
-                )
+                parameters.dependencyClassifiers(targetProvider.target)
             )
         )
 

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/deserialize.kt

@@ -1,30 +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.tree.deserializer
-
-import org.jetbrains.kotlin.commonizer.CommonizerParameters
-import org.jetbrains.kotlin.commonizer.TargetProvider
-import org.jetbrains.kotlin.commonizer.tree.CirTreeRoot
-
-
-private val defaultRootCirTreeDeserializer = RootCirTreeDeserializer(
-    ModuleCirTreeDeserializer(
-        packageDeserializer = PackageCirTreeDeserializer(
-            propertyDeserializer = PropertyCirTreeDeserializer,
-            functionDeserializer = FunctionCirTreeDeserializer,
-            typeAliasDeserializer = TypeAliasCirTreeDeserializer,
-            classDeserializer = ClassCirTreeDeserializer(
-                propertyDeserializer = PropertyCirTreeDeserializer,
-                functionDeserializer = FunctionCirTreeDeserializer,
-                constructorDeserializer = ClassConstructorCirTreeDeserializer
-            )
-        )
-    )
-)
-
-internal fun deserialize(parameters: CommonizerParameters, target: TargetProvider): CirTreeRoot {
-    return defaultRootCirTreeDeserializer(parameters, target)
-}

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

@@ -3,7 +3,7 @@
  * 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.tree.merger
+package org.jetbrains.kotlin.commonizer.tree
 
 import org.jetbrains.kotlin.commonizer.TargetDependent
 import org.jetbrains.kotlin.commonizer.cir.CirRoot

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

@@ -208,17 +208,16 @@ private class AnalyzedModules(
         resultsConsumer: ResultsConsumer,
         manifestDataProvider: NativeManifestDataProvider = MockNativeManifestDataProvider()
     ) = CommonizerParameters(
+        outputTarget = SharedCommonizerTarget(leafTargets.toSet()),
+        manifestProvider = TargetDependent(sharedTarget.withAllAncestors()) { manifestDataProvider },
+        dependenciesProvider = TargetDependent(sharedTarget.withAllAncestors()) { dependencyModules[it]?.let(MockModulesProvider::create) },
         targetProviders = TargetDependent(leafTargets) { leafTarget ->
             TargetProvider(
                 target = leafTarget,
-                modulesProvider = MockModulesProvider.create(originalModules.getValue(leafTarget)),
-                dependencyModulesProvider = dependencyModules[leafTarget]?.let(MockModulesProvider::create),
-                manifestProvider = manifestDataProvider
+                modulesProvider = MockModulesProvider.create(originalModules.getValue(leafTarget))
             )
         },
         resultsConsumer = resultsConsumer,
-        commonManifestProvider = manifestDataProvider,
-        commonDependencyModulesProvider = dependencyModules[sharedTarget]?.let(MockModulesProvider::create)
     )
 
     companion object {

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

@@ -0,0 +1,39 @@
+/*
+ * 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 TargetDependentTest {
+    @Test
+    fun toMap() {
+        val targetDependent = TargetDependent(listOf(LeafCommonizerTarget("a"), LeafCommonizerTarget("b"))) {
+            (it as LeafCommonizerTarget).name
+        }
+
+        assertEquals(
+            mapOf(LeafCommonizerTarget("a") as CommonizerTarget to "a", LeafCommonizerTarget("b") as CommonizerTarget to "b"),
+            targetDependent.toMap()
+        )
+    }
+
+    @Test
+    fun `create from map`() {
+        val map = mapOf(LeafCommonizerTarget("a") to "a", LeafCommonizerTarget("b") to "b")
+        val targetDependent = map.toTargetDependent()
+
+        assertEquals(
+            listOf(LeafCommonizerTarget("a"), LeafCommonizerTarget("b")),
+            targetDependent.targets
+        )
+
+        @Suppress("useless_cast")
+        assertEquals(
+            map.mapKeys { (k, _) -> k as CommonizerTarget }, targetDependent.toMap(),
+        )
+    }
+}

native/commonizer/tests/org/jetbrains/kotlin/commonizer/utils/mocks.kt

@@ -53,7 +53,8 @@ private fun createValidClassifierId(classifierId: String): CirEntityId {
 
 internal val MOCK_CLASSIFIERS = CirKnownClassifiers(
     commonizedNodes = object : CirCommonizedClassifierNodes {
-        private val MOCK_CLASS_NODE = CirClassNode(
+        override fun classNode(classId: CirEntityId) = CirClassNode(
+            classId,
             CommonizedGroup(0),
             LockBasedStorageManager.NO_LOCKS.createNullableLazyValue {
                 CirClass.create(
@@ -73,7 +74,6 @@ internal val MOCK_CLASSIFIERS = CirKnownClassifiers(
             }
         )
 
-        override fun classNode(classId: CirEntityId) = MOCK_CLASS_NODE
         override fun typeAliasNode(typeAliasId: CirEntityId) = error("This method should not be called")
         override fun addClassNode(classId: CirEntityId, node: CirClassNode) = error("This method should not be called")
         override fun addTypeAliasNode(typeAliasId: CirEntityId, node: CirTypeAliasNode) = error("This method should not be called")