[Commonizer] Minor. Renamings

- Absent* -> Missing* - Target -> CommonizerTarget - Result -> CommonizerResult - Parameters -> CommonizerParameters
2020-12-11 17:11:08 +03:00
parent b7330a9e14
commit 2be62c13b0
19 changed files with 109 additions and 108 deletions
@@ -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

@@ -8,18 +8,18 @@ package org.jetbrains.kotlin.descriptors.commonizer
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import java.io.File

-sealed class Result {
-    object NothingToCommonize : Result()
+sealed class CommonizerResult {
+    object NothingToDo : CommonizerResult()

-    class Commonized(
-        val modulesByTargets: Map<Target, Collection<ModuleResult>>
-    ) : Result() {
+    class Done(
+        val modulesByTargets: Map<CommonizerTarget, Collection<ModuleResult>>
+    ) : 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()
 }
@@ -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())
    }
@@ -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 modulesByTargets: Map<Target, MutableList<ModuleDescriptorImpl>> = allTargets.associateWithTo(HashMap()) { mutableListOf() }
+        val allTargets: List<CommonizerTarget> = (node.targetDeclarations + node.commonDeclaration()).map { it!!.target }
+        val modulesByTargets: Map<CommonizerTarget, MutableList<ModuleDescriptorImpl>> =
+            allTargets.associateWithTo(HashMap()) { mutableListOf() }

        // collect module descriptors:
        for (moduleNode in node.modules.values) {
@@ -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.Target
+import org.jetbrains.kotlin.descriptors.commonizer.CommonizerParameters
+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)

@@ -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
 }
@@ -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 {
@@ -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
@@ -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)
-            mergeResult.absentModuleInfos.getValue(target).map { ModuleResult.Absent(it.originalLocation) }
+        val missingModules: List<ModuleResult.Missing> = if (target is LeafTarget)
+            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(),
@@ -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> =
-                        moduleResults.mapNotNull { (it as? ModuleResult.Absent)?.originalLocation }
+                    val missingModuleLocations: List<File> =
+                        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) {
-            val libraryName = absentModuleLocation.name
-            absentModuleLocation.copyRecursively(librariesDestination.resolve(libraryName))
+        for (missingModuleLocation in missingModuleLocations) {
+            val libraryName = missingModuleLocation.name
+            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)
@@ -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
-            target to absentInfos
+            val missingInfos = moduleInfos.filterKeys { name -> name !in commonModuleNames }.values
+            target to missingInfos
        }.toMap()

        return CirTreeMergeResult(
            root = rootNode,
-            absentModuleInfos = absentModuleInfos
+            missingModuleInfos = missingModuleInfos
        )
    }

@@ -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 =
@@ -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(),
-                fraction(failedBecauseAbsent).toString(),
+                failedBecauseMissing.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 -> {
-                if (row.platform.any { it == RawStatsCollector.PlatformDeclarationStatus.ABSENT }) {
-                    aggregatedStatsRow.failedBecauseAbsent++
+            MISSING -> {
+                if (row.platform.any { it == RawStatsCollector.PlatformDeclarationStatus.MISSING }) {
+                    aggregatedStatsRow.failedBecauseMissing++
                } else {
                    aggregatedStatsRow.failedOther++
                }
@@ -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('-')
    }
 }
@@ -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 dependeeRoots: Map<Target, SourceModuleRoot>
+    val commonizedRoots: Map<CommonizerTarget, 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 commonizedModules: Map<Target, ModuleDescriptor>,
-    val dependeeModules: Map<Target, List<ModuleDescriptor>>
+    val originalModules: Map<CommonizerTarget, ModuleDescriptor>,
+    val commonizedModules: Map<CommonizerTarget, 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 {
-        val parameters = Parameters()
+    fun toCommonizationParameters(): CommonizerParameters {
+        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> {
-            val result = mutableMapOf<Target, ModuleDescriptor>()
+        ): Map<CommonizerTarget, 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>()
@@ -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 -> {
-                        actualAbsentModuleNames += moduleResult.originalLocation.name
+                    is ModuleResult.Missing -> {
+                        actualMissingModuleNames += moduleResult.originalLocation.name
                    }
                }
            }

            assertEquals(expectedCommonizedModuleNames, actualCommonizedModuleNames)
-            assertEquals(expectedAbsentModuleNames, actualAbsentModuleNames)
+            assertEquals(expectedMissingModuleNames, actualMissingModuleNames)
        }
    }
 }
@@ -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
    )

@@ -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)
@@ -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)
-        fail("$result is not instance of ${Result.Commonized::class}")
+    if (result !is CommonizerResult.Done)
+        fail("$result is not instance of ${CommonizerResult.Done::class}")
 }

@ExperimentalContracts