[Commonizer] Clean-up in facade API

konan/commonizer/build.gradle.kts

@@ -9,6 +9,8 @@ dependencies {
 
     compile(kotlinStdlib())
 
+    compile(project(":kotlin-native:kotlin-native-utils"))
+
     testCompile(commonDep("junit:junit"))
     testCompile(projectTests(":compiler:tests-common"))
 

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/Target.kt

@@ -5,13 +5,15 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer
 
+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 TargetId
+sealed class Target
 
-data class ConcreteTargetId(val name: String) : TargetId()
+data class InputTarget(val name: String, val konanTarget: KonanTarget? = null) : Target()
 
-data class CommonTargetId(val targets: Set<TargetId>) : TargetId() {
+data class OutputTarget(val targets: Set<Target>) : Target() {
     init {
         require(targets.isNotEmpty())
     }

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/DeclarationsBuilderVisitor.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.builder
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.commonizer.CommonizedGroup
-import org.jetbrains.kotlin.descriptors.commonizer.TargetId
+import org.jetbrains.kotlin.descriptors.commonizer.Target
 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.ir.*
@@ -21,12 +21,12 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 internal class DeclarationsBuilderVisitor(
     private val storageManager: StorageManager,
     private val builtIns: KotlinBuiltIns,
-    private val collector: (TargetId, Collection<ModuleDescriptor>) -> Unit
+    private val collector: (Target, Collection<ModuleDescriptor>) -> Unit
 ) : NodeVisitor<List<DeclarationDescriptor?>, List<DeclarationDescriptor?>> {
     override fun visitRootNode(node: RootNode, data: List<DeclarationDescriptor?>): List<DeclarationDescriptor?> {
-        val allTargets = (node.target + node.common()!!).map { it.targetId }
+        val allTargets = (node.target + node.common()!!).map { it.target }
 
-        val modulesByTargets = HashMap<TargetId, MutableList<ModuleDescriptorImpl>>()
+        val modulesByTargets = HashMap<Target, MutableList<ModuleDescriptorImpl>>()
 
         // collect module descriptors:
         for (moduleNode in node.modules) {
@@ -45,7 +45,7 @@ internal class DeclarationsBuilderVisitor(
 
         // return result (preserve platforms order):
         for (target in allTargets) {
-            collector(target, modulesByTargets[target]!!)
+            collector(target, modulesByTargets.getValue(target))
         }
 
         return noReturningDeclarations()

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/moduleDescriptors.kt

@@ -35,7 +35,7 @@ private fun Module.buildDescriptor(
         moduleName = name,
         storageManager = storageManager,
         builtIns = builtIns,
-        capabilities = emptyMap() // TODO: specify capabilities
+        capabilities = emptyMap() // TODO: preserve capabilities from the original module descriptors, KT-33998
     )
 
     output[index] = moduleDescriptor

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/propertyDescriptors.kt

@@ -27,9 +27,6 @@ internal fun PropertyNode.buildDescriptors(
     val markAsExpectAndActual = commonProperty != null && commonProperty.kind != CallableMemberDescriptor.Kind.SYNTHESIZED
 
     target.forEachIndexed { index, property ->
-        // target property is DELEGATION
-        // AND
-        // the property it overrides is actual
         property?.buildDescriptor(output, index, containingDeclarations, storageManager, isActual = markAsExpectAndActual)
     }
 

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/ModalityCommonizer.kt

@@ -31,7 +31,8 @@ private class DefaultModalityCommonizer : ModalityCommonizer {
         return !error
     }
 
-    private fun getNext(current: Modality, next: Modality): Modality? = when {
+    @Suppress("NOTHING_TO_INLINE")
+    private inline fun getNext(current: Modality, next: Modality): Modality? = when {
         current == Modality.FINAL && next == Modality.OPEN -> Modality.FINAL
         current == Modality.OPEN && next == Modality.FINAL -> Modality.FINAL
         current == next -> current

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeCommonizer.kt

@@ -106,7 +106,7 @@ private fun areAbbreviatedTypesEqual(
         return false
 
     // N.B. both lists of arguments are already known to be of the same size
-    for (i in 0 until a.arguments.size) {
+    for (i in a.arguments.indices) {
         val aArg = a.arguments[i]
         val bArg = b.arguments[i]
 

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

@@ -13,26 +13,24 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.mergeRoots
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
 class CommonizationParameters {
-    private val modulesByTargets = LinkedHashMap<ConcreteTargetId, Collection<ModuleDescriptor>>()
+    // use linked hash map to preserve order
+    private val modulesByTargets = LinkedHashMap<InputTarget, Collection<ModuleDescriptor>>()
 
-    fun addTarget(targetName: String, modules: Collection<ModuleDescriptor>): CommonizationParameters {
+    fun addTarget(target: InputTarget, modules: Collection<ModuleDescriptor>): CommonizationParameters {
-        val targetId = ConcreteTargetId(targetName)
+        require(target !in modulesByTargets) { "Target $target is already added" }
-        require(targetId !in modulesByTargets) {
-            "Target $targetId is already added"
-        }
 
         val modulesWithUniqueNames = modules.groupingBy { it.name }.eachCount()
         require(modulesWithUniqueNames.size == modules.size) {
             "Modules with duplicated names found: ${modulesWithUniqueNames.filter { it.value > 1 }}"
         }
 
-        modulesByTargets[targetId] = modules
+        modulesByTargets[target] = modules
 
         return this
     }
 
     // get them as ordered immutable collection (List) for further processing
-    fun getModulesByTargets(): List<Pair<ConcreteTargetId, Collection<ModuleDescriptor>>> =
+    fun getModulesByTargets(): List<Pair<InputTarget, Collection<ModuleDescriptor>>> =
         modulesByTargets.map { it.key to it.value }
 
     fun hasIntersection(): Boolean {
@@ -51,9 +49,16 @@ sealed class CommonizationResult
 object NothingToCommonize : CommonizationResult()
 
 class CommonizationPerformed(
-    val commonModules: Collection<ModuleDescriptor>,
+    val modulesByTargets: Map<Target, Collection<ModuleDescriptor>>
-    val modulesByTargets: Map<String, Collection<ModuleDescriptor>>
+) : CommonizationResult() {
-) : CommonizationResult()
+    val commonTarget: OutputTarget by lazy {
+        modulesByTargets.keys.filterIsInstance<OutputTarget>().single()
+    }
+
+    val concreteTargets: Set<InputTarget> by lazy {
+        modulesByTargets.keys.filterIsInstance<InputTarget>().toSet()
+    }
+}
 
 fun runCommonization(parameters: CommonizationParameters): CommonizationResult {
     if (!parameters.hasIntersection())
@@ -66,24 +71,14 @@ fun runCommonization(parameters: CommonizationParameters): CommonizationResult {
     // commonize:
     mergedTree.accept(CommonizationVisitor(mergedTree), Unit)
 
-    var commonModules: Collection<ModuleDescriptor>? = null
+    val modulesByTargets = LinkedHashMap<Target, Collection<ModuleDescriptor>>() // use linked hash map to preserve order
-    val otherModulesByTargets = LinkedHashMap<String, Collection<ModuleDescriptor>>()
 
     // build resulting descriptors:
-    val visitor = DeclarationsBuilderVisitor(storageManager, DefaultBuiltIns.Instance) { targetId, commonizedModules ->
+    val visitor = DeclarationsBuilderVisitor(storageManager, DefaultBuiltIns.Instance) { target, commonizedModules ->
-        when (targetId) {
+        check(target !in modulesByTargets)
-            is CommonTargetId -> {
+        modulesByTargets[target] = commonizedModules
-                check(commonModules == null)
-                commonModules = commonizedModules
-            }
-            is ConcreteTargetId -> {
-                val targetName = targetId.name
-                check(targetName !in otherModulesByTargets)
-                otherModulesByTargets[targetName] = commonizedModules
-            }
-        }
     }
     mergedTree.accept(visitor, DeclarationsBuilderVisitor.noContainingDeclarations())
 
-    return CommonizationPerformed(commonModules!!, otherModulesByTargets)
+    return CommonizationPerformed(modulesByTargets)
 }

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/Module.kt

@@ -5,8 +5,9 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.name.Name
 
-data class Module(
+data class Module(val name: Name) : Declaration {
-    val name: Name
+    constructor(descriptor: ModuleDescriptor) : this(descriptor.name)
-) : Declaration
+}

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/Package.kt

@@ -7,6 +7,4 @@ package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
 import org.jetbrains.kotlin.name.FqName
 
-data class Package(
+data class Package(val fqName: FqName) : Declaration
-    val fqName: FqName
-) : Declaration

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/Root.kt

@@ -5,6 +5,6 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
-import org.jetbrains.kotlin.descriptors.commonizer.TargetId
+import org.jetbrains.kotlin.descriptors.commonizer.Target
 
-data class Root(val targetId: TargetId) : Declaration
+data class Root(val target: Target) : Declaration

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/nodeBuilders.kt

@@ -12,39 +12,39 @@ import org.jetbrains.kotlin.descriptors.commonizer.core.*
 import org.jetbrains.kotlin.descriptors.commonizer.firstNonNull
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.RootNode.ClassifiersCacheImpl
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.NullableLazyValue
 import org.jetbrains.kotlin.storage.StorageManager
 
 internal fun buildRootNode(
-    targets: List<ConcreteTargetId>
+    storageManager: StorageManager,
+    targets: List<InputTarget>
 ): RootNode = RootNode(
     target = targets.map { Root(it) },
-    common = LockBasedStorageManager.NO_LOCKS.createNullableLazyValue {
+    common = storageManager.createNullableLazyValue {
-        Root(CommonTargetId(targets.toSet()))
+        Root(OutputTarget(targets.toSet()))
     }
 )
 
 internal fun buildModuleNode(
-    moduleName: Name,
+    storageManager: StorageManager,
     modules: List<ModuleDescriptor?>
 ): ModuleNode = buildNode(
-    storageManager = LockBasedStorageManager.NO_LOCKS,
+    storageManager = storageManager,
     descriptors = modules,
-    targetDeclarationProducer = { Module(moduleName) },
+    targetDeclarationProducer = ::Module,
-    commonValueProducer = { Module(moduleName) },
+    commonValueProducer = { Module(it.firstNonNull().name) },
     recursionMarker = null,
     nodeProducer = ::ModuleNode
 )
 
 internal fun buildPackageNode(
+    storageManager: StorageManager,
     packageFqName: FqName,
     packageMemberScopes: List<MemberScope?>
 ): PackageNode = buildNode(
-    storageManager = LockBasedStorageManager.NO_LOCKS,
+    storageManager = storageManager,
     descriptors = packageMemberScopes,
     targetDeclarationProducer = { Package(packageFqName) },
     commonValueProducer = { Package(packageFqName) },

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/modules.kt

@@ -22,10 +22,9 @@ import org.jetbrains.kotlin.utils.alwaysTrue
 internal fun mergeModules(
     storageManager: StorageManager,
     cacheRW: RootNode.ClassifiersCacheImpl,
-    moduleName: Name,
     modules: List<ModuleDescriptor?>
 ): ModuleNode {
-    val node = buildModuleNode(moduleName, modules)
+    val node = buildModuleNode(storageManager, modules)
 
     val packageMemberScopesMap = CommonizedGroupMap<FqName, MemberScope>(modules.size)
 

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/packages.kt

@@ -24,7 +24,7 @@ internal fun mergePackages(
     packageFqName: FqName,
     packageMemberScopes: List<MemberScope?>
 ): PackageNode {
-    val node = buildPackageNode(packageFqName, packageMemberScopes)
+    val node = buildPackageNode(storageManager, packageFqName, packageMemberScopes)
 
     val propertiesMap = CommonizedGroupMap<PropertyApproximationKey, PropertyDescriptor>(packageMemberScopes.size)
     val functionsMap = CommonizedGroupMap<FunctionApproximationKey, SimpleFunctionDescriptor>(packageMemberScopes.size)

konan/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/root.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.mergedtree
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.commonizer.CommonizedGroupMap
-import org.jetbrains.kotlin.descriptors.commonizer.ConcreteTargetId
+import org.jetbrains.kotlin.descriptors.commonizer.InputTarget
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.RootNode
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.buildRootNode
 import org.jetbrains.kotlin.name.Name
@@ -15,9 +15,9 @@ import org.jetbrains.kotlin.storage.StorageManager
 
 internal fun mergeRoots(
     storageManager: StorageManager,
-    modulesByTargets: List<Pair<ConcreteTargetId, Collection<ModuleDescriptor>>>
+    modulesByTargets: List<Pair<InputTarget, Collection<ModuleDescriptor>>>
 ): RootNode {
-    val node = buildRootNode(modulesByTargets.map { it.first })
+    val node = buildRootNode(storageManager, modulesByTargets.map { it.first })
 
     val modulesMap = CommonizedGroupMap<Name, ModuleDescriptor>(modulesByTargets.size)
 
@@ -27,8 +27,8 @@ internal fun mergeRoots(
         }
     }
 
-    for ((moduleName, modulesGroup) in modulesMap) {
+    for ((_, modulesGroup) in modulesMap) {
-        node.modules += mergeModules(storageManager, node.cache, moduleName, modulesGroup.toList())
+        node.modules += mergeModules(storageManager, node.cache, modulesGroup.toList())
     }
 
     return node

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

@@ -32,12 +32,12 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
         }
 
         fun Collection<ModuleDescriptor>.eachModuleAsTarget() = mapIndexed { index, moduleDescriptor ->
-            "target_$index" to moduleDescriptor
+            InputTarget("target_$index") to moduleDescriptor
         }.toMap().toCommonizationParameters()
 
-        fun Map<String, ModuleDescriptor>.toCommonizationParameters() = CommonizationParameters().also {
+        fun Map<InputTarget, ModuleDescriptor>.toCommonizationParameters() = CommonizationParameters().also {
-            forEach { (targetName, moduleDescriptor) ->
+            forEach { (target, moduleDescriptor) ->
-                it.addTarget(targetName, listOf(moduleDescriptor))
+                it.addTarget(target, listOf(moduleDescriptor))
             }
         }
     }
@@ -71,7 +71,7 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
                 .also(::assertIsDirectory)
         }
 
-    protected val sourceModuleRoots: Pair<Set<File>, Set<File>>
+    protected val sourceModuleRoots: Triple<Set<File>, Set<File>, File>
         get() {
             val testDataDir = testDataDir
 
@@ -89,19 +89,21 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
                 ?.toSet()
                 ?.also { it.forEach(::assertIsDirectory) }
 
+            val commonRoot = commonizedRoots?.singleOrNull { it.name == "common" }
+
             check(
-                !originalRoots.isNullOrEmpty() && !commonizedRoots.isNullOrEmpty()
+                !originalRoots.isNullOrEmpty() && !commonizedRoots.isNullOrEmpty() && commonRoot != null
-                        && (originalRoots.map { it.name } + "common").toSet() == commonizedRoots.map { it.name }.toSet()
+                        && (originalRoots + commonRoot).map { it.name }.toSet() == commonizedRoots.map { it.name }.toSet()
             ) {
                 "Source module misconfiguration in $testDataDir"
             }
 
-            return originalRoots to commonizedRoots
+            return Triple(originalRoots, commonizedRoots - commonRoot, commonRoot)
         }
 
-    protected val sourceModuleDescriptors: Pair<Map<String, ModuleDescriptor>, Map<String, ModuleDescriptor>>
+    protected val sourceModuleDescriptors: Pair<Map<InputTarget, ModuleDescriptor>, Map<Target, ModuleDescriptor>>
         get() {
-            fun analyzeTarget(targetRoot: File): Pair<String, ModuleDescriptor> {
+            fun analyzeTarget(targetRoot: File): ModuleDescriptor {
                 val environment = createEnvironment(targetRoot.parentFile.parentFile.name)
                 val psiFactory = KtPsiFactory(environment.project)
 
@@ -110,7 +112,7 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
                     .map { psiFactory.createFile(it.name, doLoadFile(it)) }
                     .toList()
 
-                val moduleDescriptor = CommonResolverForModuleFactory.analyzeFiles(
+                return CommonResolverForModuleFactory.analyzeFiles(
                     files = psiFiles,
                     moduleName = environment.moduleName,
                     dependOnBuiltIns = true,
@@ -118,11 +120,19 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
                 ) { content ->
                     environment.createPackagePartProvider(content.moduleContentScope)
                 }.moduleDescriptor
-
-                return targetRoot.name to moduleDescriptor
             }
 
-            return sourceModuleRoots.first.map(::analyzeTarget).toMap() to sourceModuleRoots.second.map(::analyzeTarget).toMap()
+            val originalModules = sourceModuleRoots.first
+                .map { InputTarget(it.name) to analyzeTarget(it) }
+                .toMap()
+
+            val commonizedModules = sourceModuleRoots.second
+                .map { InputTarget(it.name) to analyzeTarget(it) }
+                .toMap()
+
+            val commonModule = OutputTarget(commonizedModules.keys) to analyzeTarget(sourceModuleRoots.third)
+
+            return originalModules to commonizedModules + commonModule
         }
 
     protected fun doTestSuccessfulCommonization() {
@@ -131,23 +141,26 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() {
         val result = runCommonization(originalModules.toCommonizationParameters())
         assertCommonizationPerformed(result)
 
-        val commonModuleAsExpected = commonizedModules.getValue("common")
+        val commonTarget = commonizedModules.keys.filterIsInstance<OutputTarget>().single()
-        val commonModuleByCommonizer = result.commonModules.single()
+        assertEquals(commonTarget, result.commonTarget)
+
+        val commonModuleAsExpected = commonizedModules.getValue(commonTarget)
+        val commonModuleByCommonizer = result.modulesByTargets.getValue(commonTarget).single()
 
         assertValidModule(commonModuleAsExpected)
         assertValidModule(commonModuleByCommonizer)
-        assertModulesAreEqual(commonModuleAsExpected, commonModuleByCommonizer, "\"common\" target")
+        assertModulesAreEqual(commonModuleAsExpected, commonModuleByCommonizer, "\"$commonTarget\" target")
 
-        val concreteTargetNames = commonizedModules.keys - "common"
+        val concreteTargets = commonizedModules.keys - commonTarget
-        assertEquals(concreteTargetNames, result.modulesByTargets.keys)
+        assertEquals(concreteTargets, result.concreteTargets)
 
-        for (targetName in concreteTargetNames) {
+        for (target in concreteTargets) {
-            val targetModuleAsExpected = commonizedModules.getValue(targetName)
+            val targetModuleAsExpected = commonizedModules.getValue(target)
-            val targetModuleByCommonizer = result.modulesByTargets.getValue(targetName).single()
+            val targetModuleByCommonizer = result.modulesByTargets.getValue(target).single()
 
             assertValidModule(targetModuleAsExpected)
             assertValidModule(targetModuleByCommonizer)
-            assertModulesAreEqual(targetModuleAsExpected, targetModuleByCommonizer, "\"$targetName\" target")
+            assertModulesAreEqual(targetModuleAsExpected, targetModuleByCommonizer, "\"$target\" target")
         }
     }
 }

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

@@ -37,7 +37,7 @@ class CommonizerFacadeTest {
     }
 
     @Test
-    fun nothingToCommonize2() {
+    fun commonized() {
         val modules = listOf(
             mockEmptyModule("<foo>"),
             mockEmptyModule("<foo>")
@@ -47,11 +47,11 @@ class CommonizerFacadeTest {
 
         assertCommonizationPerformed(result)
 
-        assertSingleModuleForTarget("<foo>", result.commonModules)
+        assertSingleModuleForTarget("<foo>", result.modulesByTargets.getValue(result.commonTarget))
 
-        assertEquals(2, result.modulesByTargets.size)
+        assertEquals(2, result.concreteTargets.size)
-        for (modulesSamePlatform in result.modulesByTargets.values) {
+        for (target in result.concreteTargets) {
-            assertSingleModuleForTarget("<foo>", modulesSamePlatform)
+            assertSingleModuleForTarget("<foo>", result.modulesByTargets.getValue(target))
         }
     }
 

konan/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/DefaultExtensionReceiverCommonizerTest.kt

@@ -10,10 +10,8 @@ import org.jetbrains.kotlin.descriptors.commonizer.utils.EMPTY_CLASSIFIERS_CACHE
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.ExtensionReceiver
 import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType
 import org.jetbrains.kotlin.types.UnwrappedType
-import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import org.junit.Test
 
-@TypeRefinement
 class DefaultExtensionReceiverCommonizerTest : AbstractCommonizerTest<ExtensionReceiver?, UnwrappedType?>() {
 
     @Test
@@ -56,7 +54,6 @@ class DefaultExtensionReceiverCommonizerTest : AbstractCommonizerTest<ExtensionR
     override fun createCommonizer() = ExtensionReceiverCommonizer.default(EMPTY_CLASSIFIERS_CACHE)
 }
 
-@TypeRefinement
 private fun mockExtensionReceiver(typeFqName: String) = ExtensionReceiver(
     annotations = Annotations.EMPTY,
     type = mockClassType(typeFqName).unwrap()

konan/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/DefaultTypeCommonizerTest.kt

@@ -19,11 +19,9 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.UnwrappedType
 import org.jetbrains.kotlin.types.getAbbreviation
-import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import org.junit.Before
 import org.junit.Test
 
-@TypeRefinement
 class DefaultTypeCommonizerTest : AbstractCommonizerTest<KotlinType, UnwrappedType>() {
 
     private lateinit var cache: ClassifiersCacheImpl

konan/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/DefaultTypeParameterCommonizerTest.kt

@@ -11,10 +11,8 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.TypeParameter
 import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import org.junit.Test
 
-@TypeRefinement
 class DefaultTypeParameterCommonizerTest : AbstractCommonizerTest<TypeParameter, TypeParameter>() {
     override fun createCommonizer() = TypeParameterCommonizer.default(EMPTY_CLASSIFIERS_CACHE)
 

konan/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/DefaultTypeParameterListCommonizerTest.kt

@@ -7,10 +7,8 @@ package org.jetbrains.kotlin.descriptors.commonizer.core
 
 import org.jetbrains.kotlin.descriptors.commonizer.utils.EMPTY_CLASSIFIERS_CACHE
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.TypeParameter
-import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import org.junit.Test
 
-@TypeRefinement
 class DefaultTypeParameterListCommonizerTest : AbstractCommonizerTest<List<TypeParameter>, List<TypeParameter>>() {
 
     @Test

konan/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/DefaultValueParameterCommonizerTest.kt

@@ -13,10 +13,8 @@ import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.ValueParameter
 import org.jetbrains.kotlin.descriptors.commonizer.utils.mockClassType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.UnwrappedType
-import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import org.junit.Test
 
-@TypeRefinement
 class DefaultValueParameterCommonizerTest : AbstractCommonizerTest<ValueParameter, ValueParameter>() {
 
     @Test

konan/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/DefaultValueParameterListCommonizerTest.kt

@@ -8,10 +8,8 @@ package org.jetbrains.kotlin.descriptors.commonizer.core
 import org.jetbrains.kotlin.descriptors.commonizer.utils.EMPTY_CLASSIFIERS_CACHE
 import org.jetbrains.kotlin.descriptors.commonizer.core.TestValueParameter.Companion.areEqual
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.ValueParameter
-import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import org.junit.Test
 
-@TypeRefinement
 class DefaultValueParameterListCommonizerTest : AbstractCommonizerTest<List<ValueParameter>, List<ValueParameter>>() {
 
     @Test
@@ -174,7 +172,7 @@ class DefaultValueParameterListCommonizerTest : AbstractCommonizerTest<List<Valu
         else if (a == null || b == null || a.size != b.size)
             return false
 
-        for (i in 0 until a.size) {
+        for (i in a.indices) {
             if (!areEqual(EMPTY_CLASSIFIERS_CACHE, a[i], b[i]))
                 return false
         }

konan/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/mocks.kt

@@ -7,18 +7,15 @@ package org.jetbrains.kotlin.descriptors.commonizer.utils
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.commonizer.builder.CommonizedClassDescriptor
+import org.jetbrains.kotlin.descriptors.commonizer.builder.CommonizedTypeAliasDescriptor
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.*
-import org.jetbrains.kotlin.descriptors.impl.AbstractTypeAliasDescriptor
-import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase
-import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.parentOrNull
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
-import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import kotlin.random.Random
 
 // expected special name for module
@@ -28,57 +25,41 @@ internal fun mockEmptyModule(moduleName: String): ModuleDescriptor {
     return module
 }
 
-@TypeRefinement
 internal fun mockClassType(
     fqName: String,
     nullable: Boolean = false
 ): KotlinType = LazyWrappedType(LockBasedStorageManager.NO_LOCKS) {
     val classFqName = FqName(fqName)
 
-    val classTypeConstructor = object : AbstractClassTypeConstructor(LockBasedStorageManager.NO_LOCKS) {
+    val classDescriptor = CommonizedClassDescriptor(
-        lateinit var classDescriptor: ClassDescriptor
+        storageManager = LockBasedStorageManager.NO_LOCKS,
-        override fun getParameters(): List<TypeParameterDescriptor> = emptyList()
+        containingDeclaration = createPackageFragmentForClassifier(classFqName),
-        override fun computeSupertypes(): List<KotlinType> = emptyList()
+        annotations = Annotations.EMPTY,
-        override fun isDenotable() = true
+        name = classFqName.shortName(),
-        override fun getDeclarationDescriptor() = classDescriptor
+        kind = ClassKind.CLASS,
-        override val supertypeLoopChecker = SupertypeLoopChecker.EMPTY
+        modality = Modality.FINAL,
-        override fun toString() = "class type constructor ${declarationDescriptor.name}"
+        visibility = Visibilities.PUBLIC,
-    }
+        isCompanion = false,
+        isData = false,
+        isInline = false,
+        isInner = false,
+        isExternal = false,
+        isExpect = false,
+        isActual = false,
+        companionObjectName = null,
+        supertypes = emptyList()
+    )
 
-    val classDescriptor = object : ClassDescriptorBase(
+    classDescriptor.declaredTypeParameters = emptyList()
-        /*storageManager =*/ LockBasedStorageManager.NO_LOCKS,
-        /*containingDeclaration =*/ createPackageFragmentForClassifier(classFqName),
-        /*name =*/ classFqName.shortName(),
-        /*source =*/ SourceElement.NO_SOURCE,
-        /*isExternal =*/ false
-    ) {
-        override fun getStaticScope() = MemberScope.Empty
-        override fun getConstructors(): List<ClassConstructorDescriptor> = emptyList()
-        override fun getCompanionObjectDescriptor(): ClassDescriptor? = null
-        override fun getKind() = ClassKind.CLASS
-        override fun getModality() = Modality.FINAL
-        override fun getVisibility() = Visibilities.PUBLIC
-        override fun isCompanionObject() = false
-        override fun isData() = false
-        override fun isInline() = false
-        override fun getUnsubstitutedPrimaryConstructor(): ClassConstructorDescriptor? = null
-        override fun isExpect() = false
-        override fun getUnsubstitutedMemberScope(kotlinTypeRefiner: KotlinTypeRefiner) = MemberScope.Empty
-        override fun isActual() = false
-        override fun getSealedSubclasses(): List<ClassDescriptor> = emptyList()
-        override fun getTypeConstructor() = classTypeConstructor
-        override fun isInner() = false
-        override fun getDeclaredTypeParameters(): List<TypeParameterDescriptor> = emptyList()
-        override val annotations = Annotations.EMPTY
-        override fun toString() = "class descriptor $name"
-    }
 
-    classTypeConstructor.classDescriptor = classDescriptor
+    classDescriptor.initialize(
+        unsubstitutedMemberScope = MemberScope.Empty,
+        constructors = emptyList()
+    )
 
-    createSimpleType(classTypeConstructor, nullable)
+    classDescriptor.defaultType.makeNullableAsSpecified(nullable)
 }
 
-@TypeRefinement
 internal fun mockTAType(
     fqName: String,
     nullable: Boolean = false,
@@ -88,27 +69,24 @@ internal fun mockTAType(
 
     val rightHandSideType = rightHandSideTypeProvider().lowerIfFlexible()
 
-    val typeAliasDescriptor = object : AbstractTypeAliasDescriptor(
+    val typeAliasDescriptor = CommonizedTypeAliasDescriptor(
+        storageManager = LockBasedStorageManager.NO_LOCKS,
         containingDeclaration = createPackageFragmentForClassifier(typeAliasFqName),
         annotations = Annotations.EMPTY,
         name = typeAliasFqName.shortName(),
-        sourceElement = SourceElement.NO_SOURCE,
+        visibility = Visibilities.PUBLIC,
-        visibilityImpl = Visibilities.PUBLIC
+        isActual = false
-    ) {
+    )
-        private val myDefaultType by lazy { createSimpleType(typeConstructor, nullable) }
-        override val storageManager = LockBasedStorageManager.NO_LOCKS
-        override fun getTypeConstructorTypeParameters(): List<TypeParameterDescriptor> = emptyList()
-        override val underlyingType by lazy { rightHandSideType.getAbbreviation() ?: rightHandSideType }
-        override fun getDefaultType() = myDefaultType
-        override val classDescriptor get() = expandedType.constructor.declarationDescriptor as ClassDescriptor?
-        override val constructors: Collection<TypeAliasConstructorDescriptor> = emptyList()
-        override fun substitute(substitutor: TypeSubstitutor) = this
-        override val expandedType by lazy { rightHandSideType }
-    }.apply {
-        initialize(emptyList())
-    }
 
-    (rightHandSideType.getAbbreviatedType()?.expandedType ?: rightHandSideType).withAbbreviation(typeAliasDescriptor.defaultType)
+    typeAliasDescriptor.initialize(
+        declaredTypeParameters = emptyList(),
+        underlyingType = rightHandSideType.getAbbreviation() ?: rightHandSideType,
+        expandedType = rightHandSideType
+    )
+
+    (rightHandSideType.getAbbreviatedType()?.expandedType ?: rightHandSideType)
+        .withAbbreviation(typeAliasDescriptor.defaultType)
+        .makeNullableAsSpecified(nullable)
 }
 
 private fun createPackageFragmentForClassifier(classifierFqName: FqName): PackageFragmentDescriptor =
@@ -126,16 +104,6 @@ private fun createPackageFragmentForClassifier(classifierFqName: FqName): Packag
         override fun toString() = "package $name"
     }
 
-private fun createSimpleType(typeConstructor: TypeConstructor, nullable: Boolean): SimpleType =
-    KotlinTypeFactory.simpleTypeWithNonTrivialMemberScope(
-        annotations = Annotations.EMPTY,
-        constructor = typeConstructor,
-        arguments = emptyList(),
-        nullable = nullable,
-        memberScope = MemberScope.Empty,
-        refinedTypeFactory = { null }
-    )
-
 internal val EMPTY_CLASSIFIERS_CACHE = object : ClassifiersCache {
     override val classes: Map<FqName, ClassNode> get() = emptyMap()
     override val typeAliases: Map<FqName, TypeAliasNode> get() = emptyMap()