[Commonizer] Refactor CIR to avoid strong refs on descriptors

This is necessary to reduce memory consumption in commonizer while
processing sets of massive libraries.
Ex: ios_x64 (127 libraries) vs ios_arm64 (127 libraries).

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

@@ -39,7 +39,7 @@ internal fun List<CirTypeParameter>.buildDescriptorsAndTypeParameterResolver(
             targetComponents = targetComponents,
             typeParameterResolver = typeParameterResolver,
             containingDeclaration = containingDeclaration,
-            annotations = param.annotations,
+            annotations = param.annotations.buildDescriptors(targetComponents),
             name = param.name,
             variance = param.variance,
             isReified = param.isReified,
@@ -61,7 +61,7 @@ internal fun List<CirValueParameter>.buildDescriptors(
         containingDeclaration,
         null,
         index,
-        param.annotations,
+        param.annotations.buildDescriptors(targetComponents),
         param.name,
         param.returnType.buildType(targetComponents, typeParameterResolver),
         param.declaresDefaultValue,

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

@@ -80,7 +80,7 @@ private fun CirProperty.buildDescriptor(
     val getterDescriptor = getter?.let { getter ->
         DescriptorFactory.createGetter(
             propertyDescriptor,
-            getter.annotations,
+            getter.annotations.buildDescriptors(targetComponents),
             getter.isDefault,
             getter.isExternal,
             getter.isInline
@@ -92,8 +92,8 @@ private fun CirProperty.buildDescriptor(
     val setterDescriptor = setter?.let { setter ->
         DescriptorFactory.createSetter(
             propertyDescriptor,
-            setter.annotations,
+            setter.annotations.buildDescriptors(targetComponents),
-            setter.parameterAnnotations,
+            setter.parameterAnnotations.buildDescriptors(targetComponents),
             setter.isDefault,
             setter.isExternal,
             setter.isInline,
@@ -102,8 +102,13 @@ private fun CirProperty.buildDescriptor(
         )
     }
 
-    val backingField = backingFieldAnnotations?.let { FieldDescriptorImpl(it, propertyDescriptor) }
+    val backingField = backingFieldAnnotations?.let { annotations ->
-    val delegateField = delegateFieldAnnotations?.let { FieldDescriptorImpl(it, propertyDescriptor) }
+        FieldDescriptorImpl(annotations.buildDescriptors(targetComponents), propertyDescriptor)
+    }
+
+    val delegateField = delegateFieldAnnotations?.let { annotations ->
+        FieldDescriptorImpl(annotations.buildDescriptors(targetComponents), propertyDescriptor)
+    }
 
     propertyDescriptor.initialize(
         getterDescriptor,

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirAnnotation.kt

@@ -8,9 +8,37 @@ package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.constants.ConstantValue
+import org.jetbrains.kotlin.resolve.constants.*
 
-class CirAnnotation(private val wrapped: AnnotationDescriptor) {
+class CirAnnotation(original: AnnotationDescriptor) {
-    val fqName: FqName get() = wrapped.fqName ?: error("Annotation with no FQ name: ${wrapped::class.java}, $wrapped")
+    val fqName: FqName = original.fqName ?: error("Annotation with no FQ name: ${original::class.java}, $original")
-    val allValueArguments: Map<Name, ConstantValue<*>> get() = wrapped.allValueArguments
+    val allValueArguments: Map<Name, ConstantValue<*>> = original.allValueArguments
+
+    init {
+        allValueArguments.forEach { (name, constantValue) ->
+            checkSupportedInCommonization(constantValue) { "${original::class.java}, $original[$name]" }
+        }
+    }
+}
+
+internal fun checkSupportedInCommonization(constantValue: ConstantValue<*>, location: () -> String) {
+    @Suppress("TrailingComma")
+    return when (constantValue) {
+        is StringValue,
+        is IntegerValueConstant<*>,
+        is UnsignedValueConstant<*>,
+        is BooleanValue,
+        is NullValue,
+        is DoubleValue,
+        is FloatValue,
+        is EnumValue -> {
+            // OK
+        }
+        is ArrayValue -> {
+            constantValue.value.forEachIndexed { index, innerConstantValue ->
+                checkSupportedInCommonization(innerConstantValue) { "${location()}[$index]" }
+            }
+        }
+        else -> error("Unsupported const value type: ${constantValue::class.java}, $constantValue at ${location()}")
+    }
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirClass.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import kotlin.LazyThreadSafetyMode.PUBLICATION
 
 interface CirClass : CirAnnotatedDeclaration, CirNamedDeclaration, CirDeclarationWithTypeParameters, CirDeclarationWithVisibility, CirDeclarationWithModality {
     val companion: FqName? // null means no companion object
@@ -62,39 +61,37 @@ data class CirCommonClassConstructor(
     override val containingClassIsData get() = unsupported()
 }
 
-class CirWrappedClass(private val wrapped: ClassDescriptor) : CirClass {
+class CirClassImpl(original: ClassDescriptor) : CirClass {
-    override val annotations by lazy(PUBLICATION) { wrapped.annotations.map(::CirAnnotation) }
+    override val annotations = original.annotations.map(::CirAnnotation)
-    override val name get() = wrapped.name
+    override val name = original.name
-    override val typeParameters by lazy(PUBLICATION) { wrapped.declaredTypeParameters.map(::CirWrappedTypeParameter) }
+    override val typeParameters = original.declaredTypeParameters.map(::CirTypeParameterImpl)
-    override val companion by lazy(PUBLICATION) { wrapped.companionObjectDescriptor?.fqNameSafe }
+    override val companion = original.companionObjectDescriptor?.fqNameSafe
-    override val kind get() = wrapped.kind
+    override val kind = original.kind
-    override val modality get() = wrapped.modality
+    override val modality = original.modality
-    override val visibility get() = wrapped.visibility
+    override val visibility = original.visibility
-    override val isCompanion get() = wrapped.isCompanionObject
+    override val isCompanion = original.isCompanionObject
-    override val isData get() = wrapped.isData
+    override val isData = original.isData
-    override val isInline get() = wrapped.isInline
+    override val isInline = original.isInline
-    override val isInner get() = wrapped.isInner
+    override val isInner = original.isInner
-    override val isExternal get() = wrapped.isExternal
+    override val isExternal = original.isExternal
-    override val supertypes by lazy(PUBLICATION) { wrapped.typeConstructor.supertypes.map(CirType.Companion::create) }
+    override val supertypes = original.typeConstructor.supertypes.map(CirType.Companion::create)
 }
 
-class CirWrappedClassConstructor(private val wrapped: ClassConstructorDescriptor) : CirClassConstructor {
+class CirClassConstructorImpl(original: ClassConstructorDescriptor) : CirClassConstructor {
-    override val isPrimary get() = wrapped.isPrimary
+    override val isPrimary = original.isPrimary
-    override val kind get() = wrapped.kind
+    override val kind = original.kind
-    override val containingClassKind get() = wrapped.containingDeclaration.kind
+    override val containingClassKind = original.containingDeclaration.kind
-    override val containingClassModality get() = wrapped.containingDeclaration.modality
+    override val containingClassModality = original.containingDeclaration.modality
-    override val containingClassIsData get() = wrapped.containingDeclaration.isData
+    override val containingClassIsData = original.containingDeclaration.isData
-    override val annotations by lazy(PUBLICATION) { wrapped.annotations.map(::CirAnnotation) }
+    override val annotations = original.annotations.map(::CirAnnotation)
-    override val visibility get() = wrapped.visibility
+    override val visibility = original.visibility
-    override val typeParameters by lazy(PUBLICATION) {
+    override val typeParameters = original.typeParameters.mapNotNull { typeParameter ->
-        wrapped.typeParameters.mapNotNull { typeParameter ->
+        // save only type parameters that are contributed by the constructor itself
-            // save only type parameters that are contributed by the constructor itself
+        typeParameter.takeIf { it.containingDeclaration == original }?.let(::CirTypeParameterImpl)
-            typeParameter.takeIf { it.containingDeclaration == wrapped }?.let(::CirWrappedTypeParameter)
-        }
     }
-    override val valueParameters by lazy(PUBLICATION) { wrapped.valueParameters.map(::CirWrappedValueParameter) }
+    override val valueParameters = original.valueParameters.map(::CirValueParameterImpl)
-    override val hasStableParameterNames get() = wrapped.hasStableParameterNames()
+    override val hasStableParameterNames = original.hasStableParameterNames()
-    override val hasSynthesizedParameterNames get() = wrapped.hasSynthesizedParameterNames()
+    override val hasSynthesizedParameterNames = original.hasSynthesizedParameterNames()
 }
 
 object CirClassRecursionMarker : CirClass, CirRecursionMarker {

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirFunction.kt

@@ -6,9 +6,7 @@
 package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.Name
-import kotlin.LazyThreadSafetyMode.PUBLICATION
 
 interface CirFunctionModifiers {
     val isOperator: Boolean
@@ -41,20 +39,20 @@ data class CirCommonFunction(
     override val hasSynthesizedParameterNames: Boolean
 ) : CirCommonFunctionOrProperty(), CirFunction, CirFunctionModifiers by modifiers
 
-class CirWrappedFunction(wrapped: SimpleFunctionDescriptor) : CirWrappedFunctionOrProperty<SimpleFunctionDescriptor>(wrapped), CirFunction {
+class CirFunctionImpl(original: SimpleFunctionDescriptor) : CirFunctionOrPropertyImpl<SimpleFunctionDescriptor>(original), CirFunction {
-    override val isOperator get() = wrapped.isOperator
+    override val isOperator = original.isOperator
-    override val isInfix get() = wrapped.isInfix
+    override val isInfix = original.isInfix
-    override val isInline get() = wrapped.isInline
+    override val isInline = original.isInline
-    override val isTailrec get() = wrapped.isTailrec
+    override val isTailrec = original.isTailrec
-    override val isSuspend get() = wrapped.isSuspend
+    override val isSuspend = original.isSuspend
-    override val valueParameters by lazy(PUBLICATION) { wrapped.valueParameters.map(::CirWrappedValueParameter) }
+    override val valueParameters = original.valueParameters.map(::CirValueParameterImpl)
-    override val hasStableParameterNames get() = wrapped.hasStableParameterNames()
+    override val hasStableParameterNames = original.hasStableParameterNames()
-    override val hasSynthesizedParameterNames get() = wrapped.hasSynthesizedParameterNames()
+    override val hasSynthesizedParameterNames = original.hasSynthesizedParameterNames()
 }
 
 interface CirValueParameter {
     val name: Name
-    val annotations: Annotations
+    val annotations: List<CirAnnotation>
     val returnType: CirType
     val varargElementType: CirType?
     val declaresDefaultValue: Boolean
@@ -69,16 +67,16 @@ data class CirCommonValueParameter(
     override val isCrossinline: Boolean,
     override val isNoinline: Boolean
 ) : CirValueParameter {
-    override val annotations get() = Annotations.EMPTY
+    override val annotations: List<CirAnnotation> get() = emptyList()
     override val declaresDefaultValue get() = false
 }
 
-data class CirWrappedValueParameter(private val wrapped: ValueParameterDescriptor) : CirValueParameter {
+class CirValueParameterImpl(original: ValueParameterDescriptor) : CirValueParameter {
-    override val name get() = wrapped.name
+    override val name = original.name
-    override val annotations get() = wrapped.annotations
+    override val annotations = original.annotations.map(::CirAnnotation)
-    override val returnType by lazy(PUBLICATION) { CirType.create(wrapped.returnType!!) }
+    override val returnType = CirType.create(original.returnType!!)
-    override val varargElementType by lazy(PUBLICATION) { wrapped.varargElementType?.let(CirType.Companion::create) }
+    override val varargElementType = original.varargElementType?.let(CirType.Companion::create)
-    override val declaresDefaultValue get() = wrapped.declaresDefaultValue()
+    override val declaresDefaultValue = original.declaresDefaultValue()
-    override val isCrossinline get() = wrapped.isCrossinline
+    override val isCrossinline = original.isCrossinline
-    override val isNoinline get() = wrapped.isNoinline
+    override val isNoinline = original.isNoinline
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirFunctionOrProperty.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirExtensionReceiver.Companion.toReceiver
-import kotlin.LazyThreadSafetyMode.PUBLICATION
 
 interface CirFunctionOrProperty : CirAnnotatedDeclaration, CirNamedDeclaration, CirDeclarationWithTypeParameters, CirDeclarationWithVisibility, CirDeclarationWithModality, CirMaybeCallableMemberOfClass {
     val isExternal: Boolean
@@ -23,20 +22,26 @@ abstract class CirCommonFunctionOrProperty : CirFunctionOrProperty {
     final override val containingClassIsData: Boolean? get() = unsupported()
 }
 
-abstract class CirWrappedFunctionOrProperty<T : CallableMemberDescriptor>(protected val wrapped: T) : CirFunctionOrProperty {
+abstract class CirFunctionOrPropertyImpl<T : CallableMemberDescriptor>(original: T) : CirFunctionOrProperty {
-    final override val annotations by lazy(PUBLICATION) { wrapped.annotations.map(::CirAnnotation) }
+    final override val annotations = original.annotations.map(::CirAnnotation)
-    final override val name get() = wrapped.name
+    final override val name = original.name
-    final override val modality get() = wrapped.modality
+    final override val modality = original.modality
-    final override val visibility get() = wrapped.visibility
+    final override val visibility = original.visibility
-    final override val isExternal get() = wrapped.isExternal
+    final override val isExternal = original.isExternal
-    final override val extensionReceiver by lazy(PUBLICATION) { wrapped.extensionReceiverParameter?.toReceiver() }
+    final override val extensionReceiver = original.extensionReceiverParameter?.toReceiver()
-    final override val returnType by lazy(PUBLICATION) { CirType.create(wrapped.returnType!!) }
+    final override val returnType = CirType.create(original.returnType!!)
-    final override val kind get() = wrapped.kind
+    final override val kind = original.kind
-    final override val containingClassKind: ClassKind? get() = containingClass?.kind
+    final override val containingClassKind: ClassKind?
-    final override val containingClassModality: Modality? get() = containingClass?.modality
+    final override val containingClassModality: Modality?
-    final override val containingClassIsData: Boolean? get() = containingClass?.isData
+    final override val containingClassIsData: Boolean?
-    final override val typeParameters by lazy(PUBLICATION) { wrapped.typeParameters.map(::CirWrappedTypeParameter) }
+    final override val typeParameters = original.typeParameters.map(::CirTypeParameterImpl)
-    private val containingClass: ClassDescriptor? get() = wrapped.containingDeclaration as? ClassDescriptor
+
+    init {
+        val containingClass = original.containingDeclaration as? ClassDescriptor
+        containingClassKind = containingClass?.kind
+        containingClassModality = containingClass?.modality
+        containingClassIsData = containingClass?.isData
+    }
 }
 
 data class CirExtensionReceiver(

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirModule.kt

@@ -10,5 +10,5 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.name.Name
 
 data class CirModule(val name: Name, val builtIns: KotlinBuiltIns) : CirDeclaration {
-    constructor(descriptor: ModuleDescriptor) : this(descriptor.name, descriptor.builtIns)
+    constructor(descriptor: ModuleDescriptor) : this(descriptor.name, descriptor.builtIns) // TODO: strong ref
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirProperty.kt

@@ -6,12 +6,10 @@
 package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirGetter.Companion.toGetter
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirSetter.Companion.toSetter
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
-import kotlin.LazyThreadSafetyMode.PUBLICATION
 
 interface CirProperty : CirFunctionOrProperty {
     val isVar: Boolean
@@ -20,8 +18,8 @@ interface CirProperty : CirFunctionOrProperty {
     val isDelegate: Boolean
     val getter: CirGetter?
     val setter: CirSetter?
-    val backingFieldAnnotations: Annotations? // null assumes no backing field
+    val backingFieldAnnotations: List<CirAnnotation>? // null assumes no backing field
-    val delegateFieldAnnotations: Annotations? // null assumes no backing field
+    val delegateFieldAnnotations: List<CirAnnotation>? // null assumes no backing field
     val compileTimeInitializer: ConstantValue<*>?
 }
 
@@ -41,50 +39,56 @@ data class CirCommonProperty(
     override val isConst get() = false
     override val isDelegate get() = false
     override val getter get() = CirGetter.DEFAULT_NO_ANNOTATIONS
-    override val backingFieldAnnotations: Annotations? get() = null
+    override val backingFieldAnnotations: List<CirAnnotation>? get() = null
-    override val delegateFieldAnnotations: Annotations? get() = null
+    override val delegateFieldAnnotations: List<CirAnnotation>? get() = null
     override val compileTimeInitializer: ConstantValue<*>? get() = null
 }
 
-class CirWrappedProperty(wrapped: PropertyDescriptor) : CirWrappedFunctionOrProperty<PropertyDescriptor>(wrapped), CirProperty {
+class CirPropertyImpl(original: PropertyDescriptor) : CirFunctionOrPropertyImpl<PropertyDescriptor>(original), CirProperty {
-    override val isVar get() = wrapped.isVar
+    override val isVar = original.isVar
-    override val isLateInit get() = wrapped.isLateInit
+    override val isLateInit = original.isLateInit
-    override val isConst get() = wrapped.isConst
+    override val isConst = original.isConst
-    override val isDelegate get() = @Suppress("DEPRECATION") wrapped.isDelegated
+    override val isDelegate = @Suppress("DEPRECATION") original.isDelegated
-    override val getter by lazy(PUBLICATION) { wrapped.getter?.toGetter() }
+    override val getter = original.getter?.toGetter()
-    override val setter by lazy(PUBLICATION) { wrapped.setter?.toSetter() }
+    override val setter = original.setter?.toSetter()
-    override val backingFieldAnnotations get() = wrapped.backingField?.annotations
+    override val backingFieldAnnotations = original.backingField?.annotations?.map(::CirAnnotation)
-    override val delegateFieldAnnotations get() = wrapped.delegateField?.annotations
+    override val delegateFieldAnnotations = original.delegateField?.annotations?.map(::CirAnnotation)
-    override val compileTimeInitializer get() = wrapped.compileTimeInitializer
+    override val compileTimeInitializer = original.compileTimeInitializer
+
+    init {
+        compileTimeInitializer?.let { compileTimeInitializer ->
+            checkSupportedInCommonization(compileTimeInitializer) { "${original::class.java}, $original" }
+        }
+    }
 }
 
 interface CirPropertyAccessor {
-    val annotations: Annotations
+    val annotations: List<CirAnnotation>
     val isDefault: Boolean
     val isExternal: Boolean
     val isInline: Boolean
 }
 
 data class CirGetter(
-    override val annotations: Annotations,
+    override val annotations: List<CirAnnotation>,
     override val isDefault: Boolean,
     override val isExternal: Boolean,
     override val isInline: Boolean
 ) : CirPropertyAccessor {
     companion object {
-        val DEFAULT_NO_ANNOTATIONS = CirGetter(Annotations.EMPTY, isDefault = true, isExternal = false, isInline = false)
+        val DEFAULT_NO_ANNOTATIONS = CirGetter(emptyList(), isDefault = true, isExternal = false, isInline = false)
 
         fun PropertyGetterDescriptor.toGetter() =
             if (isDefault && annotations.isEmpty())
                 DEFAULT_NO_ANNOTATIONS
             else
-                CirGetter(annotations, isDefault, isExternal, isInline)
+                CirGetter(annotations.map(::CirAnnotation), isDefault, isExternal, isInline)
     }
 }
 
 data class CirSetter(
-    override val annotations: Annotations,
+    override val annotations: List<CirAnnotation>,
-    val parameterAnnotations: Annotations,
+    val parameterAnnotations: List<CirAnnotation>,
     override val visibility: Visibility,
     override val isDefault: Boolean,
     override val isExternal: Boolean,
@@ -92,8 +96,8 @@ data class CirSetter(
 ) : CirPropertyAccessor, CirDeclarationWithVisibility {
     companion object {
         fun createDefaultNoAnnotations(visibility: Visibility) = CirSetter(
-            Annotations.EMPTY,
+            emptyList(),
-            Annotations.EMPTY,
+            emptyList(),
             visibility,
             isDefault = visibility == Visibilities.PUBLIC,
             isExternal = false,
@@ -101,8 +105,8 @@ data class CirSetter(
         )
 
         fun PropertySetterDescriptor.toSetter() = CirSetter(
-            annotations,
+            annotations.map(::CirAnnotation),
-            valueParameters.single().annotations,
+            valueParameters.single().annotations.map(::CirAnnotation),
             visibility,
             isDefault,
             isExternal,

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirType.kt

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.descriptors.commonizer.utils.fqName
 import org.jetbrains.kotlin.descriptors.commonizer.utils.fqNameWithTypeParameters
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.types.*
-import kotlin.LazyThreadSafetyMode.PUBLICATION
 
 sealed class CirType {
     companion object {
@@ -36,25 +35,35 @@ sealed class CirType {
  * 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.
  *
- * There is no difference between [abbreviation] and [expanded] for types representing classes and type parameters.
+ * There is no difference between "abbreviation" and "expanded" for types representing classes and type parameters.
  */
-class CirSimpleType(private val wrapped: SimpleType) : CirType() {
+class CirSimpleType(original: SimpleType) : CirType() {
-    val annotations by lazy(PUBLICATION) { abbreviation.annotations.map(::CirAnnotation) }
+    val annotations: List<CirAnnotation>
-    val kind = CirSimpleTypeKind.determineKind(abbreviation.declarationDescriptor)
+    val kind: CirSimpleTypeKind
-    val fqName by lazy(PUBLICATION) { abbreviation.fqName }
+    val fqName: FqName
-    val arguments by lazy(PUBLICATION) { abbreviation.arguments.map(::CirTypeProjection) }
+    val arguments: List<CirTypeProjection>
-    val isMarkedNullable get() = abbreviation.isMarkedNullable
+    val isMarkedNullable: Boolean
-    val isDefinitelyNotNullType get() = abbreviation.isDefinitelyNotNullType
+    val isDefinitelyNotNullType: Boolean
-    val expandedTypeConstructorId by lazy(PUBLICATION) { CirTypeConstructorId(expanded) }
+    val expandedTypeConstructorId: CirTypeConstructorId
+
+    init {
+        val abbreviation = (original as? AbbreviatedType)?.abbreviation ?: original
+        val expanded = (original as? AbbreviatedType)?.expandedType ?: original
+
+        annotations = abbreviation.annotations.map(::CirAnnotation)
+        kind = CirSimpleTypeKind.determineKind(abbreviation.declarationDescriptor)
+        fqName = abbreviation.fqName
+        arguments = abbreviation.arguments.map(::CirTypeProjection)
+        isMarkedNullable = abbreviation.isMarkedNullable
+        isDefinitelyNotNullType = abbreviation.isDefinitelyNotNullType
+        expandedTypeConstructorId = CirTypeConstructorId(expanded)
+    }
 
     inline val isClassOrTypeAlias get() = (kind == CLASS || kind == TYPE_ALIAS)
-    val fqNameWithTypeParameters by lazy(PUBLICATION) { wrapped.fqNameWithTypeParameters }
+    val fqNameWithTypeParameters = original.fqNameWithTypeParameters
 
-    override fun equals(other: Any?) = wrapped == (other as? CirSimpleType)?.wrapped
+    override fun equals(other: Any?) = fqNameWithTypeParameters == (other as? CirSimpleType)?.fqNameWithTypeParameters
-    override fun hashCode() = wrapped.hashCode()
+    override fun hashCode() = fqNameWithTypeParameters.hashCode()
-
-    private inline val abbreviation: SimpleType get() = (wrapped as? AbbreviatedType)?.abbreviation ?: wrapped
-    private inline val expanded: SimpleType get() = (wrapped as? AbbreviatedType)?.expandedType ?: wrapped
 }
 
 enum class CirSimpleTypeKind {
@@ -79,10 +88,10 @@ data class CirTypeConstructorId(val fqName: FqName, val numberOfTypeParameters:
     constructor(type: SimpleType) : this(type.fqName, type.constructor.parameters.size)
 }
 
-class CirTypeProjection(private val wrapped: TypeProjection) {
+class CirTypeProjection(original: TypeProjection) {
-    val projectionKind get() = wrapped.projectionKind
+    val projectionKind = original.projectionKind
-    val isStarProjection get() = wrapped.isStarProjection
+    val isStarProjection = original.isStarProjection
-    val type by lazy(PUBLICATION) { CirType.create(wrapped.type) }
+    val type = CirType.create(original.type)
 }
 
 data class CirFlexibleType(val lowerBound: CirSimpleType, val upperBound: CirSimpleType) : CirType()

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirTypeAlias.kt

@@ -6,18 +6,17 @@
 package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
-import kotlin.LazyThreadSafetyMode.PUBLICATION
 
 interface CirTypeAlias : CirAnnotatedDeclaration, CirNamedDeclaration, CirDeclarationWithTypeParameters, CirDeclarationWithVisibility {
     val underlyingType: CirSimpleType
     val expandedType: CirSimpleType
 }
 
-class CirWrappedTypeAlias(private val wrapped: TypeAliasDescriptor) : CirTypeAlias {
+class CirTypeAliasImpl(original: TypeAliasDescriptor) : CirTypeAlias {
-    override val annotations by lazy(PUBLICATION) { wrapped.annotations.map(::CirAnnotation) }
+    override val annotations = original.annotations.map(::CirAnnotation)
-    override val name get() = wrapped.name
+    override val name = original.name
-    override val typeParameters by lazy(PUBLICATION) { wrapped.declaredTypeParameters.map(::CirWrappedTypeParameter) }
+    override val typeParameters = original.declaredTypeParameters.map(::CirTypeParameterImpl)
-    override val visibility get() = wrapped.visibility
+    override val visibility = original.visibility
-    override val underlyingType by lazy(PUBLICATION) { CirSimpleType(wrapped.underlyingType) }
+    override val underlyingType = CirSimpleType(original.underlyingType)
-    override val expandedType by lazy(PUBLICATION) { CirSimpleType(wrapped.expandedType) }
+    override val expandedType = CirSimpleType(original.expandedType)
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/ir/CirTypeParameter.kt

@@ -6,13 +6,11 @@
 package org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir
 
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
-import kotlin.LazyThreadSafetyMode.PUBLICATION
 
 interface CirTypeParameter {
-    val annotations: Annotations
+    val annotations: List<CirAnnotation>
     val name: Name
     val isReified: Boolean
     val variance: Variance
@@ -25,13 +23,13 @@ data class CirCommonTypeParameter(
     override val variance: Variance,
     override val upperBounds: List<CirType>
 ) : CirTypeParameter {
-    override val annotations get() = Annotations.EMPTY
+    override val annotations: List<CirAnnotation> get() = emptyList()
 }
 
-data class CirWrappedTypeParameter(private val wrapped: TypeParameterDescriptor) : CirTypeParameter {
+class CirTypeParameterImpl(original: TypeParameterDescriptor) : CirTypeParameter {
-    override val annotations get() = wrapped.annotations
+    override val annotations = original.annotations.map(::CirAnnotation)
-    override val name get() = wrapped.name
+    override val name = original.name
-    override val isReified get() = wrapped.isReified
+    override val isReified = original.isReified
-    override val variance get() = wrapped.variance
+    override val variance = original.variance
-    override val upperBounds by lazy(PUBLICATION) { wrapped.upperBounds.map(CirType.Companion::create) }
+    override val upperBounds = original.upperBounds.map(CirType.Companion::create)
 }

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

@@ -66,7 +66,7 @@ internal fun buildPropertyNode(
 ): CirPropertyNode = buildNode(
     storageManager = storageManager,
     descriptors = properties,
-    targetDeclarationProducer = ::CirWrappedProperty,
+    targetDeclarationProducer = ::CirPropertyImpl,
     commonValueProducer = { commonize(containingDeclarationCommon, it, PropertyCommonizer(cache)) },
     recursionMarker = null,
     nodeProducer = ::CirPropertyNode
@@ -80,7 +80,7 @@ internal fun buildFunctionNode(
 ): CirFunctionNode = buildNode(
     storageManager = storageManager,
     descriptors = functions,
-    targetDeclarationProducer = ::CirWrappedFunction,
+    targetDeclarationProducer = ::CirFunctionImpl,
     commonValueProducer = { commonize(containingDeclarationCommon, it, FunctionCommonizer(cache)) },
     recursionMarker = null,
     nodeProducer = ::CirFunctionNode
@@ -94,7 +94,7 @@ internal fun buildClassNode(
 ): CirClassNode = buildNode(
     storageManager = storageManager,
     descriptors = classes,
-    targetDeclarationProducer = ::CirWrappedClass,
+    targetDeclarationProducer = ::CirClassImpl,
     commonValueProducer = { commonize(containingDeclarationCommon, it, ClassCommonizer(cacheRW)) },
     recursionMarker = CirClassRecursionMarker,
     nodeProducer = ::CirClassNode
@@ -113,7 +113,7 @@ internal fun buildClassConstructorNode(
 ): CirClassConstructorNode = buildNode(
     storageManager = storageManager,
     descriptors = constructors,
-    targetDeclarationProducer = ::CirWrappedClassConstructor,
+    targetDeclarationProducer = ::CirClassConstructorImpl,
     commonValueProducer = { commonize(containingDeclarationCommon, it, ClassConstructorCommonizer(cache)) },
     recursionMarker = null,
     nodeProducer = ::CirClassConstructorNode
@@ -126,7 +126,7 @@ internal fun buildTypeAliasNode(
 ): CirTypeAliasNode = buildNode(
     storageManager = storageManager,
     descriptors = typeAliases,
-    targetDeclarationProducer = ::CirWrappedTypeAlias,
+    targetDeclarationProducer = ::CirTypeAliasImpl,
     commonValueProducer = { commonize(it, TypeAliasCommonizer(cacheRW)) },
     recursionMarker = CirClassRecursionMarker,
     nodeProducer = ::CirTypeAliasNode

native/commonizer/testData/generalCommonization/annotations/commonized/common/package_root.kt

@@ -1,8 +1,8 @@
 expect annotation class CommonAnnotationForAnnotationClassesOnly(text: String) { val text: String }
 expect annotation class CommonAnnotation(text: String) { val text: String }
 
-expect annotation class CommonOuterAnnotation(inner: CommonInnerAnnotation) { val inner: CommonInnerAnnotation }
+//expect annotation class CommonOuterAnnotation(inner: CommonInnerAnnotation) { val inner: CommonInnerAnnotation }
-expect annotation class CommonInnerAnnotation(text: String) { val text: String }
+//expect annotation class CommonInnerAnnotation(text: String) { val text: String }
 
 expect var propertyWithoutBackingField: Double
 expect val propertyWithBackingField: Double
@@ -15,4 +15,4 @@ expect fun <Q : Number> Q.function2(): Q
 expect class AnnotatedClass(value: String) { val value: String }
 expect class AnnotatedTypeAlias
 
-expect object ObjectWithNestedAnnotations
+//expect object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/commonized/js/package_root.kt

@@ -16,13 +16,13 @@ annotation class JsAnnotationForAnnotationClassesOnly(val text: String)
 @CommonAnnotationForAnnotationClassesOnly("annotation-class")
 annotation class JsAnnotation(val text: String)
 
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-actual annotation class CommonOuterAnnotation(actual val inner: CommonInnerAnnotation)
+//actual annotation class CommonOuterAnnotation(actual val inner: CommonInnerAnnotation)
-actual annotation class CommonInnerAnnotation(actual val text: String)
+//actual annotation class CommonInnerAnnotation(actual val text: String)
 
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-annotation class JsOuterAnnotation(val inner: JsInnerAnnotation)
+//annotation class JsOuterAnnotation(val inner: JsInnerAnnotation)
-annotation class JsInnerAnnotation(val text: String)
+//annotation class JsInnerAnnotation(val text: String)
 
 @JsAnnotation("property")
 @CommonAnnotation("property")
@@ -57,6 +57,6 @@ actual class AnnotatedClass @JsAnnotation("constructor") @CommonAnnotation("cons
 @CommonAnnotation("type-alias")
 actual typealias AnnotatedTypeAlias = AnnotatedClass
 
-@JsOuterAnnotation(inner = JsInnerAnnotation("nested-annotations"))
+//@JsOuterAnnotation(inner = JsInnerAnnotation("nested-annotations"))
-@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+//@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
-actual object ObjectWithNestedAnnotations
+//actual object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/commonized/jvm/package_root.kt

@@ -16,13 +16,13 @@ annotation class JvmAnnotationForAnnotationClassesOnly(val text: String)
 @CommonAnnotationForAnnotationClassesOnly("annotation-class")
 annotation class JvmAnnotation(val text: String)
 
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-actual annotation class CommonOuterAnnotation(actual val inner: CommonInnerAnnotation)
+//actual annotation class CommonOuterAnnotation(actual val inner: CommonInnerAnnotation)
-actual annotation class CommonInnerAnnotation(actual val text: String)
+//actual annotation class CommonInnerAnnotation(actual val text: String)
-
+//
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-annotation class JvmOuterAnnotation(val inner: JvmInnerAnnotation)
+//annotation class JvmOuterAnnotation(val inner: JvmInnerAnnotation)
-annotation class JvmInnerAnnotation(val text: String)
+//annotation class JvmInnerAnnotation(val text: String)
 
 @JvmAnnotation("property")
 @CommonAnnotation("property")
@@ -57,6 +57,6 @@ actual class AnnotatedClass @JvmAnnotation("constructor") @CommonAnnotation("con
 @CommonAnnotation("type-alias")
 actual typealias AnnotatedTypeAlias = AnnotatedClass
 
-@JvmOuterAnnotation(inner = JvmInnerAnnotation("nested-annotations"))
+//@JvmOuterAnnotation(inner = JvmInnerAnnotation("nested-annotations"))
-@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+//@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
-actual object ObjectWithNestedAnnotations
+//actual object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/original/js/package_root.kt

@@ -16,13 +16,13 @@ annotation class JsAnnotationForAnnotationClassesOnly(val text: String)
 @CommonAnnotationForAnnotationClassesOnly("annotation-class")
 annotation class JsAnnotation(val text: String)
 
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-annotation class CommonOuterAnnotation(val inner: CommonInnerAnnotation)
+//annotation class CommonOuterAnnotation(val inner: CommonInnerAnnotation)
-annotation class CommonInnerAnnotation(val text: String)
+//annotation class CommonInnerAnnotation(val text: String)
-
+//
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-annotation class JsOuterAnnotation(val inner: JsInnerAnnotation)
+//annotation class JsOuterAnnotation(val inner: JsInnerAnnotation)
-annotation class JsInnerAnnotation(val text: String)
+//annotation class JsInnerAnnotation(val text: String)
 
 @JsAnnotation("property")
 @CommonAnnotation("property")
@@ -57,6 +57,6 @@ class AnnotatedClass @JsAnnotation("constructor") @CommonAnnotation("constructor
 @CommonAnnotation("type-alias")
 typealias AnnotatedTypeAlias = AnnotatedClass
 
-@JsOuterAnnotation(inner = JsInnerAnnotation("nested-annotations"))
+//@JsOuterAnnotation(inner = JsInnerAnnotation("nested-annotations"))
-@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+//@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
-object ObjectWithNestedAnnotations
+//object ObjectWithNestedAnnotations

native/commonizer/testData/generalCommonization/annotations/original/jvm/package_root.kt

@@ -16,13 +16,13 @@ annotation class JvmAnnotationForAnnotationClassesOnly(val text: String)
 @CommonAnnotationForAnnotationClassesOnly("annotation-class")
 annotation class JvmAnnotation(val text: String)
 
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-annotation class CommonOuterAnnotation(val inner: CommonInnerAnnotation)
+//annotation class CommonOuterAnnotation(val inner: CommonInnerAnnotation)
-annotation class CommonInnerAnnotation(val text: String)
+//annotation class CommonInnerAnnotation(val text: String)
-
+//
-@Target(AnnotationTarget.CLASS)
+//@Target(AnnotationTarget.CLASS)
-annotation class JvmOuterAnnotation(val inner: JvmInnerAnnotation)
+//annotation class JvmOuterAnnotation(val inner: JvmInnerAnnotation)
-annotation class JvmInnerAnnotation(val text: String)
+//annotation class JvmInnerAnnotation(val text: String)
 
 @JvmAnnotation("property")
 @CommonAnnotation("property")
@@ -57,6 +57,6 @@ class AnnotatedClass @JvmAnnotation("constructor") @CommonAnnotation("constructo
 @CommonAnnotation("type-alias")
 typealias AnnotatedTypeAlias = AnnotatedClass
 
-@JvmOuterAnnotation(inner = JvmInnerAnnotation("nested-annotations"))
+//@JvmOuterAnnotation(inner = JvmInnerAnnotation("nested-annotations"))
-@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
+//@CommonOuterAnnotation(inner = CommonInnerAnnotation("nested-annotations"))
-object ObjectWithNestedAnnotations
+//object ObjectWithNestedAnnotations

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

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.descriptors.commonizer.core
 
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.commonizer.utils.EMPTY_CLASSIFIERS_CACHE
 import org.jetbrains.kotlin.descriptors.commonizer.core.CirTestValueParameter.Companion.areEqual
+import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirAnnotation
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirClassifiersCache
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirType
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ir.CirValueParameter
@@ -157,7 +157,7 @@ class DefaultValueParameterCommonizerTest : AbstractCommonizerTest<CirValueParam
 
             return CirTestValueParameter(
                 name = Name.identifier(name),
-                annotations = Annotations.EMPTY,
+                annotations = emptyList(),
                 returnType = returnType,
                 varargElementType = returnType.takeIf { hasVarargElementType }, // the vararg type itself does not matter here, only it's presence matters
                 isCrossinline = isCrossinline,
@@ -170,7 +170,7 @@ class DefaultValueParameterCommonizerTest : AbstractCommonizerTest<CirValueParam
 
 internal data class CirTestValueParameter(
     override val name: Name,
-    override val annotations: Annotations,
+    override val annotations: List<CirAnnotation>,
     override val returnType: CirType,
     override val varargElementType: CirType?,
     override val declaresDefaultValue: Boolean,