IR: create IrExpressionBody via IrFactory

2020-07-14 19:39:39 +02:00
parent d1dc938a5d
commit 9ad4a754ce
31 changed files with 110 additions and 65 deletions
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.ir.descriptors.WrappedEnumEntryDescriptor
 import org.jetbrains.kotlin.ir.descriptors.WrappedTypeAliasDescriptor
 import org.jetbrains.kotlin.ir.descriptors.WrappedTypeParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.impl.IrEnumConstructorCallImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrEnumEntrySymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol
@@ -408,7 +407,7 @@ class Fir2IrClassifierStorage(
                        // which will be translated via visitor later.
                    } else if (irParent != null && origin == IrDeclarationOrigin.DEFINED) {
                        val constructor = irParent.constructors.first()
-                        this.initializerExpression = IrExpressionBodyImpl(
+                        this.initializerExpression = factory.createExpressionBody(
                            IrEnumConstructorCallImpl(
                                startOffset, endOffset, irType, constructor.symbol,
                                valueArgumentsCount = constructor.valueParameters.size,
@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrSyntheticBodyKind
 import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.types.IrErrorType
 import org.jetbrains.kotlin.ir.types.IrSimpleType
@@ -670,7 +669,7 @@ class Fir2IrDeclarationStorage(
                                if (initializer is FirConstExpression<*>) {
                                    // TODO: Normally we shouldn't have error type here
                                    val constType = initializer.typeRef.toIrType().takeIf { it !is IrErrorType } ?: type
-                                    field.initializer = IrExpressionBodyImpl(initializer.toIrConst(constType))
+                                    field.initializer = factory.createExpressionBody(initializer.toIrConst(constType))
                                }
                            }
                        } else if (delegate != null) {
@@ -794,7 +793,7 @@ class Fir2IrDeclarationStorage(
                            it != null && (useStubForDefaultValueStub || it !is FirExpressionStub)
                        }
                    ) {
-                        this.defaultValue = IrExpressionBodyImpl(
+                        this.defaultValue = factory.createExpressionBody(
                            IrErrorExpressionImpl(
                                UNDEFINED_OFFSET, UNDEFINED_OFFSET, type,
                                "Stub expression for default value of ${valueParameter.name}"
@@ -127,7 +127,7 @@ class Fir2IrVisitor(
                    memberGenerator.convertClassContent(correspondingClass, anonymousObject)
                }
                val constructor = correspondingClass.constructors.first()
-                irEnumEntry.initializerExpression = IrExpressionBodyImpl(
+                irEnumEntry.initializerExpression = irFactory.createExpressionBody(
                    IrEnumConstructorCallImpl(
                        startOffset, endOffset, enumEntry.returnTypeRef.toIrType(),
                        constructor.symbol,
@@ -144,7 +144,9 @@ class Fir2IrVisitor(
            val delegatedConstructor = primaryConstructor?.delegatedConstructor
            if (delegatedConstructor != null) {
                with(memberGenerator) {
-                    irEnumEntry.initializerExpression = IrExpressionBodyImpl(delegatedConstructor.toIrDelegatingConstructorCall())
+                    irEnumEntry.initializerExpression = irFactory.createExpressionBody(
+                        delegatedConstructor.toIrDelegatingConstructorCall()
+                    )
                }
            }
        }
@@ -27,7 +27,10 @@ import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.constructedClassType
+import org.jetbrains.kotlin.ir.util.isAnnotationClass
+import org.jetbrains.kotlin.ir.util.isSetter
+import org.jetbrains.kotlin.ir.util.parentAsClass

 internal class ClassMemberGenerator(
    private val components: Fir2IrComponents,
@@ -221,7 +224,7 @@ internal class ClassMemberGenerator(
            declarationStorage.enterScope(this@initializeBackingField)
            // NB: initializer can be already converted
            if (initializer == null && initializerExpression != null) {
-                initializer = IrExpressionBodyImpl(visitor.convertToIrExpression(initializerExpression))
+                initializer = irFactory.createExpressionBody(visitor.convertToIrExpression(initializerExpression))
            }
            declarationStorage.leaveScope(this@initializeBackingField)
        }
@@ -356,7 +359,7 @@ internal class ClassMemberGenerator(
    private fun IrValueParameter.setDefaultValue(firValueParameter: FirValueParameter) {
        val firDefaultValue = firValueParameter.defaultValue
        if (firDefaultValue != null) {
-            this.defaultValue = IrExpressionBodyImpl(visitor.convertToIrExpression(firDefaultValue))
+            this.defaultValue = factory.createExpressionBody(visitor.convertToIrExpression(firDefaultValue))
        }
    }
-}
+}
@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.symbols.Fir2IrPropertySymbol
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.types.IrErrorType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.isInterface
@@ -103,7 +102,7 @@ class Fir2IrLazyProperty(
                        if (initializer is FirConstExpression<*>) {
                            // TODO: Normally we shouldn't have error type here
                            val constType = with(typeConverter) { initializer.typeRef.toIrType().takeIf { it !is IrErrorType } ?: type }
-                            field.initializer = IrExpressionBodyImpl(initializer.toIrConst(constType))
+                            field.initializer = factory.createExpressionBody(initializer.toIrConst(constType))
                        }
                    }
                }
@@ -22,7 +22,10 @@ import org.jetbrains.kotlin.ir.builders.declarations.buildTypeParameter
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
@@ -142,7 +145,7 @@ fun IrValueParameter.copyTo(
    }
    val symbol = IrValueParameterSymbolImpl(descriptor)
    val defaultValueCopy = defaultValue?.let { originalDefault ->
-        IrExpressionBodyImpl(originalDefault.startOffset, originalDefault.endOffset) {
+        factory.createExpressionBody(originalDefault.startOffset, originalDefault.endOffset) {
            expression = originalDefault.expression.deepCopyWithVariables().also {
                it.patchDeclarationParents(irFunction)
            }
@@ -435,8 +435,9 @@ class DefaultParameterCleaner(
        if (declaration is IrValueParameter && declaration.defaultValue != null) {
            if (replaceDefaultValuesWithStubs) {
                if (context.mapping.defaultArgumentsOriginalFunction[declaration.parent as IrFunction] == null) {
-                    declaration.defaultValue =
-                        IrExpressionBodyImpl(IrErrorExpressionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, declaration.type, "Default Stub"))
+                    declaration.defaultValue = context.irFactory.createExpressionBody(
+                        IrErrorExpressionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, declaration.type, "Default Stub")
+                    )
                }
            } else {
                declaration.defaultValue = null
@@ -562,10 +563,9 @@ private fun IrFunction.generateDefaultsFunctionImpl(
            newFunction,
            type = if (makeNullable) newType.makeNullable() else newType,
            defaultValue = if (it.defaultValue != null) {
-                IrExpressionBodyImpl(IrErrorExpressionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, it.type, "Default Stub"))
+                factory.createExpressionBody(IrErrorExpressionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, it.type, "Default Stub"))
            } else null
        )
-
    }

    for (i in 0 until (valueParameters.size + 31) / 32) {
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrBlockImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrSetFieldImpl
 import org.jetbrains.kotlin.ir.util.constructedClass
@@ -112,11 +111,13 @@ class InitializersCleanupLowering(
            } else {
                declaration.initializer?.let {
                    declaration.initializer =
-                        IrExpressionBodyImpl(it.startOffset, it.endOffset) { expression = it.expression.deepCopyWithSymbols() }
+                        context.irFactory.createExpressionBody(it.startOffset, it.endOffset) {
+                            expression = it.expression.deepCopyWithSymbols()
+                        }
                }
            }
        }

        return null
    }
-}
+}
@@ -48,7 +48,7 @@ class InnerClassesLowering(val context: BackendContext, private val innerClasses
            val oldConstructorParameterToNew = innerClassesSupport.primaryConstructorParameterMap(declaration)
            for ((oldParam, newParam) in oldConstructorParameterToNew.entries) {
                newParam.defaultValue = oldParam.defaultValue?.let { oldDefault ->
-                    IrExpressionBodyImpl(oldDefault.startOffset, oldDefault.endOffset) {
+                    context.irFactory.createExpressionBody(oldDefault.startOffset, oldDefault.endOffset) {
                        expression = oldDefault.expression.patchDeclarationParents(newConstructor)
                    }
                }
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrVarargImpl
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.makeNullable
@@ -150,7 +149,7 @@ class EnumClassConstructorLowering(val context: JsCommonBackendContext) : Declar
                old.valueParameter = new

                old.defaultValue?.let { default ->
-                    new.defaultValue = IrExpressionBodyImpl(default.startOffset, default.endOffset) {
+                    new.defaultValue = context.irFactory.createExpressionBody(default.startOffset, default.endOffset) {
                        expression = default.expression
                        expression.patchDeclarationParents(newConstructor)
                        context.fixReferencesToConstructorParameters(enumClass, this)
@@ -96,7 +96,7 @@ class PrivateMembersLowering(val context: JsIrBackendContext) : DeclarationTrans

            parameterMapping[it]?.apply {
                it.defaultValue?.let { originalDefault ->
-                    defaultValue = IrExpressionBodyImpl(it.startOffset, it.endOffset) {
+                    defaultValue = context.irFactory.createExpressionBody(it.startOffset, it.endOffset) {
                        expression = (originalDefault.copyWithParameters() as IrExpressionBody).expression
                    }
                }
@@ -108,7 +108,7 @@ class PrivateMembersLowering(val context: JsIrBackendContext) : DeclarationTrans
                is IrBlockBody -> IrBlockBodyImpl(it.startOffset, it.endOffset) {
                    statements += (it.copyWithParameters() as IrBlockBody).statements
                }
-                is IrExpressionBody -> IrExpressionBodyImpl(it.startOffset, it.endOffset) {
+                is IrExpressionBody -> context.irFactory.createExpressionBody(it.startOffset, it.endOffset) {
                    expression = (it.copyWithParameters() as IrExpressionBody).expression
                }
                is IrSyntheticBody -> it
@@ -5,7 +5,6 @@

 package org.jetbrains.kotlin.ir.backend.js.lower.inline

-
 import org.jetbrains.kotlin.backend.common.DeclarationTransformer
 import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
@@ -13,7 +12,6 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols

 class RemoveInlineFunctionsWithReifiedTypeParametersLowering: DeclarationTransformer {
@@ -40,12 +38,13 @@ class CopyInlineFunctionBodyLowering(val context: JsIrBackendContext) : Declarat

        if (declaration is IrValueParameter && declaration.parent.let { it is IrFunction && it.isInline }) {
            declaration.defaultValue?.let { originalDefault ->
-                declaration.defaultValue = IrExpressionBodyImpl(originalDefault.startOffset, originalDefault.endOffset) {
-                    expression = originalDefault.expression.deepCopyWithSymbols(declaration.parent)
-                }
+                declaration.defaultValue =
+                    context.irFactory.createExpressionBody(originalDefault.startOffset, originalDefault.endOffset) {
+                        expression = originalDefault.expression.deepCopyWithSymbols(declaration.parent)
+                    }
            }
        }

        return null
    }
-}
+}
@@ -71,7 +71,7 @@ class BodyGenerator(
    }

    fun generateExpressionBody(ktExpression: KtExpression): IrExpressionBody =
-        IrExpressionBodyImpl(createStatementGenerator().generateExpression(ktExpression))
+        context.irFactory.createExpressionBody(createStatementGenerator().generateExpression(ktExpression))

    fun generateLambdaBody(ktFun: KtFunctionLiteral): IrBody {
        val statementGenerator = createStatementGenerator()
@@ -498,7 +498,7 @@ class ClassGenerator(

            if (!enumEntryDescriptor.isExpect) {
                irEnumEntry.initializerExpression =
-                    IrExpressionBodyImpl(createBodyGenerator(irEnumEntry.symbol)
+                    context.irFactory.createExpressionBody(createBodyGenerator(irEnumEntry.symbol)
                        .generateEnumEntryInitializer(ktEnumEntry, enumEntryDescriptor))
            }

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.ir.descriptors.IrLocalDelegatedPropertyDelegateDescr
 import org.jetbrains.kotlin.ir.descriptors.IrPropertyDelegateDescriptor
 import org.jetbrains.kotlin.ir.descriptors.IrPropertyDelegateDescriptorImpl
 import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
@@ -166,7 +165,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D
        val irProvideDelegate = CallGenerator(statementGenerator).generateCall(
            ktDelegate.startOffsetSkippingComments, ktDelegate.endOffset, provideDelegateCall
        )
-        return IrExpressionBodyImpl(irProvideDelegate)
+        return context.irFactory.createExpressionBody(irProvideDelegate)
    }

    private fun createBackingFieldValueForDelegate(
@@ -344,11 +344,11 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        val constantDefaultValue =
            ConstantExpressionEvaluator.getConstant(valueExpression, context.bindingContext)?.toConstantValue(valueParameterDescriptor.type)
                ?: error("Constant value expected for default parameter value in annotation, got $valueExpression")
-        return IrExpressionBodyImpl(
+        return context.irFactory.createExpressionBody(
            UNDEFINED_OFFSET, UNDEFINED_OFFSET,
            context.constantValueGenerator.generateConstantValueAsExpression(
                UNDEFINED_OFFSET, UNDEFINED_OFFSET, constantDefaultValue, valueParameterDescriptor.varargElementType
            )
        )
    }
-}
+}
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.NotFoundClasses
 import org.jetbrains.kotlin.ir.builders.IrGeneratorContext
-import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
 import org.jetbrains.kotlin.ir.util.ConstantValueGenerator
@@ -33,8 +32,6 @@ class GeneratorContext(
    val constantValueGenerator: ConstantValueGenerator,
    override val irBuiltIns: IrBuiltIns
 ) : IrGeneratorContext {
-    val irFactory: IrFactory get() = symbolTable.irFactory
-
    val callToSubstitutedDescriptorMap = mutableMapOf<IrDeclarationReference, CallableDescriptor>()

    val sourceManager = PsiSourceManager()
@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
@@ -54,7 +53,7 @@ class PropertyGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
        ).also { irProperty ->
            irProperty.backingField =
                generatePropertyBackingField(ktParameter, propertyDescriptor) {
-                    IrExpressionBodyImpl(
+                    context.irFactory.createExpressionBody(
                        IrGetValueImpl(
                            ktParameter.startOffsetSkippingComments, ktParameter.endOffset,
                            irPropertyType,
@@ -119,7 +118,7 @@ class PropertyGenerator(declarationGenerator: DeclarationGenerator) : Declaratio
                        ktProperty.initializer?.let { ktInitializer ->
                            val compileTimeConst = propertyDescriptor.compileTimeInitializer
                            if (propertyDescriptor.isConst && compileTimeConst != null)
-                                IrExpressionBodyImpl(
+                                context.irFactory.createExpressionBody(
                                    context.constantValueGenerator.generateConstantValueAsExpression(
                                        ktInitializer.startOffsetSkippingComments, ktInitializer.endOffset,
                                        compileTimeConst
@@ -9,12 +9,9 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.symbols.*
-import org.jetbrains.kotlin.ir.types.impl.IrErrorTypeImpl
 import org.jetbrains.kotlin.ir.util.SYNTHETIC_OFFSET
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.Variance

 class SyntheticDeclarationsGenerator(context: GeneratorContext) : DeclarationDescriptorVisitor<Unit, IrDeclarationContainer?> {

@@ -36,7 +33,7 @@ class SyntheticDeclarationsGenerator(context: GeneratorContext) : DeclarationDes
        if (!descriptor.declaresDefaultValue()) return null

        val description = "Default Argument Value stub for ${descriptor.name}|${descriptor.index}"
-        return IrExpressionBodyImpl(IrErrorExpressionImpl(startOffset, endOffset, parameter.type, description))
+        return factory.createExpressionBody(IrErrorExpressionImpl(startOffset, endOffset, parameter.type, description))
    }

    private val defaultFactoryReference: IrFunction.(IrValueParameter) -> IrExpressionBody? = { defaultArgumentFactory(it) }
@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.ir.builders

 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
@@ -68,7 +67,7 @@ fun <T : IrElement> IrStatementsBuilder<T>.irTemporaryVar(


 fun IrBuilderWithScope.irExprBody(value: IrExpression) =
-    IrExpressionBodyImpl(startOffset, endOffset, value)
+    context.irFactory.createExpressionBody(startOffset, endOffset, value)

 fun IrBuilderWithScope.irWhen(type: IrType, branches: List<IrBranch>) =
    IrWhenImpl(startOffset, endOffset, type, null, branches)
@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.ir.builders

 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
+import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns

 interface IrGenerator {
@@ -35,6 +36,8 @@ interface IrGeneratorContextInterface {
 interface IrGeneratorContext : IrGeneratorContextInterface {
    @ObsoleteDescriptorBasedAPI
    val builtIns: KotlinBuiltIns get() = irBuiltIns.builtIns
+
+    val irFactory: IrFactory get() = irBuiltIns.irFactory
 }

-open class IrGeneratorContextBase(override val irBuiltIns: IrBuiltIns) : IrGeneratorContext
+open class IrGeneratorContextBase(override val irBuiltIns: IrBuiltIns) : IrGeneratorContext
@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.ir.declarations

 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.name.Name
@@ -192,4 +194,22 @@ interface IrFactory {
        isCrossinline: Boolean,
        isNoinline: Boolean,
    ): IrValueParameter
+
+    // Bodies
+
+    fun createExpressionBody(
+        startOffset: Int,
+        endOffset: Int,
+        initializer: IrExpressionBody.() -> Unit,
+    ): IrExpressionBody
+
+    fun createExpressionBody(
+        startOffset: Int,
+        endOffset: Int,
+        expression: IrExpression,
+    ): IrExpressionBody
+
+    fun createExpressionBody(
+        expression: IrExpression,
+    ): IrExpressionBody
 }
@@ -7,6 +7,9 @@ package org.jetbrains.kotlin.ir.declarations.impl

 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
+import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.name.Name
@@ -222,4 +225,23 @@ object IrFactoryImpl : IrFactory {
        isNoinline: Boolean,
    ): IrValueParameter =
        IrValueParameterImpl(startOffset, endOffset, origin, symbol, name, index, type, varargElementType, isCrossinline, isNoinline)
+
+    override fun createExpressionBody(
+        startOffset: Int,
+        endOffset: Int,
+        initializer: IrExpressionBody.() -> Unit,
+    ): IrExpressionBody =
+        IrExpressionBodyImpl(startOffset, endOffset, initializer)
+
+    override fun createExpressionBody(
+        startOffset: Int,
+        endOffset: Int,
+        expression: IrExpression,
+    ): IrExpressionBody =
+        IrExpressionBodyImpl(startOffset, endOffset, expression)
+
+    override fun createExpressionBody(
+        expression: IrExpression,
+    ): IrExpressionBody =
+        IrExpressionBodyImpl(expression)
 }
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.MetadataSource
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -57,7 +56,7 @@ class IrLazyField(

    override var initializer: IrExpressionBody? by lazyVar {
        descriptor.compileTimeInitializer?.let {
-            IrExpressionBodyImpl(
+            factory.createExpressionBody(
                typeTranslator.constantValueGenerator.generateConstantValueAsExpression(UNDEFINED_OFFSET, UNDEFINED_OFFSET, it)
            )
        }
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOriginImpl
+import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
@@ -42,7 +43,7 @@ class IrBuiltIns(
    val languageVersionSettings = typeTranslator.languageVersionSettings

    lateinit var functionFactory: IrAbstractFunctionFactory
-    private val irFactory = symbolTable.irFactory
+    val irFactory: IrFactory = symbolTable.irFactory

    private val builtInsModule = builtIns.builtInsModule

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.ir.expressions

 import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer

 interface IrBody : IrElement {
@@ -25,6 +26,8 @@ interface IrBody : IrElement {
 }

 interface IrExpressionBody : IrBody {
+    val factory: IrFactory
+
    var expression: IrExpression

    override fun <D> transform(transformer: IrElementTransformer<D>, data: D): IrExpressionBody =
@@ -41,4 +44,3 @@ enum class IrSyntheticBodyKind {
    ENUM_VALUES,
    ENUM_VALUEOF
 }
-
@@ -16,7 +16,9 @@

 package org.jetbrains.kotlin.ir.expressions.impl

+import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.declarations.impl.IrBodyBase
+import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
@@ -44,6 +46,9 @@ class IrExpressionBodyImpl private constructor(
            checkEnabled { expressionField = e }
        }

+    override val factory: IrFactory
+        get() = IrFactoryImpl
+
    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
        visitor.visitExpressionBody(this, data)

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.lazy.*
 import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.linkage.IrProvider
 import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
@@ -255,7 +254,7 @@ class DeclarationStubGenerator(
        ).also { irValueParameter ->
            if (descriptor.declaresDefaultValue()) {
                irValueParameter.defaultValue =
-                    IrExpressionBodyImpl(
+                    irValueParameter.factory.createExpressionBody(
                        IrErrorExpressionImpl(
                            UNDEFINED_OFFSET, UNDEFINED_OFFSET, descriptor.type.toIrType(),
                            "Stub expression for default value of ${descriptor.name}"
@@ -369,7 +369,7 @@ open class DeepCopyIrTreeWithSymbols(
        throw IllegalArgumentException("Unsupported body type: $body")

    override fun visitExpressionBody(body: IrExpressionBody): IrExpressionBody =
-        IrExpressionBodyImpl(body.expression.transform())
+        body.factory.createExpressionBody(body.expression.transform())

    override fun visitBlockBody(body: IrBlockBody): IrBlockBody =
        IrBlockBodyImpl(
@@ -6,12 +6,11 @@
 package org.jetbrains.kotlin.ir.util

 import org.jetbrains.kotlin.descriptors.MemberDescriptor
-import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
-import org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBodyImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
 import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
@@ -95,7 +94,7 @@ class ExpectDeclarationRemover(val symbolTable: ReferenceSymbolTable, private va
        val defaultValue = expectParameter.defaultValue ?: return

        defaultValue.let { originalDefault ->
-            declaration.defaultValue = IrExpressionBodyImpl(originalDefault.startOffset, originalDefault.endOffset) {
+            declaration.defaultValue = declaration.factory.createExpressionBody(originalDefault.startOffset, originalDefault.endOffset) {
                expression = originalDefault.expression.deepCopyWithSymbols(function).remapExpectValueSymbols()
            }
        }
@@ -1014,7 +1014,7 @@ abstract class IrFileDeserializer(
                flags.isNoInline
            ).apply {
                if (proto.hasDefaultValue())
-                    defaultValue = IrExpressionBodyImpl(deserializeExpressionBody(proto.defaultValue))
+                    defaultValue = irFactory.createExpressionBody(deserializeExpressionBody(proto.defaultValue))

                (descriptor as? WrappedValueParameterDescriptor)?.bind(this)
                (descriptor as? WrappedReceiverParameterDescriptor)?.bind(this)
@@ -1239,7 +1239,7 @@ abstract class IrFileDeserializer(
                if (proto.hasCorrespondingClass())
                    correspondingClass = deserializeIrClass(proto.correspondingClass)
                if (proto.hasInitializer())
-                    initializerExpression = IrExpressionBodyImpl(deserializeExpressionBody(proto.initializer))
+                    initializerExpression = irFactory.createExpressionBody(deserializeExpressionBody(proto.initializer))

                (descriptor as? WrappedEnumEntryDescriptor)?.bind(this)
            }
@@ -1297,7 +1297,7 @@ abstract class IrFileDeserializer(
            }.usingParent {
                if (proto.hasInitializer()) {
                    withInitializerGuard(isPrivateProperty) {
-                        initializer = IrExpressionBodyImpl(deserializeExpressionBody(proto.initializer))
+                        initializer = irFactory.createExpressionBody(deserializeExpressionBody(proto.initializer))
                    }
                }