[Commonizer] Put all CIR utils to a single file

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

@@ -30,6 +30,3 @@ object CirClassifierRecursionMarker : CirClassifier, CirRecursionMarker {
     override val typeParameters get() = unsupported()
     override val visibility get() = unsupported()
 }
-
-@Suppress("unused", "NOTHING_TO_INLINE")
-internal inline fun CirDeclaration.unsupported(): Nothing = error("This method should never be called on ${this::class.java}, $this")

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

@@ -9,13 +9,14 @@ import kotlinx.metadata.KmTypeAlias
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirClassOrTypeAliasType
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirName
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeAlias
+import org.jetbrains.kotlin.descriptors.commonizer.cir.unabbreviate
 import org.jetbrains.kotlin.descriptors.commonizer.metadata.decodeVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap
 
 object CirTypeAliasFactory {
     fun create(name: CirName, source: KmTypeAlias, typeResolver: CirTypeResolver): CirTypeAlias {
         val underlyingType = CirTypeFactory.create(source.underlyingType, typeResolver) as CirClassOrTypeAliasType
-        val expandedType = CirTypeFactory.unabbreviate(underlyingType)
+        val expandedType = underlyingType.unabbreviate()
 
         return CirTypeAlias.create(
             annotations = CirAnnotationFactory.createAnnotations(source.flags, typeResolver, source::annotations),

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.descriptors.commonizer.cir.factory
 import gnu.trove.TIntObjectHashMap
 import kotlinx.metadata.*
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
-import org.jetbrains.kotlin.descriptors.commonizer.core.computeExpandedType
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirProvided
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirProvidedClassifiers
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.TypeParameterResolver
@@ -68,39 +67,6 @@ object CirTypeFactory {
         }
     }
 
-    fun <T : CirSimpleType> makeNullable(type: T): T {
-        if (type.isMarkedNullable)
-            return type
-
-        val result = when (type) {
-            is CirClassType -> CirClassType.createInterned(
-                classId = type.classifierId,
-                outerType = type.outerType,
-                visibility = type.visibility,
-                arguments = type.arguments,
-                isMarkedNullable = true
-            )
-            is CirTypeAliasType -> CirTypeAliasType.createInterned(
-                typeAliasId = type.classifierId,
-                underlyingType = makeNullable(type.underlyingType),
-                arguments = type.arguments,
-                isMarkedNullable = true
-            )
-            is CirTypeParameterType -> CirTypeParameterType.createInterned(
-                index = type.index,
-                isMarkedNullable = true
-            )
-            else -> error("Unsupported type: $type")
-        }
-
-        @Suppress("UNCHECKED_CAST")
-        return result as T
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    inline fun <T : CirSimpleType> makeNullableIfNecessary(type: T, necessary: Boolean): T =
-        if (!necessary) type else makeNullable(type)
-
     @Suppress("NOTHING_TO_INLINE")
     inline fun decodeVariance(variance: KmVariance): Variance = when (variance) {
         KmVariance.INVARIANT -> Variance.INVARIANT
@@ -108,42 +74,6 @@ object CirTypeFactory {
         KmVariance.OUT -> Variance.OUT_VARIANCE
     }
 
-    fun unabbreviate(type: CirClassOrTypeAliasType): CirClassType = when (type) {
-        is CirClassType -> {
-            var hasAbbreviationsInArguments = false
-            val unabbreviatedArguments = type.arguments.compactMap { argument ->
-                val argumentType =
-                    (argument as? CirTypeProjectionImpl)?.type as? CirClassOrTypeAliasType ?: return@compactMap argument
-                val unabbreviatedArgumentType = unabbreviate(argumentType)
-
-                if (argumentType == unabbreviatedArgumentType)
-                    argument
-                else {
-                    hasAbbreviationsInArguments = true
-                    CirTypeProjectionImpl(
-                        projectionKind = argument.projectionKind,
-                        type = unabbreviatedArgumentType
-                    )
-                }
-            }
-
-            val outerType = type.outerType
-            val unabbreviatedOuterType = outerType?.let(::unabbreviate)
-
-            if (!hasAbbreviationsInArguments && outerType == unabbreviatedOuterType)
-                type
-            else
-                CirClassType.createInterned(
-                    classId = type.classifierId,
-                    outerType = unabbreviatedOuterType,
-                    visibility = type.visibility,
-                    arguments = unabbreviatedArguments,
-                    isMarkedNullable = type.isMarkedNullable
-                )
-        }
-        is CirTypeAliasType -> unabbreviate(computeExpandedType(type))
-    }
-
     @Suppress("NOTHING_TO_INLINE")
     private inline fun createArguments(arguments: List<KmTypeProjection>, typeResolver: CirTypeResolver): List<CirTypeProjection> {
         return arguments.compactMap { argument ->

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.descriptors.commonizer.cir
+
+import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMap
+
+fun <T : CirSimpleType> T.makeNullable(): T {
+    if (isMarkedNullable)
+        return this
+
+    val result = when (this) {
+        is CirClassType -> CirClassType.createInterned(
+            classId = classifierId,
+            outerType = outerType,
+            visibility = visibility,
+            arguments = arguments,
+            isMarkedNullable = true
+        )
+        is CirTypeAliasType -> CirTypeAliasType.createInterned(
+            typeAliasId = classifierId,
+            underlyingType = underlyingType.makeNullable(),
+            arguments = arguments,
+            isMarkedNullable = true
+        )
+        is CirTypeParameterType -> CirTypeParameterType.createInterned(
+            index = index,
+            isMarkedNullable = true
+        )
+        else -> error("Unsupported type: $this")
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    return result as T
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T : CirSimpleType> T.makeNullableIfNecessary(necessary: Boolean): T =
+    if (!necessary) this else makeNullable()
+
+fun CirClassOrTypeAliasType.unabbreviate(): CirClassType = when (this) {
+    is CirClassType -> {
+        var hasAbbreviationsInArguments = false
+        val unabbreviatedArguments = arguments.compactMap { argument ->
+            val argumentType =
+                (argument as? CirTypeProjectionImpl)?.type as? CirClassOrTypeAliasType ?: return@compactMap argument
+            val unabbreviatedArgumentType = argumentType.unabbreviate()
+
+            if (argumentType == unabbreviatedArgumentType)
+                argument
+            else {
+                hasAbbreviationsInArguments = true
+                CirTypeProjectionImpl(
+                    projectionKind = argument.projectionKind,
+                    type = unabbreviatedArgumentType
+                )
+            }
+        }
+
+        val outerType = outerType
+        val unabbreviatedOuterType = outerType?.unabbreviate()
+
+        if (!hasAbbreviationsInArguments && outerType == unabbreviatedOuterType)
+            this
+        else
+            CirClassType.createInterned(
+                classId = classifierId,
+                outerType = unabbreviatedOuterType,
+                visibility = visibility,
+                arguments = unabbreviatedArguments,
+                isMarkedNullable = isMarkedNullable
+            )
+    }
+    is CirTypeAliasType -> computeExpandedType(this).unabbreviate()
+}
+
+internal tailrec fun computeExpandedType(underlyingType: CirClassOrTypeAliasType): CirClassType {
+    return when (underlyingType) {
+        is CirClassType -> underlyingType
+        is CirTypeAliasType -> computeExpandedType(underlyingType.underlyingType)
+    }
+}
+
+@Suppress("unused", "NOTHING_TO_INLINE")
+internal inline fun CirDeclaration.unsupported(): Nothing = error("This method should never be called on ${this::class.java}, $this")

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.descriptors.commonizer.core
 
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
-import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory
 import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizedTypeAliasAnswer.Companion.FAILURE_MISSING_IN_SOME_TARGET
 import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizedTypeAliasAnswer.Companion.SUCCESS_FROM_DEPENDENCY_LIBRARY
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers
@@ -143,7 +142,7 @@ private class TypeAliasTypeCommonizer(private val classifiers: CirKnownClassifie
             // type alias don't needs to be commonized because it is from the standard library
             fun forKnownUnderlyingType(underlyingType: CirClassOrTypeAliasType) = object : CommonizedTypeAliasTypeBuilder {
                 override fun build(typeAliasId: CirEntityId, arguments: List<CirTypeProjection>, isMarkedNullable: Boolean): CirTypeAliasType {
-                    val underlyingTypeWithProperNullability = CirTypeFactory.makeNullableIfNecessary(underlyingType, isMarkedNullable)
+                    val underlyingTypeWithProperNullability = underlyingType.makeNullableIfNecessary(isMarkedNullable)
                     return CirTypeAliasType.createInterned(
                         typeAliasId = typeAliasId,
                         underlyingType = underlyingTypeWithProperNullability, // TODO replace arguments???

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

@@ -11,13 +11,6 @@ import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeAliasType
 import org.jetbrains.kotlin.descriptors.commonizer.cir.CirTypeProjection
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers
 
-tailrec fun computeExpandedType(underlyingType: CirClassOrTypeAliasType): CirClassType {
-    return when (underlyingType) {
-        is CirClassType -> underlyingType
-        is CirTypeAliasType -> computeExpandedType(underlyingType.underlyingType)
-    }
-}
-
 internal tailrec fun computeSuitableUnderlyingType(
     classifiers: CirKnownClassifiers,
     underlyingType: CirClassOrTypeAliasType

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/CirTypeAliasExpander.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.descriptors.commonizer.metadata
 
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
-import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeResolver
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirProvided
 import org.jetbrains.kotlin.descriptors.commonizer.utils.compactMapIndexed
@@ -52,7 +51,7 @@ object CirTypeAliasExpander {
         }
 
         val expandedType = expandedProjection.type as CirClassOrTypeAliasType
-        return CirTypeFactory.makeNullableIfNecessary(expandedType, expansion.isMarkedNullable)
+        return expandedType.makeNullableIfNecessary(expansion.isMarkedNullable)
     }
 
     private fun expandTypeProjection(
@@ -101,7 +100,7 @@ object CirTypeAliasExpander {
                     }
                 }
 
-                val substitutedType = CirTypeFactory.makeNullableIfNecessary(argumentType, type.isMarkedNullable)
+                val substitutedType = argumentType.makeNullableIfNecessary(type.isMarkedNullable)
 
                 CirTypeProjectionImpl(resultingVariance, substitutedType)
             }
@@ -170,7 +169,7 @@ object CirTypeAliasExpander {
 
                 CirTypeProjectionImpl(
                     projectionKind = projection.projectionKind,
-                    type = CirTypeFactory.makeNullable(projectionType)
+                    type = projectionType.makeNullable()
                 )
             }
         }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/metadata/entityBuilders.kt

@@ -10,7 +10,6 @@ import kotlinx.metadata.klib.*
 import org.jetbrains.kotlin.backend.common.serialization.metadata.DynamicTypeDeserializer
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
-import org.jetbrains.kotlin.descriptors.commonizer.core.computeExpandedType
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.*
 import org.jetbrains.kotlin.descriptors.commonizer.metadata.TypeAliasExpansion.*
 import org.jetbrains.kotlin.descriptors.commonizer.utils.DEFAULT_SETTER_VALUE_NAME

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

@@ -30,7 +30,7 @@ internal fun mockTAType(
     underlyingType: () -> CirClassOrTypeAliasType
 ): CirTypeAliasType = CirTypeAliasType.createInterned(
     typeAliasId = createValidClassifierId(typeAliasId),
-    underlyingType = CirTypeFactory.makeNullableIfNecessary(underlyingType(), nullable),
+    underlyingType = underlyingType().makeNullableIfNecessary(nullable),
     arguments = emptyList(),
     isMarkedNullable = nullable
 )