IR: transform base classes of lazy IR to interfaces

2020-07-22 13:41:56 +02:00
parent b02653a524
commit 3cecf81176
16 changed files with 252 additions and 251 deletions
@@ -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>
-
-    override lateinit var parent: IrDeclarationParent
-
-    @ObsoleteDescriptorBasedAPI
-    override val descriptor: DeclarationDescriptor
-        get() = symbol.descriptor
-
-    override var annotations: List<IrConstructorCall> by lazyVar {
+    fun createLazyAnnotations(): ReadWriteProperty<Any?, List<IrConstructorCall>> = lazyVar {
        fir.annotations.mapNotNull {
            callGenerator.convertToIrConstructorCall(it) as? IrConstructorCall
        }
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
-    fir: FirRegularClass,
-    symbol: Fir2IrClassSymbol
-) : AbstractFir2IrLazyDeclaration<FirRegularClass, IrClass>(
-    components, startOffset, endOffset, origin, fir, symbol
-), IrClass {
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
+    override val fir: FirRegularClass,
+    override val symbol: Fir2IrClassSymbol,
+) : IrClass, AbstractFir2IrLazyDeclaration<FirRegularClass, IrClass>, Fir2IrComponents by components {
    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
-
-    override val symbol: Fir2IrClassSymbol
-        get() = super.symbol as Fir2IrClassSymbol
+        get() = symbol.descriptor

    override val name: Name
        get() = fir.name
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
-    fir: FirConstructor,
-    symbol: Fir2IrConstructorSymbol
-) : AbstractFir2IrLazyDeclaration<FirConstructor, IrConstructor>(
-    components, startOffset, endOffset, origin, fir, symbol
-), IrConstructor {
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
+    override val fir: FirConstructor,
+    override val symbol: Fir2IrConstructorSymbol,
+) : IrConstructor, AbstractFir2IrLazyDeclaration<FirConstructor, IrConstructor>, Fir2IrComponents by components {
    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
-
-    override val symbol: Fir2IrConstructorSymbol
-        get() = super.symbol as Fir2IrConstructorSymbol
+        get() = symbol.descriptor

    override val isInline: Boolean
        get() = fir.isInline
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
-    fir: FirProperty,
-    symbol: Fir2IrPropertySymbol,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
+    override val fir: FirProperty,
+    override val symbol: Fir2IrPropertySymbol,
    override val isFakeOverride: Boolean
-) : AbstractFir2IrLazyDeclaration<FirProperty, IrProperty>(
-    components, startOffset, endOffset, origin, fir, symbol
-), IrProperty {
+) : IrProperty, AbstractFir2IrLazyDeclaration<FirProperty, IrProperty>, Fir2IrComponents by components {
    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
-
-    override val symbol: Fir2IrPropertySymbol
-        get() = super.symbol as Fir2IrPropertySymbol
+        get() = symbol.descriptor

    override val isVar: Boolean
        get() = fir.isVar
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
-    fir: FirSimpleFunction,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
+    override val fir: FirSimpleFunction,
    firParent: FirRegularClass,
-    symbol: Fir2IrSimpleFunctionSymbol,
+    override val symbol: Fir2IrSimpleFunctionSymbol,
    override val isFakeOverride: Boolean
-) : AbstractFir2IrLazyDeclaration<FirSimpleFunction, IrSimpleFunction>(
-    components, startOffset, endOffset, origin, fir, symbol
-), IrSimpleFunction {
+) : IrSimpleFunction, AbstractFir2IrLazyDeclaration<FirSimpleFunction, IrSimpleFunction>, Fir2IrComponents by components {
    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
-
-    override val symbol: Fir2IrSimpleFunctionSymbol
-        get() = super.symbol as Fir2IrSimpleFunctionSymbol
+        get() = symbol.descriptor

    override val isInline: Boolean
        get() = fir.isInline
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    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,
-    typeTranslator: TypeTranslator
-) :
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrClass {
-
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator
+) : IrClass, IrLazyDeclarationBase {
    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 }
@@ -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.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+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.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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
    override val symbol: IrConstructorSymbol,
    override val descriptor: ClassConstructorDescriptor,
-    name: Name,
-    visibility: Visibility,
-    isInline: Boolean,
-    isExternal: Boolean,
+    override val name: Name,
+    override var visibility: Visibility,
+    override val isInline: Boolean,
+    override val isExternal: Boolean,
    override val isPrimary: Boolean,
-    isExpect: Boolean,
-    stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
-) :
-    IrLazyFunctionBase(
-        startOffset, endOffset, origin, name,
-        visibility, isInline, isExternal, isExpect,
-        stubGenerator, typeTranslator
-    ),
-    IrConstructor {
+    override val isExpect: Boolean,
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator,
+) : IrConstructor, IrLazyFunctionBase {
+    override var parent: IrDeclarationParent by createLazyParent()
+
+    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) {
@@ -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(
-    startOffset: Int,
-    endOffset: Int,
-    override var origin: IrDeclarationOrigin,
-    private val stubGenerator: DeclarationStubGenerator,
-    protected val typeTranslator: TypeTranslator
-) : IrElementBase(startOffset, endOffset), IrDeclaration {
+interface IrLazyDeclarationBase : IrDeclaration {
+    val stubGenerator: DeclarationStubGenerator
+    val typeTranslator: TypeTranslator
+
    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>) {
-        descriptors.mapNotNullTo(declarations) { generateMemberStub(it) }
+    fun generateChildStubs(descriptors: Collection<DeclarationDescriptor>, declarations: MutableList<IrDeclaration>) {
+        descriptors.mapNotNullTo(declarations) { descriptor ->
+            if (descriptor is DeclarationDescriptorWithVisibility && Visibilities.isPrivate(descriptor.visibility)) null
+            else stubGenerator.generateMemberStub(descriptor)
+        }
    }

-    private fun generateMemberStub(descriptor: DeclarationDescriptor): IrDeclaration? {
-        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 {
+    fun createLazyAnnotations(): ReadWriteProperty<Any?, List<IrConstructorCall>> = 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)
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
    override val symbol: IrEnumEntrySymbol,
    override val descriptor: ClassDescriptor,
-    stubGenerator: DeclarationStubGenerator,
-    typeTranslator: TypeTranslator
-) : IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrEnumEntry {
-
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator,
+) : IrEnumEntry, IrLazyDeclarationBase {
    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
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    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,
-    typeTranslator: TypeTranslator
-) : IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrField {
-
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator,
+) : IrField, IrLazyDeclarationBase {
    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)
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
    override val symbol: IrSimpleFunctionSymbol,
    override val descriptor: FunctionDescriptor,
-    name: Name,
-    visibility: Visibility,
+    override val name: Name,
+    override var visibility: Visibility,
    override val modality: Modality,
-    isInline: Boolean,
-    isExternal: Boolean,
+    override val isInline: 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,
-    typeTranslator: TypeTranslator
-) :
-    IrLazyFunctionBase(startOffset, endOffset, origin, name, visibility, isInline, isExternal, isExpect, stubGenerator, typeTranslator),
-    IrSimpleFunction {
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator,
+) : IrSimpleFunction, IrLazyFunctionBase {
+    override var parent: IrDeclarationParent by createLazyParent()
+
+    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
@@ -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 org.jetbrains.kotlin.ir.util.TypeTranslator
-import org.jetbrains.kotlin.name.Name
+import kotlin.properties.ReadOnlyProperty
+import kotlin.properties.ReadWriteProperty

-@OptIn(ObsoleteDescriptorBasedAPI::class)
-abstract class IrLazyFunctionBase(
-    startOffset: Int,
-    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 {
+interface IrLazyFunctionBase : IrLazyDeclarationBase, IrTypeParametersContainer {
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
+    override val descriptor: FunctionDescriptor

-    val initialSignatureFunction: IrFunction? by lazyVar {
-        descriptor.initialSignatureDescriptor?.takeIf { it != descriptor }?.original?.let(stubGenerator::generateFunctionStub)
-    }
+    val initialSignatureFunction: IrFunction?

-    override var dispatchReceiverParameter: IrValueParameter? by lazyVar {
-        typeTranslator.buildWithScope(this) {
-            descriptor.dispatchReceiverParameter?.generateReceiverParameterStub()?.also { it.parent = this@IrLazyFunctionBase }
+    fun createInitialSignatureFunction(): ReadOnlyProperty<Any?, IrFunction?> =
+        lazyVar {
+            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 {
-        typeTranslator.buildWithScope(this) {
-            descriptor.valueParameters.mapTo(arrayListOf()) {
-                stubGenerator.generateValueParameterStub(it).apply { parent = this@IrLazyFunctionBase }
+    fun createValueParameters(): ReadWriteProperty<Any?, List<IrValueParameter>> =
+        lazyVar {
+            typeTranslator.buildWithScope(this) {
+                descriptor.valueParameters.mapTo(arrayListOf()) {
+                    stubGenerator.generateValueParameterStub(it).apply { parent = this@IrLazyFunctionBase }
+                }
            }
        }
-    }

-    final override var body: IrBody? = null
-
-    final override var returnType: IrType by lazyVar {
-        typeTranslator.buildWithScope(this) {
-            descriptor.returnType!!.toIrType()
+    fun createReceiverParameter(parameter: ReceiverParameterDescriptor?): ReadWriteProperty<Any?, IrValueParameter?> =
+        lazyVar {
+            typeTranslator.buildWithScope(this) {
+                parameter?.generateReceiverParameterStub()?.also { it.parent = this@IrLazyFunctionBase }
+            }
        }
-    }

-    override var metadata: MetadataSource?
-        get() = null
-        set(_) = error("We should never need to store metadata of external declarations.")
+    fun createReturnType(): ReadWriteProperty<Any?, IrType> =
+        lazyVar {
+            typeTranslator.buildWithScope(this) {
+                descriptor.returnType!!.toIrType()
+            }
+        }
 }
@@ -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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    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,
-    typeTranslator: TypeTranslator,
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator,
    bindingContext: BindingContext? = null
-) :
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrProperty {
-
+) : IrProperty, IrLazyDeclarationBase {
    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)

@@ -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.IrTypeAlias
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.declarations.withInitialIr
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    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,
-    typeTranslator: TypeTranslator
-) :
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrTypeAlias {
-
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator,
+) : IrTypeAlias, IrLazyDeclarationBase {
    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)
@@ -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.IrTypeParameter
-import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer
-import org.jetbrains.kotlin.ir.declarations.withInitialIr
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 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,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    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,
-    typeTranslator: TypeTranslator
-) :
-    IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator),
-    IrTypeParameter {
-
+    override val stubGenerator: DeclarationStubGenerator,
+    override val typeTranslator: TypeTranslator,
+) : IrTypeParameter, IrLazyDeclarationBase {
    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) {
@@ -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 var isInitialized = false;
+private class UnsafeLazyVar<T>(initializer: () -> T) : ReadWriteProperty<Any?, T> {
+    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
    }
-}
+}