IR: transform base classes of lazy IR to interfaces

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

@@ -5,30 +5,28 @@
 
 package org.jetbrains.kotlin.fir.lazy
 
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.toIrType
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.symbols.Fir2IrBindableSymbol
-import org.jetbrains.kotlin.ir.IrElementBase
-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.IrConstructorCall
+import kotlin.properties.ReadWriteProperty
+
+interface AbstractFir2IrLazyDeclaration<F : FirMemberDeclaration, D : IrSymbolOwner> :
+    IrDeclaration, IrDeclarationParent, Fir2IrComponents {
+
+    val fir: F
+    val symbol: Fir2IrBindableSymbol<*, D>
 
-abstract class AbstractFir2IrLazyDeclaration<F : FirMemberDeclaration, D : IrSymbolOwner>(
-    private val components: Fir2IrComponents,
-    startOffset: Int,
-    endOffset: Int,
-    override var origin: IrDeclarationOrigin,
-    val fir: F,
-    open val symbol: Fir2IrBindableSymbol<*, D>
-) : IrElementBase(startOffset, endOffset), IrDeclaration, IrDeclarationParent, Fir2IrComponents by components {
     override val factory: IrFactory
-        get() = components.irFactory
+        get() = irFactory
 
-    internal fun prepareTypeParameters() {
+    var typeParameters: List<IrTypeParameter>
+
+    fun prepareTypeParameters() {
         typeParameters = fir.typeParameters.mapIndexedNotNull { index, typeParameter ->
             if (typeParameter !is FirTypeParameter) return@mapIndexedNotNull null
             classifierStorage.getIrTypeParameter(typeParameter, index).apply {
@@ -40,15 +38,7 @@ abstract class AbstractFir2IrLazyDeclaration<F : FirMemberDeclaration, D : IrSym
         }
     }
 
-    lateinit var typeParameters: List<IrTypeParameter>
+    fun createLazyAnnotations(): ReadWriteProperty<Any?, List<IrConstructorCall>> = lazyVar {
-
-    override lateinit var parent: IrDeclarationParent
-
-    @ObsoleteDescriptorBasedAPI
-    override val descriptor: DeclarationDescriptor
-        get() = symbol.descriptor
-
-    override var annotations: List<IrConstructorCall> by lazyVar {
         fir.annotations.mapNotNull {
             callGenerator.convertToIrConstructorCall(it) as? IrConstructorCall
         }

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

@@ -19,34 +19,34 @@ import org.jetbrains.kotlin.fir.types.isNullableAny
 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.IrConstructorCall
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
 import org.jetbrains.kotlin.name.Name
 
 class Fir2IrLazyClass(
     components: Fir2IrComponents,
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
-    fir: FirRegularClass,
+    override val fir: FirRegularClass,
-    symbol: Fir2IrClassSymbol
+    override val symbol: Fir2IrClassSymbol,
-) : AbstractFir2IrLazyDeclaration<FirRegularClass, IrClass>(
+) : IrClass, AbstractFir2IrLazyDeclaration<FirRegularClass, IrClass>, Fir2IrComponents by components {
-    components, startOffset, endOffset, origin, fir, symbol
-), IrClass {
     init {
         symbol.bind(this)
         classifierStorage.preCacheTypeParameters(fir)
     }
 
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+    override lateinit var typeParameters: List<IrTypeParameter>
+    override lateinit var parent: IrDeclarationParent
+
     override val source: SourceElement
         get() = SourceElement.NO_SOURCE
 
     @ObsoleteDescriptorBasedAPI
     override val descriptor: ClassDescriptor
-        get() = super.descriptor as ClassDescriptor
+        get() = symbol.descriptor
-
-    override val symbol: Fir2IrClassSymbol
-        get() = super.symbol as Fir2IrClassSymbol
 
     override val name: Name
         get() = fir.name

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

@@ -16,6 +16,7 @@ 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.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.parentClassOrNull
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -23,28 +24,27 @@ import org.jetbrains.kotlin.name.Name
 
 class Fir2IrLazyConstructor(
     components: Fir2IrComponents,
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
-    fir: FirConstructor,
+    override val fir: FirConstructor,
-    symbol: Fir2IrConstructorSymbol
+    override val symbol: Fir2IrConstructorSymbol,
-) : AbstractFir2IrLazyDeclaration<FirConstructor, IrConstructor>(
+) : IrConstructor, AbstractFir2IrLazyDeclaration<FirConstructor, IrConstructor>, Fir2IrComponents by components {
-    components, startOffset, endOffset, origin, fir, symbol
-), IrConstructor {
     init {
         symbol.bind(this)
         classifierStorage.preCacheTypeParameters(fir)
     }
 
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+    override lateinit var typeParameters: List<IrTypeParameter>
+    override lateinit var parent: IrDeclarationParent
+
     override val isPrimary: Boolean
         get() = fir.isPrimary
 
     @ObsoleteDescriptorBasedAPI
     override val descriptor: ClassConstructorDescriptor
-        get() = super.descriptor as ClassConstructorDescriptor
+        get() = symbol.descriptor
-
-    override val symbol: Fir2IrConstructorSymbol
-        get() = super.symbol as Fir2IrConstructorSymbol
 
     override val isInline: Boolean
         get() = fir.isInline

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

@@ -18,6 +18,7 @@ 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.IrConstructorCall
 import org.jetbrains.kotlin.ir.types.IrErrorType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.isInterface
@@ -25,27 +26,25 @@ import org.jetbrains.kotlin.name.Name
 
 class Fir2IrLazyProperty(
     components: Fir2IrComponents,
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
-    fir: FirProperty,
+    override val fir: FirProperty,
-    symbol: Fir2IrPropertySymbol,
+    override val symbol: Fir2IrPropertySymbol,
     override val isFakeOverride: Boolean
-) : AbstractFir2IrLazyDeclaration<FirProperty, IrProperty>(
+) : IrProperty, AbstractFir2IrLazyDeclaration<FirProperty, IrProperty>, Fir2IrComponents by components {
-    components, startOffset, endOffset, origin, fir, symbol
-), IrProperty {
     init {
         symbol.bind(this)
         classifierStorage.preCacheTypeParameters(fir)
-        typeParameters = emptyList()
     }
 
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+    override var typeParameters: List<IrTypeParameter> = emptyList()
+    override lateinit var parent: IrDeclarationParent
+
     @ObsoleteDescriptorBasedAPI
     override val descriptor: PropertyDescriptor
-        get() = super.descriptor as PropertyDescriptor
+        get() = symbol.descriptor
-
-    override val symbol: Fir2IrPropertySymbol
-        get() = super.symbol as Fir2IrPropertySymbol
 
     override val isVar: Boolean
         get() = fir.isVar

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

@@ -7,20 +7,18 @@ package org.jetbrains.kotlin.fir.lazy
 
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.declareThisReceiverParameter
 import org.jetbrains.kotlin.fir.backend.generateOverriddenFunctionSymbols
 import org.jetbrains.kotlin.fir.backend.toIrType
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.scopes.ProcessorAction
-import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.fir.symbols.Fir2IrSimpleFunctionSymbol
 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.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -28,21 +26,23 @@ import org.jetbrains.kotlin.name.Name
 
 class Fir2IrLazySimpleFunction(
     components: Fir2IrComponents,
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
-    fir: FirSimpleFunction,
+    override val fir: FirSimpleFunction,
     firParent: FirRegularClass,
-    symbol: Fir2IrSimpleFunctionSymbol,
+    override val symbol: Fir2IrSimpleFunctionSymbol,
     override val isFakeOverride: Boolean
-) : AbstractFir2IrLazyDeclaration<FirSimpleFunction, IrSimpleFunction>(
+) : IrSimpleFunction, AbstractFir2IrLazyDeclaration<FirSimpleFunction, IrSimpleFunction>, Fir2IrComponents by components {
-    components, startOffset, endOffset, origin, fir, symbol
-), IrSimpleFunction {
     init {
         symbol.bind(this)
         classifierStorage.preCacheTypeParameters(fir)
     }
 
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+    override lateinit var typeParameters: List<IrTypeParameter>
+    override lateinit var parent: IrDeclarationParent
+
     override val isTailrec: Boolean
         get() = fir.isTailRec
 
@@ -57,10 +57,7 @@ class Fir2IrLazySimpleFunction(
 
     @ObsoleteDescriptorBasedAPI
     override val descriptor: FunctionDescriptor
-        get() = super.descriptor as FunctionDescriptor
+        get() = symbol.descriptor
-
-    override val symbol: Fir2IrSimpleFunctionSymbol
-        get() = super.symbol as Fir2IrSimpleFunctionSymbol
 
     override val isInline: Boolean
         get() = fir.isInline

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir.declarations.lazy
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
@@ -17,12 +18,12 @@ import org.jetbrains.kotlin.metadata.deserialization.NameResolver
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
 
-@OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyClass(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrClassSymbol,
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     override val descriptor: ClassDescriptor,
     override val name: Name,
     override val kind: ClassKind,
@@ -35,16 +36,17 @@ class IrLazyClass(
     override val isInline: Boolean,
     override val isExpect: Boolean,
     override val isFun: Boolean,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
+    override val typeTranslator: TypeTranslator
-) :
+) : IrClass, IrLazyDeclarationBase {
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrClass {
-
     init {
         symbol.bind(this)
     }
 
+    override var parent: IrDeclarationParent by createLazyParent()
+
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+
     override var thisReceiver: IrValueParameter? by lazyVar {
         typeTranslator.buildWithScope(this) {
             descriptor.thisAsReceiverParameter.generateReceiverParameterStub().apply { parent = this@IrLazyClass }

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

@@ -8,10 +8,11 @@ package org.jetbrains.kotlin.ir.declarations.lazy
 import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
-import org.jetbrains.kotlin.ir.declarations.IrConstructor
+import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.expressions.IrBody
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
 import org.jetbrains.kotlin.ir.util.TypeTranslator
 import org.jetbrains.kotlin.ir.util.withScope
@@ -19,26 +20,39 @@ import org.jetbrains.kotlin.name.Name
 
 @OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyConstructor(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrConstructorSymbol,
     override val descriptor: ClassConstructorDescriptor,
-    name: Name,
+    override val name: Name,
-    visibility: Visibility,
+    override var visibility: Visibility,
-    isInline: Boolean,
+    override val isInline: Boolean,
-    isExternal: Boolean,
+    override val isExternal: Boolean,
     override val isPrimary: Boolean,
-    isExpect: Boolean,
+    override val isExpect: Boolean,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
+    override val typeTranslator: TypeTranslator,
-) :
+) : IrConstructor, IrLazyFunctionBase {
-    IrLazyFunctionBase(
+    override var parent: IrDeclarationParent by createLazyParent()
-        startOffset, endOffset, origin, name,
+
-        visibility, isInline, isExternal, isExpect,
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
-        stubGenerator, typeTranslator
+
-    ),
+    override var body: IrBody? = null
-    IrConstructor {
+
+    override var returnType: IrType by createReturnType()
+
+    override val initialSignatureFunction: IrFunction? by createInitialSignatureFunction()
+
+    override var dispatchReceiverParameter: IrValueParameter? by createReceiverParameter(descriptor.dispatchReceiverParameter)
+
+    override var extensionReceiverParameter: IrValueParameter? by createReceiverParameter(descriptor.extensionReceiverParameter)
+
+    override var valueParameters: List<IrValueParameter> by createValueParameters()
+
+    override var metadata: MetadataSource?
+        get() = null
+        set(_) = error("We should never need to store metadata of external declarations.")
 
     override var typeParameters: List<IrTypeParameter> by lazyVar {
         typeTranslator.buildWithScope(this) {

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

@@ -6,64 +6,57 @@
 package org.jetbrains.kotlin.ir.declarations.lazy
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.ir.IrElementBase
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
+import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
 import org.jetbrains.kotlin.ir.util.TypeTranslator
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
+import kotlin.properties.ReadWriteProperty
 
 @OptIn(ObsoleteDescriptorBasedAPI::class)
-abstract class IrLazyDeclarationBase(
+interface IrLazyDeclarationBase : IrDeclaration {
-    startOffset: Int,
+    val stubGenerator: DeclarationStubGenerator
-    endOffset: Int,
+    val typeTranslator: TypeTranslator
-    override var origin: IrDeclarationOrigin,
+
-    private val stubGenerator: DeclarationStubGenerator,
-    protected val typeTranslator: TypeTranslator
-) : IrElementBase(startOffset, endOffset), IrDeclaration {
     override val factory: IrFactory
         get() = stubGenerator.symbolTable.irFactory
 
-    protected fun KotlinType.toIrType() = typeTranslator.translateType(this)
+    fun KotlinType.toIrType(): IrType =
+        typeTranslator.translateType(this)
 
-    protected fun ReceiverParameterDescriptor.generateReceiverParameterStub(): IrValueParameter =
+    fun ReceiverParameterDescriptor.generateReceiverParameterStub(): IrValueParameter =
         factory.createValueParameter(
             UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, IrValueParameterSymbolImpl(this),
             name, -1, type.toIrType(), null, isCrossinline = false, isNoinline = false
         )
 
-    protected fun generateMemberStubs(memberScope: MemberScope, container: MutableList<IrDeclaration>) {
+    fun generateMemberStubs(memberScope: MemberScope, container: MutableList<IrDeclaration>) {
         generateChildStubs(memberScope.getContributedDescriptors(), container)
     }
 
-    protected fun generateChildStubs(descriptors: Collection<DeclarationDescriptor>, declarations: MutableList<IrDeclaration>) {
+    fun generateChildStubs(descriptors: Collection<DeclarationDescriptor>, declarations: MutableList<IrDeclaration>) {
-        descriptors.mapNotNullTo(declarations) { generateMemberStub(it) }
+        descriptors.mapNotNullTo(declarations) { descriptor ->
+            if (descriptor is DeclarationDescriptorWithVisibility && Visibilities.isPrivate(descriptor.visibility)) null
+            else stubGenerator.generateMemberStub(descriptor)
+        }
     }
 
-    private fun generateMemberStub(descriptor: DeclarationDescriptor): IrDeclaration? {
+    fun createLazyAnnotations(): ReadWriteProperty<Any?, List<IrConstructorCall>> = lazyVar {
-        if (descriptor is DeclarationDescriptorWithVisibility && Visibilities.isPrivate(descriptor.visibility)) return null
-        return stubGenerator.generateMemberStub(descriptor)
-    }
-
-    override var parent: IrDeclarationParent by lazyVar {
-        createLazyParent()!!
-    }
-
-    override var annotations: List<IrConstructorCall> by lazyVar {
         descriptor.annotations.mapNotNull(typeTranslator.constantValueGenerator::generateAnnotationConstructorCall).toMutableList()
     }
 
-    private fun createLazyParent(): IrDeclarationParent? {
+    fun createLazyParent(): ReadWriteProperty<Any?, IrDeclarationParent> = lazyVar {
         val currentDescriptor = descriptor
 
         val containingDeclaration =
             ((currentDescriptor as? PropertyAccessorDescriptor)?.correspondingProperty ?: currentDescriptor).containingDeclaration
 
-        return when (containingDeclaration) {
+        when (containingDeclaration) {
             is PackageFragmentDescriptor -> run {
                 val parent = this.takeUnless { it is IrClass }?.let {
                     stubGenerator.generateOrGetFacadeClass(descriptor)

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

@@ -20,7 +20,9 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
 import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrEnumEntrySymbol
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
@@ -29,20 +31,22 @@ import org.jetbrains.kotlin.name.Name
 
 @OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyEnumEntryImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrEnumEntrySymbol,
     override val descriptor: ClassDescriptor,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
+    override val typeTranslator: TypeTranslator,
-) : IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
+) : IrEnumEntry, IrLazyDeclarationBase {
-    IrEnumEntry {
-
     init {
         symbol.bind(this)
     }
 
+    override var parent: IrDeclarationParent by createLazyParent()
+
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+
     override val name: Name = symbol.descriptor.name
 
     override var correspondingClass: IrClass? = null

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
 import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.MetadataSource
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
@@ -21,27 +22,27 @@ import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
 import org.jetbrains.kotlin.ir.util.TypeTranslator
 import org.jetbrains.kotlin.name.Name
 
-@OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyField(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrFieldSymbol,
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     override val descriptor: PropertyDescriptor,
     override val name: Name,
     override var visibility: Visibility,
     override val isFinal: Boolean,
     override val isExternal: Boolean,
     override val isStatic: Boolean,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
+    override val typeTranslator: TypeTranslator,
-) : IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
+) : IrField, IrLazyDeclarationBase {
-    IrField {
-
     init {
         symbol.bind(this)
     }
 
+    override var parent: IrDeclarationParent by createLazyParent()
+
     override var annotations: List<IrConstructorCall> by lazyVar {
         descriptor.backingField?.annotations
             ?.mapNotNullTo(mutableListOf(), typeTranslator.constantValueGenerator::generateAnnotationConstructorCall)

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

@@ -10,8 +10,11 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 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.DeclarationStubGenerator
 import org.jetbrains.kotlin.ir.util.TypeTranslator
 import org.jetbrains.kotlin.ir.util.withScope
@@ -20,27 +23,44 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.propertyIfAccessor
 
 @OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyFunction(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrSimpleFunctionSymbol,
     override val descriptor: FunctionDescriptor,
-    name: Name,
+    override val name: Name,
-    visibility: Visibility,
+    override var visibility: Visibility,
     override val modality: Modality,
-    isInline: Boolean,
+    override val isInline: Boolean,
-    isExternal: Boolean,
+    override val isExternal: Boolean,
     override val isTailrec: Boolean,
     override val isSuspend: Boolean,
-    isExpect: Boolean,
+    override val isExpect: Boolean,
     override val isFakeOverride: Boolean,
     override val isOperator: Boolean,
     override val isInfix: Boolean,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
+    override val typeTranslator: TypeTranslator,
-) :
+) : IrSimpleFunction, IrLazyFunctionBase {
-    IrLazyFunctionBase(startOffset, endOffset, origin, name, visibility, isInline, isExternal, isExpect, stubGenerator, typeTranslator),
+    override var parent: IrDeclarationParent by createLazyParent()
-    IrSimpleFunction {
+
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+
+    override var body: IrBody? = null
+
+    override var returnType: IrType by createReturnType()
+
+    override val initialSignatureFunction: IrFunction? by createInitialSignatureFunction()
+
+    override var dispatchReceiverParameter: IrValueParameter? by createReceiverParameter(descriptor.dispatchReceiverParameter)
+
+    override var extensionReceiverParameter: IrValueParameter? by createReceiverParameter(descriptor.extensionReceiverParameter)
+
+    override var valueParameters: List<IrValueParameter> by createValueParameters()
+
+    override var metadata: MetadataSource?
+        get() = null
+        set(_) = error("We should never need to store metadata of external declarations.")
 
     override var typeParameters: List<IrTypeParameter> by lazyVar {
         typeTranslator.buildWithScope(this) {
@@ -59,7 +79,6 @@ class IrLazyFunction(
         }
     }
 
-
     override var overriddenSymbols: List<IrSimpleFunctionSymbol> by lazyVar {
         descriptor.overriddenDescriptors.mapTo(arrayListOf()) {
             stubGenerator.generateFunctionStub(it.original).symbol

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

@@ -5,66 +5,47 @@
 
 package org.jetbrains.kotlin.ir.declarations.lazy
 
-import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer
 import org.jetbrains.kotlin.ir.declarations.IrValueParameter
-import org.jetbrains.kotlin.ir.declarations.MetadataSource
-import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
+import kotlin.properties.ReadOnlyProperty
-import org.jetbrains.kotlin.ir.util.TypeTranslator
+import kotlin.properties.ReadWriteProperty
-import org.jetbrains.kotlin.name.Name
 
-@OptIn(ObsoleteDescriptorBasedAPI::class)
+interface IrLazyFunctionBase : IrLazyDeclarationBase, IrTypeParametersContainer {
-abstract class IrLazyFunctionBase(
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
-    startOffset: Int,
+    override val descriptor: FunctionDescriptor
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
-    override val name: Name,
-    override var visibility: Visibility,
-    override val isInline: Boolean,
-    override val isExternal: Boolean,
-    override val isExpect: Boolean,
-    stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
-) :
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrFunction {
 
-    val initialSignatureFunction: IrFunction? by lazyVar {
+    val initialSignatureFunction: IrFunction?
-        descriptor.initialSignatureDescriptor?.takeIf { it != descriptor }?.original?.let(stubGenerator::generateFunctionStub)
-    }
 
-    override var dispatchReceiverParameter: IrValueParameter? by lazyVar {
+    fun createInitialSignatureFunction(): ReadOnlyProperty<Any?, IrFunction?> =
-        typeTranslator.buildWithScope(this) {
+        lazyVar {
-            descriptor.dispatchReceiverParameter?.generateReceiverParameterStub()?.also { it.parent = this@IrLazyFunctionBase }
+            descriptor.initialSignatureDescriptor?.takeIf { it != descriptor }?.original?.let(stubGenerator::generateFunctionStub)
         }
-    }
-    override var extensionReceiverParameter: IrValueParameter? by lazyVar {
-        typeTranslator.buildWithScope(this) {
-            descriptor.extensionReceiverParameter?.generateReceiverParameterStub()?.also { it.parent = this@IrLazyFunctionBase }
-        }
-    }
 
-    override var valueParameters: List<IrValueParameter> by lazyVar {
+    fun createValueParameters(): ReadWriteProperty<Any?, List<IrValueParameter>> =
-        typeTranslator.buildWithScope(this) {
+        lazyVar {
-            descriptor.valueParameters.mapTo(arrayListOf()) {
+            typeTranslator.buildWithScope(this) {
-                stubGenerator.generateValueParameterStub(it).apply { parent = this@IrLazyFunctionBase }
+                descriptor.valueParameters.mapTo(arrayListOf()) {
+                    stubGenerator.generateValueParameterStub(it).apply { parent = this@IrLazyFunctionBase }
+                }
             }
         }
-    }
 
-    final override var body: IrBody? = null
+    fun createReceiverParameter(parameter: ReceiverParameterDescriptor?): ReadWriteProperty<Any?, IrValueParameter?> =
-
+        lazyVar {
-    final override var returnType: IrType by lazyVar {
+            typeTranslator.buildWithScope(this) {
-        typeTranslator.buildWithScope(this) {
+                parameter?.generateReceiverParameterStub()?.also { it.parent = this@IrLazyFunctionBase }
-            descriptor.returnType!!.toIrType()
+            }
         }
-    }
 
-    override var metadata: MetadataSource?
+    fun createReturnType(): ReadWriteProperty<Any?, IrType> =
-        get() = null
+        lazyVar {
-        set(_) = error("We should never need to store metadata of external declarations.")
+            typeTranslator.buildWithScope(this) {
+                descriptor.returnType!!.toIrType()
+            }
+        }
 }

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
 import org.jetbrains.kotlin.ir.util.TypeTranslator
@@ -17,12 +18,12 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.hasBackingField
 
-@OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyProperty(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrPropertySymbol,
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     override val descriptor: PropertyDescriptor,
     override val name: Name,
     override var visibility: Visibility,
@@ -34,17 +35,18 @@ class IrLazyProperty(
     override val isExternal: Boolean,
     override val isExpect: Boolean,
     override val isFakeOverride: Boolean,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator,
+    override val typeTranslator: TypeTranslator,
     bindingContext: BindingContext? = null
-) :
+) : IrProperty, IrLazyDeclarationBase {
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrProperty {
-
     init {
         symbol.bind(this)
     }
 
+    override var parent: IrDeclarationParent by createLazyParent()
+
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+
     private val hasBackingField: Boolean =
         descriptor.hasBackingField(bindingContext) || stubGenerator.extensions.isPropertyWithPlatformField(descriptor)
 

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

@@ -8,36 +8,35 @@ package org.jetbrains.kotlin.ir.declarations.lazy
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.IrTypeAlias
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.declarations.withInitialIr
 import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
 import org.jetbrains.kotlin.ir.util.TypeTranslator
 import org.jetbrains.kotlin.name.Name
 
-@OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyTypeAlias(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrTypeAliasSymbol,
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     override val descriptor: TypeAliasDescriptor,
     override val name: Name,
     override var visibility: Visibility,
     override val isActual: Boolean,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
+    override val typeTranslator: TypeTranslator,
-) :
+) : IrTypeAlias, IrLazyDeclarationBase {
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrTypeAlias {
-
     init {
         symbol.bind(this)
     }
 
+    override var parent: IrDeclarationParent by createLazyParent()
+
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+
     override var typeParameters: List<IrTypeParameter> by lazyVar {
         descriptor.declaredTypeParameters.mapTo(arrayListOf()) {
             stubGenerator.generateOrGetTypeParameterStub(it)

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

@@ -7,10 +7,8 @@ package org.jetbrains.kotlin.ir.declarations.lazy
 
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer
-import org.jetbrains.kotlin.ir.declarations.withInitialIr
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
@@ -20,25 +18,26 @@ import org.jetbrains.kotlin.types.Variance
 
 @OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrLazyTypeParameter(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrTypeParameterSymbol,
     override val descriptor: TypeParameterDescriptor,
     override val name: Name,
     override val index: Int,
     override val isReified: Boolean,
     override val variance: Variance,
-    stubGenerator: DeclarationStubGenerator,
+    override val stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
+    override val typeTranslator: TypeTranslator,
-) :
+) : IrTypeParameter, IrLazyDeclarationBase {
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrTypeParameter {
-
     init {
         symbol.bind(this)
     }
 
+    override var parent: IrDeclarationParent by createLazyParent()
+
+    override var annotations: List<IrConstructorCall> by createLazyAnnotations()
+
     override val superTypes: MutableList<IrType> by lazy {
         withInitialIr {
             typeTranslator.buildWithScope(this.parent as IrTypeParametersContainer) {

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

@@ -6,12 +6,13 @@
 package org.jetbrains.kotlin.ir.declarations.lazy
 
 import org.jetbrains.kotlin.ir.declarations.withInitialIr
+import kotlin.properties.ReadWriteProperty
 import kotlin.reflect.KProperty
 
-fun <T> lazyVar(initializer: () -> T): UnsafeLazyVar<T> = UnsafeLazyVar(initializer)
+fun <T> lazyVar(initializer: () -> T): ReadWriteProperty<Any?, T> = UnsafeLazyVar(initializer)
 
-class UnsafeLazyVar<T>(initializer: () -> T) {
+private class UnsafeLazyVar<T>(initializer: () -> T) : ReadWriteProperty<Any?, T> {
-    private var isInitialized = false;
+    private var isInitialized = false
     private var initializer: (() -> T)? = initializer
     private var _value: Any? = null
 
@@ -28,10 +29,10 @@ class UnsafeLazyVar<T>(initializer: () -> T) {
 
     override fun toString(): String = if (isInitialized) value.toString() else "Lazy value not initialized yet."
 
-    operator fun getValue(thisRef: Any?, property: KProperty<*>): T = value
+    override fun getValue(thisRef: Any?, property: KProperty<*>): T = value
 
-    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
+    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
         this._value = value
         isInitialized = true
     }
-}
+}