[Commonizer] Lift up identical type aliases

^KMM-55

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

@@ -129,7 +129,7 @@ internal class DeclarationsBuilderVisitor1(
         node.buildDescriptors(components, typeAliasesGroup, data)
         val typeAliases = typeAliasesGroup.toList()
 
-        val commonClass = typeAliases[node.indexOfCommon] as CommonizedClassDescriptor?
+        val commonClass = typeAliases[node.indexOfCommon] as? CommonizedClassDescriptor?
         commonClass?.unsubstitutedMemberScope = CommonizedMemberScope() // empty member scope
         commonClass?.initialize(emptyList()) // no constructors
 

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

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.storage.StorageManager
 /**
  * Temporary caches for constructed descriptors.
  */
-class DeclarationsBuilderCache(dimension: Int) {
+class DeclarationsBuilderCache(private val dimension: Int) {
     init {
         check(dimension > 0)
     }
@@ -43,8 +43,26 @@ class DeclarationsBuilderCache(dimension: Int) {
 
     fun getCachedClasses(fqName: FqName): List<CommonizedClassDescriptor?> = classes.getOrFail(fqName)
 
-    fun getCachedClassifier(fqName: FqName, index: Int): ClassifierDescriptorWithTypeParameters? =
+    fun getCachedClassifier(fqName: FqName, index: Int): ClassifierDescriptorWithTypeParameters? {
-        classes.getOrNull(fqName)?.get(index) ?: typeAliases.getOrNull(fqName)?.get(index)
+        // first, look up for class
+        val classes: CommonizedGroup<CommonizedClassDescriptor>? = classes.getOrNull(fqName)
+        classes?.get(index)?.let { return it }
+
+        // then, for type alias
+        val typeAliases: CommonizedGroup<CommonizedTypeAliasDescriptor>? = typeAliases.getOrNull(fqName)
+        typeAliases?.get(index)?.let { return it }
+
+        val indexOfCommon = dimension - 1
+        if (indexOfCommon != index) {
+            // then, for class from the common fragment
+            classes?.get(indexOfCommon)?.let { return it }
+
+            // then, for type alias from the common fragment
+            typeAliases?.get(indexOfCommon)?.let { return it }
+        }
+
+        return null
+    }
 
     fun cache(index: Int, modules: List<ModuleDescriptorImpl>) {
         this.modules[index] = modules

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.builder
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptorWithTypeParameters
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClass
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassifier
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeAlias
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirTypeAliasNode
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.indexOfCommon
@@ -19,14 +20,24 @@ internal fun CirTypeAliasNode.buildDescriptors(
     output: CommonizedGroup<ClassifierDescriptorWithTypeParameters>,
     containingDeclarations: List<DeclarationDescriptor?>
 ) {
-    val commonClass: CirClass? = common()
+    val commonClassifier: CirClassifier? = common()
-    val markAsActual = commonClass != null
+    // Note: 'expect class' and lifted up 'typealias' both can't be non-null
+    val commonTypeAlias: CirTypeAlias? = commonClassifier as? CirTypeAlias?
 
-    target.forEachIndexed { index, typeAlias ->
+    val isLiftedUp = commonTypeAlias?.isLiftedUp == true
-        typeAlias?.buildDescriptor(components, output, index, containingDeclarations, fqName, isActual = markAsActual)
+    val markAsActual = commonClassifier != null
+
+    if (!isLiftedUp) {
+        target.forEachIndexed { index, typeAlias ->
+            typeAlias?.buildDescriptor(components, output, index, containingDeclarations, fqName, isActual = markAsActual)
+        }
     }
 
-    commonClass?.buildDescriptor(components, output, indexOfCommon, containingDeclarations, fqName, isExpect = true)
+    if (commonTypeAlias != null) {
+        commonTypeAlias.buildDescriptor(components, output, indexOfCommon, containingDeclarations, fqName)
+    } else if (commonClassifier != null && commonClassifier is CirClass) {
+        commonClassifier.buildDescriptor(components, output, indexOfCommon, containingDeclarations, fqName, isExpect = true)
+    }
 
     // log stats
     components.statsCollector?.logStats(output.toList())

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

@@ -8,13 +8,7 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.name.FqName
 
-interface CirClass :
+interface CirClass : CirClassifier, CirDeclarationWithModality {
-    CirAnnotatedDeclaration,
-    CirNamedDeclaration,
-    CirDeclarationWithTypeParameters,
-    CirDeclarationWithVisibility,
-    CirDeclarationWithModality {
-
     val kind: ClassKind
     var companion: FqName? // null means no companion object
     val isCompanion: Boolean

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

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.descriptors.commonizer.cir
+
+interface CirClassifier :
+    CirAnnotatedDeclaration,
+    CirNamedDeclaration,
+    CirDeclarationWithTypeParameters,
+    CirDeclarationWithVisibility

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

@@ -31,10 +31,13 @@ interface CirNamedDeclaration : CirDeclaration {
     val name: Name
 }
 
-interface CirDeclarationWithVisibility : CirDeclaration {
+// TODO: merge with [CirDeclarationWithVisibility]
+interface CirHasVisibility {
     val visibility: Visibility
 }
 
+interface CirDeclarationWithVisibility : CirDeclaration, CirHasVisibility
+
 interface CirDeclarationWithModality : CirDeclaration {
     val modality: Modality
 }

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.cir
 
+import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirSimpleTypeKind.CLASS
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirSimpleTypeKind.TYPE_ALIAS
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory
@@ -17,8 +18,7 @@ sealed class CirType {
 }
 
 /**
- * All attributes except for [expandedTypeConstructorId] are read from the abbreviation type: [AbbreviatedType.abbreviation].
+ * All attributes are read from the abbreviation type: [AbbreviatedType.abbreviation].
- * And [expandedTypeConstructorId] is read from the expanded type: [AbbreviatedType.expandedType].
  *
  * This is necessary to properly compare types for type aliases, where abbreviation type represents the type alias itself while
  * expanded type represents right-hand side declaration that should be processed separately.
@@ -28,13 +28,12 @@ sealed class CirType {
  *
  * Note: Annotations at simple types are not preserved. After commonization all annotations assigned to types will be lost.
  */
-abstract class CirSimpleType : CirType() {
+abstract class CirSimpleType : CirType(), CirHasVisibility {
     abstract val kind: CirSimpleTypeKind
     abstract val fqName: FqName
     abstract val arguments: List<CirTypeProjection>
     abstract val isMarkedNullable: Boolean
     abstract val isDefinitelyNotNullType: Boolean
-    abstract val expandedTypeConstructorId: CirTypeConstructorId
 
     inline val isClassOrTypeAlias: Boolean get() = (kind == CLASS || kind == TYPE_ALIAS)
 }
@@ -50,8 +49,6 @@ enum class CirSimpleTypeKind {
     }
 }
 
-data class CirTypeConstructorId(val fqName: FqName, val numberOfTypeParameters: Int)
-
 data class CirTypeProjection(val projectionKind: Variance, val isStarProjection: Boolean, val type: CirType)
 
 data class CirFlexibleType(val lowerBound: CirSimpleType, val upperBound: CirSimpleType) : CirType() {

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

@@ -5,12 +5,7 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.cir
 
-interface CirTypeAlias :
+interface CirTypeAlias : CirClassifier, CirLiftedUpDeclaration {
-    CirAnnotatedDeclaration,
-    CirNamedDeclaration,
-    CirDeclarationWithTypeParameters,
-    CirDeclarationWithVisibility {
-
     val underlyingType: CirSimpleType
     val expandedType: CirSimpleType
 }

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

@@ -6,19 +6,41 @@
 package org.jetbrains.kotlin.descriptors.commonizer.cir.factory
 
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirAnnotation
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirSimpleType
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeAlias
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeParameter
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirTypeAliasImpl
 import org.jetbrains.kotlin.descriptors.commonizer.utils.intern
+import org.jetbrains.kotlin.name.Name
 
 object CirTypeAliasFactory {
-    fun create(source: TypeAliasDescriptor): CirTypeAlias {
+    fun create(source: TypeAliasDescriptor): CirTypeAlias = create(
+        annotations = source.annotations.map(CirAnnotationFactory::create),
+        name = source.name.intern(),
+        typeParameters = source.declaredTypeParameters.map(CirTypeParameterFactory::create),
+        visibility = source.visibility,
+        underlyingType = CirTypeFactory.create(source.underlyingType),
+        expandedType = CirTypeFactory.create(source.expandedType)
+    )
+
+    @Suppress("NOTHING_TO_INLINE")
+    inline fun create(
+        annotations: List<CirAnnotation>,
+        name: Name,
+        typeParameters: List<CirTypeParameter>,
+        visibility: Visibility,
+        underlyingType: CirSimpleType,
+        expandedType: CirSimpleType
+    ): CirTypeAlias {
         return CirTypeAliasImpl(
-            annotations = source.annotations.map(CirAnnotationFactory::create),
+            annotations = annotations,
-            name = source.name.intern(),
+            name = name,
-            typeParameters = source.declaredTypeParameters.map(CirTypeParameterFactory::create),
+            typeParameters = typeParameters,
-            visibility = source.visibility,
+            visibility = visibility,
-            underlyingType = CirTypeFactory.create(source.underlyingType),
+            underlyingType = underlyingType,
-            expandedType = CirTypeFactory.create(source.expandedType)
+            expandedType = expandedType
         )
     }
 }

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

@@ -5,10 +5,7 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.cir.factory
 
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
-import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirSimpleTypeKind.*
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirSimpleTypeImpl
@@ -30,10 +27,11 @@ object CirTypeFactory {
 
     fun create(source: SimpleType): CirSimpleType {
         val abbreviation: SimpleType = (source as? AbbreviatedType)?.abbreviation ?: source
-        val expanded: SimpleType = (source as? AbbreviatedType)?.expandedType ?: source
+        val classifierDescriptor: ClassifierDescriptor = abbreviation.declarationDescriptor
 
         val simpleType = CirSimpleTypeImpl(
-            kind = abbreviation.declarationDescriptor.cirSimpleTypeKind,
+            kind = classifierDescriptor.cirSimpleTypeKind,
+            visibility = (classifierDescriptor as? ClassifierDescriptorWithTypeParameters)?.visibility ?: Visibilities.UNKNOWN,
             fqName = abbreviation.fqNameInterned,
             arguments = abbreviation.arguments.map { projection ->
                 CirTypeProjection(
@@ -44,10 +42,6 @@ object CirTypeFactory {
             },
             isMarkedNullable = abbreviation.isMarkedNullable,
             isDefinitelyNotNullType = abbreviation.isDefinitelyNotNullType,
-            expandedTypeConstructorId = CirTypeConstructorId(
-                fqName = expanded.fqNameInterned,
-                numberOfTypeParameters = expanded.constructor.parameters.size
-            ),
             fqNameWithTypeParameters = source.fqNameWithTypeParameters
         )
 

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

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.cir.impl
 
+import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirSimpleType
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirSimpleTypeKind
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeConstructorId
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeProjection
 import org.jetbrains.kotlin.descriptors.commonizer.utils.appendHashCode
 import org.jetbrains.kotlin.descriptors.commonizer.utils.hashCode
@@ -15,17 +15,18 @@ import org.jetbrains.kotlin.name.FqName
 
 data class CirSimpleTypeImpl(
     override val kind: CirSimpleTypeKind,
+    override val visibility: Visibility, // visibility of the classifier descriptor
     override val fqName: FqName,
     override val arguments: List<CirTypeProjection>,
     override val isMarkedNullable: Boolean,
     override val isDefinitelyNotNullType: Boolean,
-    override val expandedTypeConstructorId: CirTypeConstructorId,
     override val fqNameWithTypeParameters: String
 ) : CirSimpleType() {
     // See also org.jetbrains.kotlin.types.KotlinType.cachedHashCode
     private var cachedHashCode = 0
 
     private fun computeHashCode() = hashCode(kind)
+        .appendHashCode(visibility)
         .appendHashCode(fqName)
         .appendHashCode(arguments)
         .appendHashCode(isMarkedNullable)
@@ -47,6 +48,7 @@ data class CirSimpleTypeImpl(
             isMarkedNullable == other.isMarkedNullable
                     && fqName == other.fqName
                     && kind == other.kind
+                    && visibility == other.visibility
                     && arguments == other.arguments
                     && fqNameWithTypeParameters == other.fqNameWithTypeParameters
                     && isDefinitelyNotNullType == other.isDefinitelyNotNullType

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

@@ -19,4 +19,7 @@ data class CirTypeAliasImpl(
     override val visibility: Visibility,
     override val underlyingType: CirSimpleType,
     override val expandedType: CirSimpleType
-) : CirTypeAlias
+) : CirTypeAlias {
+    // any TA in "common" fragment is already lifted up
+    override val isLiftedUp get() = true
+}

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.descriptors.commonizer.cir.impl
 
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClass
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassifier
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirRecursionMarker
 import org.jetbrains.kotlin.name.FqName
 
@@ -26,3 +27,10 @@ object CirClassRecursionMarker : CirClass, CirRecursionMarker {
     override val isExternal get() = unsupported()
     override val supertypes get() = unsupported()
 }
+
+object CirClassifierRecursionMarker : CirClassifier, CirRecursionMarker {
+    override val annotations get() = unsupported()
+    override val name get() = unsupported()
+    override val typeParameters get() = unsupported()
+    override val visibility get() = unsupported()
+}

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/Commonizer.kt

@@ -19,12 +19,15 @@ abstract class AbstractStandardCommonizer<T, R> : Commonizer<T, R> {
 
     private var state = State.EMPTY
 
-    final override val result: R
+    protected val hasResult: Boolean
         get() = when (state) {
-            State.EMPTY, State.ERROR -> throw IllegalCommonizerStateException()
+            State.EMPTY, State.ERROR -> false
-            State.IN_PROGRESS -> commonizationResult()
+            State.IN_PROGRESS -> true
         }
 
+    final override val result: R
+        get() = if (hasResult) commonizationResult() else throw IllegalCommonizerStateException()
+
     final override fun commonizeWith(next: T): Boolean {
         val result = when (state) {
             State.ERROR -> return false

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/PropertySetterCommonizer.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.descriptors.commonizer.core
 
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirDeclarationWithVisibility
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirHasVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirPropertySetter
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirPropertySetterFactory
 
-class PropertySetterCommonizer : AbstractNullableCommonizer<CirPropertySetter, CirPropertySetter, CirDeclarationWithVisibility, Visibility>(
+class PropertySetterCommonizer : AbstractNullableCommonizer<CirPropertySetter, CirPropertySetter, CirHasVisibility, Visibility>(
     wrappedCommonizerFactory = { VisibilityCommonizer.equalizing() },
     extractor = { it },
     builder = CirPropertySetterFactory::createDefaultNoAnnotations

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeAliasCommonizer.kt

@@ -7,23 +7,76 @@ package org.jetbrains.kotlin.descriptors.commonizer.core
 
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClass
+import org.jetbrains.kotlin.descriptors.commonizer.cir.*
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirSimpleTypeKind
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeAlias
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirClassFactory
+import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeAliasFactory
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirClassifiersCache
 import org.jetbrains.kotlin.name.Name
 
-class TypeAliasCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirTypeAlias, CirClass>() {
+/**
-    private lateinit var name: Name
+ * Main (optimistic) branch:
-    private val underlyingType = TypeCommonizer(cache)
+ * - Make sure that all TAs are identical, so the resulting TA can be lifted up into "common" fragment.
-    private val visibility = VisibilityCommonizer.lowering(allowPrivate = true)
+ *
+ * Secondary (backup) branch:
+ * - Produce an "expect class" for "common" fragment and the corresponding "actual typealias" declarations for each platform fragment.
+ */
+class TypeAliasCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirTypeAlias, CirClassifier>() {
+    private val main = TypeAliasLiftingUpCommonizer(cache)
+    private val secondary = TypeAliasExpectClassCommonizer()
 
-    override fun commonizationResult() = CirClassFactory.create(
+    override fun commonizationResult(): CirClassifier = main.resultOrNull ?: secondary.result
+
+    override fun initialize(first: CirTypeAlias) = Unit
+
+    @Suppress("ReplaceNegatedIsEmptyWithIsNotEmpty")
+    override fun doCommonizeWith(next: CirTypeAlias): Boolean {
+        val mainResult = main.commonizeWith(next)
+        val secondaryResult = secondary.commonizeWith(next)
+
+        // Note: don't call commonizeWith() functions in return statement to avoid short-circuiting!
+        return mainResult || secondaryResult
+    }
+}
+
+private class TypeAliasLiftingUpCommonizer(cache: CirClassifiersCache) : AbstractStandardCommonizer<CirTypeAlias, CirTypeAlias>() {
+    private lateinit var name: Name
+    private val typeParameters = TypeParameterListCommonizer(cache)
+    private val underlyingType = TypeCommonizer(cache)
+    private lateinit var expandedType: CirSimpleType
+    private val visibility = VisibilityCommonizer.lowering(allowPrivate = false)
+
+    override fun commonizationResult(): CirTypeAlias = CirTypeAliasFactory.create(
+        annotations = emptyList(),
+        name = name,
+        typeParameters = typeParameters.result,
+        visibility = visibility.result,
+        underlyingType = underlyingType.result as CirSimpleType,
+        expandedType = expandedType
+    )
+
+    val resultOrNull: CirTypeAlias?
+        get() = if (hasResult) commonizationResult() else null
+
+    override fun initialize(first: CirTypeAlias) {
+        name = first.name
+        expandedType = first.expandedType
+    }
+
+    override fun doCommonizeWith(next: CirTypeAlias) =
+        typeParameters.commonizeWith(next.typeParameters)
+                && underlyingType.commonizeWith(next.underlyingType)
+                && visibility.commonizeWith(next)
+}
+
+private class TypeAliasExpectClassCommonizer : AbstractStandardCommonizer<CirTypeAlias, CirClass>() {
+    private lateinit var name: Name
+    private val classVisibility = VisibilityCommonizer.equalizing()
+
+    override fun commonizationResult(): CirClass = CirClassFactory.create(
         annotations = emptyList(),
         name = name,
         typeParameters = emptyList(),
-        visibility = visibility.result,
+        visibility = classVisibility.result,
         modality = Modality.FINAL,
         kind = ClassKind.CLASS,
         companion = null,
@@ -43,6 +96,5 @@ class TypeAliasCommonizer(cache: CirClassifiersCache) : AbstractStandardCommoniz
         next.typeParameters.isEmpty() // TAs with declared type parameters can't be commonized
                 && next.underlyingType.arguments.isEmpty() // TAs with functional types or types with parameters at the right-hand side can't be commonized
                 && next.underlyingType.kind == CirSimpleTypeKind.CLASS // right-hand side could have only class
-                && underlyingType.commonizeWith(next.underlyingType)
+                && classVisibility.commonizeWith(next.underlyingType) // the visibilities of the right-hand classes should be equal
-                && visibility.commonizeWith(next)
 }

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

@@ -50,12 +50,7 @@ private fun areSimpleTypesEqual(cache: CirClassifiersCache, a: CirSimpleType, b:
 
     fun isClassOrTypeAliasUnderStandardKotlinPackages() =
         // N.B. only for descriptors that represent classes or type aliases, but not type parameters!
-        a.isClassOrTypeAlias && b.isClassOrTypeAlias
+        a.isClassOrTypeAlias && b.isClassOrTypeAlias && a.fqName.isUnderStandardKotlinPackages
-                && a.fqName.isUnderStandardKotlinPackages
-                // If classes are from the standard Kotlin packages, compare them only by type constructors.
-                // Effectively, this includes comparison of 1) FQ names of underlying descriptors and 2) number of type constructor parameters.
-                // See org.jetbrains.kotlin.types.AbstractClassTypeConstructor.equals() for details.
-                && (a === b || a.expandedTypeConstructorId == b.expandedTypeConstructorId)
 
     fun descriptorsCanBeCommonizedThemselves() =
         a.kind == b.kind && when (a.kind) {

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/VisibilityCommonizer.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.descriptors.commonizer.core
 
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirDeclarationWithVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirFunctionOrProperty
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirHasVisibility
 
-abstract class VisibilityCommonizer(private val allowPrivate: Boolean) : Commonizer<CirDeclarationWithVisibility, Visibility> {
+abstract class VisibilityCommonizer(private val allowPrivate: Boolean) : Commonizer<CirHasVisibility, Visibility> {
 
     companion object {
         fun lowering(allowPrivate: Boolean = false): VisibilityCommonizer = LoweringVisibilityCommonizer(allowPrivate)
@@ -22,7 +22,7 @@ abstract class VisibilityCommonizer(private val allowPrivate: Boolean) : Commoni
     override val result: Visibility
         get() = temp?.takeIf { it != Visibilities.UNKNOWN } ?: throw IllegalCommonizerStateException()
 
-    override fun commonizeWith(next: CirDeclarationWithVisibility): Boolean {
+    override fun commonizeWith(next: CirHasVisibility): Boolean {
         if (temp == Visibilities.UNKNOWN)
             return false
 
@@ -37,7 +37,7 @@ abstract class VisibilityCommonizer(private val allowPrivate: Boolean) : Commoni
         return temp != Visibilities.UNKNOWN
     }
 
-    protected abstract fun canBeCommonized(next: CirDeclarationWithVisibility): Boolean
+    protected abstract fun canBeCommonized(next: CirHasVisibility): Boolean
     protected abstract fun getNext(current: Visibility, next: Visibility): Visibility
 }
 
@@ -49,7 +49,7 @@ private class LoweringVisibilityCommonizer(allowPrivate: Boolean) : VisibilityCo
     private var atLeastOneVirtualCallableMet = false
     private var atLeastTwoVisibilitiesMet = false
 
-    override fun canBeCommonized(next: CirDeclarationWithVisibility): Boolean {
+    override fun canBeCommonized(next: CirHasVisibility): Boolean {
         if (!atLeastOneVirtualCallableMet)
             atLeastOneVirtualCallableMet = (next as? CirFunctionOrProperty)?.isVirtual() == true
 
@@ -74,7 +74,7 @@ private class LoweringVisibilityCommonizer(allowPrivate: Boolean) : VisibilityCo
  * Make sure that visibilities of all member descriptors are equal and are not private according to [Visibilities.isPrivate].
  */
 private class EqualizingVisibilityCommonizer : VisibilityCommonizer(false) {
-    override fun canBeCommonized(next: CirDeclarationWithVisibility) = true
+    override fun canBeCommonized(next: CirHasVisibility) = true
 
     override fun getNext(current: Visibility, next: Visibility) =
         if (Visibilities.compare(current, next) == 0) current else Visibilities.UNKNOWN

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.descriptors.commonizer.TargetProvider
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirDeclaration
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.*
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassRecursionMarker
+import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.CirClassifierRecursionMarker
 import org.jetbrains.kotlin.descriptors.commonizer.core.*
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirRootNode.ClassifiersCacheImpl
 import org.jetbrains.kotlin.descriptors.commonizer.utils.CommonizedGroup
@@ -133,7 +134,7 @@ internal fun buildTypeAliasNode(
     descriptors = typeAliases,
     targetDeclarationProducer = CirTypeAliasFactory::create,
     commonValueProducer = { commonize(it, TypeAliasCommonizer(cacheRW)) },
-    recursionMarker = CirClassRecursionMarker,
+    recursionMarker = CirClassifierRecursionMarker,
     nodeProducer = ::CirTypeAliasNode
 ).also { node ->
     typeAliases.firstNonNull().fqNameSafe.intern().let { fqName ->

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

@@ -118,8 +118,8 @@ class CirClassConstructorNode(
 
 class CirTypeAliasNode(
     override val target: List<CirTypeAlias?>,
-    override val common: NullableLazyValue<CirClass>
+    override val common: NullableLazyValue<CirClassifier>
-) : CirNodeWithFqName<CirTypeAlias, CirClass> {
+) : CirNodeWithFqName<CirTypeAlias, CirClassifier> {
     override lateinit var fqName: FqName
 
     override fun <R, T> accept(visitor: CirNodeVisitor<R, T>, data: T): R =

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

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.descriptors.commonizer.core
 
 import org.jetbrains.kotlin.descriptors.Visibilities.*
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirDeclarationWithVisibility
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirHasVisibility
 import org.junit.Test
 
-class EqualizingVisibilityCommonizerTest : AbstractCommonizerTest<CirDeclarationWithVisibility, Visibility>() {
+class EqualizingVisibilityCommonizerTest : AbstractCommonizerTest<CirHasVisibility, Visibility>() {
 
     @Test
     fun publicOnly() = doTestSuccess(
@@ -63,6 +63,6 @@ class EqualizingVisibilityCommonizerTest : AbstractCommonizerTest<CirDeclaration
     override fun createCommonizer() = VisibilityCommonizer.equalizing()
 }
 
-private fun Visibility.toMock() = object : CirDeclarationWithVisibility {
+private fun Visibility.toMock() = object : CirHasVisibility {
     override val visibility: Visibility = this@toMock
 }

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

@@ -10,15 +10,15 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities.*
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirContainingClassDetails
-import org.jetbrains.kotlin.descriptors.commonizer.cir.CirDeclarationWithVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirFunctionOrProperty
+import org.jetbrains.kotlin.descriptors.commonizer.cir.CirHasVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.impl.unsupported
 import org.junit.Test
 
 abstract class LoweringVisibilityCommonizerTest(
     private val allowPrivate: Boolean,
     private val areMembersVirtual: Boolean
-) : AbstractCommonizerTest<CirDeclarationWithVisibility, Visibility>() {
+) : AbstractCommonizerTest<CirHasVisibility, Visibility>() {
 
     @Test
     fun publicOnly() = doTestSuccess(