From 3cecf81176a50f085f947c99e52539398433e0fe Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 22 Jul 2020 13:41:56 +0200 Subject: [PATCH] IR: transform base classes of lazy IR to interfaces --- .../fir/lazy/AbstractFir2IrLazyDeclaration.kt | 34 +++----- .../kotlin/fir/lazy/Fir2IrLazyClass.kt | 24 +++--- .../kotlin/fir/lazy/Fir2IrLazyConstructor.kt | 24 +++--- .../kotlin/fir/lazy/Fir2IrLazyProperty.kt | 25 +++--- .../fir/lazy/Fir2IrLazySimpleFunction.kt | 27 +++---- .../ir/declarations/lazy/IrLazyClass.kt | 22 +++--- .../ir/declarations/lazy/IrLazyConstructor.kt | 54 ++++++++----- .../lazy/IrLazyDeclarationBase.kt | 43 +++++------ .../declarations/lazy/IrLazyEnumEntryImpl.kt | 20 +++-- .../ir/declarations/lazy/IrLazyField.kt | 19 ++--- .../ir/declarations/lazy/IrLazyFunction.kt | 47 +++++++---- .../declarations/lazy/IrLazyFunctionBase.kt | 77 +++++++------------ .../ir/declarations/lazy/IrLazyProperty.kt | 22 +++--- .../ir/declarations/lazy/IrLazyTypeAlias.kt | 27 ++++--- .../declarations/lazy/IrLazyTypeParameter.kt | 25 +++--- .../kotlin/ir/declarations/lazy/lazyUtil.kt | 13 ++-- 16 files changed, 252 insertions(+), 251 deletions(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyDeclaration.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyDeclaration.kt index a047b13f5a0..e29c3a623a5 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyDeclaration.kt +++ b/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 : + IrDeclaration, IrDeclarationParent, Fir2IrComponents { + + val fir: F + val symbol: Fir2IrBindableSymbol<*, D> -abstract class AbstractFir2IrLazyDeclaration( - 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 + + 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 - - override lateinit var parent: IrDeclarationParent - - @ObsoleteDescriptorBasedAPI - override val descriptor: DeclarationDescriptor - get() = symbol.descriptor - - override var annotations: List by lazyVar { + fun createLazyAnnotations(): ReadWriteProperty> = lazyVar { fir.annotations.mapNotNull { callGenerator.convertToIrConstructorCall(it) as? IrConstructorCall } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt index e10fff14a12..851c8bd34c9 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt +++ b/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( - 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, Fir2IrComponents by components { init { symbol.bind(this) classifierStorage.preCacheTypeParameters(fir) } + override var annotations: List by createLazyAnnotations() + override lateinit var typeParameters: List + 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 diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt index ef121477666..6fd373df117 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt +++ b/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( - 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, Fir2IrComponents by components { init { symbol.bind(this) classifierStorage.preCacheTypeParameters(fir) } + override var annotations: List by createLazyAnnotations() + override lateinit var typeParameters: List + 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 diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt index 866da4c410c..67ea89fcea7 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt +++ b/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( - components, startOffset, endOffset, origin, fir, symbol -), IrProperty { +) : IrProperty, AbstractFir2IrLazyDeclaration, Fir2IrComponents by components { init { symbol.bind(this) classifierStorage.preCacheTypeParameters(fir) - typeParameters = emptyList() } + override var annotations: List by createLazyAnnotations() + override var typeParameters: List = 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 diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt index 0d6b7c9213b..a499711187c 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt +++ b/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( - components, startOffset, endOffset, origin, fir, symbol -), IrSimpleFunction { +) : IrSimpleFunction, AbstractFir2IrLazyDeclaration, Fir2IrComponents by components { init { symbol.bind(this) classifierStorage.preCacheTypeParameters(fir) } + override var annotations: List by createLazyAnnotations() + override lateinit var typeParameters: List + 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 diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt index 0fe8d0568f7..643e6738a5e 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyClass.kt +++ b/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, - 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 by createLazyAnnotations() + override var thisReceiver: IrValueParameter? by lazyVar { typeTranslator.buildWithScope(this) { descriptor.thisAsReceiverParameter.generateReceiverParameterStub().apply { parent = this@IrLazyClass } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyConstructor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyConstructor.kt index d914bcbef29..47b4eb32566 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyConstructor.kt +++ b/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.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 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 by createValueParameters() + + override var metadata: MetadataSource? + get() = null + set(_) = error("We should never need to store metadata of external declarations.") override var typeParameters: List by lazyVar { typeTranslator.buildWithScope(this) { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt index cf43af948a4..0c02ac7e963 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt +++ b/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( - 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) { + fun generateMemberStubs(memberScope: MemberScope, container: MutableList) { generateChildStubs(memberScope.getContributedDescriptors(), container) } - protected fun generateChildStubs(descriptors: Collection, declarations: MutableList) { - descriptors.mapNotNullTo(declarations) { generateMemberStub(it) } + fun generateChildStubs(descriptors: Collection, declarations: MutableList) { + 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 by lazyVar { + fun createLazyAnnotations(): ReadWriteProperty> = lazyVar { descriptor.annotations.mapNotNull(typeTranslator.constantValueGenerator::generateAnnotationConstructorCall).toMutableList() } - private fun createLazyParent(): IrDeclarationParent? { + fun createLazyParent(): ReadWriteProperty = 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) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyEnumEntryImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyEnumEntryImpl.kt index 43d0ee02559..737220d1b70 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyEnumEntryImpl.kt +++ b/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, - 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 by createLazyAnnotations() + override val name: Name = symbol.descriptor.name override var correspondingClass: IrClass? = null diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt index 273eb965f61..e514c20091f 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyField.kt +++ b/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, - 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 by lazyVar { descriptor.backingField?.annotations ?.mapNotNullTo(mutableListOf(), typeTranslator.constantValueGenerator::generateAnnotationConstructorCall) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunction.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunction.kt index 068815b9618..c4189981605 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunction.kt +++ b/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, - 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 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 by createValueParameters() + + override var metadata: MetadataSource? + get() = null + set(_) = error("We should never need to store metadata of external declarations.") override var typeParameters: List by lazyVar { typeTranslator.buildWithScope(this) { @@ -59,7 +79,6 @@ class IrLazyFunction( } } - override var overriddenSymbols: List by lazyVar { descriptor.overriddenDescriptors.mapTo(arrayListOf()) { stubGenerator.generateFunctionStub(it.original).symbol diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunctionBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunctionBase.kt index 78f0f03fb6b..b1f89c1f22b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyFunctionBase.kt +++ b/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 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 = + 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 by lazyVar { - typeTranslator.buildWithScope(this) { - descriptor.valueParameters.mapTo(arrayListOf()) { - stubGenerator.generateValueParameterStub(it).apply { parent = this@IrLazyFunctionBase } + fun createValueParameters(): ReadWriteProperty> = + 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 = + 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 = + lazyVar { + typeTranslator.buildWithScope(this) { + descriptor.returnType!!.toIrType() + } + } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyProperty.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyProperty.kt index 32f18a0e406..04a08bbe892 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyProperty.kt +++ b/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, - 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 by createLazyAnnotations() + private val hasBackingField: Boolean = descriptor.hasBackingField(bindingContext) || stubGenerator.extensions.isPropertyWithPlatformField(descriptor) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeAlias.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeAlias.kt index 4c5079ef4fa..4d9c4914ef3 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeAlias.kt +++ b/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.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 by createLazyAnnotations() + override var typeParameters: List by lazyVar { descriptor.declaredTypeParameters.mapTo(arrayListOf()) { stubGenerator.generateOrGetTypeParameterStub(it) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeParameter.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeParameter.kt index a7dece1f9fe..07cd343cff6 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeParameter.kt +++ b/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.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 by createLazyAnnotations() + override val superTypes: MutableList by lazy { withInitialIr { typeTranslator.buildWithScope(this.parent as IrTypeParametersContainer) { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/lazyUtil.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/lazyUtil.kt index 2a97c13420d..39836138eb8 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/lazyUtil.kt +++ b/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 lazyVar(initializer: () -> T): UnsafeLazyVar = UnsafeLazyVar(initializer) +fun lazyVar(initializer: () -> T): ReadWriteProperty = UnsafeLazyVar(initializer) -class UnsafeLazyVar(initializer: () -> T) { - private var isInitialized = false; +private class UnsafeLazyVar(initializer: () -> T) : ReadWriteProperty { + private var isInitialized = false private var initializer: (() -> T)? = initializer private var _value: Any? = null @@ -28,10 +29,10 @@ class UnsafeLazyVar(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 } -} \ No newline at end of file +}