IR: create IrExpressionBody via IrFactory

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt

@@ -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,

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt

@@ -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}"

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -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()
+                    )
                 }
             }
         }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt

@@ -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))
         }
     }
-}
+}

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt

@@ -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))
                         }
                     }
                 }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt

@@ -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)
             }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt

@@ -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 =
+                    declaration.defaultValue = context.irFactory.createExpressionBody(
-                        IrExpressionBodyImpl(IrErrorExpressionImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, declaration.type, "Default Stub"))
+                        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) {

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InitializersLowering.kt

@@ -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
     }
-}
+}

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt

@@ -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)
                     }
                 }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt

@@ -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)

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/PrivateMembersLowering.kt

@@ -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

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/RemoveInlineFunctionsWithReifiedTypeParametersLowering.kt

@@ -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) {
+                declaration.defaultValue =
-                    expression = originalDefault.expression.deepCopyWithSymbols(declaration.parent)
+                    context.irFactory.createExpressionBody(originalDefault.startOffset, originalDefault.endOffset) {
-                }
+                        expression = originalDefault.expression.deepCopyWithSymbols(declaration.parent)
+                    }
             }
         }
 
         return null
     }
-}
+}

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt

@@ -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()

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt

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

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt

@@ -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(

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt

@@ -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
             )
         )
     }
-}
+}

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt

@@ -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()

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt

@@ -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

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SyntheticDeclarationsGenerator.kt

@@ -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) }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt

@@ -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)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/IrGenerator.kt

@@ -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

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrFactory.kt

@@ -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
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFactoryImpl.kt

@@ -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)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt

@@ -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)
             )
         }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt

@@ -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
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBody.kt

@@ -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
 }
-

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrExpressionBodyImpl.kt

@@ -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)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt

@@ -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}"

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt

@@ -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(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExpectDeclarationRemover.kt

@@ -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()
             }
         }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt

@@ -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))
                     }
                 }