diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/AbstractSerialGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/AbstractSerialGenerator.kt
index b9fab87..ea5ee96 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/AbstractSerialGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/AbstractSerialGenerator.kt
@@ -5,19 +5,9 @@
 
 package org.jetbrains.kotlinx.serialization.compiler.backend.common
 
-import org.jetbrains.kotlin.backend.jvm.ir.fileParent
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.expressions.IrClassReference
-import org.jetbrains.kotlin.ir.expressions.IrVararg
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.types.IrSimpleType
-import org.jetbrains.kotlin.ir.types.classOrNull
-import org.jetbrains.kotlin.ir.types.isNullable
-import org.jetbrains.kotlin.ir.types.typeOrNull
-import org.jetbrains.kotlin.ir.util.findAnnotation
 import org.jetbrains.kotlin.js.translate.utils.AnnotationsUtils
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -31,46 +21,15 @@
 import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations
 import org.jetbrains.kotlinx.serialization.compiler.resolve.isKSerializer
 import org.jetbrains.kotlinx.serialization.compiler.resolve.toClassDescriptor
-abstract class AbstractIrGenerator(private val currentClass: IrClass) {
-    private fun getClassListFromFileAnnotation(annotationFqName: FqName): List<IrClassSymbol> {
-        val annotation = currentClass.fileParent.annotations.findAnnotation(annotationFqName) ?: return emptyList()
-        val vararg = annotation.getValueArgument(0) as? IrVararg ?: return emptyList()
-        return vararg.elements
-            .mapNotNull { (it as? IrClassReference)?.symbol as? IrClassSymbol}
-    }
-
-    val contextualKClassListInCurrentFile: Set<IrClassSymbol> by lazy {
-        getClassListFromFileAnnotation(
-            SerializationAnnotations.contextualFqName,
-        ).plus(
-            getClassListFromFileAnnotation(
-                SerializationAnnotations.contextualOnFileFqName,
-            )
-        ).toSet()
-    }
-
-    val additionalSerializersInScopeOfCurrentFile: Map<Pair<IrClassSymbol, Boolean>, IrClassSymbol> by lazy {
-        getClassListFromFileAnnotation(SerializationAnnotations.additionalSerializersFqName,)
-            .associateBy(
-                { serializerSymbol ->
-                    val kotlinType = (serializerSymbol.owner.superTypes.find(::isKSerializer) as? IrSimpleType)?.arguments?.firstOrNull()?.typeOrNull
-                    val classSymbol = kotlinType?.classOrNull
-                        ?: throw AssertionError("Argument for ${SerializationAnnotations.additionalSerializersFqName} does not implement KSerializer or does not provide serializer for concrete type")
-                    classSymbol to kotlinType.isNullable()
-                },
-                { it }
-            )
-    }
-}
 
 abstract class AbstractSerialGenerator(val bindingContext: BindingContext?, val currentDeclaration: ClassDescriptor) {
-
     private fun getKClassListFromFileAnnotation(annotationFqName: FqName, declarationInFile: DeclarationDescriptor): List<KotlinType> {
-        if (bindingContext == null) return emptyList() // TODO: support @UseSerializers in FIR
+        if (bindingContext == null) return emptyList()
         val annotation = AnnotationsUtils
             .getContainingFileAnnotations(bindingContext, declarationInFile)
             .find { it.fqName == annotationFqName }
             ?: return emptyList()
+
         @Suppress("UNCHECKED_CAST")
         val typeList: List<KClassValue> = annotation.firstArgument()?.value as? List<KClassValue> ?: return emptyList()
         return typeList.map { it.getArgumentType(declarationInFile.module) }
@@ -102,5 +61,6 @@
     }
 
     protected fun ClassDescriptor.getFuncDesc(funcName: String): Sequence<FunctionDescriptor> =
-        unsubstitutedMemberScope.getDescriptorsFiltered { it == Name.identifier(funcName) }.asSequence().filterIsInstance<FunctionDescriptor>()
+        unsubstitutedMemberScope.getDescriptorsFiltered { it == Name.identifier(funcName) }.asSequence()
+            .filterIsInstance<FunctionDescriptor>()
 }
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCompanionCodegen.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCompanionCodegen.kt
index f0cf7c7..14fa565 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCompanionCodegen.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCompanionCodegen.kt
@@ -8,7 +8,6 @@
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlinx.serialization.compiler.resolve.*
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt
index 9de53f7..e10fb3e 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt
@@ -10,11 +10,6 @@
 import org.jetbrains.kotlin.codegen.CompilationException
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.ir.declarations.IrProperty
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.util.hasAnnotation
-import org.jetbrains.kotlin.ir.util.isTypeParameter
 import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName
 import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
 import org.jetbrains.kotlin.name.ClassId
@@ -26,32 +21,17 @@
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.typeUtil.*
 import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.enumSerializerId
 import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.referenceArraySerializerId
-import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
 import org.jetbrains.kotlinx.serialization.compiler.resolve.*
 import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationPackages.internalPackageFqName
 
-interface ISerialTypeInfo<C, D, T : KotlinTypeMarker, S : ISerializableProperty<D, T>> {
-    val property: S
-    val elementMethodPrefix: String
-    val serializer: C?
-}
-
 open class SerialTypeInfo(
-    override val property: SerializableProperty,
-    override val elementMethodPrefix: String,
-    override val serializer: ClassDescriptor? = null
-) : ISerialTypeInfo<ClassDescriptor, PropertyDescriptor, KotlinType, SerializableProperty>
-
-class IrSerialTypeInfo(
-    override val property: IrSerializableProperty,
-    override val elementMethodPrefix: String,
-    override val serializer: IrClassSymbol? = null
-) : ISerialTypeInfo<IrClassSymbol, IrProperty, IrSimpleType, IrSerializableProperty>
-
+    val property: SerializableProperty,
+    val elementMethodPrefix: String,
+    val serializer: ClassDescriptor? = null
+)
 
 fun AbstractSerialGenerator.findAddOnSerializer(propertyType: KotlinType, module: ModuleDescriptor): ClassDescriptor? {
     additionalSerializersInScopeOfCurrentFile[propertyType.toClassDescriptor to propertyType.isMarkedNullable]?.let { return it }
@@ -63,48 +43,9 @@
     return null
 }
 
-fun AbstractIrGenerator.findAddOnSerializer(propertyType: IrType, ctx: SerializationPluginContext): IrClassSymbol? {
-    val classSymbol = propertyType.classOrNull ?: return null
-    additionalSerializersInScopeOfCurrentFile[classSymbol to propertyType.isNullable()]?.let { return it }
-    if (classSymbol in contextualKClassListInCurrentFile)
-        return ctx.getClassFromRuntime(SpecialBuiltins.contextSerializer)
-    if (classSymbol.owner.annotations.hasAnnotation(SerializationAnnotations.polymorphicFqName))
-        return ctx.getClassFromRuntime(SpecialBuiltins.polymorphicSerializer)
-    if (propertyType.isNullable()) return findAddOnSerializer(propertyType.makeNotNull(), ctx)
-    return null
-}
-
-
 fun KotlinType.isGeneratedSerializableObject() =
     toClassDescriptor?.run { kind == ClassKind.OBJECT && hasSerializableOrMetaAnnotationWithoutArgs } == true
 
-fun AbstractIrGenerator.getIrSerialTypeInfo(property: IrSerializableProperty, ctx: SerializationPluginContext): IrSerialTypeInfo {
-    fun SerializableInfo(serializer: IrClassSymbol?) =
-        IrSerialTypeInfo(property, if (property.type.isNullable()) "Nullable" else "", serializer)
-
-    val T = property.type
-    property.serializableWith(ctx)?.let { return SerializableInfo(it) }
-    findAddOnSerializer(T, ctx)?.let { return SerializableInfo(it) }
-    T.overridenSerializer?.let { return SerializableInfo(it) }
-    return when {
-        T.isTypeParameter() -> IrSerialTypeInfo(property, if (property.type.isMarkedNullable()) "Nullable" else "", null)
-        T.isPrimitiveType() -> IrSerialTypeInfo(
-            property,
-            T.classFqName!!.asString().removePrefix("kotlin.")
-        )
-        T.isString() -> IrSerialTypeInfo(property, "String")
-        T.isArray() -> {
-            val serializer = property.serializableWith(ctx) ?: ctx.getClassFromInternalSerializationPackage(SpecialBuiltins.referenceArraySerializer)
-            SerializableInfo(serializer)
-        }
-        else -> {
-            val serializer =
-                findTypeSerializerOrContext(ctx, property.type)
-            SerializableInfo(serializer)
-        }
-    }
-}
-
 @Suppress("FunctionName", "LocalVariableName")
 fun AbstractSerialGenerator.getSerialTypeInfo(property: SerializableProperty): SerialTypeInfo {
     fun SerializableInfo(serializer: ClassDescriptor?) =
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtilIr.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtilIr.kt
deleted file mode 100644
index a10c7c0..0000000
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtilIr.kt
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * Copyright 2010-2022 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.kotlinx.serialization.compiler.backend.common
-
-import org.jetbrains.kotlin.backend.jvm.ir.getStringConstArgument
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.expressions.IrClassReference
-import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
-import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.util.*
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.*
-import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
-import org.jetbrains.kotlinx.serialization.compiler.fir.SerializationPluginKey
-import org.jetbrains.kotlinx.serialization.compiler.resolve.*
-
-fun AbstractIrGenerator.findTypeSerializerOrContextUnchecked(
-    context: SerializationPluginContext, kType: IrType
-): IrClassSymbol? {
-    val annotations = kType.annotations
-    if (kType.isTypeParameter()) return null
-    annotations.serializableWith()?.let { return it }
-    additionalSerializersInScopeOfCurrentFile[kType.classOrNull!! to kType.isNullable()]?.let {
-        return it
-    }
-    if (kType.isMarkedNullable()) return findTypeSerializerOrContextUnchecked(context, kType.makeNotNull())
-    if (kType.classOrNull in contextualKClassListInCurrentFile) return context.referenceClass(contextSerializerId)
-    return analyzeSpecialSerializers(context, annotations) ?: findTypeSerializer(context, kType)
-}
-
-fun analyzeSpecialSerializers(
-    context: SerializationPluginContext,
-    annotations: List<IrConstructorCall>
-): IrClassSymbol? = when {
-    annotations.hasAnnotation(SerializationAnnotations.contextualFqName) || annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyFqName) ->
-        context.referenceClass(contextSerializerId)
-    // can be annotation on type usage, e.g. List<@Polymorphic Any>
-    annotations.hasAnnotation(SerializationAnnotations.polymorphicFqName) ->
-        context.referenceClass(polymorphicSerializerId)
-    else -> null
-}
-
-fun AbstractIrGenerator.findTypeSerializerOrContext(
-    context: SerializationPluginContext, kType: IrType
-): IrClassSymbol? {
-    if (kType.isTypeParameter()) return null
-    return findTypeSerializerOrContextUnchecked(context, kType) ?: error("Serializer for element of type ${kType.render()} has not been found")
-}
-
-fun findTypeSerializer(context: SerializationPluginContext, type: IrType): IrClassSymbol? {
-    type.overridenSerializer?.let { return it }
-    if (type.isTypeParameter()) return null
-    if (type.isArray()) return context.referenceClass(referenceArraySerializerId)
-    if (type.isGeneratedSerializableObject()) return context.referenceClass(objectSerializerId)
-    val stdSer = findStandardKotlinTypeSerializer(context, type) // see if there is a standard serializer
-        ?: findEnumTypeSerializer(context, type)
-    if (stdSer != null) return stdSer
-    if (type.isInterface() && type.classOrNull?.owner?.isSealedSerializableInterface == false) return context.referenceClass(
-        polymorphicSerializerId
-    )
-    return type.classOrNull?.owner.classSerializer(context) // check for serializer defined on the type
-}
-
-internal fun IrClass?.classSerializer(context: SerializationPluginContext): IrClassSymbol? = this?.let {
-    // serializer annotation on class?
-    serializableWith?.let { return it }
-    // companion object serializer?
-    if (hasCompanionObjectAsSerializer) return companionObject()?.symbol
-    // can infer @Poly?
-    polymorphicSerializerIfApplicableAutomatically(context)?.let { return it }
-    // default serializable?
-    if (shouldHaveGeneratedSerializer) {
-        // $serializer nested class
-        return this.declarations
-            .filterIsInstance<IrClass>()
-            .singleOrNull { it.name == SerialEntityNames.SERIALIZER_CLASS_NAME }?.symbol
-    }
-    return null
-}
-
-private val IrClass.isSerialInfoAnnotation: Boolean
-    get() = annotations.hasAnnotation(SerializationAnnotations.serialInfoFqName)
-            || annotations.hasAnnotation(SerializationAnnotations.inheritableSerialInfoFqName)
-            || annotations.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationFqName)
-
-internal val IrClass.shouldHaveGeneratedSerializer: Boolean
-    get() = (isInternalSerializable && (modality == Modality.FINAL || modality == Modality.OPEN))
-            || isEnumWithLegacyGeneratedSerializer()
-
-internal fun IrClass.polymorphicSerializerIfApplicableAutomatically(context: SerializationPluginContext): IrClassSymbol? {
-    val serializer = when {
-        kind == ClassKind.INTERFACE && modality == Modality.SEALED -> SpecialBuiltins.sealedSerializer
-        kind == ClassKind.INTERFACE -> SpecialBuiltins.polymorphicSerializer
-        isInternalSerializable && modality == Modality.ABSTRACT -> SpecialBuiltins.polymorphicSerializer
-        isInternalSerializable && modality == Modality.SEALED -> SpecialBuiltins.sealedSerializer
-        else -> null
-    }
-    return serializer?.let {
-        context.getClassFromRuntimeOrNull(
-            it,
-            SerializationPackages.packageFqName,
-            SerializationPackages.internalPackageFqName
-        )
-    }
-}
-
-internal val IrClass.isInternalSerializable: Boolean
-    get() {
-        if (kind != ClassKind.CLASS) return false
-        return hasSerializableOrMetaAnnotationWithoutArgs()
-    }
-
-internal val IrClass.isAbstractOrSealedSerializableClass: Boolean get() = isInternalSerializable && (modality == Modality.ABSTRACT || modality == Modality.SEALED)
-
-internal val IrClass.isStaticSerializable: Boolean get() = this.typeParameters.isEmpty()
-
-
-internal val IrClass.hasCompanionObjectAsSerializer: Boolean
-    get() = isInternallySerializableObject || companionObject()?.serializerForClass == this.symbol
-
-internal val IrClass.isInternallySerializableObject: Boolean
-    get() = kind == ClassKind.OBJECT && hasSerializableOrMetaAnnotationWithoutArgs()
-
-internal val IrClass.serializerForClass: IrClassSymbol?
-    get() = (annotations.findAnnotation(SerializationAnnotations.serializerAnnotationFqName)
-        ?.getValueArgument(0) as? IrClassReference)?.symbol as? IrClassSymbol
-
-fun findEnumTypeSerializer(context: SerializationPluginContext, type: IrType): IrClassSymbol? {
-    val classSymbol = type.classOrNull?.owner ?: return null
-    return if (classSymbol.kind == ClassKind.ENUM_CLASS && !classSymbol.isEnumWithLegacyGeneratedSerializer())
-        context.referenceClass(enumSerializerId)
-    else null
-}
-
-internal fun IrClass.isEnumWithLegacyGeneratedSerializer(): Boolean = isInternallySerializableEnum() && useGeneratedEnumSerializer
-
-internal val IrClass.useGeneratedEnumSerializer: Boolean
-    get() = true // FIXME This would break if we try to use this new IR compiler with pre-1.4.1 serialization versions. I think we just need to raise min runtime version.
-
-internal val IrClass.isSealedSerializableInterface: Boolean
-    get() = kind == ClassKind.INTERFACE && modality == Modality.SEALED && hasSerializableOrMetaAnnotation()
-
-internal fun IrClass.isInternallySerializableEnum(): Boolean =
-    kind == ClassKind.ENUM_CLASS && hasSerializableOrMetaAnnotationWithoutArgs()
-
-fun findStandardKotlinTypeSerializer(context: SerializationPluginContext, type: IrType): IrClassSymbol? {
-    val typeName = type.classFqName?.toString()
-    val name = when (typeName) {
-        "Z" -> if (type.isBoolean()) "BooleanSerializer" else null
-        "B" -> if (type.isByte()) "ByteSerializer" else null
-        "S" -> if (type.isShort()) "ShortSerializer" else null
-        "I" -> if (type.isInt()) "IntSerializer" else null
-        "J" -> if (type.isLong()) "LongSerializer" else null
-        "F" -> if (type.isFloat()) "FloatSerializer" else null
-        "D" -> if (type.isDouble()) "DoubleSerializer" else null
-        "C" -> if (type.isChar()) "CharSerializer" else null
-        null -> null
-        else -> findStandardKotlinTypeSerializer(typeName)
-    } ?: return null
-    return context.getClassFromRuntimeOrNull(name, SerializationPackages.internalPackageFqName, SerializationPackages.packageFqName)
-}
-
-fun IrType.isGeneratedSerializableObject(): Boolean {
-    return classOrNull?.run { owner.kind == ClassKind.OBJECT && owner.hasSerializableOrMetaAnnotationWithoutArgs() } == true
-}
-
-internal val IrClass.isSerializableObject: Boolean
-    get() = kind == ClassKind.OBJECT && hasSerializableOrMetaAnnotation()
-
-// todo: optimize & unify with hasSerializableOrMeta
-internal fun IrClass.hasSerializableOrMetaAnnotationWithoutArgs(): Boolean {
-    val annot = getAnnotation(SerializationAnnotations.serializableAnnotationFqName)
-    if (annot != null) {
-        for (i in 0 until annot.valueArgumentsCount) {
-            if (annot.getValueArgument(i) != null) return false
-        }
-        return true
-    }
-    val metaAnnotation = annotations
-        .flatMap { it.symbol.owner.constructedClass.annotations }
-        .find { it.isAnnotation(SerializationAnnotations.metaSerializableAnnotationFqName) }
-    return metaAnnotation != null
-}
-
-fun SerializationPluginContext.getClassFromRuntimeOrNull(className: String, vararg packages: FqName): IrClassSymbol? {
-    val listToSearch = if (packages.isEmpty()) SerializationPackages.allPublicPackages else packages.toList()
-    for (pkg in listToSearch) {
-        referenceClass(ClassId(pkg, Name.identifier(className)))?.let { return it }
-    }
-    return null
-}
-
-fun SerializationPluginContext.getClassFromRuntime(className: String, vararg packages: FqName): IrClassSymbol {
-    return getClassFromRuntimeOrNull(className, *packages) ?: error(
-        "Class $className wasn't found in ${packages.toList().ifEmpty { SerializationPackages.allPublicPackages }}. " +
-                "Check that you have correct version of serialization runtime in classpath."
-    )
-}
-
-fun SerializationPluginContext.getClassFromInternalSerializationPackage(className: String): IrClassSymbol =
-    getClassFromRuntimeOrNull(className, SerializationPackages.internalPackageFqName)
-        ?: error("Class $className wasn't found in ${SerializationPackages.internalPackageFqName}. Check that you have correct version of serialization runtime in classpath.")
-
-
-internal val IrType.overridenSerializer: IrClassSymbol?
-    get() {
-        val desc = this.classOrNull ?: return null
-        desc.owner.serializableWith?.let { return it }
-        return null
-    }
-
-internal val IrClass.serializableWith: IrClassSymbol?
-    get() = annotations.serializableWith()
-
-
-// @Serializable(X::class) -> X
-internal fun List<IrConstructorCall>.serializableWith(): IrClassSymbol? {
-    val annotation = findAnnotation(SerializationAnnotations.serializableAnnotationFqName) ?: return null
-    val arg = annotation.getValueArgument(0) as? IrClassReference ?: return null
-    return arg.symbol as? IrClassSymbol
-}
-
-internal fun getSerializableClassByCompanion(companionClass: IrClass): IrClass? {
-    if (companionClass.isSerializableObject) return companionClass
-    if (!companionClass.isCompanion) return null
-    val classDescriptor = (companionClass.parent as? IrClass) ?: return null
-    if (!classDescriptor.shouldHaveGeneratedMethodsInCompanion) return null
-    return classDescriptor
-}
-
-internal val IrClass.shouldHaveGeneratedMethodsInCompanion: Boolean
-    get() = this.isSerializableObject || this.isSerializableEnum() || (this.kind == ClassKind.CLASS && hasSerializableOrMetaAnnotation()) || this.isSealedSerializableInterface
-
-internal fun IrClass.isSerializableEnum(): Boolean = kind == ClassKind.ENUM_CLASS && hasSerializableOrMetaAnnotation()
-
-fun IrClass.hasSerializableOrMetaAnnotation() = descriptor.hasSerializableOrMetaAnnotation // TODO
-
-internal val IrType.genericIndex: Int?
-    get() = (this.classifierOrNull as? IrTypeParameterSymbol)?.owner?.index
-
-fun IrType.serialName(): String = this.classOrNull!!.owner.serialName()
-fun IrClass.serialName(): String {
-    return annotations.serialNameValue ?: fqNameWhenAvailable?.asString() ?: error("${this.render()} does not have fqName")
-}
-
-fun AbstractIrGenerator.allSealedSerializableSubclassesFor(
-    irClass: IrClass,
-    context: SerializationPluginContext
-): Pair<List<IrSimpleType>, List<IrClassSymbol>> {
-    assert(irClass.modality == Modality.SEALED)
-    fun recursiveSealed(klass: IrClass): Collection<IrClass> {
-        return klass.sealedSubclasses.map { it.owner }.flatMap { if (it.modality == Modality.SEALED) recursiveSealed(it) else setOf(it) }
-    }
-
-    val serializableSubtypes = recursiveSealed(irClass).map { it.defaultType }
-    return serializableSubtypes.mapNotNull { subtype ->
-        findTypeSerializerOrContextUnchecked(context, subtype)?.let { Pair(subtype, it) }
-    }.unzip()
-}
-
-fun IrClass.findEnumValuesMethod() = this.functions.singleOrNull { f ->
-    f.name == Name.identifier("values") && f.valueParameters.isEmpty() && f.extensionReceiverParameter == null
-} ?: throw AssertionError("Enum class does not have single .values() function")
-
-internal fun IrClass.enumEntries(): List<IrEnumEntry> {
-    check(this.kind == ClassKind.ENUM_CLASS)
-    return declarations.filterIsInstance<IrEnumEntry>().toList()
-}
-
-internal fun IrClass.isEnumWithSerialInfoAnnotation(): Boolean {
-    if (kind != ClassKind.ENUM_CLASS) return false
-    if (annotations.hasAnySerialAnnotation) return true
-    return enumEntries().any { (it.annotations.hasAnySerialAnnotation) }
-}
-
-internal val List<IrConstructorCall>.hasAnySerialAnnotation: Boolean
-    get() = serialNameValue != null || any { it.annotationClass.isSerialInfoAnnotation == true }
-
-internal val List<IrConstructorCall>.serialNameValue: String?
-    get() = findAnnotation(SerializationAnnotations.serialNameAnnotationFqName)?.getStringConstArgument(0) // @SerialName("foo")
-
-internal fun getSerializableClassDescriptorBySerializer(serializer: IrClass): IrClass? {
-    val serializerForClass = serializer.serializerForClass
-    if (serializerForClass != null) return serializerForClass.owner
-    if (serializer.name !in setOf(
-            SerialEntityNames.SERIALIZER_CLASS_NAME,
-            SerialEntityNames.GENERATED_SERIALIZER_CLASS
-        )
-    ) return null
-    val classDescriptor = (serializer.parent as? IrClass) ?: return null
-    if (!classDescriptor.shouldHaveGeneratedSerializer) return null
-    return classDescriptor
-}
-
-internal fun isKSerializer(type: IrType): Boolean {
-    val simpleType = type as? IrSimpleType ?: return false
-    val classifier = simpleType.classifier as? IrClassSymbol ?: return false
-    val fqName = classifier.owner.fqNameWhenAvailable
-    return fqName == SerialEntityNames.KSERIALIZER_NAME_FQ || fqName == SerialEntityNames.GENERATED_SERIALIZER_FQ
-}
-
-internal fun IrClass.findPluginGeneratedMethod(name: String): IrSimpleFunction? {
-    return this.functions.find {
-        it.name.asString() == name && it.isFromPlugin()
-    }
-}
-
-internal fun IrDeclaration.isFromPlugin(): Boolean =
-    this.origin == IrDeclarationOrigin.GeneratedByPlugin(SerializationPluginKey) || (this.descriptor as? CallableMemberDescriptor)?.kind == CallableMemberDescriptor.Kind.SYNTHESIZED // old FE doesn't specify origin
-
-internal fun IrConstructor.isSerializationCtor(): Boolean {
-    /*kind == CallableMemberDescriptor.Kind.SYNTHESIZED does not work because DeserializedClassConstructorDescriptor loses its kind*/
-    return valueParameters.lastOrNull()?.run {
-        name == SerialEntityNames.dummyParamName && type.classFqName == SerializationPackages.internalPackageFqName.child(
-            SerialEntityNames.SERIAL_CTOR_MARKER_NAME
-        )
-    } == true
-}
-
-internal fun IrExpression.isInitializePropertyFromParameter(): Boolean =
-    this is IrGetValueImpl && this.origin == IrStatementOrigin.INITIALIZE_PROPERTY_FROM_PARAMETER
-
-internal val IrConstructorCall.annotationClass
-    get() = this.symbol.owner.constructedClass
\ No newline at end of file
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/BaseIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/BaseIrGenerator.kt
new file mode 100644
index 0000000..0a6c9f1
--- /dev/null
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/BaseIrGenerator.kt
@@ -0,0 +1,578 @@
+/*
+ * Copyright 2010-2022 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.kotlinx.serialization.compiler.backend.ir
+
+import org.jetbrains.kotlin.backend.common.lower.irIfThen
+import org.jetbrains.kotlin.backend.jvm.functionByName
+import org.jetbrains.kotlin.backend.jvm.ir.fileParent
+import org.jetbrains.kotlin.backend.jvm.ir.representativeUpperBound
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.isSealed
+import org.jetbrains.kotlin.ir.builders.*
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrValueDeclaration
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.deepCopyWithVariables
+import org.jetbrains.kotlin.ir.expressions.IrClassReference
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
+import org.jetbrains.kotlin.ir.expressions.IrVararg
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
+import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
+import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection
+import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.util.OperatorNameConventions
+import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.*
+import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
+import org.jetbrains.kotlinx.serialization.compiler.resolve.*
+
+abstract class BaseIrGenerator(private val currentClass: IrClass, final override val compilerContext: SerializationPluginContext): IrBuilderWithPluginContext {
+
+    private val throwMissedFieldExceptionFunc
+        = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.SINGLE_MASK_FIELD_MISSING_FUNC_NAME)).singleOrNull()
+
+    private val throwMissedFieldExceptionArrayFunc
+        = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.ARRAY_MASK_FIELD_MISSING_FUNC_NAME)).singleOrNull()
+
+    private val enumSerializerFactoryFunc
+        = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.ENUM_SERIALIZER_FACTORY_FUNC_NAME)).singleOrNull()
+
+    private val markedEnumSerializerFactoryFunc
+        = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.MARKED_ENUM_SERIALIZER_FACTORY_FUNC_NAME)).singleOrNull()
+
+    fun useFieldMissingOptimization(): Boolean {
+        return throwMissedFieldExceptionFunc != null && throwMissedFieldExceptionArrayFunc != null
+    }
+
+    private fun getClassListFromFileAnnotation(annotationFqName: FqName): List<IrClassSymbol> {
+        val annotation = currentClass.fileParent.annotations.findAnnotation(annotationFqName) ?: return emptyList()
+        val vararg = annotation.getValueArgument(0) as? IrVararg ?: return emptyList()
+        return vararg.elements
+            .mapNotNull { (it as? IrClassReference)?.symbol as? IrClassSymbol }
+    }
+
+    val contextualKClassListInCurrentFile: Set<IrClassSymbol> by lazy {
+        getClassListFromFileAnnotation(
+            SerializationAnnotations.contextualFqName,
+        ).plus(
+            getClassListFromFileAnnotation(
+                SerializationAnnotations.contextualOnFileFqName,
+            )
+        ).toSet()
+    }
+
+    val additionalSerializersInScopeOfCurrentFile: Map<Pair<IrClassSymbol, Boolean>, IrClassSymbol> by lazy {
+        getClassListFromFileAnnotation(SerializationAnnotations.additionalSerializersFqName,)
+            .associateBy(
+                { serializerSymbol ->
+                    val kotlinType = (serializerSymbol.owner.superTypes.find(IrType::isKSerializer) as? IrSimpleType)?.arguments?.firstOrNull()?.typeOrNull
+                    val classSymbol = kotlinType?.classOrNull
+                        ?: throw AssertionError("Argument for ${SerializationAnnotations.additionalSerializersFqName} does not implement KSerializer or does not provide serializer for concrete type")
+                    classSymbol to kotlinType.isNullable()
+                },
+                { it }
+            )
+    }
+
+    fun IrBlockBodyBuilder.generateGoldenMaskCheck(
+        seenVars: List<IrValueDeclaration>,
+        properties: IrSerializableProperties,
+        serialDescriptor: IrExpression
+    ) {
+        val fieldsMissedTest: IrExpression
+        val throwErrorExpr: IrExpression
+
+        val maskSlotCount = seenVars.size
+        if (maskSlotCount == 1) {
+            val goldenMask = properties.goldenMask
+
+
+            throwErrorExpr = irInvoke(
+                null,
+                throwMissedFieldExceptionFunc!!,
+                irGet(seenVars[0]),
+                irInt(goldenMask),
+                serialDescriptor,
+                typeHint = compilerContext.irBuiltIns.unitType
+            )
+
+            fieldsMissedTest = irNotEquals(
+                irInt(goldenMask),
+                irBinOp(
+                    OperatorNameConventions.AND,
+                    irInt(goldenMask),
+                    irGet(seenVars[0])
+                )
+            )
+        } else {
+            val goldenMaskList = properties.goldenMaskList
+
+            var compositeExpression: IrExpression? = null
+            for (i in goldenMaskList.indices) {
+                val singleCheckExpr = irNotEquals(
+                    irInt(goldenMaskList[i]),
+                    irBinOp(
+                        OperatorNameConventions.AND,
+                        irInt(goldenMaskList[i]),
+                        irGet(seenVars[i])
+                    )
+                )
+
+                compositeExpression = if (compositeExpression == null) {
+                    singleCheckExpr
+                } else {
+                    irBinOp(
+                        OperatorNameConventions.OR,
+                        compositeExpression,
+                        singleCheckExpr
+                    )
+                }
+            }
+
+            fieldsMissedTest = compositeExpression!!
+
+            throwErrorExpr = irBlock {
+                +irInvoke(
+                    null,
+                    throwMissedFieldExceptionArrayFunc!!,
+                    createPrimitiveArrayOfExpression(compilerContext.irBuiltIns.intType, goldenMaskList.indices.map { irGet(seenVars[it]) }),
+                    createPrimitiveArrayOfExpression(compilerContext.irBuiltIns.intType, goldenMaskList.map { irInt(it) }),
+                    serialDescriptor,
+                    typeHint = compilerContext.irBuiltIns.unitType
+                )
+            }
+        }
+
+        +irIfThen(compilerContext.irBuiltIns.unitType, fieldsMissedTest, throwErrorExpr)
+    }
+
+    fun IrBlockBodyBuilder.serializeAllProperties(
+        serializableProperties: List<IrSerializableProperty>,
+        objectToSerialize: IrValueDeclaration,
+        localOutput: IrValueDeclaration,
+        localSerialDesc: IrValueDeclaration,
+        kOutputClass: IrClassSymbol,
+        ignoreIndexTo: Int,
+        initializerAdapter: (IrExpressionBody) -> IrExpression,
+        genericGetter: ((Int, IrType) -> IrExpression)?
+    ) {
+
+        fun IrSerializableProperty.irGet(): IrExpression {
+            val ownerType = objectToSerialize.symbol.owner.type
+            return getProperty(
+                irGet(
+                    type = ownerType,
+                    variable = objectToSerialize.symbol
+                ), ir
+            )
+        }
+
+        for ((index, property) in serializableProperties.withIndex()) {
+            if (index < ignoreIndexTo) continue
+            // output.writeXxxElementValue(classDesc, index, value)
+            val elementCall = formEncodeDecodePropertyCall(
+                irGet(localOutput),
+                property, { innerSerial, sti ->
+                    val f =
+                        kOutputClass.functionByName("${CallingConventions.encode}${sti.elementMethodPrefix}Serializable${CallingConventions.elementPostfix}")
+                    f to listOf(
+                        irGet(localSerialDesc),
+                        irInt(index),
+                        innerSerial,
+                        property.irGet()
+                    )
+                }, {
+                    val f =
+                        kOutputClass.functionByName("${CallingConventions.encode}${it.elementMethodPrefix}${CallingConventions.elementPostfix}")
+                    val args: MutableList<IrExpression> = mutableListOf(irGet(localSerialDesc), irInt(index))
+                    if (it.elementMethodPrefix != "Unit") args.add(property.irGet())
+                    f to args
+                },
+                genericGetter
+            )
+
+            // check for call to .shouldEncodeElementDefault
+            val encodeDefaults = property.ir.getEncodeDefaultAnnotationValue()
+            val field =
+                property.ir.backingField // Nullable when property from another module; can't compare it with default value on JS or Native
+            if (!property.optional || encodeDefaults == true || field == null) {
+                // emit call right away
+                +elementCall
+            } else {
+                val partB = irNotEquals(property.irGet(), initializerAdapter(field.initializer!!))
+
+                val condition = if (encodeDefaults == false) {
+                    // drop default without call to .shouldEncodeElementDefault
+                    partB
+                } else {
+                    // emit check:
+                    // if (if (output.shouldEncodeElementDefault(this.descriptor, i)) true else {obj.prop != DEFAULT_VALUE} ) {
+                    //    output.encodeIntElement(this.descriptor, i, obj.prop)// block {obj.prop != DEFAULT_VALUE} may contain several statements
+                    val shouldEncodeFunc = kOutputClass.functionByName(CallingConventions.shouldEncodeDefault)
+                    val partA = irInvoke(irGet(localOutput), shouldEncodeFunc, irGet(localSerialDesc), irInt(index))
+                    // Ir infrastructure does not have dedicated symbol for ||, so
+                    //  `a || b == if (a) true else b`, see org.jetbrains.kotlin.ir.builders.PrimitivesKt.oror
+                    irIfThenElse(compilerContext.irBuiltIns.booleanType, partA, irTrue(), partB)
+                }
+                +irIfThen(condition, elementCall)
+            }
+        }
+    }
+
+
+    fun IrBlockBodyBuilder.formEncodeDecodePropertyCall(
+        encoder: IrExpression,
+        property: IrSerializableProperty,
+        whenHaveSerializer: (serializer: IrExpression, sti: IrSerialTypeInfo) -> FunctionWithArgs,
+        whenDoNot: (sti: IrSerialTypeInfo) -> FunctionWithArgs,
+        genericGetter: ((Int, IrType) -> IrExpression)? = null,
+        returnTypeHint: IrType? = null
+    ): IrExpression {
+        val sti = getIrSerialTypeInfo(property, compilerContext)
+        val innerSerial = serializerInstance(
+            sti.serializer,
+            compilerContext,
+            property.type,
+            property.genericIndex,
+            genericGetter
+        )
+        val (functionToCall, args: List<IrExpression>) = if (innerSerial != null) whenHaveSerializer(innerSerial, sti) else whenDoNot(sti)
+        val typeArgs = if (functionToCall.descriptor.typeParameters.isNotEmpty()) listOf(property.type) else listOf()
+        return irInvoke(encoder, functionToCall, typeArguments = typeArgs, valueArguments = args, returnTypeHint = returnTypeHint)
+    }
+
+    fun IrBuilderWithScope.callSerializerFromCompanion(
+        thisIrType: IrType,
+        typeArgs: List<IrType>,
+        args: List<IrExpression>
+    ): IrExpression? {
+        val baseClass = thisIrType.getClass() ?: return null
+        val companionClass = baseClass.companionObject() ?: return null
+        val serializerProviderFunction = companionClass.declarations.singleOrNull {
+            it is IrFunction && it.name == SerialEntityNames.SERIALIZER_PROVIDER_NAME && it.valueParameters.size == baseClass.typeParameters.size
+        } ?: return null
+
+        val adjustedArgs: List<IrExpression> =
+            // if typeArgs.size == args.size then the serializer is custom - we need to use the actual serializers from the arguments
+            if ((typeArgs.size != args.size) && (baseClass.descriptor.isSealed() || baseClass.descriptor.modality == Modality.ABSTRACT)) {
+                val serializer = findStandardKotlinTypeSerializer(compilerContext, context.irBuiltIns.unitType)!!
+                // workaround for sealed and abstract classes - the `serializer` function expects non-null serializers, but does not use them, so serializers of any type can be passed
+                List(baseClass.typeParameters.size) { irGetObject(serializer) }
+            } else {
+                args
+            }
+
+        with(serializerProviderFunction as IrFunction) {
+            // Note that [typeArgs] may be unused if we short-cut to e.g. SealedClassSerializer
+            return irInvoke(
+                irGetObject(companionClass),
+                symbol,
+                typeArgs.takeIf { it.size == typeParameters.size }.orEmpty(),
+                adjustedArgs.takeIf { it.size == valueParameters.size }.orEmpty()
+            )
+        }
+    }
+
+    // Does not use sti and therefore does not perform encoder calls optimization
+    fun IrBuilderWithScope.serializerTower(
+        generator: SerializerIrGenerator,
+        dispatchReceiverParameter: IrValueParameter,
+        property: IrSerializableProperty
+    ): IrExpression? {
+        val nullableSerClass = compilerContext.referenceProperties(SerialEntityNames.wrapIntoNullableCallableId).single()
+        val serializer =
+            property.serializableWith(compilerContext)
+                ?: if (!property.type.isTypeParameter()) generator.findTypeSerializerOrContext(
+                    compilerContext,
+                    property.type
+                ) else null
+        return serializerInstance(
+            serializer,
+            compilerContext,
+            property.type,
+            genericIndex = property.genericIndex
+        ) { it, _ ->
+            val (_, ir) = generator.localSerializersFieldsDescriptors[it]
+            irGetField(irGet(dispatchReceiverParameter), ir.backingField!!)
+        }?.let { expr -> wrapWithNullableSerializerIfNeeded(property.type, expr, nullableSerClass) }
+    }
+
+    private fun IrBuilderWithScope.wrapWithNullableSerializerIfNeeded(
+        type: IrType,
+        expression: IrExpression,
+        nullableProp: IrPropertySymbol
+    ): IrExpression = if (type.isMarkedNullable()) {
+        val resultType = type.makeNotNull()
+        val typeArguments = listOf(resultType)
+        val callee = nullableProp.owner.getter!!
+
+        val returnType = callee.returnType.substitute(callee.typeParameters, typeArguments)
+
+        irInvoke(
+            callee = callee.symbol,
+            typeArguments = typeArguments,
+            valueArguments = emptyList(),
+            returnTypeHint = returnType
+        ).apply { extensionReceiver = expression }
+    } else {
+        expression
+    }
+
+    fun wrapIrTypeIntoKSerializerIrType(
+        type: IrType,
+        variance: Variance = Variance.INVARIANT
+    ): IrType {
+        val kSerClass = compilerContext.referenceClass(ClassId(SerializationPackages.packageFqName, SerialEntityNames.KSERIALIZER_NAME))
+            ?: error("Couldn't find class ${SerialEntityNames.KSERIALIZER_NAME}")
+        return IrSimpleTypeImpl(
+            kSerClass, hasQuestionMark = false, arguments = listOf(
+                makeTypeProjection(type, variance)
+            ), annotations = emptyList()
+        )
+    }
+
+    fun IrBuilderWithScope.serializerInstance(
+        serializerClassOriginal: IrClassSymbol?,
+        pluginContext: SerializationPluginContext,
+        kType: IrType,
+        genericIndex: Int? = null,
+        genericGetter: ((Int, IrType) -> IrExpression)? = null
+    ): IrExpression? {
+        val nullableSerClass = compilerContext.referenceProperties(SerialEntityNames.wrapIntoNullableCallableId).single()
+        if (serializerClassOriginal == null) {
+            if (genericIndex == null) return null
+            return genericGetter?.invoke(genericIndex, kType)
+        }
+        if (serializerClassOriginal.owner.kind == ClassKind.OBJECT) {
+            return irGetObject(serializerClassOriginal)
+        }
+        fun instantiate(serializer: IrClassSymbol?, type: IrType): IrExpression? {
+            val expr = serializerInstance(
+                serializer,
+                pluginContext,
+                type,
+                type.genericIndex,
+                genericGetter
+            ) ?: return null
+            return wrapWithNullableSerializerIfNeeded(type, expr, nullableSerClass)
+        }
+
+        var serializerClass = serializerClassOriginal
+        var args: List<IrExpression>
+        var typeArgs: List<IrType>
+        val thisIrType = (kType as? IrSimpleType) ?: error("Don't know how to work with type ${kType::class}")
+        var needToCopyAnnotations = false
+
+        when (serializerClassOriginal.owner.classId) {
+            polymorphicSerializerId -> {
+                needToCopyAnnotations = true
+                args = listOf(classReference(kType))
+                typeArgs = listOf(thisIrType)
+            }
+            contextSerializerId -> {
+                args = listOf(classReference(kType))
+                typeArgs = listOf(thisIrType)
+
+                val hasNewCtxSerCtor = compilerContext.referenceConstructors(contextSerializerId).any { it.owner.valueParameters.size == 3 }
+
+                if (hasNewCtxSerCtor) {
+                    // new signature of context serializer
+                    args = args + mutableListOf<IrExpression>().apply {
+                        val fallbackDefaultSerializer = findTypeSerializer(pluginContext, kType)
+                        add(instantiate(fallbackDefaultSerializer, kType) ?: irNull())
+                        add(
+                            createArrayOfExpression(
+                                wrapIrTypeIntoKSerializerIrType(
+                                    thisIrType,
+                                    variance = Variance.OUT_VARIANCE
+                                ),
+                                thisIrType.arguments.map {
+                                    val argSer = findTypeSerializerOrContext(
+                                        compilerContext,
+                                        it.typeOrNull!! //todo: handle star projections here?
+                                    )
+                                    instantiate(argSer, it.typeOrNull!!)!!
+                                })
+                        )
+                    }
+                }
+            }
+            objectSerializerId -> {
+                needToCopyAnnotations = true
+                args = listOf(irString(kType.serialName()), irGetObject(kType.classOrNull!!))
+                typeArgs = listOf(thisIrType)
+            }
+            sealedSerializerId -> {
+                needToCopyAnnotations = true
+                args = mutableListOf<IrExpression>().apply {
+                    add(irString(kType.serialName()))
+                    add(classReference(kType))
+                    val (subclasses, subSerializers) = allSealedSerializableSubclassesFor(
+                        kType.classOrNull!!.owner,
+                        pluginContext
+                    )
+                    val projectedOutCurrentKClass =
+                        compilerContext.irBuiltIns.kClassClass.typeWithArguments(
+                            listOf(makeTypeProjection(thisIrType, Variance.OUT_VARIANCE))
+                        )
+                    add(
+                        createArrayOfExpression(
+                            projectedOutCurrentKClass,
+                            subclasses.map { classReference(it) }
+                        )
+                    )
+                    add(
+                        createArrayOfExpression(
+                            wrapIrTypeIntoKSerializerIrType(thisIrType, variance = Variance.OUT_VARIANCE),
+                            subSerializers.mapIndexed { i, serializer ->
+                                val type = subclasses[i]
+                                val expr = serializerInstance(
+                                    serializer,
+                                    pluginContext,
+                                    type,
+                                    type.genericIndex
+                                ) { _, genericType ->
+                                    serializerInstance(
+                                        pluginContext.referenceClass(polymorphicSerializerId),
+                                        pluginContext,
+                                        (genericType.classifierOrNull as IrTypeParameterSymbol).owner.representativeUpperBound
+                                    )!!
+                                }!!
+                                wrapWithNullableSerializerIfNeeded(type, expr, nullableSerClass)
+                            }
+                        )
+                    )
+                }
+                typeArgs = listOf(thisIrType)
+            }
+            enumSerializerId -> {
+                serializerClass = pluginContext.referenceClass(enumSerializerId)
+                val enumDescriptor = kType.classOrNull!!
+                typeArgs = listOf(thisIrType)
+                // instantiate serializer only inside enum Companion
+                if (this@BaseIrGenerator !is SerializableCompanionIrGenerator) {
+                    // otherwise call Companion.serializer()
+                    callSerializerFromCompanion(thisIrType, typeArgs, emptyList())?.let { return it }
+                }
+
+                val enumArgs = mutableListOf(
+                    irString(thisIrType.serialName()),
+                    irCall(enumDescriptor.owner.findEnumValuesMethod()),
+                )
+
+                val enumSerializerFactoryFunc = enumSerializerFactoryFunc
+                val markedEnumSerializerFactoryFunc = markedEnumSerializerFactoryFunc
+                if (enumSerializerFactoryFunc != null && markedEnumSerializerFactoryFunc != null) {
+                    // runtime contains enum serializer factory functions
+                    val factoryFunc: IrSimpleFunctionSymbol = if (enumDescriptor.owner.isEnumWithSerialInfoAnnotation()) {
+                        // need to store SerialInfo annotation in descriptor
+                        val enumEntries = enumDescriptor.owner.enumEntries()
+                        val entriesNames = enumEntries.map { it.annotations.serialNameValue?.let { n -> irString(n) } ?: irNull() }
+                        val entriesAnnotations = enumEntries.map {
+                            val annotationConstructors = it.annotations.map { a ->
+                                a.deepCopyWithVariables()
+                            }
+                            val annotationsConstructors = copyAnnotationsFrom(annotationConstructors)
+                            if (annotationsConstructors.isEmpty()) {
+                                irNull()
+                            } else {
+                                createArrayOfExpression(compilerContext.irBuiltIns.annotationType, annotationsConstructors)
+                            }
+                        }
+                        val annotationArrayType =
+                            compilerContext.irBuiltIns.arrayClass.typeWith(compilerContext.irBuiltIns.annotationType.makeNullable())
+
+                        enumArgs += createArrayOfExpression(compilerContext.irBuiltIns.stringType.makeNullable(), entriesNames)
+                        enumArgs += createArrayOfExpression(annotationArrayType, entriesAnnotations)
+
+                        markedEnumSerializerFactoryFunc
+                    } else {
+                        enumSerializerFactoryFunc
+                    }
+
+                    val factoryReturnType = factoryFunc.owner.returnType.substitute(factoryFunc.owner.typeParameters, typeArgs)
+                    return irInvoke(null, factoryFunc, typeArgs, enumArgs, factoryReturnType)
+                } else {
+                    // support legacy serializer instantiation by constructor for old runtimes
+                    args = enumArgs
+                }
+            }
+            else -> {
+                args = kType.arguments.map {
+                    val argSer = findTypeSerializerOrContext(
+                        pluginContext,
+                        it.typeOrNull!! // todo: stars?
+                    )
+                    instantiate(argSer, it.typeOrNull!!) ?: return null
+                }
+                typeArgs = kType.arguments.map { it.typeOrNull!! }
+            }
+
+        }
+        if (serializerClassOriginal.owner.classId == referenceArraySerializerId) {
+            args = listOf(wrapperClassReference(kType.arguments.single().typeOrNull!!)) + args
+            typeArgs = listOf(typeArgs[0].makeNotNull()) + typeArgs
+        }
+
+        // If KType is interface, .classSerializer always yields PolymorphicSerializer, which may be unavailable for interfaces from other modules
+        if (!kType.isInterface() && serializerClassOriginal == kType.classOrNull!!.owner.classSerializer(pluginContext) && this@BaseIrGenerator !is SerializableCompanionIrGenerator) {
+            // This is default type serializer, we can shortcut through Companion.serializer()
+            // BUT not during generation of this method itself
+            callSerializerFromCompanion(thisIrType, typeArgs, args)?.let { return it }
+        }
+
+
+        val serializable = serializerClass?.owner?.let { getSerializableClassDescriptorBySerializer(it) }
+        requireNotNull(serializerClass)
+        val ctor = if (serializable?.typeParameters?.isNotEmpty() == true) {
+            requireNotNull(
+                findSerializerConstructorForTypeArgumentsSerializers(serializerClass.owner)
+            ) { "Generated serializer does not have constructor with required number of arguments" }
+        } else {
+            val constructors = serializerClass.constructors
+            // search for new signature of polymorphic/sealed/contextual serializer
+            if (!needToCopyAnnotations) {
+                constructors.single { it.owner.isPrimary }
+            } else {
+                constructors.find { it.owner.lastArgumentIsAnnotationArray() } ?: run {
+                    // not found - we are using old serialization runtime without this feature
+                    // todo: optimize allocating an empty array when no annotations defined, maybe use old constructor?
+                    needToCopyAnnotations = false
+                    constructors.single { it.owner.isPrimary }
+                }
+            }
+        }
+        // Return type should be correctly substituted
+        assert(ctor.isBound)
+        val ctorDecl = ctor.owner
+        if (needToCopyAnnotations) {
+            val classAnnotations = copyAnnotationsFrom(thisIrType.getClass()?.let { collectSerialInfoAnnotations(it) }.orEmpty())
+            args = args + createArrayOfExpression(compilerContext.irBuiltIns.annotationType, classAnnotations)
+        }
+
+        val typeParameters = ctorDecl.parentAsClass.typeParameters
+        val substitutedReturnType = ctorDecl.returnType.substitute(typeParameters, typeArgs)
+        return irInvoke(
+            null,
+            ctor,
+            // User may declare serializer with fixed type arguments, e.g. class SomeSerializer : KSerializer<ClosedRange<Float>>
+            typeArguments = typeArgs.takeIf { it.size == ctorDecl.typeParameters.size }.orEmpty(),
+            valueArguments = args.takeIf { it.size == ctorDecl.valueParameters.size }.orEmpty(),
+            returnTypeHint = substitutedReturnType
+        )
+    }
+
+}
\ No newline at end of file
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/DefaultValuesUtils.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/DefaultValuesUtils.kt
new file mode 100644
index 0000000..43c07c6
--- /dev/null
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/DefaultValuesUtils.kt
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2010-2022 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.kotlinx.serialization.compiler.backend.ir
+
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
+import org.jetbrains.kotlin.ir.builders.irGet
+import org.jetbrains.kotlin.ir.builders.irGetField
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrProperty
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.deepCopyWithVariables
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
+import org.jetbrains.kotlin.ir.expressions.IrGetValue
+import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
+import org.jetbrains.kotlin.ir.util.constructors
+import org.jetbrains.kotlin.ir.util.properties
+import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
+
+fun IrBuilderWithScope.getProperty(receiver: IrExpression, property: IrProperty): IrExpression {
+    return if (property.getter != null)
+        irGet(property.getter!!.returnType, receiver, property.getter!!.symbol)
+    else
+        irGetField(receiver, property.backingField!!)
+}
+
+/*
+  Create a function that creates `get property value expressions` for given corresponded constructor's param
+    (constructor_params) -> get_property_value_expression
+ */
+fun IrBuilderWithScope.createPropertyByParamReplacer(
+    irClass: IrClass,
+    serialProperties: List<IrSerializableProperty>,
+    instance: IrValueParameter
+): (ValueParameterDescriptor) -> IrExpression? {
+    fun IrSerializableProperty.irGet(): IrExpression {
+        val ownerType = instance.symbol.owner.type
+        return getProperty(
+            irGet(
+                type = ownerType,
+                variable = instance.symbol
+            ), ir
+        )
+    }
+
+    val serialPropertiesMap = serialProperties.associateBy { it.ir }
+
+    val transientPropertiesSet =
+        irClass.declarations.asSequence()
+            .filterIsInstance<IrProperty>()
+            .filter { it.backingField != null }
+            .filter { !serialPropertiesMap.containsKey(it) }
+            .toSet()
+
+    return { vpd ->
+        val propertyDescriptor = irClass.properties.find { it.name == vpd.name }
+        if (propertyDescriptor != null) {
+            val value = serialPropertiesMap[propertyDescriptor]
+            value?.irGet() ?: run {
+                if (propertyDescriptor in transientPropertiesSet)
+                    getProperty(
+                        irGet(instance),
+                        propertyDescriptor
+                    )
+                else null
+            }
+        } else {
+            null
+        }
+    }
+}
+
+/*
+    Creates an initializer adapter function that can replace IR expressions of getting constructor parameter value by some other expression.
+    Also adapter may replace IR expression of getting `this` value by another expression.
+     */
+fun createInitializerAdapter(
+    irClass: IrClass,
+    paramGetReplacer: (ValueParameterDescriptor) -> IrExpression?,
+    thisGetReplacer: Pair<IrValueSymbol, () -> IrExpression>? = null
+): (IrExpressionBody) -> IrExpression {
+    val initializerTransformer = object : IrElementTransformerVoid() {
+        // try to replace `get some value` expression
+        override fun visitGetValue(expression: IrGetValue): IrExpression {
+            val symbol = expression.symbol
+            if (thisGetReplacer != null && thisGetReplacer.first == symbol) {
+                // replace `get this value` expression
+                return thisGetReplacer.second()
+            }
+
+            val descriptor = symbol.descriptor
+            if (descriptor is ValueParameterDescriptor) {
+                // replace `get parameter value` expression
+                paramGetReplacer(descriptor)?.let { return it }
+            }
+
+            // otherwise leave expression as it is
+            return super.visitGetValue(expression)
+        }
+    }
+    val defaultsMap = extractDefaultValuesFromConstructor(irClass)
+    return fun(initializer: IrExpressionBody): IrExpression {
+        val rawExpression = initializer.expression
+        val expression =
+            if (rawExpression.isInitializePropertyFromParameter()) {
+                // this is a primary constructor property, use corresponding default of value parameter
+                defaultsMap.getValue((rawExpression as IrGetValue).symbol)!!
+            } else {
+                rawExpression
+            }
+        return expression.deepCopyWithVariables().transform(initializerTransformer, null)
+    }
+}
+
+private fun extractDefaultValuesFromConstructor(irClass: IrClass?): Map<IrValueSymbol, IrExpression?> {
+    if (irClass == null) return emptyMap()
+    val original = irClass.constructors.singleOrNull { it.isPrimary }
+    // default arguments of original constructor
+    val defaultsMap: Map<IrValueSymbol, IrExpression?> =
+        original?.valueParameters?.associate { it.symbol to it.defaultValue?.expression } ?: emptyMap()
+    return defaultsMap + extractDefaultValuesFromConstructor(irClass.getSuperClassNotAny())
+}
\ No newline at end of file
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt
deleted file mode 100644
index 9f6861a..0000000
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt
+++ /dev/null
@@ -1,1367 +0,0 @@
-/*
- * 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.kotlinx.serialization.compiler.backend.ir
-
-import org.jetbrains.kotlin.backend.common.extensions.FirIncompatiblePluginAPI
-import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder
-import org.jetbrains.kotlin.backend.common.lower.irIfThen
-import org.jetbrains.kotlin.backend.jvm.functionByName
-import org.jetbrains.kotlin.backend.jvm.ir.representativeUpperBound
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.ir.builders.*
-import org.jetbrains.kotlin.ir.builders.declarations.buildFun
-import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.deepCopyWithVariables
-import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.expressions.impl.*
-import org.jetbrains.kotlin.ir.symbols.*
-import org.jetbrains.kotlin.ir.symbols.impl.*
-import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
-import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection
-import org.jetbrains.kotlin.ir.util.*
-import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
-import org.jetbrains.kotlin.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.jvm.isJvm
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
-import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.TypeProjectionImpl
-import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.replace
-import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithStarProjections
-import org.jetbrains.kotlin.types.typeUtil.representativeUpperBound
-import org.jetbrains.kotlin.util.OperatorNameConventions
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.*
-import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.*
-import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
-import org.jetbrains.kotlinx.serialization.compiler.resolve.*
-import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationDependencies.LAZY_FQ
-import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationDependencies.LAZY_MODE_FQ
-import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationDependencies.LAZY_PUBLICATION_MODE_NAME
-
-interface IrBuilderExtension {
-    val compilerContext: SerializationPluginContext
-
-    private val throwMissedFieldExceptionFunc
-        get() = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.SINGLE_MASK_FIELD_MISSING_FUNC_NAME)).singleOrNull()
-
-    private val throwMissedFieldExceptionArrayFunc
-        get() = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.ARRAY_MASK_FIELD_MISSING_FUNC_NAME)).singleOrNull()
-
-    private val enumSerializerFactoryFunc
-        get() = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.ENUM_SERIALIZER_FACTORY_FUNC_NAME)).singleOrNull()
-
-    private val markedEnumSerializerFactoryFunc
-        get() = compilerContext.referenceFunctions(CallableId(SerializationPackages.internalPackageFqName, SerialEntityNames.MARKED_ENUM_SERIALIZER_FACTORY_FUNC_NAME)).singleOrNull()
-
-    private inline fun <reified T : IrDeclaration> IrClass.searchForDeclaration(descriptor: DeclarationDescriptor): T? {
-        return declarations.singleOrNull { it.descriptor == descriptor } as? T
-    }
-
-    fun useFieldMissingOptimization(): Boolean {
-        return throwMissedFieldExceptionFunc != null && throwMissedFieldExceptionArrayFunc != null
-    }
-
-    fun <F: IrFunction> addFunctionBody(function: F, bodyGen: IrBlockBodyBuilder.(F) -> Unit) {
-        val parentClass = function.parent
-        val startOffset = function.startOffset.takeIf { it >= 0 } ?: parentClass.startOffset
-        val endOffset = function.endOffset.takeIf { it >= 0 } ?: parentClass.endOffset
-        function.body = DeclarationIrBuilder(compilerContext, function.symbol, startOffset, endOffset).irBlockBody(
-            startOffset,
-            endOffset
-        ) { bodyGen(function) }
-    }
-
-    fun IrClass.contributeFunction(descriptor: FunctionDescriptor, ignoreWhenMissing: Boolean = false, bodyGen: IrBlockBodyBuilder.(IrFunction) -> Unit) {
-        val f: IrSimpleFunction = searchForDeclaration(descriptor)
-            ?: (if (ignoreWhenMissing) return else compilerContext.symbolTable.referenceSimpleFunction(descriptor).owner)
-        f.body = DeclarationIrBuilder(compilerContext, f.symbol, this.startOffset, this.endOffset).irBlockBody(
-            this.startOffset,
-            this.endOffset
-        ) { bodyGen(f) }
-    }
-
-    fun IrClass.contributeConstructor(
-        descriptor: ClassConstructorDescriptor,
-        declareNew: Boolean = true,
-        overwriteValueParameters: Boolean = false,
-        bodyGen: IrBlockBodyBuilder.(IrConstructor) -> Unit
-    ) {
-        val c: IrConstructor = searchForDeclaration(descriptor) ?: compilerContext.symbolTable.referenceConstructor(descriptor).owner
-        c.body = DeclarationIrBuilder(compilerContext, c.symbol, this.startOffset, this.endOffset).irBlockBody(
-            this.startOffset,
-            this.endOffset
-        ) { bodyGen(c) }
-    }
-
-    fun IrClass.createLambdaExpression(
-        type: IrType,
-        bodyGen: IrBlockBodyBuilder.() -> Unit
-    ): IrFunctionExpression {
-        val function = compilerContext.irFactory.buildFun {
-            this.startOffset = this@createLambdaExpression.startOffset
-            this.endOffset = this@createLambdaExpression.endOffset
-            this.returnType = type
-            name = Name.identifier("<anonymous>")
-            visibility = DescriptorVisibilities.LOCAL
-            origin = SERIALIZABLE_PLUGIN_ORIGIN
-        }
-        function.body =
-            DeclarationIrBuilder(compilerContext, function.symbol, startOffset, endOffset).irBlockBody(startOffset, endOffset, bodyGen)
-        function.parent = this
-
-        val f0Type = compilerContext.irBuiltIns.functionN(0)
-        val f0ParamSymbol = f0Type.typeParameters[0].symbol
-        val f0IrType = f0Type.defaultType.substitute(mapOf(f0ParamSymbol to type))
-
-        return IrFunctionExpressionImpl(
-            startOffset,
-            endOffset,
-            f0IrType,
-            function,
-            IrStatementOrigin.LAMBDA
-        )
-    }
-
-    fun createLazyProperty(
-        containingClass: IrClass,
-        targetIrType: IrType,
-        name: Name,
-        initializerBuilder: IrBlockBodyBuilder.() -> Unit
-    ): IrProperty {
-        val lazySafeModeClassDescriptor = compilerContext.referenceClass(ClassId.topLevel(LAZY_MODE_FQ))!!.owner
-        val lazyFunctionSymbol = compilerContext.referenceFunctions(CallableId(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, Name.identifier("lazy"))).single {
-            it.owner.valueParameters.size == 2 && it.owner.valueParameters[0].type == lazySafeModeClassDescriptor.defaultType
-        }
-        val publicationEntryDescriptor = lazySafeModeClassDescriptor.enumEntries().single { it.name == LAZY_PUBLICATION_MODE_NAME }
-
-        val lazyIrClass = compilerContext.referenceClass(ClassId.topLevel(LAZY_FQ))!!.owner
-        val lazyIrType = lazyIrClass.defaultType.substitute(mapOf(lazyIrClass.typeParameters[0].symbol to targetIrType))
-
-        val propertyDescriptor =
-            KSerializerDescriptorResolver.createValPropertyDescriptor(
-                Name.identifier(name.asString() + "\$delegate"),
-                containingClass.descriptor,
-                lazyIrType.toKotlinType(),
-                createGetter = true
-            )
-
-        return generateSimplePropertyWithBackingField(propertyDescriptor, containingClass).apply {
-            val builder = DeclarationIrBuilder(compilerContext, containingClass.symbol, startOffset, endOffset)
-            val initializerBody = builder.run {
-                val enumElement = IrGetEnumValueImpl(
-                    startOffset,
-                    endOffset,
-                    lazySafeModeClassDescriptor.defaultType,
-                    publicationEntryDescriptor.symbol
-                )
-
-                val lambdaExpression = containingClass.createLambdaExpression(targetIrType, initializerBuilder)
-
-                irExprBody(
-                    irInvoke(null, lazyFunctionSymbol, listOf(targetIrType), listOf(enumElement, lambdaExpression), lazyIrType)
-                )
-            }
-            backingField!!.initializer = initializerBody
-        }
-    }
-
-    fun createCompanionValProperty(
-        companionClass: IrClass,
-        type: IrType,
-        name: Name,
-        initializerBuilder: IrBlockBodyBuilder.() -> Unit
-    ): IrProperty {
-        val targetKotlinType = type.toKotlinType()
-        val propertyDescriptor =
-            KSerializerDescriptorResolver.createValPropertyDescriptor(name, companionClass.descriptor, targetKotlinType)
-
-        return generateSimplePropertyWithBackingField(propertyDescriptor, companionClass, name).apply {
-            companionClass.contributeAnonymousInitializer {
-                val irBlockBody = irBlockBody(startOffset, endOffset, initializerBuilder)
-                irBlockBody.statements.dropLast(1).forEach { +it }
-                val expression = irBlockBody.statements.last() as? IrExpression
-                    ?: throw AssertionError("Last statement in property initializer builder is not an a expression")
-                +irSetField(irGetObject(companionClass), backingField!!, expression)
-            }
-        }
-    }
-
-    fun IrClass.contributeAnonymousInitializer(bodyGen: IrBlockBodyBuilder.() -> Unit) {
-        val symbol = IrAnonymousInitializerSymbolImpl(descriptor)
-        factory.createAnonymousInitializer(startOffset, endOffset, SERIALIZABLE_PLUGIN_ORIGIN, symbol).also {
-            it.parent = this
-            declarations.add(it)
-            it.body = DeclarationIrBuilder(compilerContext, symbol, startOffset, endOffset).irBlockBody(startOffset, endOffset, bodyGen)
-        }
-    }
-
-    fun IrBlockBodyBuilder.getLazyValueExpression(thisParam: IrValueParameter, property: IrProperty, type: IrType): IrExpression {
-        val lazyIrClass = compilerContext.referenceClass(ClassId.topLevel(LAZY_FQ))!!.owner
-        val valueGetter = lazyIrClass.getPropertyGetter("value")!!
-
-        val propertyGetter = property.getter!!
-
-        return irInvoke(
-            irGet(propertyGetter.returnType, irGet(thisParam), propertyGetter.symbol),
-            valueGetter,
-            typeHint = type
-        )
-    }
-
-    fun IrBuilderWithScope.irInvoke(
-        dispatchReceiver: IrExpression? = null,
-        callee: IrFunctionSymbol,
-        vararg args: IrExpression,
-        typeHint: IrType? = null
-    ): IrMemberAccessExpression<*> {
-        assert(callee.isBound) { "Symbol $callee expected to be bound" }
-        val returnType = typeHint ?: callee.owner.returnType
-        val call = irCall(callee, type = returnType)
-        call.dispatchReceiver = dispatchReceiver
-        args.forEachIndexed(call::putValueArgument)
-        return call
-    }
-
-    fun IrBuilderWithScope.irInvoke(
-        dispatchReceiver: IrExpression? = null,
-        callee: IrFunctionSymbol,
-        typeArguments: List<IrType?>,
-        valueArguments: List<IrExpression>,
-        returnTypeHint: IrType? = null
-    ): IrMemberAccessExpression<*> =
-        irInvoke(
-            dispatchReceiver,
-            callee,
-            *valueArguments.toTypedArray(),
-            typeHint = returnTypeHint
-        ).also { call -> typeArguments.forEachIndexed(call::putTypeArgument) }
-
-    fun IrBuilderWithScope.createArrayOfExpression(
-        arrayElementType: IrType,
-        arrayElements: List<IrExpression>
-    ): IrExpression {
-
-        val arrayType = compilerContext.irBuiltIns.arrayClass.typeWith(arrayElementType)
-        val arg0 = IrVarargImpl(startOffset, endOffset, arrayType, arrayElementType, arrayElements)
-        val typeArguments = listOf(arrayElementType)
-
-        return irCall(compilerContext.irBuiltIns.arrayOf, arrayType, typeArguments = typeArguments).apply {
-            putValueArgument(0, arg0)
-        }
-    }
-
-    fun IrBuilderWithScope.createPrimitiveArrayOfExpression(
-        elementPrimitiveType: IrType,
-        arrayElements: List<IrExpression>
-    ): IrExpression {
-        val arrayType = compilerContext.irBuiltIns.primitiveArrayForType.getValue(elementPrimitiveType).defaultType
-        val arg0 = IrVarargImpl(startOffset, endOffset, arrayType, elementPrimitiveType, arrayElements)
-        val typeArguments = listOf(elementPrimitiveType)
-
-        return irCall(compilerContext.irBuiltIns.arrayOf, arrayType, typeArguments = typeArguments).apply {
-            putValueArgument(0, arg0)
-        }
-    }
-
-    fun IrBuilderWithScope.irBinOp(name: Name, lhs: IrExpression, rhs: IrExpression): IrExpression {
-        val classFqName = (lhs.type as IrSimpleType).classOrNull!!.owner.fqNameWhenAvailable!!
-        val symbol = compilerContext.referenceFunctions(CallableId(ClassId.topLevel(classFqName), name)).single()
-        return irInvoke(lhs, symbol, rhs)
-    }
-
-    fun IrBuilderWithScope.irGetObject(irObject: IrClass) =
-        IrGetObjectValueImpl(
-            startOffset,
-            endOffset,
-            irObject.defaultType,
-            irObject.symbol
-        )
-
-    fun <T : IrDeclaration> T.buildWithScope(builder: (T) -> Unit): T =
-        also { irDeclaration ->
-            compilerContext.symbolTable.withReferenceScope(irDeclaration) {
-                builder(irDeclaration)
-            }
-        }
-
-    class BranchBuilder(
-        val irWhen: IrWhen,
-        context: IrGeneratorContext,
-        scope: Scope,
-        startOffset: Int,
-        endOffset: Int
-    ) : IrBuilderWithScope(context, scope, startOffset, endOffset) {
-        operator fun IrBranch.unaryPlus() {
-            irWhen.branches.add(this)
-        }
-    }
-
-    fun IrBuilderWithScope.irWhen(typeHint: IrType? = null, block: BranchBuilder.() -> Unit): IrWhen {
-        val whenExpr = IrWhenImpl(startOffset, endOffset, typeHint ?: compilerContext.irBuiltIns.unitType)
-        val builder = BranchBuilder(whenExpr, context, scope, startOffset, endOffset)
-        builder.block()
-        return whenExpr
-    }
-
-    fun BranchBuilder.elseBranch(result: IrExpression): IrElseBranch =
-        IrElseBranchImpl(
-            IrConstImpl.boolean(result.startOffset, result.endOffset, compilerContext.irBuiltIns.booleanType, true),
-            result
-        )
-
-    @FirIncompatiblePluginAPI
-    fun KotlinType.toIrType() = compilerContext.typeTranslator.translateType(this)
-
-    // note: this method should be used only for properties from current module. Fields from other modules are private and inaccessible.
-    val IrSerializableProperty.irField: IrField?
-        get() = this.descriptor.backingField
-
-
-
-
-    /*
-      Create a function that creates `get property value expressions` for given corresponded constructor's param
-        (constructor_params) -> get_property_value_expression
-     */
-    fun IrBuilderWithScope.createPropertyByParamReplacer(
-        irClass: IrClass,
-        serialProperties: List<IrSerializableProperty>,
-        instance: IrValueParameter
-    ): (ValueParameterDescriptor) -> IrExpression? {
-        fun IrSerializableProperty.irGet(): IrExpression {
-            val ownerType = instance.symbol.owner.type
-            return getProperty(
-                irGet(
-                    type = ownerType,
-                    variable = instance.symbol
-                ), descriptor
-            )
-        }
-
-        val serialPropertiesMap = serialProperties.associateBy { it.descriptor }
-
-        val transientPropertiesSet =
-            irClass.declarations.asSequence()
-                .filterIsInstance<IrProperty>()
-                .filter { it.backingField != null }
-                .filter { !serialPropertiesMap.containsKey(it) }
-                .toSet()
-
-        return { vpd ->
-            val propertyDescriptor = irClass.properties.find { it.name == vpd.name }
-            if (propertyDescriptor != null) {
-                val value = serialPropertiesMap[propertyDescriptor]
-                value?.irGet() ?: run {
-                    if (propertyDescriptor in transientPropertiesSet)
-                        getProperty(
-                            irGet(instance),
-                            propertyDescriptor
-                        )
-                    else null
-                }
-            } else {
-                null
-            }
-        }
-    }
-
-    fun IrBuilderWithScope.getProperty(receiver: IrExpression, property: IrProperty): IrExpression {
-        return if (property.getter != null)
-            irGet(property.getter!!.returnType, receiver, property.getter!!.symbol)
-        else
-            irGetField(receiver, property.backingField!!)
-    }
-
-    fun IrBuilderWithScope.setProperty(receiver: IrExpression, property: IrProperty, value: IrExpression): IrExpression {
-        return if (property.setter != null)
-            irSet(property.setter!!.returnType, receiver, property.setter!!.symbol, value)
-        else
-            irSetField(receiver, property.backingField!!, value)
-    }
-
-    /*
-     The rest of the file is mainly copied from FunctionGenerator.
-     However, I can't use it's directly because all generateSomething methods require KtProperty (psi element)
-     Also, FunctionGenerator itself has DeclarationGenerator as ctor param, which is a part of psi2ir
-     (it can be instantiated here, but I don't know how good is that idea)
-     */
-
-    fun IrBuilderWithScope.generateAnySuperConstructorCall(toBuilder: IrBlockBodyBuilder) {
-        val anyConstructor = compilerContext.irBuiltIns.anyClass.owner.declarations.single { it is IrConstructor } as IrConstructor
-        with(toBuilder) {
-            +IrDelegatingConstructorCallImpl.fromSymbolDescriptor(
-                startOffset, endOffset,
-                compilerContext.irBuiltIns.unitType,
-                anyConstructor.symbol
-            )
-        }
-    }
-
-    fun IrBlockBodyBuilder.generateGoldenMaskCheck(
-        seenVars: List<IrValueDeclaration>,
-        properties: IrSerializableProperties,
-        serialDescriptor: IrExpression
-    ) {
-        val fieldsMissedTest: IrExpression
-        val throwErrorExpr: IrExpression
-
-        val maskSlotCount = seenVars.size
-        if (maskSlotCount == 1) {
-            val goldenMask = properties.goldenMask
-
-
-            throwErrorExpr = irInvoke(
-                null,
-                throwMissedFieldExceptionFunc!!,
-                irGet(seenVars[0]),
-                irInt(goldenMask),
-                serialDescriptor,
-                typeHint = compilerContext.irBuiltIns.unitType
-            )
-
-            fieldsMissedTest = irNotEquals(
-                irInt(goldenMask),
-                irBinOp(
-                    OperatorNameConventions.AND,
-                    irInt(goldenMask),
-                    irGet(seenVars[0])
-                )
-            )
-        } else {
-            val goldenMaskList = properties.goldenMaskList
-
-            var compositeExpression: IrExpression? = null
-            for (i in goldenMaskList.indices) {
-                val singleCheckExpr = irNotEquals(
-                    irInt(goldenMaskList[i]),
-                    irBinOp(
-                        OperatorNameConventions.AND,
-                        irInt(goldenMaskList[i]),
-                        irGet(seenVars[i])
-                    )
-                )
-
-                compositeExpression = if (compositeExpression == null) {
-                    singleCheckExpr
-                } else {
-                    irBinOp(
-                        OperatorNameConventions.OR,
-                        compositeExpression,
-                        singleCheckExpr
-                    )
-                }
-            }
-
-            fieldsMissedTest = compositeExpression!!
-
-            throwErrorExpr = irBlock {
-                +irInvoke(
-                    null,
-                    throwMissedFieldExceptionArrayFunc!!,
-                    createPrimitiveArrayOfExpression(compilerContext.irBuiltIns.intType, goldenMaskList.indices.map { irGet(seenVars[it]) }),
-                    createPrimitiveArrayOfExpression(compilerContext.irBuiltIns.intType, goldenMaskList.map { irInt(it) }),
-                    serialDescriptor,
-                    typeHint = compilerContext.irBuiltIns.unitType
-                )
-            }
-        }
-
-        +irIfThen(compilerContext.irBuiltIns.unitType, fieldsMissedTest, throwErrorExpr)
-    }
-
-    fun generateSimplePropertyWithBackingField(
-        propertyDescriptor: PropertyDescriptor,
-        propertyParent: IrClass,
-        fieldName: Name = propertyDescriptor.name,
-    ): IrProperty {
-        val irProperty = propertyParent.searchForDeclaration(propertyDescriptor) ?: run {
-            with(propertyDescriptor) {
-                propertyParent.factory.createProperty(
-                    propertyParent.startOffset, propertyParent.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrPropertySymbolImpl(propertyDescriptor),
-                    name, visibility, modality, isVar, isConst, isLateInit, isDelegated, isExternal
-                ).also {
-                    it.parent = propertyParent
-                    propertyParent.addMember(it)
-                }
-            }
-        }
-
-        propertyParent.generatePropertyBackingFieldIfNeeded(propertyDescriptor, irProperty, fieldName)
-        val fieldSymbol = irProperty.backingField!!.symbol
-        irProperty.getter = propertyDescriptor.getter?.let {
-            propertyParent.generatePropertyAccessor(propertyDescriptor, irProperty, it, fieldSymbol, isGetter = true)
-        }?.apply { parent = propertyParent }
-        irProperty.setter = propertyDescriptor.setter?.let {
-            propertyParent.generatePropertyAccessor(propertyDescriptor, irProperty, it, fieldSymbol, isGetter = false)
-        }?.apply { parent = propertyParent }
-        return irProperty
-    }
-
-    fun IrType.kClassToJClassIfNeeded(): IrType = this
-
-    fun kClassExprToJClassIfNeeded(startOffset: Int, endOffset: Int, irExpression: IrExpression): IrExpression = irExpression
-
-    private fun IrClass.generatePropertyBackingFieldIfNeeded(
-        propertyDescriptor: PropertyDescriptor,
-        originProperty: IrProperty,
-        name: Name,
-    ) {
-        if (originProperty.backingField != null) return
-
-        val field = with(propertyDescriptor) {
-            // TODO: type parameters
-            @OptIn(FirIncompatiblePluginAPI::class)// should be called only with old FE
-            originProperty.factory.createField(
-                originProperty.startOffset, originProperty.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrFieldSymbolImpl(propertyDescriptor), name, type.toIrType(),
-                visibility, !isVar, isEffectivelyExternal(), dispatchReceiverParameter == null
-            )
-        }
-        field.apply {
-            parent = this@generatePropertyBackingFieldIfNeeded
-            correspondingPropertySymbol = originProperty.symbol
-        }
-
-        originProperty.backingField = field
-    }
-
-    private fun IrClass.generatePropertyAccessor(
-        propertyDescriptor: PropertyDescriptor,
-        property: IrProperty,
-        descriptor: PropertyAccessorDescriptor,
-        fieldSymbol: IrFieldSymbol,
-        isGetter: Boolean,
-    ): IrSimpleFunction {
-        val irAccessor: IrSimpleFunction = when (isGetter) {
-            true -> searchForDeclaration<IrProperty>(propertyDescriptor)?.getter
-            false -> searchForDeclaration<IrProperty>(propertyDescriptor)?.setter
-        } ?: run {
-            with(descriptor) {
-                @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
-                property.factory.createFunction(
-                    fieldSymbol.owner.startOffset, fieldSymbol.owner.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrSimpleFunctionSymbolImpl(descriptor),
-                    name, visibility, modality, returnType!!.toIrType(),
-                    isInline, isEffectivelyExternal(), isTailrec, isSuspend, isOperator, isInfix, isExpect
-                )
-            }.also { f ->
-                generateOverriddenFunctionSymbols(f, compilerContext.symbolTable)
-                f.createParameterDeclarations(descriptor)
-                @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
-                f.returnType = descriptor.returnType!!.toIrType()
-                f.correspondingPropertySymbol = fieldSymbol.owner.correspondingPropertySymbol
-            }
-        }
-
-        irAccessor.body = when (isGetter) {
-            true -> generateDefaultGetterBody(descriptor as PropertyGetterDescriptor, irAccessor)
-            false -> generateDefaultSetterBody(descriptor as PropertySetterDescriptor, irAccessor)
-        }
-
-        return irAccessor
-    }
-
-    private fun generateDefaultGetterBody(
-        getter: PropertyGetterDescriptor,
-        irAccessor: IrSimpleFunction
-    ): IrBlockBody {
-        val property = getter.correspondingProperty
-        val irProperty = irAccessor.correspondingPropertySymbol?.owner ?: error("Expected property for $getter")
-
-        val startOffset = irAccessor.startOffset
-        val endOffset = irAccessor.endOffset
-        val irBody = irAccessor.factory.createBlockBody(startOffset, endOffset)
-
-        val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!.symbol, property)
-
-        val propertyIrType = irAccessor.returnType
-        irBody.statements.add(
-            IrReturnImpl(
-                startOffset, endOffset, compilerContext.irBuiltIns.nothingType,
-                irAccessor.symbol,
-                IrGetFieldImpl(
-                    startOffset, endOffset,
-                    irProperty.backingField?.symbol ?: error("Property expected to have backing field"),
-                    propertyIrType,
-                    receiver
-                ).let {
-                    if (propertyIrType.isKClass()) {
-                        irAccessor.returnType = irAccessor.returnType.kClassToJClassIfNeeded()
-                        kClassExprToJClassIfNeeded(startOffset, endOffset, it)
-                    } else it
-                }
-            )
-        )
-        return irBody
-    }
-
-    private fun generateDefaultSetterBody(
-        setter: PropertySetterDescriptor,
-        irAccessor: IrSimpleFunction
-    ): IrBlockBody {
-        val property = setter.correspondingProperty
-        val irProperty = irAccessor.correspondingPropertySymbol?.owner ?: error("Expected corresponding property for accessor $setter")
-        val startOffset = irAccessor.startOffset
-        val endOffset = irAccessor.endOffset
-        val irBody = irAccessor.factory.createBlockBody(startOffset, endOffset)
-
-        val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!.symbol, property)
-
-        val irValueParameter = irAccessor.valueParameters.single()
-        irBody.statements.add(
-            IrSetFieldImpl(
-                startOffset, endOffset,
-                irProperty.backingField?.symbol ?: error("Property $property expected to have backing field"),
-                receiver,
-                IrGetValueImpl(startOffset, endOffset, irValueParameter.type, irValueParameter.symbol),
-                compilerContext.irBuiltIns.unitType
-            )
-        )
-        return irBody
-    }
-
-    fun generateReceiverExpressionForFieldAccess( // todo: remove this
-        ownerSymbol: IrValueSymbol,
-        property: PropertyDescriptor
-    ): IrExpression {
-        val containingDeclaration = property.containingDeclaration
-        return when (containingDeclaration) {
-            is ClassDescriptor ->
-                IrGetValueImpl(
-                    ownerSymbol.owner.startOffset, ownerSymbol.owner.endOffset,
-                    ownerSymbol
-                )
-            else -> throw AssertionError("Property must be in class")
-        }
-    }
-
-    fun IrFunction.createParameterDeclarations(
-        descriptor: FunctionDescriptor,
-        overwriteValueParameters: Boolean = false,
-        copyTypeParameters: Boolean = true
-    ) {
-        val function = this
-        fun irValueParameter(descriptor: ParameterDescriptor): IrValueParameter = with(descriptor) {
-            @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
-            factory.createValueParameter(
-                function.startOffset, function.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrValueParameterSymbolImpl(this),
-                name, indexOrMinusOne, type.toIrType(), varargElementType?.toIrType(), isCrossinline, isNoinline,
-                isHidden = false, isAssignable = false
-            ).also {
-                it.parent = function
-            }
-        }
-
-        if (copyTypeParameters) {
-            assert(typeParameters.isEmpty())
-            copyTypeParamsFromDescriptor(descriptor)
-        }
-
-        dispatchReceiverParameter = descriptor.dispatchReceiverParameter?.let { irValueParameter(it) }
-        extensionReceiverParameter = descriptor.extensionReceiverParameter?.let { irValueParameter(it) }
-
-        if (!overwriteValueParameters)
-            assert(valueParameters.isEmpty())
-
-        valueParameters = descriptor.valueParameters.map { irValueParameter(it) }
-    }
-
-    fun IrFunction.copyTypeParamsFromDescriptor(descriptor: FunctionDescriptor) {
-        val newTypeParameters = descriptor.typeParameters.map {
-            factory.createTypeParameter(
-                startOffset, endOffset,
-                SERIALIZABLE_PLUGIN_ORIGIN,
-                IrTypeParameterSymbolImpl(it),
-                it.name, it.index, it.isReified, it.variance
-            ).also { typeParameter ->
-                typeParameter.parent = this
-            }
-        }
-        @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
-        newTypeParameters.forEach { typeParameter ->
-            typeParameter.superTypes = typeParameter.descriptor.upperBounds.map { it.toIrType() }
-        }
-
-        typeParameters = newTypeParameters
-    }
-
-    fun createClassReference(classType: IrType, startOffset: Int, endOffset: Int): IrClassReference {
-        return IrClassReferenceImpl(
-            startOffset,
-            endOffset,
-            compilerContext.irBuiltIns.kClassClass.starProjectedType,
-            classType.classifierOrFail,
-            classType
-        )
-    }
-
-    // It is impossible to use star projections right away, because Array<Int>::class differ from Array<String>::class :
-    // detailed information about type arguments required for class references on jvm
-    private val KotlinType.approximateJvmErasure: KotlinType
-        get() = when (val classifier = constructor.declarationDescriptor) {
-            is TypeParameterDescriptor -> {
-                // Note that if the upper bound is Array, the argument type will be replaced with star here, which is probably incorrect.
-                classifier.classBound.defaultType.replaceArgumentsWithStarProjections()
-            }
-            is ClassDescriptor -> if (KotlinBuiltIns.isArray(this)) {
-                replace(arguments.map { TypeProjectionImpl(Variance.INVARIANT, it.type.approximateJvmErasure) })
-            } else {
-                replaceArgumentsWithStarProjections()
-            }
-            else -> error("Unsupported classifier: $this")
-        }
-
-    private val TypeParameterDescriptor.classBound: ClassDescriptor
-        get() = when (val bound = representativeUpperBound.constructor.declarationDescriptor) {
-            is ClassDescriptor -> bound
-            is TypeParameterDescriptor -> bound.classBound
-            else -> error("Unsupported classifier: $this")
-        }
-
-
-    fun IrBuilderWithScope.classReference(classSymbol: IrType): IrClassReference =
-        createClassReference(classSymbol, startOffset, endOffset)
-
-    private fun extractDefaultValuesFromConstructor(irClass: IrClass?): Map<IrValueSymbol, IrExpression?> {
-        if (irClass == null) return emptyMap()
-        val original = irClass.constructors.singleOrNull { it.isPrimary }
-        // default arguments of original constructor
-        val defaultsMap: Map<IrValueSymbol, IrExpression?> =
-            original?.valueParameters?.associate { it.symbol to it.defaultValue?.expression } ?: emptyMap()
-        return defaultsMap + extractDefaultValuesFromConstructor(irClass.getSuperClassNotAny())
-    }
-
-    /*
-    Creates an initializer adapter function that can replace IR expressions of getting constructor parameter value by some other expression.
-    Also adapter may replace IR expression of getting `this` value by another expression.
-     */
-    fun createInitializerAdapter(
-        irClass: IrClass,
-        paramGetReplacer: (ValueParameterDescriptor) -> IrExpression?,
-        thisGetReplacer: Pair<IrValueSymbol, () -> IrExpression>? = null
-    ): (IrExpressionBody) -> IrExpression {
-        val initializerTransformer = object : IrElementTransformerVoid() {
-            // try to replace `get some value` expression
-            override fun visitGetValue(expression: IrGetValue): IrExpression {
-                val symbol = expression.symbol
-                if (thisGetReplacer != null && thisGetReplacer.first == symbol) {
-                    // replace `get this value` expression
-                    return thisGetReplacer.second()
-                }
-
-                val descriptor = symbol.descriptor
-                if (descriptor is ValueParameterDescriptor) {
-                    // replace `get parameter value` expression
-                    paramGetReplacer(descriptor)?.let { return it }
-                }
-
-                // otherwise leave expression as it is
-                return super.visitGetValue(expression)
-            }
-        }
-        val defaultsMap = extractDefaultValuesFromConstructor(irClass)
-        return fun(initializer: IrExpressionBody): IrExpression {
-            val rawExpression = initializer.expression
-            val expression =
-                if (rawExpression.isInitializePropertyFromParameter()) {
-                    // this is a primary constructor property, use corresponding default of value parameter
-                     defaultsMap.getValue((rawExpression as IrGetValue).symbol)!!
-                } else {
-                    rawExpression
-                }
-            return expression.deepCopyWithVariables().transform(initializerTransformer, null)
-        }
-    }
-
-    private fun getEnumMembersNames(enumClass: ClassDescriptor): Sequence<String> {
-        assert(enumClass.kind == ClassKind.ENUM_CLASS)
-        return enumClass.unsubstitutedMemberScope.getContributedDescriptors().asSequence()
-            .filterIsInstance<ClassDescriptor>()
-            .filter { it.kind == ClassKind.ENUM_ENTRY }
-            .map { it.name.toString() }
-    }
-
-    fun IrBuilderWithScope.copyAnnotationsFrom(annotations: List<IrConstructorCall>): List<IrExpression> =
-        annotations.mapNotNull { annotationCall ->
-            val annotationClass = annotationCall.symbol.owner.parentAsClass
-            if (!annotationClass.descriptor.isSerialInfoAnnotation) return@mapNotNull null
-
-            if (compilerContext.platform.isJvm()) {
-                val implClass = compilerContext.serialInfoImplJvmIrGenerator.getImplClass(annotationClass)
-                val ctor = implClass.constructors.singleOrNull { it.valueParameters.size == annotationCall.valueArgumentsCount }
-                    ?: error("No constructor args found for SerialInfo annotation Impl class: ${implClass.render()}")
-                irCall(ctor).apply {
-                    for (i in 0 until annotationCall.valueArgumentsCount) {
-                        val argument = annotationCall.getValueArgument(i)
-                            ?: annotationClass.primaryConstructor!!.valueParameters[i].defaultValue?.expression
-                        putValueArgument(i, argument!!.deepCopyWithVariables())
-                    }
-                }
-            } else {
-                annotationCall.deepCopyWithVariables()
-            }
-        }
-
-    // Does not use sti and therefore does not perform encoder calls optimization
-    fun IrBuilderWithScope.serializerTower(
-        generator: SerializerIrGenerator,
-        dispatchReceiverParameter: IrValueParameter,
-        property: IrSerializableProperty
-    ): IrExpression? {
-        val nullableSerClass = compilerContext.referenceProperties(SerialEntityNames.wrapIntoNullableCallableId).single()
-        val serializer =
-            property.serializableWith(compilerContext)
-                ?: if (!property.type.isTypeParameter()) generator.findTypeSerializerOrContext(
-                    compilerContext,
-                    property.type
-                ) else null
-        return serializerInstance(
-            generator,
-            dispatchReceiverParameter,
-            serializer,
-            compilerContext,
-            property.type,
-            genericIndex = property.genericIndex
-        )
-            ?.let { expr -> wrapWithNullableSerializerIfNeeded(property.type, expr, nullableSerClass) }
-    }
-
-    private fun IrBuilderWithScope.wrapWithNullableSerializerIfNeeded(
-        type: IrType,
-        expression: IrExpression,
-        nullableProp: IrPropertySymbol
-    ): IrExpression = if (type.isMarkedNullable()) {
-        val resultType = type.makeNotNull()
-        val typeArguments = listOf(resultType)
-        val callee = nullableProp.owner.getter!!
-
-        val returnType = callee.returnType.substitute(callee.typeParameters, typeArguments)
-
-        irInvoke(
-            callee = callee.symbol,
-            typeArguments = typeArguments,
-            valueArguments = emptyList(),
-            returnTypeHint = returnType
-        ).apply { extensionReceiver = expression }
-    } else {
-        expression
-    }
-
-    fun wrapIrTypeIntoKSerializerIrType(
-        type: IrType,
-        variance: Variance = Variance.INVARIANT
-    ): IrType {
-        val kSerClass = compilerContext.referenceClass(ClassId(SerializationPackages.packageFqName, SerialEntityNames.KSERIALIZER_NAME))
-            ?: error("Couldn't find class ${SerialEntityNames.KSERIALIZER_NAME}")
-        return IrSimpleTypeImpl(
-            kSerClass, hasQuestionMark = false, arguments = listOf(
-                makeTypeProjection(type, variance)
-            ), annotations = emptyList()
-        )
-    }
-
-    fun IrBuilderWithScope.serializerInstance(
-        enclosingGenerator: SerializerIrGenerator,
-        dispatchReceiverParameter: IrValueParameter,
-        serializerClassOriginal: IrClassSymbol?,
-        pluginContext: SerializationPluginContext,
-        kType: IrType,
-        genericIndex: Int? = null
-    ): IrExpression? = serializerInstance(
-        enclosingGenerator,
-        serializerClassOriginal,
-        pluginContext,
-        kType,
-        genericIndex
-    ) { it, _ ->
-        val (_, ir) = enclosingGenerator.localSerializersFieldsDescriptors[it]
-        irGetField(irGet(dispatchReceiverParameter), ir.backingField!!)
-    }
-
-    fun IrBuilderWithScope.serializerInstance(
-        enclosingGenerator: AbstractIrGenerator,
-        serializerClassOriginal: ClassDescriptor?,
-        module: ModuleDescriptor,
-        kType: IrType,
-        genericIndex: Int? = null,
-        genericGetter: ((Int) -> IrExpression)? = null
-    ): IrExpression? {
-        return serializerInstance(
-            enclosingGenerator,
-            serializerClassOriginal?.let { compilerContext.symbolTable.referenceClass(it) },
-            compilerContext,
-            kType,
-            genericIndex,
-            if (genericGetter != null) { i, _ -> genericGetter(i) } else null
-        )
-    }
-
-    fun IrBuilderWithScope.serializerInstance(
-        enclosingGenerator: AbstractIrGenerator,
-        serializerClassOriginal: IrClassSymbol?,
-        pluginContext: SerializationPluginContext,
-        kType: IrType,
-        genericIndex: Int? = null,
-        genericGetter: ((Int, IrType) -> IrExpression)? = null
-    ): IrExpression? {
-        val nullableSerClass = compilerContext.referenceProperties(SerialEntityNames.wrapIntoNullableCallableId).single()
-        if (serializerClassOriginal == null) {
-            if (genericIndex == null) return null
-            return genericGetter?.invoke(genericIndex, kType)
-        }
-        if (serializerClassOriginal.owner.kind == ClassKind.OBJECT) {
-            return irGetObject(serializerClassOriginal)
-        }
-        fun instantiate(serializer: IrClassSymbol?, type: IrType): IrExpression? {
-            val expr = serializerInstance(
-                enclosingGenerator,
-                serializer,
-                pluginContext,
-                type,
-                type.genericIndex,
-                genericGetter
-            ) ?: return null
-            return wrapWithNullableSerializerIfNeeded(type, expr, nullableSerClass)
-        }
-
-        var serializerClass = serializerClassOriginal
-        var args: List<IrExpression>
-        var typeArgs: List<IrType>
-        val thisIrType = (kType as? IrSimpleType) ?: error("Don't know how to work with type ${kType::class}")
-        var needToCopyAnnotations = false
-
-        when (serializerClassOriginal.owner.classId) {
-            polymorphicSerializerId -> {
-                needToCopyAnnotations = true
-                args = listOf(classReference(kType))
-                typeArgs = listOf(thisIrType)
-            }
-            contextSerializerId -> {
-                args = listOf(classReference(kType))
-                typeArgs = listOf(thisIrType)
-
-                val hasNewCtxSerCtor = compilerContext.referenceConstructors(contextSerializerId).any { it.owner.valueParameters.size == 3 }
-
-                if (hasNewCtxSerCtor) {
-                    // new signature of context serializer
-                    args = args + mutableListOf<IrExpression>().apply {
-                        val fallbackDefaultSerializer = findTypeSerializer(pluginContext, kType)
-                        add(instantiate(fallbackDefaultSerializer, kType) ?: irNull())
-                        add(
-                            createArrayOfExpression(
-                                wrapIrTypeIntoKSerializerIrType(
-                                    thisIrType,
-                                    variance = Variance.OUT_VARIANCE
-                                ),
-                                thisIrType.arguments.map {
-                                    val argSer = enclosingGenerator.findTypeSerializerOrContext(
-                                        compilerContext,
-                                        it.typeOrNull!! //todo: handle star projections here?
-                                    )
-                                    instantiate(argSer, it.typeOrNull!!)!!
-                                })
-                        )
-                    }
-                }
-            }
-            objectSerializerId -> {
-                needToCopyAnnotations = true
-                args = listOf(irString(kType.serialName()), irGetObject(kType.classOrNull!!))
-                typeArgs = listOf(thisIrType)
-            }
-            sealedSerializerId -> {
-                needToCopyAnnotations = true
-                args = mutableListOf<IrExpression>().apply {
-                    add(irString(kType.serialName()))
-                    add(classReference(kType))
-                    val (subclasses, subSerializers) = enclosingGenerator.allSealedSerializableSubclassesFor(
-                        kType.classOrNull!!.owner,
-                        pluginContext
-                    )
-                    val projectedOutCurrentKClass =
-                        compilerContext.irBuiltIns.kClassClass.typeWithArguments(
-                            listOf(makeTypeProjection(thisIrType, Variance.OUT_VARIANCE))
-                        )
-                    add(
-                        createArrayOfExpression(
-                            projectedOutCurrentKClass,
-                            subclasses.map { classReference(it) }
-                        )
-                    )
-                    add(
-                        createArrayOfExpression(
-                            wrapIrTypeIntoKSerializerIrType(thisIrType, variance = Variance.OUT_VARIANCE),
-                            subSerializers.mapIndexed { i, serializer ->
-                                val type = subclasses[i]
-                                val expr = serializerInstance(
-                                    enclosingGenerator,
-                                    serializer,
-                                    pluginContext,
-                                    type,
-                                    type.genericIndex
-                                ) { _, genericType ->
-                                    serializerInstance(
-                                        enclosingGenerator,
-                                        pluginContext.referenceClass(polymorphicSerializerId),
-                                        pluginContext,
-                                        (genericType.classifierOrNull as IrTypeParameterSymbol).owner.representativeUpperBound
-                                    )!!
-                                }!!
-                                wrapWithNullableSerializerIfNeeded(type, expr, nullableSerClass)
-                            }
-                        )
-                    )
-                }
-                typeArgs = listOf(thisIrType)
-            }
-            enumSerializerId -> {
-                serializerClass = pluginContext.referenceClass(enumSerializerId)
-                val enumDescriptor = kType.classOrNull!!
-                typeArgs = listOf(thisIrType)
-                // instantiate serializer only inside enum Companion
-                if (enclosingGenerator !is SerializableCompanionIrGenerator) {
-                    // otherwise call Companion.serializer()
-                    callSerializerFromCompanion(thisIrType, typeArgs, emptyList())?.let { return it }
-                }
-
-                val enumArgs = mutableListOf(
-                    irString(thisIrType.serialName()),
-                    irCall(enumDescriptor.owner.findEnumValuesMethod()),
-                )
-
-                val enumSerializerFactoryFunc = enumSerializerFactoryFunc
-                val markedEnumSerializerFactoryFunc = markedEnumSerializerFactoryFunc
-                if (enumSerializerFactoryFunc != null && markedEnumSerializerFactoryFunc != null) {
-                    // runtime contains enum serializer factory functions
-                    val factoryFunc: IrSimpleFunctionSymbol = if (enumDescriptor.owner.isEnumWithSerialInfoAnnotation()) {
-                        // need to store SerialInfo annotation in descriptor
-                        val enumEntries = enumDescriptor.owner.enumEntries()
-                        val entriesNames = enumEntries.map { it.annotations.serialNameValue?.let { n -> irString(n) } ?: irNull() }
-                        val entriesAnnotations = enumEntries.map {
-                            val annotationConstructors = it.annotations.map { a ->
-//                                compilerContext.typeTranslator.constantValueGenerator.generateAnnotationConstructorCall(a)
-                                a.deepCopyWithVariables()
-                            }
-                            val annotationsConstructors = copyAnnotationsFrom(annotationConstructors)
-                            if (annotationsConstructors.isEmpty()) {
-                                irNull()
-                            } else {
-                                createArrayOfExpression(compilerContext.irBuiltIns.annotationType, annotationsConstructors)
-                            }
-                        }
-                        val annotationArrayType =
-                            compilerContext.irBuiltIns.arrayClass.typeWith(compilerContext.irBuiltIns.annotationType.makeNullable())
-
-                        enumArgs += createArrayOfExpression(compilerContext.irBuiltIns.stringType.makeNullable(), entriesNames)
-                        enumArgs += createArrayOfExpression(annotationArrayType, entriesAnnotations)
-
-                        markedEnumSerializerFactoryFunc
-                    } else {
-                        enumSerializerFactoryFunc
-                    }
-
-                    val factoryReturnType = factoryFunc.owner.returnType.substitute(factoryFunc.owner.typeParameters, typeArgs)
-                    return irInvoke(null, factoryFunc, typeArgs, enumArgs, factoryReturnType)
-                } else {
-                    // support legacy serializer instantiation by constructor for old runtimes
-                    args = enumArgs
-                }
-            }
-            else -> {
-                args = kType.arguments.map {
-                    val argSer = enclosingGenerator.findTypeSerializerOrContext(
-                        pluginContext,
-                        it.typeOrNull!! // todo: stars?
-                    )
-                    instantiate(argSer, it.typeOrNull!!) ?: return null
-                }
-                typeArgs = kType.arguments.map { it.typeOrNull!! }
-            }
-
-        }
-        if (serializerClassOriginal.owner.classId == referenceArraySerializerId) {
-            args = listOf(wrapperClassReference(kType.arguments.single().typeOrNull!!)) + args
-            typeArgs = listOf(typeArgs[0].makeNotNull()) + typeArgs
-        }
-
-        // If KType is interface, .classSerializer always yields PolymorphicSerializer, which may be unavailable for interfaces from other modules
-        if (!kType.isInterface() && serializerClassOriginal == kType.classOrNull!!.owner.classSerializer(pluginContext) && enclosingGenerator !is SerializableCompanionIrGenerator) {
-            // This is default type serializer, we can shortcut through Companion.serializer()
-            // BUT not during generation of this method itself
-            callSerializerFromCompanion(thisIrType, typeArgs, args)?.let { return it }
-        }
-
-
-        val serializable = serializerClass?.owner?.let { getSerializableClassDescriptorBySerializer(it) }
-        requireNotNull(serializerClass)
-        val ctor = if (serializable?.typeParameters?.isNotEmpty() == true) {
-            requireNotNull(
-                findSerializerConstructorForTypeArgumentsSerializers(serializerClass.owner)
-            ) { "Generated serializer does not have constructor with required number of arguments" }
-        } else {
-            val constructors = serializerClass.constructors
-            // search for new signature of polymorphic/sealed/contextual serializer
-            if (!needToCopyAnnotations) {
-                constructors.single { it.owner.isPrimary }
-            } else {
-                constructors.find { it.owner.lastArgumentIsAnnotationArray() } ?: run {
-                    // not found - we are using old serialization runtime without this feature
-                    // todo: optimize allocating an empty array when no annotations defined, maybe use old constructor?
-                    needToCopyAnnotations = false
-                    constructors.single { it.owner.isPrimary }
-                }
-            }
-        }
-        // Return type should be correctly substituted
-        assert(ctor.isBound)
-        val ctorDecl = ctor.owner
-        if (needToCopyAnnotations) {
-            val classAnnotations = copyAnnotationsFrom(thisIrType.getClass()?.let { collectSerialInfoAnnotations(it) }.orEmpty())
-            args = args + createArrayOfExpression(compilerContext.irBuiltIns.annotationType, classAnnotations)
-        }
-
-        val typeParameters = ctorDecl.parentAsClass.typeParameters
-        val substitutedReturnType = ctorDecl.returnType.substitute(typeParameters, typeArgs)
-        return irInvoke(
-            null,
-            ctor,
-            // User may declare serializer with fixed type arguments, e.g. class SomeSerializer : KSerializer<ClosedRange<Float>>
-            typeArguments = typeArgs.takeIf { it.size == ctorDecl.typeParameters.size }.orEmpty(),
-            valueArguments = args.takeIf { it.size == ctorDecl.valueParameters.size }.orEmpty(),
-            returnTypeHint = substitutedReturnType
-        )
-    }
-
-    fun collectSerialInfoAnnotations(irClass: IrClass): List<IrConstructorCall> {
-        if (!(irClass.isInterface || irClass.descriptor.hasSerializableOrMetaAnnotation)) return emptyList()
-        val annotationByFq: MutableMap<FqName, IrConstructorCall> =
-            irClass.annotations.associateBy { it.symbol.owner.parentAsClass.descriptor.fqNameSafe }.toMutableMap()
-        for (clazz in irClass.getAllSuperclasses()) {
-            val annotations = clazz.annotations
-                .mapNotNull {
-                    val descriptor = it.symbol.owner.parentAsClass.descriptor
-                    if (descriptor.isInheritableSerialInfoAnnotation) descriptor.fqNameSafe to it else null
-                }
-            annotations.forEach { (fqname, call) ->
-                if (fqname !in annotationByFq) {
-                    annotationByFq[fqname] = call
-                } else {
-                    // SerializationPluginDeclarationChecker already reported inconsistency
-                }
-            }
-        }
-        return annotationByFq.values.toList()
-    }
-
-    fun IrBuilderWithScope.callSerializerFromCompanion(
-        thisIrType: IrType,
-        typeArgs: List<IrType>,
-        args: List<IrExpression>
-    ): IrExpression? {
-        val baseClass = thisIrType.getClass() ?: return null
-        val companionClass = baseClass.companionObject() ?: return null
-        val serializerProviderFunction = companionClass.declarations.singleOrNull {
-            it is IrFunction && it.name == SerialEntityNames.SERIALIZER_PROVIDER_NAME && it.valueParameters.size == baseClass.typeParameters.size
-        } ?: return null
-
-        val adjustedArgs: List<IrExpression> =
-            // if typeArgs.size == args.size then the serializer is custom - we need to use the actual serializers from the arguments
-            if ((typeArgs.size != args.size) && (baseClass.descriptor.isSealed() || baseClass.descriptor.modality == Modality.ABSTRACT)) {
-                val serializer = findStandardKotlinTypeSerializer(compilerContext, context.irBuiltIns.unitType)!!
-                // workaround for sealed and abstract classes - the `serializer` function expects non-null serializers, but does not use them, so serializers of any type can be passed
-                List(baseClass.typeParameters.size) { irGetObject(serializer) }
-            } else {
-                args
-            }
-
-        with(serializerProviderFunction as IrFunction) {
-            // Note that [typeArgs] may be unused if we short-cut to e.g. SealedClassSerializer
-            return irInvoke(
-                irGetObject(companionClass),
-                symbol,
-                typeArgs.takeIf { it.size == typeParameters.size }.orEmpty(),
-                adjustedArgs.takeIf { it.size == valueParameters.size }.orEmpty()
-            )
-        }
-    }
-
-    private fun IrConstructor.lastArgumentIsAnnotationArray(): Boolean {
-        val lastArgType = valueParameters.lastOrNull()?.type
-        if (lastArgType == null || !lastArgType.isArray()) return false
-        return ((lastArgType as? IrSimpleType)?.arguments?.firstOrNull()?.typeOrNull?.classFqName?.toString() == "kotlin.Annotation")
-    }
-
-    private fun IrBuilderWithScope.wrapperClassReference(classType: IrType): IrClassReference {
-        if (compilerContext.platform.isJvm()) {
-            // "Byte::class" -> "java.lang.Byte::class"
-//          TODO: get rid of descriptor
-            val wrapperFqName = KotlinBuiltIns.getPrimitiveType(classType.classOrNull!!.descriptor)?.let(JvmPrimitiveType::get)?.wrapperFqName
-            if (wrapperFqName != null) {
-                val wrapperClass = compilerContext.referenceClass(ClassId.topLevel(wrapperFqName))
-                    ?: error("Primitive wrapper class for $classType not found: $wrapperFqName")
-                return classReference(wrapperClass.defaultType)
-            }
-        }
-        return classReference(classType)
-    }
-
-    fun findSerializerConstructorForTypeArgumentsSerializers(serializer: IrClass): IrConstructorSymbol? {
-
-        val typeParamsCount = ((serializer.superTypes.find { isKSerializer(it) } as IrSimpleType).arguments.first().typeOrNull!! as IrSimpleType).arguments.size
-        if (typeParamsCount == 0) return null //don't need it
-
-        return serializer.constructors.singleOrNull {
-            it.valueParameters.let { vps -> vps.size == typeParamsCount && vps.all { vp -> isKSerializer(vp.type) } }
-        }?.symbol
-    }
-
-    private fun IrConstructor.isSerializationCtor(): Boolean {
-        val serialMarker =
-            compilerContext.referenceClass(ClassId.topLevel(SerializationPackages.internalPackageFqName.child(SerialEntityNames.SERIAL_CTOR_MARKER_NAME)))
-
-        return valueParameters.lastOrNull()?.run {
-            name == SerialEntityNames.dummyParamName && type.classifierOrNull == serialMarker
-        } == true
-    }
-
-    fun serializableSyntheticConstructor(forClass: IrClass): IrConstructorSymbol? { // todo: remove this W/A when FIR plugin will add proper ctor
-        return forClass.declarations.filterIsInstance<IrConstructor>().singleOrNull { it.isSerializationCtor() }?.symbol
-    }
-
-    fun IrClass.getSuperClassOrAny(): IrClass = getSuperClassNotAny() ?: compilerContext.irBuiltIns.anyClass.owner
-
-    fun IrClass.getSuperClassNotAny(): IrClass? {
-        val superClasses = superTypes.mapNotNull { it.classOrNull }.map { it.owner }
-
-        return superClasses.singleOrNull { it.kind == ClassKind.CLASS }
-    }
-
-    fun IrClass.findWriteSelfMethod(): IrSimpleFunction? =
-        declarations.singleOrNull { it is IrSimpleFunction && it.name == SerialEntityNames.WRITE_SELF_NAME && !it.isFakeOverride } as IrSimpleFunction?
-
-    fun IrBlockBodyBuilder.serializeAllProperties(
-        generator: AbstractIrGenerator,
-        serializableIrClass: IrClass,
-        serializableProperties: List<IrSerializableProperty>,
-        objectToSerialize: IrValueDeclaration,
-        localOutput: IrValueDeclaration,
-        localSerialDesc: IrValueDeclaration,
-        kOutputClass: IrClassSymbol,
-        ignoreIndexTo: Int,
-        initializerAdapter: (IrExpressionBody) -> IrExpression,
-        genericGetter: ((Int, IrType) -> IrExpression)?
-    ) {
-
-        fun IrSerializableProperty.irGet(): IrExpression {
-            val ownerType = objectToSerialize.symbol.owner.type
-            return getProperty(
-                irGet(
-                    type = ownerType,
-                    variable = objectToSerialize.symbol
-                ), descriptor
-            )
-        }
-
-        for ((index, property) in serializableProperties.withIndex()) {
-            if (index < ignoreIndexTo) continue
-            // output.writeXxxElementValue(classDesc, index, value)
-            val elementCall = formEncodeDecodePropertyCall(
-                generator,
-                irGet(localOutput),
-                property, { innerSerial, sti ->
-                    val f =
-                        kOutputClass.functionByName("${CallingConventions.encode}${sti.elementMethodPrefix}Serializable${CallingConventions.elementPostfix}")
-                    f to listOf(
-                        irGet(localSerialDesc),
-                        irInt(index),
-                        innerSerial,
-                        property.irGet()
-                    )
-                }, {
-                    val f =
-                        kOutputClass.functionByName("${CallingConventions.encode}${it.elementMethodPrefix}${CallingConventions.elementPostfix}")
-                    val args: MutableList<IrExpression> = mutableListOf(irGet(localSerialDesc), irInt(index))
-                    if (it.elementMethodPrefix != "Unit") args.add(property.irGet())
-                    f to args
-                },
-                genericGetter
-            )
-
-            // check for call to .shouldEncodeElementDefault
-            val encodeDefaults = property.descriptor.getEncodeDefaultAnnotationValue()
-            val field = property.irField // Nullable when property from another module; can't compare it with default value on JS or Native
-            if (!property.optional || encodeDefaults == true || field == null) {
-                // emit call right away
-                +elementCall
-            } else {
-                val partB = irNotEquals(property.irGet(), initializerAdapter(field.initializer!!))
-
-                val condition = if (encodeDefaults == false) {
-                    // drop default without call to .shouldEncodeElementDefault
-                    partB
-                } else {
-                    // emit check:
-                    // if (if (output.shouldEncodeElementDefault(this.descriptor, i)) true else {obj.prop != DEFAULT_VALUE} ) {
-                    //    output.encodeIntElement(this.descriptor, i, obj.prop)// block {obj.prop != DEFAULT_VALUE} may contain several statements
-                    val shouldEncodeFunc = kOutputClass.functionByName(CallingConventions.shouldEncodeDefault)
-                    val partA = irInvoke(irGet(localOutput), shouldEncodeFunc, irGet(localSerialDesc), irInt(index))
-                    // Ir infrastructure does not have dedicated symbol for ||, so
-                    //  `a || b == if (a) true else b`, see org.jetbrains.kotlin.ir.builders.PrimitivesKt.oror
-                    irIfThenElse(compilerContext.irBuiltIns.booleanType, partA, irTrue(), partB)
-                }
-                +irIfThen(condition, elementCall)
-            }
-        }
-    }
-
-    /**
-     * True — ALWAYS
-     * False — NEVER
-     * null — not specified
-     */
-    fun IrProperty.getEncodeDefaultAnnotationValue(): Boolean? {
-        val call = annotations.findAnnotation(SerializationAnnotations.encodeDefaultFqName) ?: return null
-        val arg = call.getValueArgument(0) ?: return true // ALWAYS by default
-        val argValue = (arg as? IrGetEnumValue
-            ?: error("Argument of enum constructor expected to implement IrGetEnumValue, got $arg")).symbol.owner.name.toString()
-        return when (argValue) {
-            "ALWAYS" -> true
-            "NEVER" -> false
-            else -> error("Unknown EncodeDefaultMode enum value: $argValue")
-        }
-    }
-
-
-    fun IrBlockBodyBuilder.formEncodeDecodePropertyCall(
-        enclosingGenerator: AbstractIrGenerator,
-        encoder: IrExpression,
-        property: IrSerializableProperty,
-        whenHaveSerializer: (serializer: IrExpression, sti: IrSerialTypeInfo) -> FunctionWithArgs,
-        whenDoNot: (sti: IrSerialTypeInfo) -> FunctionWithArgs,
-        genericGetter: ((Int, IrType) -> IrExpression)? = null,
-        returnTypeHint: IrType? = null
-    ): IrExpression {
-        val sti = enclosingGenerator.getIrSerialTypeInfo(property, compilerContext)
-        val innerSerial = serializerInstance(
-            enclosingGenerator,
-            sti.serializer,
-            compilerContext,
-            property.type,
-            property.genericIndex,
-            genericGetter
-        )
-        val (functionToCall, args: List<IrExpression>) = if (innerSerial != null) whenHaveSerializer(innerSerial, sti) else whenDoNot(sti)
-        val typeArgs = if (functionToCall.descriptor.typeParameters.isNotEmpty()) listOf(property.type) else listOf()
-        return irInvoke(encoder, functionToCall, typeArguments = typeArgs, valueArguments = args, returnTypeHint = returnTypeHint)
-    }
-
-}
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrBuilderWithPluginContext.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrBuilderWithPluginContext.kt
new file mode 100644
index 0000000..e39488b
--- /dev/null
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrBuilderWithPluginContext.kt
@@ -0,0 +1,582 @@
+/*
+ * 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.kotlinx.serialization.compiler.backend.ir
+
+import org.jetbrains.kotlin.backend.common.extensions.FirIncompatiblePluginAPI
+import org.jetbrains.kotlin.backend.common.lower.DeclarationIrBuilder
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.ir.builders.*
+import org.jetbrains.kotlin.ir.builders.declarations.buildFun
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.deepCopyWithVariables
+import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
+import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
+import org.jetbrains.kotlin.ir.symbols.impl.*
+import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.jvm.isJvm
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
+import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
+import org.jetbrains.kotlinx.serialization.compiler.resolve.KSerializerDescriptorResolver
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationDependencies.LAZY_FQ
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationDependencies.LAZY_MODE_FQ
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationDependencies.LAZY_PUBLICATION_MODE_NAME
+import org.jetbrains.kotlinx.serialization.compiler.resolve.hasSerializableOrMetaAnnotation
+import org.jetbrains.kotlinx.serialization.compiler.resolve.isInheritableSerialInfoAnnotation
+import org.jetbrains.kotlinx.serialization.compiler.resolve.isSerialInfoAnnotation
+
+
+interface IrBuilderWithPluginContext {
+    val compilerContext: SerializationPluginContext
+
+    fun <F: IrFunction> addFunctionBody(function: F, bodyGen: IrBlockBodyBuilder.(F) -> Unit) {
+        val parentClass = function.parent
+        val startOffset = function.startOffset.takeIf { it >= 0 } ?: parentClass.startOffset
+        val endOffset = function.endOffset.takeIf { it >= 0 } ?: parentClass.endOffset
+        function.body = DeclarationIrBuilder(compilerContext, function.symbol, startOffset, endOffset).irBlockBody(
+            startOffset,
+            endOffset
+        ) { bodyGen(function) }
+    }
+
+    fun IrClass.createLambdaExpression(
+        type: IrType,
+        bodyGen: IrBlockBodyBuilder.() -> Unit
+    ): IrFunctionExpression {
+        val function = compilerContext.irFactory.buildFun {
+            this.startOffset = this@createLambdaExpression.startOffset
+            this.endOffset = this@createLambdaExpression.endOffset
+            this.returnType = type
+            name = Name.identifier("<anonymous>")
+            visibility = DescriptorVisibilities.LOCAL
+            origin = SERIALIZABLE_PLUGIN_ORIGIN
+        }
+        function.body =
+            DeclarationIrBuilder(compilerContext, function.symbol, startOffset, endOffset).irBlockBody(startOffset, endOffset, bodyGen)
+        function.parent = this
+
+        val f0Type = compilerContext.irBuiltIns.functionN(0)
+        val f0ParamSymbol = f0Type.typeParameters[0].symbol
+        val f0IrType = f0Type.defaultType.substitute(mapOf(f0ParamSymbol to type))
+
+        return IrFunctionExpressionImpl(
+            startOffset,
+            endOffset,
+            f0IrType,
+            function,
+            IrStatementOrigin.LAMBDA
+        )
+    }
+
+    fun createLazyProperty(
+        containingClass: IrClass,
+        targetIrType: IrType,
+        name: Name,
+        initializerBuilder: IrBlockBodyBuilder.() -> Unit
+    ): IrProperty {
+        val lazySafeModeClassDescriptor = compilerContext.referenceClass(ClassId.topLevel(LAZY_MODE_FQ))!!.owner
+        val lazyFunctionSymbol = compilerContext.referenceFunctions(CallableId(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, Name.identifier("lazy"))).single {
+            it.owner.valueParameters.size == 2 && it.owner.valueParameters[0].type == lazySafeModeClassDescriptor.defaultType
+        }
+        val publicationEntryDescriptor = lazySafeModeClassDescriptor.enumEntries().single { it.name == LAZY_PUBLICATION_MODE_NAME }
+
+        val lazyIrClass = compilerContext.referenceClass(ClassId.topLevel(LAZY_FQ))!!.owner
+        val lazyIrType = lazyIrClass.defaultType.substitute(mapOf(lazyIrClass.typeParameters[0].symbol to targetIrType))
+
+        val propertyDescriptor =
+            KSerializerDescriptorResolver.createValPropertyDescriptor(
+                Name.identifier(name.asString() + "\$delegate"),
+                containingClass.descriptor,
+                lazyIrType.toKotlinType(),
+                createGetter = true
+            )
+
+        return generateSimplePropertyWithBackingField(propertyDescriptor, containingClass).apply {
+            val builder = DeclarationIrBuilder(compilerContext, containingClass.symbol, startOffset, endOffset)
+            val initializerBody = builder.run {
+                val enumElement = IrGetEnumValueImpl(
+                    startOffset,
+                    endOffset,
+                    lazySafeModeClassDescriptor.defaultType,
+                    publicationEntryDescriptor.symbol
+                )
+
+                val lambdaExpression = containingClass.createLambdaExpression(targetIrType, initializerBuilder)
+
+                irExprBody(
+                    irInvoke(null, lazyFunctionSymbol, listOf(targetIrType), listOf(enumElement, lambdaExpression), lazyIrType)
+                )
+            }
+            backingField!!.initializer = initializerBody
+        }
+    }
+
+    fun createCompanionValProperty(
+        companionClass: IrClass,
+        type: IrType,
+        name: Name,
+        initializerBuilder: IrBlockBodyBuilder.() -> Unit
+    ): IrProperty {
+        val targetKotlinType = type.toKotlinType()
+        val propertyDescriptor =
+            KSerializerDescriptorResolver.createValPropertyDescriptor(name, companionClass.descriptor, targetKotlinType)
+
+        return generateSimplePropertyWithBackingField(propertyDescriptor, companionClass, name).apply {
+            companionClass.contributeAnonymousInitializer {
+                val irBlockBody = irBlockBody(startOffset, endOffset, initializerBuilder)
+                irBlockBody.statements.dropLast(1).forEach { +it }
+                val expression = irBlockBody.statements.last() as? IrExpression
+                    ?: throw AssertionError("Last statement in property initializer builder is not an a expression")
+                +irSetField(irGetObject(companionClass), backingField!!, expression)
+            }
+        }
+    }
+
+    fun IrClass.contributeAnonymousInitializer(bodyGen: IrBlockBodyBuilder.() -> Unit) {
+        val symbol = IrAnonymousInitializerSymbolImpl(descriptor)
+        factory.createAnonymousInitializer(startOffset, endOffset, SERIALIZABLE_PLUGIN_ORIGIN, symbol).also {
+            it.parent = this
+            declarations.add(it)
+            it.body = DeclarationIrBuilder(compilerContext, symbol, startOffset, endOffset).irBlockBody(startOffset, endOffset, bodyGen)
+        }
+    }
+
+    fun IrBlockBodyBuilder.getLazyValueExpression(thisParam: IrValueParameter, property: IrProperty, type: IrType): IrExpression {
+        val lazyIrClass = compilerContext.referenceClass(ClassId.topLevel(LAZY_FQ))!!.owner
+        val valueGetter = lazyIrClass.getPropertyGetter("value")!!
+
+        val propertyGetter = property.getter!!
+
+        return irInvoke(
+            irGet(propertyGetter.returnType, irGet(thisParam), propertyGetter.symbol),
+            valueGetter,
+            typeHint = type
+        )
+    }
+
+    fun IrBuilderWithScope.irInvoke(
+        dispatchReceiver: IrExpression? = null,
+        callee: IrFunctionSymbol,
+        vararg args: IrExpression,
+        typeHint: IrType? = null
+    ): IrMemberAccessExpression<*> {
+        assert(callee.isBound) { "Symbol $callee expected to be bound" }
+        val returnType = typeHint ?: callee.owner.returnType
+        val call = irCall(callee, type = returnType)
+        call.dispatchReceiver = dispatchReceiver
+        args.forEachIndexed(call::putValueArgument)
+        return call
+    }
+
+    fun IrBuilderWithScope.irInvoke(
+        dispatchReceiver: IrExpression? = null,
+        callee: IrFunctionSymbol,
+        typeArguments: List<IrType?>,
+        valueArguments: List<IrExpression>,
+        returnTypeHint: IrType? = null
+    ): IrMemberAccessExpression<*> =
+        irInvoke(
+            dispatchReceiver,
+            callee,
+            *valueArguments.toTypedArray(),
+            typeHint = returnTypeHint
+        ).also { call -> typeArguments.forEachIndexed(call::putTypeArgument) }
+
+    fun IrBuilderWithScope.createArrayOfExpression(
+        arrayElementType: IrType,
+        arrayElements: List<IrExpression>
+    ): IrExpression {
+
+        val arrayType = compilerContext.irBuiltIns.arrayClass.typeWith(arrayElementType)
+        val arg0 = IrVarargImpl(startOffset, endOffset, arrayType, arrayElementType, arrayElements)
+        val typeArguments = listOf(arrayElementType)
+
+        return irCall(compilerContext.irBuiltIns.arrayOf, arrayType, typeArguments = typeArguments).apply {
+            putValueArgument(0, arg0)
+        }
+    }
+
+    fun IrBuilderWithScope.createPrimitiveArrayOfExpression(
+        elementPrimitiveType: IrType,
+        arrayElements: List<IrExpression>
+    ): IrExpression {
+        val arrayType = compilerContext.irBuiltIns.primitiveArrayForType.getValue(elementPrimitiveType).defaultType
+        val arg0 = IrVarargImpl(startOffset, endOffset, arrayType, elementPrimitiveType, arrayElements)
+        val typeArguments = listOf(elementPrimitiveType)
+
+        return irCall(compilerContext.irBuiltIns.arrayOf, arrayType, typeArguments = typeArguments).apply {
+            putValueArgument(0, arg0)
+        }
+    }
+
+    fun IrBuilderWithScope.irBinOp(name: Name, lhs: IrExpression, rhs: IrExpression): IrExpression {
+        val classFqName = (lhs.type as IrSimpleType).classOrNull!!.owner.fqNameWhenAvailable!!
+        val symbol = compilerContext.referenceFunctions(CallableId(ClassId.topLevel(classFqName), name)).single()
+        return irInvoke(lhs, symbol, rhs)
+    }
+
+    fun IrBuilderWithScope.irGetObject(irObject: IrClass) =
+        IrGetObjectValueImpl(
+            startOffset,
+            endOffset,
+            irObject.defaultType,
+            irObject.symbol
+        )
+
+    fun <T : IrDeclaration> T.buildWithScope(builder: (T) -> Unit): T =
+        also { irDeclaration ->
+            compilerContext.symbolTable.withReferenceScope(irDeclaration) {
+                builder(irDeclaration)
+            }
+        }
+
+    class BranchBuilder(
+        val irWhen: IrWhen,
+        context: IrGeneratorContext,
+        scope: Scope,
+        startOffset: Int,
+        endOffset: Int
+    ) : IrBuilderWithScope(context, scope, startOffset, endOffset) {
+        operator fun IrBranch.unaryPlus() {
+            irWhen.branches.add(this)
+        }
+    }
+
+    fun IrBuilderWithScope.irWhen(typeHint: IrType? = null, block: BranchBuilder.() -> Unit): IrWhen {
+        val whenExpr = IrWhenImpl(startOffset, endOffset, typeHint ?: compilerContext.irBuiltIns.unitType)
+        val builder = BranchBuilder(whenExpr, context, scope, startOffset, endOffset)
+        builder.block()
+        return whenExpr
+    }
+
+    fun BranchBuilder.elseBranch(result: IrExpression): IrElseBranch =
+        IrElseBranchImpl(
+            IrConstImpl.boolean(result.startOffset, result.endOffset, compilerContext.irBuiltIns.booleanType, true),
+            result
+        )
+
+    @FirIncompatiblePluginAPI
+    fun KotlinType.toIrType() = compilerContext.typeTranslator.translateType(this)
+
+    fun IrBuilderWithScope.setProperty(receiver: IrExpression, property: IrProperty, value: IrExpression): IrExpression {
+        return if (property.setter != null)
+            irSet(property.setter!!.returnType, receiver, property.setter!!.symbol, value)
+        else
+            irSetField(receiver, property.backingField!!, value)
+    }
+
+    fun IrBuilderWithScope.generateAnySuperConstructorCall(toBuilder: IrBlockBodyBuilder) {
+        val anyConstructor = compilerContext.irBuiltIns.anyClass.owner.declarations.single { it is IrConstructor } as IrConstructor
+        with(toBuilder) {
+            +IrDelegatingConstructorCallImpl.fromSymbolDescriptor(
+                startOffset, endOffset,
+                compilerContext.irBuiltIns.unitType,
+                anyConstructor.symbol
+            )
+        }
+    }
+
+    private inline fun <reified T : IrDeclaration> IrClass.searchForDeclaration(descriptor: DeclarationDescriptor): T? {
+        return declarations.singleOrNull { it.descriptor == descriptor } as? T
+    }
+
+    fun generateSimplePropertyWithBackingField(
+        propertyDescriptor: PropertyDescriptor,
+        propertyParent: IrClass,
+        fieldName: Name = propertyDescriptor.name,
+    ): IrProperty {
+        val irProperty = propertyParent.searchForDeclaration(propertyDescriptor) ?: run {
+            with(propertyDescriptor) {
+                propertyParent.factory.createProperty(
+                    propertyParent.startOffset, propertyParent.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrPropertySymbolImpl(propertyDescriptor),
+                    name, visibility, modality, isVar, isConst, isLateInit, isDelegated, isExternal
+                ).also {
+                    it.parent = propertyParent
+                    propertyParent.addMember(it)
+                }
+            }
+        }
+
+        propertyParent.generatePropertyBackingFieldIfNeeded(propertyDescriptor, irProperty, fieldName)
+        val fieldSymbol = irProperty.backingField!!.symbol
+        irProperty.getter = propertyDescriptor.getter?.let {
+            propertyParent.generatePropertyAccessor(propertyDescriptor, irProperty, it, fieldSymbol, isGetter = true)
+        }?.apply { parent = propertyParent }
+        irProperty.setter = propertyDescriptor.setter?.let {
+            propertyParent.generatePropertyAccessor(propertyDescriptor, irProperty, it, fieldSymbol, isGetter = false)
+        }?.apply { parent = propertyParent }
+        return irProperty
+    }
+
+    fun IrType.kClassToJClassIfNeeded(): IrType = this
+
+    fun kClassExprToJClassIfNeeded(startOffset: Int, endOffset: Int, irExpression: IrExpression): IrExpression = irExpression
+
+    private fun IrClass.generatePropertyBackingFieldIfNeeded(
+        propertyDescriptor: PropertyDescriptor,
+        originProperty: IrProperty,
+        name: Name,
+    ) {
+        if (originProperty.backingField != null) return
+
+        val field = with(propertyDescriptor) {
+            // TODO: type parameters
+            @OptIn(FirIncompatiblePluginAPI::class)// should be called only with old FE
+            originProperty.factory.createField(
+                originProperty.startOffset, originProperty.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrFieldSymbolImpl(propertyDescriptor), name, type.toIrType(),
+                visibility, !isVar, isEffectivelyExternal(), dispatchReceiverParameter == null
+            )
+        }
+        field.apply {
+            parent = this@generatePropertyBackingFieldIfNeeded
+            correspondingPropertySymbol = originProperty.symbol
+        }
+
+        originProperty.backingField = field
+    }
+
+    private fun IrClass.generatePropertyAccessor(
+        propertyDescriptor: PropertyDescriptor,
+        property: IrProperty,
+        descriptor: PropertyAccessorDescriptor,
+        fieldSymbol: IrFieldSymbol,
+        isGetter: Boolean,
+    ): IrSimpleFunction {
+        val irAccessor: IrSimpleFunction = when (isGetter) {
+            true -> searchForDeclaration<IrProperty>(propertyDescriptor)?.getter
+            false -> searchForDeclaration<IrProperty>(propertyDescriptor)?.setter
+        } ?: run {
+            with(descriptor) {
+                @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
+                property.factory.createFunction(
+                    fieldSymbol.owner.startOffset, fieldSymbol.owner.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrSimpleFunctionSymbolImpl(descriptor),
+                    name, visibility, modality, returnType!!.toIrType(),
+                    isInline, isEffectivelyExternal(), isTailrec, isSuspend, isOperator, isInfix, isExpect
+                )
+            }.also { f ->
+                generateOverriddenFunctionSymbols(f, compilerContext.symbolTable)
+                f.createParameterDeclarations(descriptor)
+                @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
+                f.returnType = descriptor.returnType!!.toIrType()
+                f.correspondingPropertySymbol = fieldSymbol.owner.correspondingPropertySymbol
+            }
+        }
+
+        irAccessor.body = when (isGetter) {
+            true -> generateDefaultGetterBody(descriptor as PropertyGetterDescriptor, irAccessor)
+            false -> generateDefaultSetterBody(descriptor as PropertySetterDescriptor, irAccessor)
+        }
+
+        return irAccessor
+    }
+
+    private fun generateDefaultGetterBody(
+        getter: PropertyGetterDescriptor,
+        irAccessor: IrSimpleFunction
+    ): IrBlockBody {
+        val property = getter.correspondingProperty
+        val irProperty = irAccessor.correspondingPropertySymbol?.owner ?: error("Expected property for $getter")
+
+        val startOffset = irAccessor.startOffset
+        val endOffset = irAccessor.endOffset
+        val irBody = irAccessor.factory.createBlockBody(startOffset, endOffset)
+
+        val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!.symbol, property)
+
+        val propertyIrType = irAccessor.returnType
+        irBody.statements.add(
+            IrReturnImpl(
+                startOffset, endOffset, compilerContext.irBuiltIns.nothingType,
+                irAccessor.symbol,
+                IrGetFieldImpl(
+                    startOffset, endOffset,
+                    irProperty.backingField?.symbol ?: error("Property expected to have backing field"),
+                    propertyIrType,
+                    receiver
+                ).let {
+                    if (propertyIrType.isKClass()) {
+                        irAccessor.returnType = irAccessor.returnType.kClassToJClassIfNeeded()
+                        kClassExprToJClassIfNeeded(startOffset, endOffset, it)
+                    } else it
+                }
+            )
+        )
+        return irBody
+    }
+
+    private fun generateDefaultSetterBody(
+        setter: PropertySetterDescriptor,
+        irAccessor: IrSimpleFunction
+    ): IrBlockBody {
+        val property = setter.correspondingProperty
+        val irProperty = irAccessor.correspondingPropertySymbol?.owner ?: error("Expected corresponding property for accessor $setter")
+        val startOffset = irAccessor.startOffset
+        val endOffset = irAccessor.endOffset
+        val irBody = irAccessor.factory.createBlockBody(startOffset, endOffset)
+
+        val receiver = generateReceiverExpressionForFieldAccess(irAccessor.dispatchReceiverParameter!!.symbol, property)
+
+        val irValueParameter = irAccessor.valueParameters.single()
+        irBody.statements.add(
+            IrSetFieldImpl(
+                startOffset, endOffset,
+                irProperty.backingField?.symbol ?: error("Property $property expected to have backing field"),
+                receiver,
+                IrGetValueImpl(startOffset, endOffset, irValueParameter.type, irValueParameter.symbol),
+                compilerContext.irBuiltIns.unitType
+            )
+        )
+        return irBody
+    }
+
+    fun generateReceiverExpressionForFieldAccess( // todo: remove this
+        ownerSymbol: IrValueSymbol,
+        property: PropertyDescriptor
+    ): IrExpression {
+        val containingDeclaration = property.containingDeclaration
+        return when (containingDeclaration) {
+            is ClassDescriptor ->
+                IrGetValueImpl(
+                    ownerSymbol.owner.startOffset, ownerSymbol.owner.endOffset,
+                    ownerSymbol
+                )
+            else -> throw AssertionError("Property must be in class")
+        }
+    }
+
+    fun IrFunction.createParameterDeclarations(
+        descriptor: FunctionDescriptor,
+        overwriteValueParameters: Boolean = false,
+        copyTypeParameters: Boolean = true
+    ) {
+        val function = this
+        fun irValueParameter(descriptor: ParameterDescriptor): IrValueParameter = with(descriptor) {
+            @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
+            factory.createValueParameter(
+                function.startOffset, function.endOffset, SERIALIZABLE_PLUGIN_ORIGIN, IrValueParameterSymbolImpl(this),
+                name, indexOrMinusOne, type.toIrType(), varargElementType?.toIrType(), isCrossinline, isNoinline,
+                isHidden = false, isAssignable = false
+            ).also {
+                it.parent = function
+            }
+        }
+
+        if (copyTypeParameters) {
+            assert(typeParameters.isEmpty())
+            copyTypeParamsFromDescriptor(descriptor)
+        }
+
+        dispatchReceiverParameter = descriptor.dispatchReceiverParameter?.let { irValueParameter(it) }
+        extensionReceiverParameter = descriptor.extensionReceiverParameter?.let { irValueParameter(it) }
+
+        if (!overwriteValueParameters)
+            assert(valueParameters.isEmpty())
+
+        valueParameters = descriptor.valueParameters.map { irValueParameter(it) }
+    }
+
+    fun IrFunction.copyTypeParamsFromDescriptor(descriptor: FunctionDescriptor) {
+        val newTypeParameters = descriptor.typeParameters.map {
+            factory.createTypeParameter(
+                startOffset, endOffset,
+                SERIALIZABLE_PLUGIN_ORIGIN,
+                IrTypeParameterSymbolImpl(it),
+                it.name, it.index, it.isReified, it.variance
+            ).also { typeParameter ->
+                typeParameter.parent = this
+            }
+        }
+        @OptIn(FirIncompatiblePluginAPI::class) // should never be called after FIR frontend
+        newTypeParameters.forEach { typeParameter ->
+            typeParameter.superTypes = typeParameter.descriptor.upperBounds.map { it.toIrType() }
+        }
+
+        typeParameters = newTypeParameters
+    }
+
+    fun createClassReference(classType: IrType, startOffset: Int, endOffset: Int): IrClassReference {
+        return IrClassReferenceImpl(
+            startOffset,
+            endOffset,
+            compilerContext.irBuiltIns.kClassClass.starProjectedType,
+            classType.classifierOrFail,
+            classType
+        )
+    }
+
+    fun IrBuilderWithScope.classReference(classSymbol: IrType): IrClassReference =
+        createClassReference(classSymbol, startOffset, endOffset)
+
+    fun collectSerialInfoAnnotations(irClass: IrClass): List<IrConstructorCall> {
+        if (!(irClass.isInterface || irClass.descriptor.hasSerializableOrMetaAnnotation)) return emptyList()
+        val annotationByFq: MutableMap<FqName, IrConstructorCall> =
+            irClass.annotations.associateBy { it.symbol.owner.parentAsClass.descriptor.fqNameSafe }.toMutableMap()
+        for (clazz in irClass.getAllSuperclasses()) {
+            val annotations = clazz.annotations
+                .mapNotNull {
+                    val descriptor = it.symbol.owner.parentAsClass.descriptor
+                    if (descriptor.isInheritableSerialInfoAnnotation) descriptor.fqNameSafe to it else null
+                }
+            annotations.forEach { (fqname, call) ->
+                if (fqname !in annotationByFq) {
+                    annotationByFq[fqname] = call
+                } else {
+                    // SerializationPluginDeclarationChecker already reported inconsistency
+                }
+            }
+        }
+        return annotationByFq.values.toList()
+    }
+
+    fun IrBuilderWithScope.copyAnnotationsFrom(annotations: List<IrConstructorCall>): List<IrExpression> =
+        annotations.mapNotNull { annotationCall ->
+            val annotationClass = annotationCall.symbol.owner.parentAsClass
+            if (!annotationClass.descriptor.isSerialInfoAnnotation) return@mapNotNull null
+
+            if (compilerContext.platform.isJvm()) {
+                val implClass = compilerContext.serialInfoImplJvmIrGenerator.getImplClass(annotationClass)
+                val ctor = implClass.constructors.singleOrNull { it.valueParameters.size == annotationCall.valueArgumentsCount }
+                    ?: error("No constructor args found for SerialInfo annotation Impl class: ${implClass.render()}")
+                irCall(ctor).apply {
+                    for (i in 0 until annotationCall.valueArgumentsCount) {
+                        val argument = annotationCall.getValueArgument(i)
+                            ?: annotationClass.primaryConstructor!!.valueParameters[i].defaultValue?.expression
+                        putValueArgument(i, argument!!.deepCopyWithVariables())
+                    }
+                }
+            } else {
+                annotationCall.deepCopyWithVariables()
+            }
+        }
+
+    fun IrBuilderWithScope.wrapperClassReference(classType: IrType): IrClassReference {
+        if (compilerContext.platform.isJvm()) {
+            // "Byte::class" -> "java.lang.Byte::class"
+//          TODO: get rid of descriptor
+            val wrapperFqName = KotlinBuiltIns.getPrimitiveType(classType.classOrNull!!.descriptor)?.let(JvmPrimitiveType::get)?.wrapperFqName
+            if (wrapperFqName != null) {
+                val wrapperClass = compilerContext.referenceClass(ClassId.topLevel(wrapperFqName))
+                    ?: error("Primitive wrapper class for $classType not found: $wrapperFqName")
+                return classReference(wrapperClass.defaultType)
+            }
+        }
+        return classReference(classType)
+    }
+
+    fun IrClass.getSuperClassOrAny(): IrClass = getSuperClassNotAny() ?: compilerContext.irBuiltIns.anyClass.owner
+}
\ No newline at end of file
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrPredicates.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrPredicates.kt
new file mode 100644
index 0000000..de87f71
--- /dev/null
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrPredicates.kt
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2010-2022 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.kotlinx.serialization.compiler.backend.ir
+
+import org.jetbrains.kotlin.backend.jvm.ir.getStringConstArgument
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
+import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
+import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
+import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlinx.serialization.compiler.fir.SerializationPluginKey
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationPackages
+import org.jetbrains.kotlinx.serialization.compiler.resolve.hasSerializableOrMetaAnnotation
+
+internal fun IrType.isKSerializer(): Boolean {
+    val simpleType = this as? IrSimpleType ?: return false
+    val classifier = simpleType.classifier as? IrClassSymbol ?: return false
+    val fqName = classifier.owner.fqNameWhenAvailable
+    return fqName == SerialEntityNames.KSERIALIZER_NAME_FQ || fqName == SerialEntityNames.GENERATED_SERIALIZER_FQ
+}
+
+internal val IrClass.isInternalSerializable: Boolean
+    get() {
+        if (kind != ClassKind.CLASS) return false
+        return hasSerializableOrMetaAnnotationWithoutArgs()
+    }
+
+internal val IrClass.isAbstractOrSealedSerializableClass: Boolean get() = isInternalSerializable && (modality == Modality.ABSTRACT || modality == Modality.SEALED)
+
+internal val IrClass.isStaticSerializable: Boolean get() = this.typeParameters.isEmpty()
+
+
+internal val IrClass.hasCompanionObjectAsSerializer: Boolean
+    get() = isInternallySerializableObject || companionObject()?.serializerForClass == this.symbol
+
+internal val IrClass.isInternallySerializableObject: Boolean
+    get() = kind == ClassKind.OBJECT && hasSerializableOrMetaAnnotationWithoutArgs()
+
+
+internal fun IrClass.findPluginGeneratedMethod(name: String): IrSimpleFunction? {
+    return this.functions.find {
+        it.name.asString() == name && it.isFromPlugin()
+    }
+}
+
+internal fun IrClass.isEnumWithLegacyGeneratedSerializer(): Boolean = isInternallySerializableEnum() && useGeneratedEnumSerializer
+
+internal val IrClass.useGeneratedEnumSerializer: Boolean
+    get() = true // FIXME This would break if we try to use this new IR compiler with pre-1.4.1 serialization versions. I think we just need to raise min runtime version.
+
+internal val IrClass.isSealedSerializableInterface: Boolean
+    get() = kind == ClassKind.INTERFACE && modality == Modality.SEALED && hasSerializableOrMetaAnnotation()
+
+internal fun IrClass.isInternallySerializableEnum(): Boolean =
+    kind == ClassKind.ENUM_CLASS && hasSerializableOrMetaAnnotationWithoutArgs()
+
+fun IrType.isGeneratedSerializableObject(): Boolean {
+    return classOrNull?.run { owner.kind == ClassKind.OBJECT && owner.hasSerializableOrMetaAnnotationWithoutArgs() } == true
+}
+
+internal val IrClass.isSerializableObject: Boolean
+    get() = kind == ClassKind.OBJECT && hasSerializableOrMetaAnnotation()
+
+// todo: optimize & unify with hasSerializableOrMeta
+internal fun IrClass.hasSerializableOrMetaAnnotationWithoutArgs(): Boolean {
+    val annot = getAnnotation(SerializationAnnotations.serializableAnnotationFqName)
+    if (annot != null) {
+        for (i in 0 until annot.valueArgumentsCount) {
+            if (annot.getValueArgument(i) != null) return false
+        }
+        return true
+    }
+    val metaAnnotation = annotations
+        .flatMap { it.symbol.owner.constructedClass.annotations }
+        .find { it.isAnnotation(SerializationAnnotations.metaSerializableAnnotationFqName) }
+    return metaAnnotation != null
+}
+
+internal val IrClass.isSerialInfoAnnotation: Boolean
+    get() = annotations.hasAnnotation(SerializationAnnotations.serialInfoFqName)
+            || annotations.hasAnnotation(SerializationAnnotations.inheritableSerialInfoFqName)
+            || annotations.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationFqName)
+
+internal val IrClass.shouldHaveGeneratedSerializer: Boolean
+    get() = (isInternalSerializable && (modality == Modality.FINAL || modality == Modality.OPEN))
+            || isEnumWithLegacyGeneratedSerializer()
+
+internal val IrClass.shouldHaveGeneratedMethodsInCompanion: Boolean
+    get() = this.isSerializableObject || this.isSerializableEnum() || (this.kind == ClassKind.CLASS && hasSerializableOrMetaAnnotation()) || this.isSealedSerializableInterface
+
+internal fun IrClass.isSerializableEnum(): Boolean = kind == ClassKind.ENUM_CLASS && hasSerializableOrMetaAnnotation()
+
+fun IrClass.hasSerializableOrMetaAnnotation() = descriptor.hasSerializableOrMetaAnnotation // TODO
+
+internal val IrType.genericIndex: Int?
+    get() = (this.classifierOrNull as? IrTypeParameterSymbol)?.owner?.index
+
+fun IrType.serialName(): String = this.classOrNull!!.owner.serialName()
+
+fun IrClass.serialName(): String {
+    return annotations.serialNameValue ?: fqNameWhenAvailable?.asString() ?: error("${this.render()} does not have fqName")
+}
+
+fun IrClass.findEnumValuesMethod() = this.functions.singleOrNull { f ->
+    f.name == Name.identifier("values") && f.valueParameters.isEmpty() && f.extensionReceiverParameter == null
+} ?: throw AssertionError("Enum class does not have single .values() function")
+
+internal fun IrClass.enumEntries(): List<IrEnumEntry> {
+    check(this.kind == ClassKind.ENUM_CLASS)
+    return declarations.filterIsInstance<IrEnumEntry>().toList()
+}
+
+internal fun IrClass.isEnumWithSerialInfoAnnotation(): Boolean {
+    if (kind != ClassKind.ENUM_CLASS) return false
+    if (annotations.hasAnySerialAnnotation) return true
+    return enumEntries().any { (it.annotations.hasAnySerialAnnotation) }
+}
+
+fun IrClass.findWriteSelfMethod(): IrSimpleFunction? =
+    functions.singleOrNull { it.name == SerialEntityNames.WRITE_SELF_NAME && !it.isFakeOverride }
+
+fun IrClass.getSuperClassNotAny(): IrClass? {
+    val parentClass =
+        superTypes
+            .mapNotNull { it.classOrNull?.owner }
+            .singleOrNull { it.kind == ClassKind.CLASS || it.kind == ClassKind.ENUM_CLASS } ?: return null
+    return if (parentClass.defaultType.isAny()) null else parentClass
+}
+
+internal fun IrDeclaration.isFromPlugin(): Boolean =
+    this.origin == IrDeclarationOrigin.GeneratedByPlugin(SerializationPluginKey) || (this.descriptor as? CallableMemberDescriptor)?.kind == CallableMemberDescriptor.Kind.SYNTHESIZED // old FE doesn't specify origin
+
+internal fun IrConstructor.isSerializationCtor(): Boolean {
+    /*kind == CallableMemberDescriptor.Kind.SYNTHESIZED does not work because DeserializedClassConstructorDescriptor loses its kind*/
+    return valueParameters.lastOrNull()?.run {
+        name == SerialEntityNames.dummyParamName && type.classFqName == SerializationPackages.internalPackageFqName.child(
+            SerialEntityNames.SERIAL_CTOR_MARKER_NAME
+        )
+    } == true
+}
+
+
+internal fun IrConstructor.lastArgumentIsAnnotationArray(): Boolean {
+    val lastArgType = valueParameters.lastOrNull()?.type
+    if (lastArgType == null || !lastArgType.isArray()) return false
+    return ((lastArgType as? IrSimpleType)?.arguments?.firstOrNull()?.typeOrNull?.classFqName?.toString() == "kotlin.Annotation")
+}
+
+fun IrClass.serializableSyntheticConstructor(): IrConstructorSymbol? { // todo: remove nullability W/A when FIR plugin will add proper ctor
+    return declarations.filterIsInstance<IrConstructor>().singleOrNull { it.isSerializationCtor() }?.symbol
+}
+
+internal fun IrExpression.isInitializePropertyFromParameter(): Boolean =
+    this is IrGetValueImpl && this.origin == IrStatementOrigin.INITIALIZE_PROPERTY_FROM_PARAMETER
+
+internal val IrConstructorCall.annotationClass
+    get() = this.symbol.owner.constructedClass
+
+internal val List<IrConstructorCall>.hasAnySerialAnnotation: Boolean
+    get() = serialNameValue != null || any { it.annotationClass.isSerialInfoAnnotation == true }
+
+internal val List<IrConstructorCall>.serialNameValue: String?
+    get() = findAnnotation(SerializationAnnotations.serialNameAnnotationFqName)?.getStringConstArgument(0) // @SerialName("foo")
+
+/**
+ * True — ALWAYS
+ * False — NEVER
+ * null — not specified
+ */
+fun IrProperty.getEncodeDefaultAnnotationValue(): Boolean? {
+    val call = annotations.findAnnotation(SerializationAnnotations.encodeDefaultFqName) ?: return null
+    val arg = call.getValueArgument(0) ?: return true // ALWAYS by default
+    val argValue = (arg as? IrGetEnumValue
+        ?: error("Argument of enum constructor expected to implement IrGetEnumValue, got $arg")).symbol.owner.name.toString()
+    return when (argValue) {
+        "ALWAYS" -> true
+        "NEVER" -> false
+        else -> error("Unknown EncodeDefaultMode enum value: $argValue")
+    }
+}
+
+fun findSerializerConstructorForTypeArgumentsSerializers(serializer: IrClass): IrConstructorSymbol? {
+    val typeParamsCount = ((serializer.superTypes.find { it.isKSerializer() } as IrSimpleType).arguments.first().typeOrNull!! as IrSimpleType).arguments.size
+    if (typeParamsCount == 0) return null //don't need it
+
+    return serializer.constructors.singleOrNull {
+        it.valueParameters.let { vps -> vps.size == typeParamsCount && vps.all { vp -> vp.type.isKSerializer() } }
+    }?.symbol
+}
\ No newline at end of file
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrSerializableProperties.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrSerializableProperties.kt
new file mode 100644
index 0000000..1aff0d2
--- /dev/null
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/IrSerializableProperties.kt
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2010-2022 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.kotlinx.serialization.compiler.backend.ir
+
+import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrProperty
+import org.jetbrains.kotlin.ir.types.IrSimpleType
+import org.jetbrains.kotlin.ir.util.hasAnnotation
+import org.jetbrains.kotlin.ir.util.hasDefaultValue
+import org.jetbrains.kotlin.ir.util.primaryConstructor
+import org.jetbrains.kotlin.ir.util.properties
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor
+import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationDescriptorSerializerPlugin
+import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
+import org.jetbrains.kotlinx.serialization.compiler.resolve.ISerializableProperties
+import org.jetbrains.kotlinx.serialization.compiler.resolve.ISerializableProperty
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations
+import org.jetbrains.kotlinx.serialization.compiler.resolve.declaresDefaultValue
+
+class IrSerializableProperty(
+    val ir: IrProperty,
+    override val isConstructorParameterWithDefault: Boolean,
+    hasBackingField: Boolean,
+    declaresDefaultValue: Boolean
+) : ISerializableProperty<IrSimpleType> {
+    override val name = ir.annotations.serialNameValue ?: ir.name.asString()
+    override val type = ir.getter!!.returnType as IrSimpleType
+    override val genericIndex = type.genericIndex
+    fun serializableWith(ctx: SerializationPluginContext) = ir.annotations.serializableWith() ?: analyzeSpecialSerializers(ctx, ir.annotations)
+    override val optional = !ir.annotations.hasAnnotation(SerializationAnnotations.requiredAnnotationFqName) && declaresDefaultValue
+    override val transient = ir.annotations.hasAnnotation(SerializationAnnotations.serialTransientFqName) || !hasBackingField
+}
+
+class IrSerializableProperties(
+    override val serializableProperties: List<IrSerializableProperty>,
+    override val isExternallySerializable: Boolean,
+    override val serializableConstructorProperties: List<IrSerializableProperty>,
+    override val serializableStandaloneProperties: List<IrSerializableProperty>
+) : ISerializableProperties<IrSimpleType, IrSerializableProperty>
+
+internal fun serializablePropertiesForIrBackend(
+    classDescriptor: IrClass,
+    serializationDescriptorSerializer: SerializationDescriptorSerializerPlugin? = null
+): IrSerializableProperties {
+    val properties = classDescriptor.properties.toList()
+    val primaryConstructorParams = classDescriptor.primaryConstructor?.valueParameters.orEmpty()
+    val primaryParamsAsProps = properties.associateBy { it.name }.let { namesMap ->
+        primaryConstructorParams.mapNotNull {
+            if (it.name !in namesMap) null else namesMap.getValue(it.name) to it.hasDefaultValue()
+        }.toMap()
+    }
+
+    fun isPropSerializable(it: IrProperty) =
+        if (classDescriptor.isInternalSerializable) !it.annotations.hasAnnotation(SerializationAnnotations.serialTransientFqName)
+        else !DescriptorVisibilities.isPrivate(it.visibility) && ((it.isVar && !it.annotations.hasAnnotation(SerializationAnnotations.serialTransientFqName)) || primaryParamsAsProps.contains(
+            it
+        ))
+
+    val (primaryCtorSerializableProps, bodySerializableProps) = properties
+        .asSequence()
+        .filter { !it.isFakeOverride && !it.isDelegated }
+        .filter(::isPropSerializable)
+        .map {
+            val isConstructorParameterWithDefault = primaryParamsAsProps[it] ?: false
+            // FIXME: workaround because IrLazyProperty doesn't deserialize information about backing fields. Fallback to descriptor won't work with FIR.
+            val isPropertyFromAnotherModuleDeclaresDefaultValue = it.descriptor is DeserializedPropertyDescriptor &&  it.descriptor.declaresDefaultValue()
+            val isPropertyWithBackingFieldFromAnotherModule = it.descriptor is DeserializedPropertyDescriptor && (it.descriptor.backingField != null || isPropertyFromAnotherModuleDeclaresDefaultValue)
+            IrSerializableProperty(
+                it,
+                isConstructorParameterWithDefault,
+                it.backingField != null || isPropertyWithBackingFieldFromAnotherModule,
+                it.backingField?.initializer.let { init -> init != null && !init.expression.isInitializePropertyFromParameter() } || isConstructorParameterWithDefault
+                        || isPropertyFromAnotherModuleDeclaresDefaultValue
+            )
+        }
+        .filterNot { it.transient }
+        .partition { primaryParamsAsProps.contains(it.ir) }
+
+    val serializableProps = run {
+        val supers = classDescriptor.getSuperClassNotAny()
+        if (supers == null || !supers.isInternalSerializable)
+            primaryCtorSerializableProps + bodySerializableProps
+        else
+            serializablePropertiesForIrBackend(
+                supers,
+                serializationDescriptorSerializer
+            ).serializableProperties + primaryCtorSerializableProps + bodySerializableProps
+    } // todo: implement unsorting
+
+    val isExternallySerializable =
+        classDescriptor.isInternallySerializableEnum() || primaryConstructorParams.size == primaryParamsAsProps.size
+
+    return IrSerializableProperties(serializableProps, isExternallySerializable, primaryCtorSerializableProps, bodySerializableProps)
+}
\ No newline at end of file
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt
index b5b61c9..ac81e44 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt
@@ -42,7 +42,7 @@
 class SerialInfoImplJvmIrGenerator(
     private val context: SerializationPluginContext,
     private val moduleFragment: IrModuleFragment,
-) : IrBuilderExtension {
+) : IrBuilderWithPluginContext {
     override val compilerContext: SerializationPluginContext
         get() = context
 
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableCompanionIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableCompanionIrGenerator.kt
index 5b57523..1614cec 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableCompanionIrGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableCompanionIrGenerator.kt
@@ -6,7 +6,6 @@
 package org.jetbrains.kotlinx.serialization.compiler.backend.ir
 
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
 import org.jetbrains.kotlin.ir.builders.irGet
 import org.jetbrains.kotlin.ir.builders.irInt
@@ -21,41 +20,37 @@
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.AbstractIrGenerator
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.findTypeSerializer
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.getSerializableClassByCompanion
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.isKSerializer
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
-import org.jetbrains.kotlinx.serialization.compiler.resolve.*
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationPackages
+import org.jetbrains.kotlinx.serialization.compiler.resolve.needSerializerFactory
 
 class SerializableCompanionIrGenerator(
     val irClass: IrClass,
     val serializableIrClass: IrClass,
-    override val compilerContext: SerializationPluginContext,
-) : AbstractIrGenerator(irClass), IrBuilderExtension {
+    compilerContext: SerializationPluginContext,
+) : BaseIrGenerator(irClass, compilerContext) {
 
-    private val serializableDescriptor = serializableIrClass.descriptor
-
-    private fun getSerializerGetterDescriptor(): FunctionDescriptor {
+    private fun getSerializerGetterFunction(): IrSimpleFunction {
         return irClass.findDeclaration<IrSimpleFunction> {
-            (it.valueParameters.size == serializableDescriptor.declaredTypeParameters.size
-                    && it.valueParameters.all { p -> isKSerializer(p.type) }) && isKSerializer(it.returnType)
-        }?.descriptor ?: throw IllegalStateException(
+            (it.valueParameters.size == serializableIrClass.typeParameters.size
+                    && it.valueParameters.all { p -> p.type.isKSerializer() }) && it.returnType.isKSerializer()
+        } ?: throw IllegalStateException(
             "Can't find synthesized 'Companion.serializer()' function to generate, " +
                     "probably clash with user-defined function has occurred"
         )
     }
 
     fun generate() {
-        val serializerGetterDescriptor = getSerializerGetterDescriptor()
+        val serializerGetterFunction = getSerializerGetterFunction()
 
-        if (serializableDescriptor.isSerializableObject
-            || serializableDescriptor.isAbstractOrSealedSerializableClass()
-            || serializableDescriptor.isSerializableEnum()
+        if (serializableIrClass.isSerializableObject
+            || serializableIrClass.isAbstractOrSealedSerializableClass
+            || serializableIrClass.isSerializableEnum()
         ) {
-            generateLazySerializerGetter(serializerGetterDescriptor)
+            generateLazySerializerGetter(serializerGetterFunction)
         } else {
-            generateSerializerGetter(serializerGetterDescriptor)
+            generateSerializerGetter(serializerGetterFunction)
         }
     }
 
@@ -64,8 +59,8 @@
             irClass: IrClass,
             context: SerializationPluginContext,
         ) {
-            val companionDescriptor = irClass.descriptor
-            val serializableClass = getSerializableClassDescriptorByCompanion(companionDescriptor) ?: return
+            val companionDescriptor = irClass
+            val serializableClass = getSerializableClassByCompanion(companionDescriptor) ?: return
             if (serializableClass.shouldHaveGeneratedMethodsInCompanion) {
                 SerializableCompanionIrGenerator(irClass, getSerializableClassByCompanion(irClass)!!, context).generate()
                 val declaration = irClass.constructors.primary // todo: move to appropriate place
@@ -110,7 +105,7 @@
         irSerializableClass.annotations += annotationCtorCall
     }
 
-    fun generateLazySerializerGetter(methodDescriptor: FunctionDescriptor) {
+    fun generateLazySerializerGetter(methodDescriptor: IrSimpleFunction) {
         val serializer = requireNotNull(
             findTypeSerializer(
                 compilerContext,
@@ -124,21 +119,20 @@
 
         val property = createLazyProperty(irClass, targetIrType, SerialEntityNames.CACHED_SERIALIZER_PROPERTY_NAME) {
             val expr = serializerInstance(
-                this@SerializableCompanionIrGenerator,
                 serializer, compilerContext, serializableIrClass.defaultType
             )
             patchSerializableClassWithMarkerAnnotation(kSerializerIrClass)
             +irReturn(requireNotNull(expr))
         }
 
-        irClass.contributeFunction(methodDescriptor) {
+        addFunctionBody(methodDescriptor) {
             +irReturn(getLazyValueExpression(it.dispatchReceiverParameter!!, property, targetIrType))
         }
         generateSerializerFactoryIfNeeded(methodDescriptor)
     }
 
-    fun generateSerializerGetter(methodDescriptor: FunctionDescriptor) {
-        irClass.contributeFunction(methodDescriptor) { getter ->
+    fun generateSerializerGetter(methodDescriptor: IrSimpleFunction) {
+        addFunctionBody(methodDescriptor) { getter ->
             val serializer = requireNotNull(
                 findTypeSerializer(
                     compilerContext,
@@ -147,7 +141,6 @@
             )
             val args: List<IrExpression> = getter.valueParameters.map { irGet(it) }
             val expr = serializerInstance(
-                this@SerializableCompanionIrGenerator,
                 serializer, compilerContext,
                 serializableIrClass.defaultType
             ) { it, _ -> args[it] }
@@ -157,25 +150,25 @@
         generateSerializerFactoryIfNeeded(methodDescriptor)
     }
 
-    private fun generateSerializerFactoryIfNeeded(getterDescriptor: FunctionDescriptor) {
+    private fun generateSerializerFactoryIfNeeded(getterDescriptor: IrSimpleFunction) {
         if (!irClass.descriptor.needSerializerFactory()) return
         val serialFactoryDescriptor = irClass.findDeclaration<IrSimpleFunction> {
             it.valueParameters.size == 1
                     && it.valueParameters.first().isVararg
-//                    && it.kind == CallableMemberDescriptor.Kind.SYNTHESIZED
-                    && isKSerializer(it.returnType)
+                    && it.returnType.isKSerializer()
+                    && it.isFromPlugin()
         } ?: return
         addFunctionBody(serialFactoryDescriptor) { factory ->
             val kSerializerStarType = factory.returnType
             val array = factory.valueParameters.first()
-            val argsSize = serializableDescriptor.declaredTypeParameters.size
+            val argsSize = serializableIrClass.typeParameters.size
             val arrayGet = compilerContext.irBuiltIns.arrayClass.owner.declarations.filterIsInstance<IrSimpleFunction>()
                 .single { it.name.asString() == "get" }
 
             val serializers: List<IrExpression> = (0 until argsSize).map {
                 irInvoke(irGet(array), arrayGet.symbol, irInt(it), typeHint = kSerializerStarType)
             }
-            val serializerCall = compilerContext.symbolTable.referenceSimpleFunction(getterDescriptor)
+            val serializerCall = getterDescriptor.symbol
             val call = irInvoke(
                 IrGetValueImpl(startOffset, endOffset, factory.dispatchReceiverParameter!!.symbol),
                 serializerCall,
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt
index b974b20..959e212 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt
@@ -24,7 +24,6 @@
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.getOrPutNullable
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.*
 import org.jetbrains.kotlinx.serialization.compiler.diagnostic.serializableAnnotationIsUseless
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
 import org.jetbrains.kotlinx.serialization.compiler.resolve.*
@@ -36,8 +35,8 @@
 
 class SerializableIrGenerator(
     val irClass: IrClass,
-    override val compilerContext: SerializationPluginContext
-) : AbstractIrGenerator(irClass), IrBuilderExtension {
+    compilerContext: SerializationPluginContext
+) : BaseIrGenerator(irClass, compilerContext) {
 
     protected val properties = serializablePropertiesForIrBackend(irClass)
 
@@ -65,7 +64,7 @@
             val thiz = irClass.thisReceiver!!
             val serializableProperties = properties.serializableProperties
 
-            val serialDescs = serializableProperties.map { it.descriptor }.toSet()
+            val serialDescs = serializableProperties.map { it.ir }.toSet()
 
             val propertyByParamReplacer: (ValueParameterDescriptor) -> IrExpression? =
                 createPropertyByParamReplacer(irClass, serializableProperties, thiz)
@@ -137,19 +136,19 @@
                 val paramRef = ctor.valueParameters[index + seenVarsOffset]
                 // Assign this.a = a in else branch
                 // Set field directly w/o setter to match behavior of old backend plugin
-                val backingFieldToAssign = prop.descriptor.backingField!!
+                val backingFieldToAssign = prop.ir.backingField!!
                 val assignParamExpr = irSetField(irGet(thiz), backingFieldToAssign, irGet(paramRef))
 
                 val ifNotSeenExpr: IrExpression = if (prop.optional) {
                     val initializerBody =
-                        requireNotNull(initializerAdapter(prop.irField?.initializer!!)) { "Optional value without an initializer" } // todo: filter abstract here
+                        requireNotNull(initializerAdapter(prop.ir.backingField?.initializer!!)) { "Optional value without an initializer" } // todo: filter abstract here
                     irSetField(irGet(thiz), backingFieldToAssign, initializerBody)
                 } else {
                     // property required
                     if (useFieldMissingOptimization()) {
                         // field definitely not empty as it's checked before - no need another IF, only assign property from param
                         +assignParamExpr
-                        statementsAfterSerializableProperty[prop.descriptor]?.forEach { +it }
+                        statementsAfterSerializableProperty[prop.ir]?.forEach { +it }
                         continue
                     } else {
                         irThrow(irInvoke(null, exceptionCtorRef, irString(prop.name), typeHint = exceptionType))
@@ -168,7 +167,7 @@
 
                 +irIfThenElse(compilerContext.irBuiltIns.unitType, propNotSeenTest, ifNotSeenExpr, assignParamExpr)
 
-                statementsAfterSerializableProperty[prop.descriptor]?.forEach { +it }
+                statementsAfterSerializableProperty[prop.ir]?.forEach { +it }
             }
 
             // Handle function-intialized interface delegates
@@ -271,7 +270,7 @@
         propertiesStart: Int
     ): Int {
         check(superClass.isInternalSerializable)
-        val superCtorRef = serializableSyntheticConstructor(superClass)!!
+        val superCtorRef = superClass.serializableSyntheticConstructor()!!
         val superProperties = serializablePropertiesForIrBackend(superClass).serializableProperties
         val superSlots = superProperties.bitMaskSlotCount()
         val arguments = allValueParameters.subList(0, superSlots) +
@@ -332,7 +331,6 @@
                         val genericIdx = irClass.defaultType.arguments.indexOf(arg).let { if (it == -1) null else it }
                         val serial = findTypeSerializerOrContext(compilerContext, arg.typeOrNull!!)
                         serializerInstance(
-                            this@SerializableIrGenerator,
                             serial,
                             compilerContext,
                             arg.typeOrNull!!,
@@ -346,9 +344,9 @@
             }
 
             serializeAllProperties(
-                this@SerializableIrGenerator, irClass, serializableProperties,
-                objectToSerialize, localOutput, localSerialDesc,
-                kOutputClass, ignoreIndexTo, initializerAdapter
+                serializableProperties, objectToSerialize,
+                localOutput, localSerialDesc, kOutputClass,
+                ignoreIndexTo, initializerAdapter
             ) { it, _ ->
                 irGet(writeSelfFunction.valueParameters[3 + it])
             }
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForEnumsGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForEnumsGenerator.kt
index 5110370..687bfd4 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForEnumsGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForEnumsGenerator.kt
@@ -7,8 +7,6 @@
 
 import org.jetbrains.kotlin.backend.jvm.functionByName
 import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
@@ -23,14 +21,9 @@
 import org.jetbrains.kotlin.ir.util.functions
 import org.jetbrains.kotlin.ir.util.properties
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.enumEntries
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.getClassFromInternalSerializationPackage
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.getClassFromRuntime
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.serialNameValue
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
-import org.jetbrains.kotlinx.serialization.compiler.resolve.*
+import org.jetbrains.kotlinx.serialization.compiler.resolve.CallingConventions
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames
 
 class SerializerForEnumsGenerator(
     irClass: IrClass,
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt
index a94c333..9327fc1 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt
@@ -6,8 +6,6 @@
 package org.jetbrains.kotlinx.serialization.compiler.backend.ir
 
 import org.jetbrains.kotlin.backend.jvm.functionByName
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
@@ -18,12 +16,9 @@
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.typeOrNull
 import org.jetbrains.kotlin.ir.util.constructors
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.getClassFromInternalSerializationPackage
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.getClassFromRuntime
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
-import org.jetbrains.kotlinx.serialization.compiler.resolve.*
+import org.jetbrains.kotlinx.serialization.compiler.resolve.CallingConventions
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames
 
 class SerializerForInlineClassGenerator(
     irClass: IrClass,
@@ -44,7 +39,7 @@
         val inlineEncoder = irTemporary(encodeInlineCall, nameHint = "inlineEncoder")
 
         val property = serializableProperties.first()
-        val value = getFromBox(irGet(saveFunc.valueParameters[1]), property)
+        val value = getProperty(irGet(saveFunc.valueParameters[1]), property.ir)
 
         // inlineEncoder.encodeInt/String/SerializableValue
         val elementCall = formEncodeDecodePropertyCall(irGet(inlineEncoder), saveFunc.dispatchReceiverParameter!!, property, {innerSerial, sti ->
@@ -109,6 +104,4 @@
             listOf(expression)
         )
 
-    private fun IrBlockBodyBuilder.getFromBox(expression: IrExpression, serializableProperty: IrSerializableProperty): IrExpression =
-        getProperty(expression, serializableProperty.descriptor)
 }
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt
index 75c4587..706be67 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt
@@ -37,7 +37,6 @@
 import org.jetbrains.kotlin.resolve.isInlineClass
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.cast
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.*
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationDescriptorSerializerPlugin
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
 import org.jetbrains.kotlinx.serialization.compiler.resolve.*
@@ -55,10 +54,10 @@
 
 open class SerializerIrGenerator(
     val irClass: IrClass,
-    final override val compilerContext: SerializationPluginContext,
+    compilerContext: SerializationPluginContext,
     metadataPlugin: SerializationDescriptorSerializerPlugin?,
     private val serialInfoJvmGenerator: SerialInfoImplJvmIrGenerator,
-) : AbstractIrGenerator(irClass), IrBuilderExtension {
+) : BaseIrGenerator(irClass, compilerContext) {
     protected val serializableIrClass = getSerializableClassDescriptorBySerializer(irClass)!!
 
     protected val serialName: String = serializableIrClass.serialName()
@@ -91,7 +90,7 @@
         if (count == 0) return emptyList()
         val propNames = (0 until count).map { "${SerialEntityNames.typeArgPrefix}$it" }
         return propNames.mapNotNull { name ->
-            getProperty(name) { isKSerializer(it.getter!!.returnType) }
+            getProperty(name) { it.getter!!.returnType.isKSerializer() }
         }
     }
 
@@ -184,7 +183,7 @@
             if (classProp.transient) continue
             +addFieldCall(classProp)
             // add property annotations
-            val property = classProp.descriptor//.getIrPropertyFrom(serializableIrClass)
+            val property = classProp.ir//.getIrPropertyFrom(serializableIrClass)
             copySerialInfoAnnotationsToDescriptor(
                 property.annotations,
                 localDescriptor,
@@ -305,8 +304,8 @@
                 createInitializerAdapter(serializableIrClass, propertyByParamReplacer, thisSymbol to { irGet(objectToSerialize) })
 
             serializeAllProperties(
-                this@SerializerIrGenerator, serializableIrClass, serializableProperties, objectToSerialize,
-                localOutput, localSerialDesc, kOutputClass, ignoreIndexTo = -1, initializerAdapter
+                serializableProperties, objectToSerialize, localOutput,
+                localSerialDesc, kOutputClass, ignoreIndexTo = -1, initializerAdapter
             ) { it, _ ->
                 val (_, ir) = localSerializersFieldsDescriptors[it]
                 irGetField(irGet(saveFunc.dispatchReceiverParameter!!), ir.backingField!!)
@@ -326,7 +325,6 @@
         whenDoNot: (sti: IrSerialTypeInfo) -> FunctionWithArgs,
         returnTypeHint: IrType? = null
     ): IrExpression = formEncodeDecodePropertyCall(
-        this@SerializerIrGenerator,
         encoder,
         property,
         whenHaveSerializer,
@@ -385,7 +383,7 @@
 
         val serialPropertiesIndexes = serializableProperties
             .mapIndexed { i, property -> property to i }
-            .associate { (p, i) -> p.descriptor to i }
+            .associate { (p, i) -> p.ir to i }
 
         val transients = serializableIrClass.declarations.asSequence()
             .filterIsInstance<IrProperty>()
@@ -395,7 +393,7 @@
         // var bitMask0 = 0, bitMask1 = 0...
         val bitMasks = (0 until blocksCnt).map { irTemporary(irInt(0), "bitMask$it", isMutable = true) }
         // var local0 = null, local1 = null ...
-        val serialPropertiesMap = serializableProperties.mapIndexed { i, prop -> i to prop.descriptor }.associate { (i, descriptor) ->
+        val serialPropertiesMap = serializableProperties.mapIndexed { i, prop -> i to prop.ir }.associate { (i, descriptor) ->
             val (expr, type) = defaultValueAndType(descriptor)
             descriptor to irTemporary(expr, "local$i", type, isMutable = true)
         }
@@ -425,7 +423,7 @@
                                 it.owner.name.asString() == "${CallingConventions.decode}${sti.elementMethodPrefix}Serializable${CallingConventions.elementPostfix}" &&
                                         it.owner.valueParameters.size == 4
                             } to listOf(
-                                localSerialDesc.get(), irInt(index), innerSerial, serialPropertiesMap.getValue(property.descriptor).get()
+                                localSerialDesc.get(), irInt(index), innerSerial, serialPropertiesMap.getValue(property.ir).get()
                             )
                         }, {sti ->
                                                          inputClass.functions.single {
@@ -435,7 +433,7 @@
                                                      }, returnTypeHint = property.type)
                     // local$i = localInput.decode...(...)
                     +irSet(
-                        serialPropertiesMap.getValue(property.descriptor).symbol,
+                        serialPropertiesMap.getValue(property.ir).symbol,
                         decodeFuncToCall
                     )
                     // bitMask[i] |= 1 << x
@@ -492,9 +490,9 @@
         )
 
         val typeArgs = (loadFunc.returnType as IrSimpleType).arguments.map { (it as IrTypeProjection).type }
-        val deserCtor: IrConstructorSymbol? = serializableSyntheticConstructor(serializableIrClass)
+        val deserCtor: IrConstructorSymbol? = serializableIrClass.serializableSyntheticConstructor()
         if (serializableIrClass.isInternalSerializable && deserCtor != null) {
-            var args: List<IrExpression> = serializableProperties.map { serialPropertiesMap.getValue(it.descriptor).get() }
+            var args: List<IrExpression> = serializableProperties.map { serialPropertiesMap.getValue(it.ir).get() }
             args = bitMasks.map { irGet(it) } + args + irNull()
             +irReturn(irInvoke(null, deserCtor, typeArgs, args))
         } else {
@@ -574,9 +572,9 @@
         bitMasks: List<IrVariable>
     ) {
         for (property in properties.serializableStandaloneProperties) {
-            val localPropIndex = propIndexes(property.descriptor)
+            val localPropIndex = propIndexes(property.ir)
             // generate setter call
-            val setter = property.descriptor.setter!!
+            val setter = property.ir.setter!!
             val propSeenTest =
                 irNotEquals(
                     irInt(0),
@@ -587,13 +585,12 @@
                     )
                 )
 
-            val setterInvokeExpr = irSet(setter.returnType, irGet(serializableVar), setter.symbol, irGet(propVars(property.descriptor)))
+            val setterInvokeExpr = irSet(setter.returnType, irGet(serializableVar), setter.symbol, irGet(propVars(property.ir)))
 
             +irIfThen(propSeenTest, setterInvokeExpr)
         }
     }
 
-    // !!! TODO: this doesn't work with OLD FE !!!
     fun generate() {
         val prop = generatedSerialDescPropertyDescriptor?.let { generateSerializableClassProperty(it); true } ?: false
         if (prop)
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerSearchUtil.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerSearchUtil.kt
new file mode 100644
index 0000000..048f837
--- /dev/null
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerSearchUtil.kt
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2010-2022 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.kotlinx.serialization.compiler.backend.ir
+
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.expressions.IrClassReference
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlinx.serialization.compiler.backend.common.findStandardKotlinTypeSerializer
+import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.*
+import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationPackages
+import org.jetbrains.kotlinx.serialization.compiler.resolve.SpecialBuiltins
+
+class IrSerialTypeInfo(
+    val property: IrSerializableProperty,
+    val elementMethodPrefix: String,
+    val serializer: IrClassSymbol? = null
+)
+
+fun BaseIrGenerator.getIrSerialTypeInfo(property: IrSerializableProperty, ctx: SerializationPluginContext): IrSerialTypeInfo {
+    fun SerializableInfo(serializer: IrClassSymbol?) =
+        IrSerialTypeInfo(property, if (property.type.isNullable()) "Nullable" else "", serializer)
+
+    val T = property.type
+    property.serializableWith(ctx)?.let { return SerializableInfo(it) }
+    findAddOnSerializer(T, ctx)?.let { return SerializableInfo(it) }
+    T.overridenSerializer?.let { return SerializableInfo(it) }
+    return when {
+        T.isTypeParameter() -> IrSerialTypeInfo(property, if (property.type.isMarkedNullable()) "Nullable" else "", null)
+        T.isPrimitiveType() -> IrSerialTypeInfo(
+            property,
+            T.classFqName!!.asString().removePrefix("kotlin.")
+        )
+        T.isString() -> IrSerialTypeInfo(property, "String")
+        T.isArray() -> {
+            val serializer = property.serializableWith(ctx) ?: ctx.getClassFromInternalSerializationPackage(SpecialBuiltins.referenceArraySerializer)
+            SerializableInfo(serializer)
+        }
+        else -> {
+            val serializer =
+                findTypeSerializerOrContext(ctx, property.type)
+            SerializableInfo(serializer)
+        }
+    }
+}
+
+fun BaseIrGenerator.findAddOnSerializer(propertyType: IrType, ctx: SerializationPluginContext): IrClassSymbol? {
+    val classSymbol = propertyType.classOrNull ?: return null
+    additionalSerializersInScopeOfCurrentFile[classSymbol to propertyType.isNullable()]?.let { return it }
+    if (classSymbol in contextualKClassListInCurrentFile)
+        return ctx.getClassFromRuntime(SpecialBuiltins.contextSerializer)
+    if (classSymbol.owner.annotations.hasAnnotation(SerializationAnnotations.polymorphicFqName))
+        return ctx.getClassFromRuntime(SpecialBuiltins.polymorphicSerializer)
+    if (propertyType.isNullable()) return findAddOnSerializer(propertyType.makeNotNull(), ctx)
+    return null
+}
+
+fun BaseIrGenerator.findTypeSerializerOrContext(
+    context: SerializationPluginContext, kType: IrType
+): IrClassSymbol? {
+    if (kType.isTypeParameter()) return null
+    return findTypeSerializerOrContextUnchecked(context, kType) ?: error("Serializer for element of type ${kType.render()} has not been found")
+}
+
+fun BaseIrGenerator.findTypeSerializerOrContextUnchecked(
+    context: SerializationPluginContext, kType: IrType
+): IrClassSymbol? {
+    val annotations = kType.annotations
+    if (kType.isTypeParameter()) return null
+    annotations.serializableWith()?.let { return it }
+    additionalSerializersInScopeOfCurrentFile[kType.classOrNull!! to kType.isNullable()]?.let {
+        return it
+    }
+    if (kType.isMarkedNullable()) return findTypeSerializerOrContextUnchecked(context, kType.makeNotNull())
+    if (kType.classOrNull in contextualKClassListInCurrentFile) return context.referenceClass(contextSerializerId)
+    return analyzeSpecialSerializers(context, annotations) ?: findTypeSerializer(context, kType)
+}
+
+fun analyzeSpecialSerializers(
+    context: SerializationPluginContext,
+    annotations: List<IrConstructorCall>
+): IrClassSymbol? = when {
+    annotations.hasAnnotation(SerializationAnnotations.contextualFqName) || annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyFqName) ->
+        context.referenceClass(contextSerializerId)
+    // can be annotation on type usage, e.g. List<@Polymorphic Any>
+    annotations.hasAnnotation(SerializationAnnotations.polymorphicFqName) ->
+        context.referenceClass(polymorphicSerializerId)
+    else -> null
+}
+
+
+fun findTypeSerializer(context: SerializationPluginContext, type: IrType): IrClassSymbol? {
+    type.overridenSerializer?.let { return it }
+    if (type.isTypeParameter()) return null
+    if (type.isArray()) return context.referenceClass(referenceArraySerializerId)
+    if (type.isGeneratedSerializableObject()) return context.referenceClass(objectSerializerId)
+    val stdSer = findStandardKotlinTypeSerializer(context, type) // see if there is a standard serializer
+        ?: findEnumTypeSerializer(context, type)
+    if (stdSer != null) return stdSer
+    if (type.isInterface() && type.classOrNull?.owner?.isSealedSerializableInterface == false) return context.referenceClass(
+        polymorphicSerializerId
+    )
+    return type.classOrNull?.owner.classSerializer(context) // check for serializer defined on the type
+}
+fun findEnumTypeSerializer(context: SerializationPluginContext, type: IrType): IrClassSymbol? {
+    val classSymbol = type.classOrNull?.owner ?: return null
+    return if (classSymbol.kind == ClassKind.ENUM_CLASS && !classSymbol.isEnumWithLegacyGeneratedSerializer())
+        context.referenceClass(enumSerializerId)
+    else null
+}
+
+internal fun IrClass?.classSerializer(context: SerializationPluginContext): IrClassSymbol? = this?.let {
+    // serializer annotation on class?
+    serializableWith?.let { return it }
+    // companion object serializer?
+    if (hasCompanionObjectAsSerializer) return companionObject()?.symbol
+    // can infer @Poly?
+    polymorphicSerializerIfApplicableAutomatically(context)?.let { return it }
+    // default serializable?
+    if (shouldHaveGeneratedSerializer) {
+        // $serializer nested class
+        return this.declarations
+            .filterIsInstance<IrClass>()
+            .singleOrNull { it.name == SerialEntityNames.SERIALIZER_CLASS_NAME }?.symbol
+    }
+    return null
+}
+
+internal fun IrClass.polymorphicSerializerIfApplicableAutomatically(context: SerializationPluginContext): IrClassSymbol? {
+    val serializer = when {
+        kind == ClassKind.INTERFACE && modality == Modality.SEALED -> SpecialBuiltins.sealedSerializer
+        kind == ClassKind.INTERFACE -> SpecialBuiltins.polymorphicSerializer
+        isInternalSerializable && modality == Modality.ABSTRACT -> SpecialBuiltins.polymorphicSerializer
+        isInternalSerializable && modality == Modality.SEALED -> SpecialBuiltins.sealedSerializer
+        else -> null
+    }
+    return serializer?.let {
+        context.getClassFromRuntimeOrNull(
+            it,
+            SerializationPackages.packageFqName,
+            SerializationPackages.internalPackageFqName
+        )
+    }
+}
+
+internal val IrType.overridenSerializer: IrClassSymbol?
+    get() {
+        val desc = this.classOrNull ?: return null
+        desc.owner.serializableWith?.let { return it }
+        return null
+    }
+
+internal val IrClass.serializableWith: IrClassSymbol?
+    get() = annotations.serializableWith()
+
+internal val IrClass.serializerForClass: IrClassSymbol?
+    get() = (annotations.findAnnotation(SerializationAnnotations.serializerAnnotationFqName)
+        ?.getValueArgument(0) as? IrClassReference)?.symbol as? IrClassSymbol
+
+fun findStandardKotlinTypeSerializer(context: SerializationPluginContext, type: IrType): IrClassSymbol? {
+    val typeName = type.classFqName?.toString()
+    val name = when (typeName) {
+        "Z" -> if (type.isBoolean()) "BooleanSerializer" else null
+        "B" -> if (type.isByte()) "ByteSerializer" else null
+        "S" -> if (type.isShort()) "ShortSerializer" else null
+        "I" -> if (type.isInt()) "IntSerializer" else null
+        "J" -> if (type.isLong()) "LongSerializer" else null
+        "F" -> if (type.isFloat()) "FloatSerializer" else null
+        "D" -> if (type.isDouble()) "DoubleSerializer" else null
+        "C" -> if (type.isChar()) "CharSerializer" else null
+        null -> null
+        else -> findStandardKotlinTypeSerializer(typeName)
+    } ?: return null
+    return context.getClassFromRuntimeOrNull(name, SerializationPackages.internalPackageFqName, SerializationPackages.packageFqName)
+}
+
+// @Serializable(X::class) -> X
+internal fun List<IrConstructorCall>.serializableWith(): IrClassSymbol? {
+    val annotation = findAnnotation(SerializationAnnotations.serializableAnnotationFqName) ?: return null
+    val arg = annotation.getValueArgument(0) as? IrClassReference ?: return null
+    return arg.symbol as? IrClassSymbol
+}
+
+internal fun getSerializableClassByCompanion(companionClass: IrClass): IrClass? {
+    if (companionClass.isSerializableObject) return companionClass
+    if (!companionClass.isCompanion) return null
+    val classDescriptor = (companionClass.parent as? IrClass) ?: return null
+    if (!classDescriptor.shouldHaveGeneratedMethodsInCompanion) return null
+    return classDescriptor
+}
+
+fun BaseIrGenerator.allSealedSerializableSubclassesFor(
+    irClass: IrClass,
+    context: SerializationPluginContext
+): Pair<List<IrSimpleType>, List<IrClassSymbol>> {
+    assert(irClass.modality == Modality.SEALED)
+    fun recursiveSealed(klass: IrClass): Collection<IrClass> {
+        return klass.sealedSubclasses.map { it.owner }.flatMap { if (it.modality == Modality.SEALED) recursiveSealed(it) else setOf(it) }
+    }
+
+    val serializableSubtypes = recursiveSealed(irClass).map { it.defaultType }
+    return serializableSubtypes.mapNotNull { subtype ->
+        findTypeSerializerOrContextUnchecked(context, subtype)?.let { Pair(subtype, it) }
+    }.unzip()
+}
+
+internal fun getSerializableClassDescriptorBySerializer(serializer: IrClass): IrClass? {
+    val serializerForClass = serializer.serializerForClass
+    if (serializerForClass != null) return serializerForClass.owner
+    if (serializer.name !in setOf(
+            SerialEntityNames.SERIALIZER_CLASS_NAME,
+            SerialEntityNames.GENERATED_SERIALIZER_CLASS
+        )
+    ) return null
+    val classDescriptor = (serializer.parent as? IrClass) ?: return null
+    if (!classDescriptor.shouldHaveGeneratedSerializer) return null
+    return classDescriptor
+}
+
+fun SerializationPluginContext.getClassFromRuntimeOrNull(className: String, vararg packages: FqName): IrClassSymbol? {
+    val listToSearch = if (packages.isEmpty()) SerializationPackages.allPublicPackages else packages.toList()
+    for (pkg in listToSearch) {
+        referenceClass(ClassId(pkg, Name.identifier(className)))?.let { return it }
+    }
+    return null
+}
+
+fun SerializationPluginContext.getClassFromRuntime(className: String, vararg packages: FqName): IrClassSymbol {
+    return getClassFromRuntimeOrNull(className, *packages) ?: error(
+        "Class $className wasn't found in ${packages.toList().ifEmpty { SerializationPackages.allPublicPackages }}. " +
+                "Check that you have correct version of serialization runtime in classpath."
+    )
+}
+
+fun SerializationPluginContext.getClassFromInternalSerializationPackage(className: String): IrClassSymbol =
+    getClassFromRuntimeOrNull(className, SerializationPackages.internalPackageFqName)
+        ?: error("Class $className wasn't found in ${SerializationPackages.internalPackageFqName}. Check that you have correct version of serialization runtime in classpath.")
+
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/Synthetics.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/Synthetics.kt
deleted file mode 100644
index 0f04d46..0000000
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/Synthetics.kt
+++ /dev/null
@@ -1,39 +0,0 @@
-package org.jetbrains.kotlinx.serialization.compiler.backend.ir
-
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.impl.FieldDescriptorImpl
-import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.KotlinType
-
-
-/**
- * Simple property descriptor with backing field without getters/setters for ir generation purposes
- */
-class SimpleSyntheticPropertyDescriptor(
-    owner: ClassDescriptor,
-    name: String,
-    type: KotlinType,
-    isVar: Boolean = false,
-    visibility: DescriptorVisibility = DescriptorVisibilities.PRIVATE
-) : PropertyDescriptorImpl(
-    owner,
-    null,
-    Annotations.EMPTY,
-    Modality.FINAL,
-    visibility,
-    isVar,
-    Name.identifier(name),
-    CallableMemberDescriptor.Kind.SYNTHESIZED,
-    owner.source,
-    false, false, false, false, false, false
-    ) {
-
-    private val _backingField = FieldDescriptorImpl(Annotations.EMPTY, this)
-
-    init {
-        super.setType(type, emptyList(), owner.thisAsReceiverParameter, null, emptyList())
-        super.initialize(null, null, _backingField, null)
-    }
-}
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperties.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperties.kt
index 6145145..1d55337 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperties.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperties.kt
@@ -6,15 +6,6 @@
 package org.jetbrains.kotlinx.serialization.compiler.resolve
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrProperty
-import org.jetbrains.kotlin.ir.declarations.lazy.IrMaybeDeserializedClass
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.types.IrSimpleType
-import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.types.classOrNull
-import org.jetbrains.kotlin.ir.types.isAny
-import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtDeclarationWithInitializer
 import org.jetbrains.kotlin.psi.KtParameter
@@ -27,15 +18,11 @@
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor
 import org.jetbrains.kotlin.serialization.deserialization.getName
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext.isInterface
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.isInitializePropertyFromParameter
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.isInternalSerializable
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.isInternallySerializableEnum
 import org.jetbrains.kotlinx.serialization.compiler.diagnostic.SERIALIZABLE_PROPERTIES
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationDescriptorSerializerPlugin
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginMetadataExtensions
 
-interface ISerializableProperties<D, T, S : ISerializableProperty<D, T>> {
+interface ISerializableProperties<T, S : ISerializableProperty<T>> {
     val serializableProperties: List<S>
     val isExternallySerializable: Boolean
     val serializableConstructorProperties: List<S>
@@ -43,7 +30,7 @@
 }
 
 class SerializableProperties(private val serializableClass: ClassDescriptor, val bindingContext: BindingContext) :
-    ISerializableProperties<PropertyDescriptor, KotlinType, SerializableProperty> {
+    ISerializableProperties<KotlinType, SerializableProperty> {
     private val primaryConstructorParameters: List<ValueParameterDescriptor> =
         serializableClass.unsubstitutedPrimaryConstructor?.valueParameters ?: emptyList()
 
@@ -134,7 +121,7 @@
 }
 
 
-internal val ISerializableProperties<*, *, *>.goldenMask: Int
+internal val ISerializableProperties<*, *>.goldenMask: Int
     get() {
         var goldenMask = 0
         var requiredBit = 1
@@ -147,7 +134,7 @@
         return goldenMask
     }
 
-internal val ISerializableProperties<*, *, *>.goldenMaskList: List<Int>
+internal val ISerializableProperties<*, *>.goldenMaskList: List<Int>
     get() {
         val maskSlotCount = serializableProperties.bitMaskSlotCount()
         val goldenMaskList = MutableList(maskSlotCount) { 0 }
@@ -162,7 +149,7 @@
         return goldenMaskList
     }
 
-internal fun List<ISerializableProperty<*, *>>.bitMaskSlotCount() = size / 32 + 1
+internal fun List<ISerializableProperty<*>>.bitMaskSlotCount() = size / 32 + 1
 internal fun bitMaskSlotAt(propertyIndex: Int) = propertyIndex / 32
 
 internal fun BindingContext.serializablePropertiesFor(
@@ -180,75 +167,4 @@
         .map { descriptor.c.nameResolver.getName(it) }
     val propsMap = props.associateBy { it.descriptor.name }
     return correctOrder.map { propsMap.getValue(it) }
-}
-
-class IrSerializableProperties(
-    override val serializableProperties: List<IrSerializableProperty>,
-    override val isExternallySerializable: Boolean,
-    override val serializableConstructorProperties: List<IrSerializableProperty>,
-    override val serializableStandaloneProperties: List<IrSerializableProperty>
-) : ISerializableProperties<IrProperty, IrSimpleType, IrSerializableProperty> {
-}
-
-internal fun serializablePropertiesForIrBackend(
-    classDescriptor: IrClass,
-    serializationDescriptorSerializer: SerializationDescriptorSerializerPlugin? = null
-): IrSerializableProperties {
-    val properties = classDescriptor.properties.toList()
-    val primaryConstructorParams = classDescriptor.primaryConstructor?.valueParameters.orEmpty()
-    val primaryParamsAsProps = properties.associateBy { it.name }.let { namesMap ->
-        primaryConstructorParams.mapNotNull {
-            if (it.name !in namesMap) null else namesMap.getValue(it.name) to it.hasDefaultValue()
-        }.toMap()
-    }
-
-    fun isPropSerializable(it: IrProperty) =
-        if (classDescriptor.isInternalSerializable) !it.annotations.hasAnnotation(SerializationAnnotations.serialTransientFqName)
-        else !DescriptorVisibilities.isPrivate(it.visibility) && ((it.isVar && !it.annotations.hasAnnotation(SerializationAnnotations.serialTransientFqName)) || primaryParamsAsProps.contains(
-            it
-        ))
-
-    val (primaryCtorSerializableProps, bodySerializableProps) = properties
-        .asSequence()
-        .filter { !it.isFakeOverride && !it.isDelegated }
-        .filter(::isPropSerializable)
-        .map {
-            val isConstructorParameterWithDefault = primaryParamsAsProps[it] ?: false
-            // FIXME: workaround because IrLazyProperty doesn't deserialize information about backing fields. Fallback to descriptor won't work with FIR.
-            val isPropertyFromAnotherModuleDeclaresDefaultValue = it.descriptor is DeserializedPropertyDescriptor &&  it.descriptor.declaresDefaultValue()
-            val isPropertyWithBackingFieldFromAnotherModule = it.descriptor is DeserializedPropertyDescriptor && (it.descriptor.backingField != null || isPropertyFromAnotherModuleDeclaresDefaultValue)
-            IrSerializableProperty(
-                it,
-                isConstructorParameterWithDefault,
-                it.backingField != null || isPropertyWithBackingFieldFromAnotherModule,
-                it.backingField?.initializer.let { init -> init != null && !init.expression.isInitializePropertyFromParameter() } || isConstructorParameterWithDefault
-                        || isPropertyFromAnotherModuleDeclaresDefaultValue
-            )
-        }
-        .filterNot { it.transient }
-        .partition { primaryParamsAsProps.contains(it.descriptor) }
-
-    val serializableProps = run {
-        val supers = classDescriptor.getParentClassNotAny()
-        if (supers == null || !supers.isInternalSerializable)
-            primaryCtorSerializableProps + bodySerializableProps
-        else
-            serializablePropertiesForIrBackend(
-                supers,
-                serializationDescriptorSerializer
-            ).serializableProperties + primaryCtorSerializableProps + bodySerializableProps
-    } // todo: implement unsorting
-
-    val isExternallySerializable =
-        classDescriptor.isInternallySerializableEnum() || primaryConstructorParams.size == primaryParamsAsProps.size
-
-    return IrSerializableProperties(serializableProps, isExternallySerializable, primaryCtorSerializableProps, bodySerializableProps)
-}
-
-fun IrClass.getParentClassNotAny(): IrClass? {
-    val parentClass =
-        superTypes
-            .mapNotNull { it.classOrNull?.owner }
-            .singleOrNull { it.kind == ClassKind.CLASS || it.kind == ClassKind.ENUM_CLASS } ?: return null
-    return if (parentClass.defaultType.isAny()) null else parentClass
 }
\ No newline at end of file
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperty.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperty.kt
index d51337a..a06e5e4 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperty.kt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/SerializableProperty.kt
@@ -16,40 +16,12 @@
 
 package org.jetbrains.kotlinx.serialization.compiler.resolve
 
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.ir.declarations.IrProperty
-import org.jetbrains.kotlin.ir.types.IrSimpleType
-import org.jetbrains.kotlin.ir.util.hasAnnotation
-import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlinx.serialization.compiler.backend.common.analyzeSpecialSerializers
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.genericIndex
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.serialNameValue
-import org.jetbrains.kotlinx.serialization.compiler.backend.common.serializableWith
-import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext
 
-class SerializableProperty(
-    override val descriptor: PropertyDescriptor,
-    override val isConstructorParameterWithDefault: Boolean,
-    hasBackingField: Boolean,
-    declaresDefaultValue: Boolean
-) : ISerializableProperty<PropertyDescriptor, KotlinType> {
-    override val name = descriptor.annotations.serialNameValue ?: descriptor.name.asString()
-    override val type = descriptor.type
-    override val genericIndex = type.genericIndex
-    val module = descriptor.module
-    val serializableWith = descriptor.serializableWith ?: analyzeSpecialSerializers(module, descriptor.annotations)?.defaultType
-    override val optional = !descriptor.annotations.serialRequired && declaresDefaultValue
-    override val transient = descriptor.annotations.serialTransient || !hasBackingField
-    val annotationsWithArguments: List<Triple<ClassDescriptor, List<ValueArgument>, List<ValueParameterDescriptor>>> =
-        descriptor.annotationsWithArguments()
-}
-
-interface ISerializableProperty<D, T> {
-    val descriptor: D
+interface ISerializableProperty<T> {
     val isConstructorParameterWithDefault: Boolean
     val name: String
     val type: T
@@ -58,16 +30,18 @@
     val transient: Boolean
 }
 
-class IrSerializableProperty(
-    override val descriptor: IrProperty,
+class SerializableProperty(
+    val descriptor: PropertyDescriptor,
     override val isConstructorParameterWithDefault: Boolean,
     hasBackingField: Boolean,
     declaresDefaultValue: Boolean
-) : ISerializableProperty<IrProperty, IrSimpleType> {
+) : ISerializableProperty<KotlinType> {
     override val name = descriptor.annotations.serialNameValue ?: descriptor.name.asString()
-    override val type = descriptor.getter!!.returnType as IrSimpleType
+    override val type = descriptor.type
     override val genericIndex = type.genericIndex
-    fun serializableWith(ctx: SerializationPluginContext) = descriptor.annotations.serializableWith() ?: analyzeSpecialSerializers(ctx, descriptor.annotations)
-    override val optional = !descriptor.annotations.hasAnnotation(SerializationAnnotations.requiredAnnotationFqName) && declaresDefaultValue
-    override val transient = descriptor.annotations.hasAnnotation(SerializationAnnotations.serialTransientFqName) || !hasBackingField
-}
\ No newline at end of file
+    val module = descriptor.module
+    val serializableWith = descriptor.serializableWith ?: analyzeSpecialSerializers(module, descriptor.annotations)?.defaultType
+    override val optional = !descriptor.annotations.serialRequired && declaresDefaultValue
+    override val transient = descriptor.annotations.serialTransient || !hasBackingField
+}
+
diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen/Sealed.ir.txt b/plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen/Sealed.ir.txt
index 077967a..9728edc 100644
--- a/plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen/Sealed.ir.txt
+++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen/Sealed.ir.txt
@@ -326,7 +326,9 @@
           DUP
           LDC (Result.Err)
           GETSTATIC (Result$Err, INSTANCE, LResult$Err;)
-          INVOKESPECIAL (kotlinx/serialization/internal/ObjectSerializer, <init>, (Ljava/lang/String;Ljava/lang/Object;)V)
+          ICONST_0
+          ANEWARRAY (java/lang/annotation/Annotation)
+          INVOKESPECIAL (kotlinx/serialization/internal/ObjectSerializer, <init>, (Ljava/lang/String;Ljava/lang/Object;[Ljava/lang/annotation/Annotation;)V)
           CHECKCAST (kotlinx/serialization/KSerializer)
           AASTORE
           ALOAD (1)
@@ -335,7 +337,9 @@
           CHECKCAST (kotlinx/serialization/KSerializer)
           AASTORE
           ALOAD (1)
-          INVOKESPECIAL (kotlinx/serialization/SealedClassSerializer, <init>, (Ljava/lang/String;Lkotlin/reflect/KClass;[Lkotlin/reflect/KClass;[Lkotlinx/serialization/KSerializer;)V)
+          ICONST_0
+          ANEWARRAY (java/lang/annotation/Annotation)
+          INVOKESPECIAL (kotlinx/serialization/SealedClassSerializer, <init>, (Ljava/lang/String;Lkotlin/reflect/KClass;[Lkotlin/reflect/KClass;[Lkotlinx/serialization/KSerializer;[Ljava/lang/annotation/Annotation;)V)
           CHECKCAST (kotlinx/serialization/KSerializer)
           ARETURN
         LABEL (L1)
@@ -410,7 +414,9 @@
           DUP
           LDC (Result.Err)
           GETSTATIC (Result$Err, INSTANCE, LResult$Err;)
-          INVOKESPECIAL (kotlinx/serialization/internal/ObjectSerializer, <init>, (Ljava/lang/String;Ljava/lang/Object;)V)
+          ICONST_0
+          ANEWARRAY (java/lang/annotation/Annotation)
+          INVOKESPECIAL (kotlinx/serialization/internal/ObjectSerializer, <init>, (Ljava/lang/String;Ljava/lang/Object;[Ljava/lang/annotation/Annotation;)V)
           CHECKCAST (kotlinx/serialization/KSerializer)
           ARETURN
         LABEL (L1)
@@ -859,7 +865,9 @@
           DUP
           LDC (Result.Err)
           GETSTATIC (Result$Err, INSTANCE, LResult$Err;)
-          INVOKESPECIAL (kotlinx/serialization/internal/ObjectSerializer, <init>, (Ljava/lang/String;Ljava/lang/Object;)V)
+          ICONST_0
+          ANEWARRAY (java/lang/annotation/Annotation)
+          INVOKESPECIAL (kotlinx/serialization/internal/ObjectSerializer, <init>, (Ljava/lang/String;Ljava/lang/Object;[Ljava/lang/annotation/Annotation;)V)
           CHECKCAST (kotlinx/serialization/KSerializer)
           AASTORE
           ALOAD (1)
@@ -868,7 +876,9 @@
           CHECKCAST (kotlinx/serialization/KSerializer)
           AASTORE
           ALOAD (1)
-          INVOKESPECIAL (kotlinx/serialization/SealedClassSerializer, <init>, (Ljava/lang/String;Lkotlin/reflect/KClass;[Lkotlin/reflect/KClass;[Lkotlinx/serialization/KSerializer;)V)
+          ICONST_0
+          ANEWARRAY (java/lang/annotation/Annotation)
+          INVOKESPECIAL (kotlinx/serialization/SealedClassSerializer, <init>, (Ljava/lang/String;Lkotlin/reflect/KClass;[Lkotlin/reflect/KClass;[Lkotlinx/serialization/KSerializer;[Ljava/lang/annotation/Annotation;)V)
           CHECKCAST (kotlinx/serialization/KSerializer)
           ARETURN
         LABEL (L1)