[Commonizer] Minor. Renamings

- Absent* -> Missing*
- Target -> CommonizerTarget
- Result -> CommonizerResult
- Parameters -> CommonizerParameters

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.descriptors.commonizer
 
 import org.jetbrains.kotlin.descriptors.commonizer.stats.StatsCollector
 
-class Parameters(
+class CommonizerParameters(
     val statsCollector: StatsCollector? = null,
     val progressLogger: ((String) -> Unit)? = null
 ) {
@@ -24,7 +24,7 @@ class Parameters(
             field = value
         }
 
-    fun addTarget(targetProvider: TargetProvider): Parameters {
+    fun addTarget(targetProvider: TargetProvider): CommonizerParameters {
         require(targetProvider.target !in _targetProviders) { "Target ${targetProvider.target} is already added" }
         _targetProviders[targetProvider.target] = targetProvider
 

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/CommonizerResult.kt

@@ -8,18 +8,18 @@ package org.jetbrains.kotlin.descriptors.commonizer
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import java.io.File
 
-sealed class Result {
+sealed class CommonizerResult {
-    object NothingToCommonize : Result()
+    object NothingToDo : CommonizerResult()
 
-    class Commonized(
+    class Done(
-        val modulesByTargets: Map<Target, Collection<ModuleResult>>
+        val modulesByTargets: Map<CommonizerTarget, Collection<ModuleResult>>
-    ) : Result() {
+    ) : CommonizerResult() {
         val sharedTarget: SharedTarget by lazy { modulesByTargets.keys.filterIsInstance<SharedTarget>().single() }
         val leafTargets: Set<LeafTarget> by lazy { modulesByTargets.keys.filterIsInstance<LeafTarget>().toSet() }
     }
 }
 
 sealed class ModuleResult {
-    class Absent(val originalLocation: File) : ModuleResult()
+    class Missing(val originalLocation: File) : ModuleResult()
     class Commonized(val module: ModuleDescriptor) : ModuleResult()
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/CommonizerTarget.kt

@@ -9,11 +9,11 @@ import org.jetbrains.kotlin.konan.target.KonanTarget
 
 // 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.
-sealed class Target
+sealed class CommonizerTarget
 
-data class LeafTarget(val name: String, val konanTarget: KonanTarget? = null) : Target()
+data class LeafTarget(val name: String, val konanTarget: KonanTarget? = null) : CommonizerTarget()
 
-data class SharedTarget(val targets: Set<Target>) : Target() {
+data class SharedTarget(val targets: Set<CommonizerTarget>) : CommonizerTarget() {
     init {
         require(targets.isNotEmpty())
     }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/DeclarationsBuilderVisitor1.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.descriptors.commonizer.builder
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.builder.CommonizedMemberScope.Companion.plusAssign
 import org.jetbrains.kotlin.descriptors.commonizer.builder.CommonizedPackageFragmentProvider.Companion.plusAssign
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.*
@@ -27,8 +27,9 @@ internal class DeclarationsBuilderVisitor1(
         check(data.isEmpty()) // root node may not have containing declarations
         check(components.targetComponents.size == node.dimension)
 
-        val allTargets: List<Target> = (node.targetDeclarations + node.commonDeclaration()).map { it!!.target }
+        val allTargets: List<CommonizerTarget> = (node.targetDeclarations + node.commonDeclaration()).map { it!!.target }
-        val modulesByTargets: Map<Target, MutableList<ModuleDescriptorImpl>> = allTargets.associateWithTo(HashMap()) { mutableListOf() }
+        val modulesByTargets: Map<CommonizerTarget, MutableList<ModuleDescriptorImpl>> =
+            allTargets.associateWithTo(HashMap()) { mutableListOf() }
 
         // collect module descriptors:
         for (moduleNode in node.modules.values) {

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/context.kt

@@ -9,8 +9,8 @@ import gnu.trove.THashMap
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.commonizer.Parameters
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerParameters
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirNode.Companion.dimension
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirNode.Companion.indexOfCommon
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirRootNode
@@ -132,7 +132,7 @@ class GlobalDeclarationsBuilderComponents(
 
 class TargetDeclarationsBuilderComponents(
     val storageManager: StorageManager,
-    val target: Target,
+    val target: CommonizerTarget,
     val builtIns: KotlinBuiltIns,
     val lazyClassifierLookupTable: NotNullLazyValue<LazyClassifierLookupTable>,
     val index: Int,
@@ -217,7 +217,7 @@ class LazyClassifierLookupTable(lazyModules: Map<String, List<ModuleDescriptor>>
 
 fun CirRootNode.createGlobalBuilderComponents(
     storageManager: StorageManager,
-    parameters: Parameters
+    parameters: CommonizerParameters
 ): GlobalDeclarationsBuilderComponents {
     val cache = DeclarationsBuilderCache(dimension)
 

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/CirRoot.kt

@@ -6,10 +6,10 @@
 package org.jetbrains.kotlin.descriptors.commonizer.cir
 
 import org.jetbrains.kotlin.descriptors.commonizer.BuiltInsProvider
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 
 interface CirRoot : CirDeclaration {
-    val target: Target
+    val target: CommonizerTarget
     val builtInsClass: String
     val builtInsProvider: BuiltInsProvider
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/factory/CirRootFactory.kt

@@ -8,13 +8,13 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir.factory
 import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
 import org.jetbrains.kotlin.descriptors.commonizer.BuiltInsProvider
 import org.jetbrains.kotlin.descriptors.commonizer.LeafTarget
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirRoot
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirRootImpl
 
 object CirRootFactory {
     fun create(
-        target: Target,
+        target: CommonizerTarget,
         builtInsClass: String,
         builtInsProvider: BuiltInsProvider
     ): CirRoot {

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/cir/impl/CirRootImpl.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.descriptors.commonizer.cir.impl
 
 import org.jetbrains.kotlin.descriptors.commonizer.BuiltInsProvider
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirRoot
 
 data class CirRootImpl(
-    override val target: Target,
+    override val target: CommonizerTarget,
     override val builtInsClass: String,
     override val builtInsProvider: BuiltInsProvider
 ) : CirRoot

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

@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirTreeMerger.CirT
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
 
-fun runCommonization(parameters: Parameters): Result {
+fun runCommonization(parameters: CommonizerParameters): CommonizerResult {
     if (!parameters.hasAnythingToCommonize())
-        return Result.NothingToCommonize
+        return CommonizerResult.NothingToDo
 
     val storageManager = LockBasedStorageManager("Declaration descriptors commonization")
 
@@ -28,26 +28,26 @@ fun runCommonization(parameters: Parameters): Result {
     mergedTree.accept(DeclarationsBuilderVisitor1(components), emptyList())
     mergedTree.accept(DeclarationsBuilderVisitor2(components), emptyList())
 
-    val modulesByTargets = LinkedHashMap<Target, Collection<ModuleResult>>() // use linked hash map to preserve order
+    val modulesByTargets = LinkedHashMap<CommonizerTarget, Collection<ModuleResult>>() // use linked hash map to preserve order
     components.targetComponents.forEach { component ->
         val target = component.target
         check(target !in modulesByTargets)
 
         val commonizedModules: List<ModuleResult.Commonized> = components.cache.getAllModules(component.index).map(ModuleResult::Commonized)
 
-        val absentModules: List<ModuleResult.Absent> = if (target is LeafTarget)
+        val missingModules: List<ModuleResult.Missing> = if (target is LeafTarget)
-            mergeResult.absentModuleInfos.getValue(target).map { ModuleResult.Absent(it.originalLocation) }
+            mergeResult.missingModuleInfos.getValue(target).map { ModuleResult.Missing(it.originalLocation) }
         else emptyList()
 
-        modulesByTargets[target] = commonizedModules + absentModules
+        modulesByTargets[target] = commonizedModules + missingModules
     }
 
     parameters.progressLogger?.invoke("Prepared new descriptors")
 
-    return Result.Commonized(modulesByTargets)
+    return CommonizerResult.Done(modulesByTargets)
 }
 
-private fun mergeAndCommonize(storageManager: StorageManager, parameters: Parameters): CirTreeMergeResult {
+private fun mergeAndCommonize(storageManager: StorageManager, parameters: CommonizerParameters): CirTreeMergeResult {
     // build merged tree:
     val classifiers = CirKnownClassifiers(
         commonized = CirCommonizedClassifiers.default(),

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

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.commonizer.*
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.konan.NativeDistributionCommonizer.StatsType.*
 import org.jetbrains.kotlin.descriptors.commonizer.stats.AggregatedStatsCollector
 import org.jetbrains.kotlin.descriptors.commonizer.stats.FileStatsOutput
@@ -136,14 +136,14 @@ class NativeDistributionCommonizer(
         return library
     }
 
-    private fun commonize(allLibraries: AllNativeLibraries): Result {
+    private fun commonize(allLibraries: AllNativeLibraries): CommonizerResult {
         val statsCollector = when (statsType) {
             RAW -> RawStatsCollector(targets, FileStatsOutput(destination, "raw"))
             AGGREGATED -> AggregatedStatsCollector(targets, FileStatsOutput(destination, "aggregated"))
             NONE -> null
         }
         statsCollector.use {
-            val parameters = Parameters(statsCollector, ::logProgress).apply {
+            val parameters = CommonizerParameters(statsCollector, ::logProgress).apply {
                 val storageManager = LockBasedStorageManager("Commonized modules")
 
                 val stdlibProvider = NativeDistributionStdlibProvider(storageManager, allLibraries.stdlib)
@@ -170,13 +170,13 @@ class NativeDistributionCommonizer(
         }
     }
 
-    private fun saveModules(originalLibraries: AllNativeLibraries, result: Result) {
+    private fun saveModules(originalLibraries: AllNativeLibraries, result: CommonizerResult) {
         // optimization: stdlib and endorsed libraries effectively remain the same across all Kotlin/Native targets,
         // so they can be just copied to the new destination without running serializer
         copyCommonStandardLibraries()
 
         when (result) {
-            is Result.NothingToCommonize -> {
+            is CommonizerResult.NothingToDo -> {
                 // It may happen that all targets to be commonized (or at least all but one target) miss platform libraries.
                 // In such case commonizer will do nothing and return a special result value 'NothingToCommonize'.
                 // So, let's just copy platform libraries from the target where they are to the new destination.
@@ -185,7 +185,7 @@ class NativeDistributionCommonizer(
                 }
             }
 
-            is Result.Commonized -> {
+            is CommonizerResult.Done -> {
                 val serializer = KlibMetadataMonolithicSerializer(
                     languageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
                     metadataVersion = KlibMetadataVersion.INSTANCE,
@@ -207,8 +207,8 @@ class NativeDistributionCommonizer(
                 targetsToSerialize.forEach { target ->
                     val moduleResults: Collection<ModuleResult> = result.modulesByTargets.getValue(target)
                     val newModules: Collection<ModuleDescriptor> = moduleResults.mapNotNull { (it as? ModuleResult.Commonized)?.module }
-                    val absentModuleLocations: List<File> =
+                    val missingModuleLocations: List<File> =
-                        moduleResults.mapNotNull { (it as? ModuleResult.Absent)?.originalLocation }
+                        moduleResults.mapNotNull { (it as? ModuleResult.Missing)?.originalLocation }
 
                     val manifestProvider: NativeManifestDataProvider
                     val starredTarget: String?
@@ -224,7 +224,7 @@ class NativeDistributionCommonizer(
                     }
 
                     val targetName = leafTargetNames.joinToString { if (it == starredTarget) "$it(*)" else it }
-                    serializeTarget(target, targetName, newModules, absentModuleLocations, manifestProvider, serializer)
+                    serializeTarget(target, targetName, newModules, missingModuleLocations, manifestProvider, serializer)
                 }
             }
         }
@@ -266,10 +266,10 @@ class NativeDistributionCommonizer(
     }
 
     private fun serializeTarget(
-        target: Target,
+        target: CommonizerTarget,
         targetName: String,
         newModules: Collection<ModuleDescriptor>,
-        absentModuleLocations: List<File>,
+        missingModuleLocations: List<File>,
         manifestProvider: NativeManifestDataProvider,
         serializer: KlibMetadataMonolithicSerializer
     ) {
@@ -291,9 +291,9 @@ class NativeDistributionCommonizer(
             writeLibrary(metadata, manifestData, libraryDestination)
         }
 
-        for (absentModuleLocation in absentModuleLocations) {
+        for (missingModuleLocation in missingModuleLocations) {
-            val libraryName = absentModuleLocation.name
+            val libraryName = missingModuleLocation.name
-            absentModuleLocation.copyRecursively(librariesDestination.resolve(libraryName))
+            missingModuleLocation.copyRecursively(librariesDestination.resolve(libraryName))
         }
 
         logProgress("Written libraries for [$targetName]")
@@ -323,7 +323,7 @@ class NativeDistributionCommonizer(
             .resolve(KONAN_DISTRIBUTION_PLATFORM_LIBS_DIR)
             .resolve(name)
 
-    private val Target.librariesDestination: File
+    private val CommonizerTarget.librariesDestination: File
         get() = when (this) {
             is LeafTarget -> destination.resolve(KONAN_DISTRIBUTION_PLATFORM_LIBS_DIR).resolve(name)
             is SharedTarget -> destination.resolve(KONAN_DISTRIBUTION_COMMON_LIBS_DIR)

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirTreeMerger.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.mergedtree
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.commonizer.LeafTarget
 import org.jetbrains.kotlin.descriptors.commonizer.ModulesProvider.ModuleInfo
-import org.jetbrains.kotlin.descriptors.commonizer.Parameters
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerParameters
 import org.jetbrains.kotlin.descriptors.commonizer.TargetProvider
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClass
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.*
@@ -49,11 +49,11 @@ import org.jetbrains.kotlin.storage.StorageManager
 class CirTreeMerger(
     private val storageManager: StorageManager,
     private val classifiers: CirKnownClassifiers,
-    private val parameters: Parameters
+    private val parameters: CommonizerParameters
 ) {
     class CirTreeMergeResult(
         val root: CirRootNode,
-        val absentModuleInfos: Map<LeafTarget, Collection<ModuleInfo>>
+        val missingModuleInfos: Map<LeafTarget, Collection<ModuleInfo>>
     )
 
     private val size = parameters.targetProviders.size
@@ -83,15 +83,15 @@ class CirTreeMerger(
             System.gc()
         }
 
-        val absentModuleInfos = allModuleInfos.mapIndexed { index, moduleInfos ->
+        val missingModuleInfos = allModuleInfos.mapIndexed { index, moduleInfos ->
             val target = parameters.targetProviders[index].target
-            val absentInfos = moduleInfos.filterKeys { name -> name !in commonModuleNames }.values
+            val missingInfos = moduleInfos.filterKeys { name -> name !in commonModuleNames }.values
-            target to absentInfos
+            target to missingInfos
         }.toMap()
 
         return CirTreeMergeResult(
             root = rootNode,
-            absentModuleInfos = absentModuleInfos
+            missingModuleInfos = missingModuleInfos
         )
     }
 

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/classifierContainers.kt

@@ -9,7 +9,7 @@ import gnu.trove.THashMap
 import gnu.trove.THashSet
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.commonizer.SharedTarget
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.utils.intern
 import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderKotlinNativeSyntheticPackages
 import org.jetbrains.kotlin.descriptors.commonizer.utils.resolveClassOrTypeAlias
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.storage.getValue
 class CirKnownClassifiers(
     val commonized: CirCommonizedClassifiers,
     val forwardDeclarations: CirForwardDeclarations,
-    val dependeeLibraries: Map<Target, CirProvidedClassifiers>
+    val dependeeLibraries: Map<CommonizerTarget, CirProvidedClassifiers>
 ) {
     // a shortcut for fast access
     val commonDependeeLibraries: CirProvidedClassifiers =

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

@@ -55,11 +55,11 @@ class AggregatedStatsCollector(
     ) : StatsOutput.StatsRow {
         var liftedUp: Int = 0
         var successfullyCommonized: Int = 0
-        var failedBecauseAbsent: Int = 0
+        var failedBecauseMissing: Int = 0
         var failedOther: Int = 0
 
         override fun toList(): List<String> {
-            val total = liftedUp + successfullyCommonized + failedBecauseAbsent + failedOther
+            val total = liftedUp + successfullyCommonized + failedBecauseMissing + failedOther
 
             fun fraction(amount: Int): Double = if (total > 0) amount.toDouble() / total else 0.0
 
@@ -69,8 +69,8 @@ class AggregatedStatsCollector(
                 fraction(liftedUp).toString(),
                 successfullyCommonized.toString(),
                 fraction(successfullyCommonized).toString(),
-                failedBecauseAbsent.toString(),
+                failedBecauseMissing.toString(),
-                fraction(failedBecauseAbsent).toString(),
+                fraction(failedBecauseMissing).toString(),
                 failedOther.toString(),
                 fraction(failedOther).toString(),
                 total.toString()
@@ -96,9 +96,9 @@ private class AggregatingOutput : StatsOutput {
         when (row.common) {
             LIFTED_UP -> aggregatedStatsRow.liftedUp++
             EXPECT -> aggregatedStatsRow.successfullyCommonized++
-            ABSENT -> {
+            MISSING -> {
-                if (row.platform.any { it == RawStatsCollector.PlatformDeclarationStatus.ABSENT }) {
+                if (row.platform.any { it == RawStatsCollector.PlatformDeclarationStatus.MISSING }) {
-                    aggregatedStatsRow.failedBecauseAbsent++
+                    aggregatedStatsRow.failedBecauseMissing++
                 } else {
                     aggregatedStatsRow.failedOther++
                 }

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

@@ -92,7 +92,7 @@ class RawStatsCollector(
         var isLiftedUp = !lastIsNull
         for (index in 0 until result.size - 1) {
             statsRow.platform += when {
-                result[index] == null -> PlatformDeclarationStatus.ABSENT
+                result[index] == null -> PlatformDeclarationStatus.MISSING
                 lastIsNull -> PlatformDeclarationStatus.ORIGINAL
                 else -> {
                     isLiftedUp = false
@@ -103,7 +103,7 @@ class RawStatsCollector(
 
         statsRow.common = when {
             isLiftedUp -> CommonDeclarationStatus.LIFTED_UP
-            lastIsNull -> CommonDeclarationStatus.ABSENT
+            lastIsNull -> CommonDeclarationStatus.MISSING
             else -> CommonDeclarationStatus.EXPECT
         }
 
@@ -157,12 +157,12 @@ class RawStatsCollector(
     enum class CommonDeclarationStatus(val alias: Char) {
         LIFTED_UP('L'),
         EXPECT('E'),
-        ABSENT('-')
+        MISSING('-')
     }
 
     enum class PlatformDeclarationStatus(val alias: Char) {
         ACTUAL('A'),
         ORIGINAL('O'),
-        ABSENT('-')
+        MISSING('-')
     }
 }

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

@@ -66,7 +66,7 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
         val sourceModuleRoots: SourceModuleRoots = SourceModuleRoots.load(getTestDataDir())
         val analyzedModules: AnalyzedModules = AnalyzedModules.create(sourceModuleRoots, testRootDisposable)
 
-        val result: Result = runCommonization(analyzedModules.toCommonizationParameters())
+        val result: CommonizerResult = runCommonization(analyzedModules.toCommonizationParameters())
         assertCommonizationPerformed(result)
 
         val sharedTarget: SharedTarget = analyzedModules.sharedTarget
@@ -115,8 +115,8 @@ private data class SourceModuleRoot(
 
 private class SourceModuleRoots(
     val originalRoots: Map<LeafTarget, SourceModuleRoot>,
-    val commonizedRoots: Map<Target, SourceModuleRoot>,
+    val commonizedRoots: Map<CommonizerTarget, SourceModuleRoot>,
-    val dependeeRoots: Map<Target, SourceModuleRoot>
+    val dependeeRoots: Map<CommonizerTarget, SourceModuleRoot>
 ) {
     val leafTargets: Set<LeafTarget> = originalRoots.keys
     val sharedTarget: SharedTarget
@@ -143,7 +143,7 @@ private class SourceModuleRoots(
             val leafTargets = originalRoots.keys
             val sharedTarget = SharedTarget(leafTargets)
 
-            fun getTarget(targetName: String): Target =
+            fun getTarget(targetName: String): CommonizerTarget =
                 if (targetName == SHARED_TARGET_NAME) sharedTarget else leafTargets.first { it.name == targetName }
 
             val commonizedRoots = listRoots(dataDir, COMMONIZED_ROOTS_DIR).mapKeys { getTarget(it.key) }
@@ -164,7 +164,7 @@ private class SourceModuleRoots(
 }
 
 private class AnalyzedModuleDependencies(
-    val regularDependencies: Map<Target, List<ModuleDescriptor>>,
+    val regularDependencies: Map<CommonizerTarget, List<ModuleDescriptor>>,
     val expectByDependencies: List<ModuleDescriptor>
 ) {
     fun withExpectByDependency(dependency: ModuleDescriptor) =
@@ -179,9 +179,9 @@ private class AnalyzedModuleDependencies(
 }
 
 private class AnalyzedModules(
-    val originalModules: Map<Target, ModuleDescriptor>,
+    val originalModules: Map<CommonizerTarget, ModuleDescriptor>,
-    val commonizedModules: Map<Target, ModuleDescriptor>,
+    val commonizedModules: Map<CommonizerTarget, ModuleDescriptor>,
-    val dependeeModules: Map<Target, List<ModuleDescriptor>>
+    val dependeeModules: Map<CommonizerTarget, List<ModuleDescriptor>>
 ) {
     val leafTargets: Set<LeafTarget>
     val sharedTarget: SharedTarget
@@ -201,8 +201,8 @@ private class AnalyzedModules(
         check(allTargets.containsAll(dependeeModules.keys))
     }
 
-    fun toCommonizationParameters(): Parameters {
+    fun toCommonizationParameters(): CommonizerParameters {
-        val parameters = Parameters()
+        val parameters = CommonizerParameters()
 
         leafTargets.forEach { leafTarget ->
             val originalModule = originalModules.getValue(leafTarget)
@@ -240,9 +240,9 @@ private class AnalyzedModules(
 
         private fun createDependeeModules(
             sharedTarget: SharedTarget,
-            dependeeRoots: Map<out Target, SourceModuleRoot>,
+            dependeeRoots: Map<out CommonizerTarget, SourceModuleRoot>,
             parentDisposable: Disposable
-        ): Pair<Map<Target, List<ModuleDescriptor>>, AnalyzedModuleDependencies> {
+        ): Pair<Map<CommonizerTarget, List<ModuleDescriptor>>, AnalyzedModuleDependencies> {
             val customDependeeModules =
                 createModules(sharedTarget, dependeeRoots, AnalyzedModuleDependencies.EMPTY, parentDisposable, isDependeeModule = true)
 
@@ -261,12 +261,12 @@ private class AnalyzedModules(
 
         private fun createModules(
             sharedTarget: SharedTarget,
-            moduleRoots: Map<out Target, SourceModuleRoot>,
+            moduleRoots: Map<out CommonizerTarget, SourceModuleRoot>,
             dependencies: AnalyzedModuleDependencies,
             parentDisposable: Disposable,
             isDependeeModule: Boolean = false
-        ): Map<Target, ModuleDescriptor> {
+        ): Map<CommonizerTarget, ModuleDescriptor> {
-            val result = mutableMapOf<Target, ModuleDescriptor>()
+            val result = mutableMapOf<CommonizerTarget, ModuleDescriptor>()
 
             var dependenciesForOthers = dependencies
 
@@ -288,7 +288,7 @@ private class AnalyzedModules(
 
         private fun createModule(
             sharedTarget: SharedTarget,
-            currentTarget: Target,
+            currentTarget: CommonizerTarget,
             moduleRoot: SourceModuleRoot,
             dependencies: AnalyzedModuleDependencies,
             parentDisposable: Disposable,
@@ -336,7 +336,7 @@ private class AnalyzedModules(
 
 private class DependenciesContainerImpl(
     sharedTarget: SharedTarget,
-    currentTarget: Target,
+    currentTarget: CommonizerTarget,
     dependencies: AnalyzedModuleDependencies
 ) : CommonDependenciesContainer {
     private val moduleInfoToModule = mutableMapOf<ModuleInfo, ModuleDescriptor>()

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

@@ -52,7 +52,7 @@ class CommonizerFacadeTest {
     )
 
     @Test
-    fun commonizedWithAbsentModules() = doTestSuccessfulCommonization(
+    fun commonizedWithMissingModules() = doTestSuccessfulCommonization(
         mapOf(
             "target1" to listOf("foo", "bar"),
             "target2" to listOf("foo", "qix")
@@ -60,7 +60,7 @@ class CommonizerFacadeTest {
     )
 
     companion object {
-        private fun Map<String, List<String>>.toCommonizationParameters() = Parameters().also {
+        private fun Map<String, List<String>>.toCommonizationParameters() = CommonizerParameters().also {
             forEach { (targetName, moduleNames) ->
                 it.addTarget(
                     TargetProvider(
@@ -76,7 +76,7 @@ class CommonizerFacadeTest {
 
         private fun doTestNothingToCommonize(originalModules: Map<String, List<String>>) {
             val result = runCommonization(originalModules.toCommonizationParameters())
-            assertEquals(Result.NothingToCommonize, result)
+            assertEquals(CommonizerResult.NothingToDo, result)
         }
 
         private fun doTestSuccessfulCommonization(originalModules: Map<String, List<String>>) {
@@ -92,17 +92,17 @@ class CommonizerFacadeTest {
             }
             assertModulesMatch(
                 expectedCommonizedModuleNames = expectedCommonModuleNames,
-                expectedAbsentModuleNames = emptySet(),
+                expectedMissingModuleNames = emptySet(),
                 actualModuleResults = result.modulesByTargets.getValue(result.sharedTarget)
             )
 
             result.leafTargets.forEach { target ->
                 val allModuleNames = originalModules.getValue(target.name).toSet()
-                val expectedAbsentModuleNames = allModuleNames - expectedCommonModuleNames
+                val expectedMissingModuleNames = allModuleNames - expectedCommonModuleNames
 
                 assertModulesMatch(
                     expectedCommonizedModuleNames = expectedCommonModuleNames,
-                    expectedAbsentModuleNames = expectedAbsentModuleNames,
+                    expectedMissingModuleNames = expectedMissingModuleNames,
                     actualModuleResults = result.modulesByTargets.getValue(target)
                 )
             }
@@ -110,27 +110,27 @@ class CommonizerFacadeTest {
 
         private fun assertModulesMatch(
             expectedCommonizedModuleNames: Set<String>,
-            expectedAbsentModuleNames: Set<String>,
+            expectedMissingModuleNames: Set<String>,
             actualModuleResults: Collection<ModuleResult>
         ) {
-            assertEquals(expectedCommonizedModuleNames.size + expectedAbsentModuleNames.size, actualModuleResults.size)
+            assertEquals(expectedCommonizedModuleNames.size + expectedMissingModuleNames.size, actualModuleResults.size)
 
             val actualCommonizedModuleNames = mutableSetOf<String>()
-            val actualAbsentModuleNames = mutableSetOf<String>()
+            val actualMissingModuleNames = mutableSetOf<String>()
 
             actualModuleResults.forEach { moduleResult ->
                 when (moduleResult) {
                     is ModuleResult.Commonized -> {
                         actualCommonizedModuleNames += moduleResult.module.name.asString().removeSurrounding("<", ">")
                     }
-                    is ModuleResult.Absent -> {
+                    is ModuleResult.Missing -> {
-                        actualAbsentModuleNames += moduleResult.originalLocation.name
+                        actualMissingModuleNames += moduleResult.originalLocation.name
                     }
                 }
             }
 
             assertEquals(expectedCommonizedModuleNames, actualCommonizedModuleNames)
-            assertEquals(expectedAbsentModuleNames, actualAbsentModuleNames)
+            assertEquals(expectedMissingModuleNames, actualMissingModuleNames)
         }
     }
 }

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/PropertySetterCommonizerTest.kt

@@ -14,28 +14,28 @@ import org.junit.Test
 class PropertySetterCommonizerTest : AbstractCommonizerTest<CirPropertySetter?, CirPropertySetter?>() {
 
     @Test
-    fun absentOnly() = super.doTestSuccess(
+    fun missingOnly() = super.doTestSuccess(
         expected = null,
         null, null, null
     )
 
     @Test(expected = IllegalCommonizerStateException::class)
-    fun absentAndPublic() = doTestFailure(
+    fun missingAndPublic() = doTestFailure(
         null, null, null, PUBLIC
     )
 
     @Test(expected = IllegalCommonizerStateException::class)
-    fun publicAndAbsent() = doTestFailure(
+    fun publicAndMissing() = doTestFailure(
         PUBLIC, PUBLIC, PUBLIC, null
     )
 
     @Test(expected = IllegalCommonizerStateException::class)
-    fun protectedAndAbsent() = doTestFailure(
+    fun protectedAndMissing() = doTestFailure(
         PROTECTED, PROTECTED, null
     )
 
     @Test(expected = IllegalCommonizerStateException::class)
-    fun absentAndInternal() = doTestFailure(
+    fun missingAndInternal() = doTestFailure(
         null, null, INTERNAL
     )
 

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/RootCommonizerTest.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
 import org.jetbrains.kotlin.descriptors.commonizer.LeafTarget
 import org.jetbrains.kotlin.descriptors.commonizer.SharedTarget
-import org.jetbrains.kotlin.descriptors.commonizer.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerTarget
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirRoot
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirRootFactory
 import org.jetbrains.kotlin.descriptors.commonizer.utils.MockBuiltInsProvider
@@ -164,7 +164,7 @@ class RootCommonizerTest : AbstractCommonizerTest<CirRoot, CirRoot>() {
         inline val JVM_BUILT_INS get() = JvmBuiltIns(LockBasedStorageManager.NO_LOCKS, JvmBuiltIns.Kind.FROM_CLASS_LOADER)
         inline val DEFAULT_BUILT_INS get() = DefaultBuiltIns.Instance
 
-        fun KotlinBuiltIns.toMock(target: Target) = CirRootFactory.create(
+        fun KotlinBuiltIns.toMock(target: CommonizerTarget) = CirRootFactory.create(
             target = target,
             builtInsClass = this::class.java.name,
             builtInsProvider = MockBuiltInsProvider(this)

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/assertions.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.descriptors.commonizer.utils
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.commonizer.Result
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerResult
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.test.util.DescriptorValidator.*
 import org.jetbrains.kotlin.types.ErrorUtils
@@ -22,13 +22,13 @@ fun assertIsDirectory(file: File) {
 }
 
 @ExperimentalContracts
-fun assertCommonizationPerformed(result: Result) {
+fun assertCommonizationPerformed(result: CommonizerResult) {
     contract {
-        returns() implies (result is Result.Commonized)
+        returns() implies (result is CommonizerResult.Done)
     }
 
-    if (result !is Result.Commonized)
+    if (result !is CommonizerResult.Done)
-        fail("$result is not instance of ${Result.Commonized::class}")
+        fail("$result is not instance of ${CommonizerResult.Done::class}")
 }
 
 @ExperimentalContracts