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

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

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

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

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