From 2ba719446792cfb26569471f4ff9379a1620d1a8 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 24 Oct 2023 12:16:40 +0300 Subject: [PATCH] [FIR2IR] Make most field-related functions of Fir2IrDeclarationStorage return symbols This is a preparation to introducing unbound symbols in fir2ir conversion --- .../fir/backend/Fir2IrDeclarationStorage.kt | 23 ++++++++++--------- .../kotlin/fir/backend/Fir2IrVisitor.kt | 3 ++- .../generators/FakeOverrideGenerator.kt | 2 +- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt index 515c28728ba..900a50f0e08 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt @@ -147,11 +147,11 @@ class Fir2IrDeclarationStorage( private val delegatedReverseCache: ConcurrentHashMap = ConcurrentHashMap() - private val fieldCache: ConcurrentHashMap = ConcurrentHashMap() + private val fieldCache: ConcurrentHashMap = ConcurrentHashMap() private data class FieldStaticOverrideKey(val lookupTag: ConeClassLikeLookupTag, val name: Name) - private val fieldStaticOverrideCache: ConcurrentHashMap = ConcurrentHashMap() + private val fieldStaticOverrideCache: ConcurrentHashMap = ConcurrentHashMap() private val localStorage: Fir2IrLocalCallableStorage by threadLocal { Fir2IrLocalCallableStorage() } @@ -609,11 +609,12 @@ class Fir2IrDeclarationStorage( val fir = firFieldSymbol.fir val staticFakeOverrideKey = getFieldStaticFakeOverrideKey(fir, fakeOverrideOwnerLookupTag) if (staticFakeOverrideKey == null) { - fieldCache[fir]?.let { return it } + fieldCache[fir]?.ownerIfBound()?.let { return it } } else { generateLazyFakeOverrides(fir.name, fakeOverrideOwnerLookupTag) // Lazy static fake override should always exist - return fieldStaticOverrideCache[staticFakeOverrideKey]!! + @OptIn(UnsafeDuringIrConstructionAPI::class) + return fieldStaticOverrideCache[staticFakeOverrideKey]!!.owner } // In case of type parameters from the parent as the field's return type, find the parent ahead to cache type parameters. val irParent = findIrParent(fir, fakeOverrideOwnerLookupTag) @@ -628,11 +629,11 @@ class Fir2IrDeclarationStorage( // TODO: there is a mess with methods for fields // we have three (!) different functions to getOrCreate field in different circumstances fun getOrCreateIrField(field: FirField, irParent: IrDeclarationParent?): IrField { - getCachedIrField(field, irParent)?.let { return it } + getCachedIrFieldSymbol(field, irParent)?.ownerIfBound()?.let { return it } return createAndCacheIrField(field, irParent) } - private fun getCachedIrField(field: FirField, irParent: IrDeclarationParent?): IrField? { + private fun getCachedIrFieldSymbol(field: FirField, irParent: IrDeclarationParent?): IrFieldSymbol? { val containingClassLookupTag = (irParent as IrClass?)?.classId?.toLookupTag() val staticFakeOverrideKey = getFieldStaticFakeOverrideKey(field, containingClassLookupTag) return if (staticFakeOverrideKey == null) { @@ -667,11 +668,11 @@ class Fir2IrDeclarationStorage( } } - fun getCachedIrDelegateOrBackingField(field: FirField): IrField? { + fun getCachedIrDelegateOrBackingFieldSymbol(field: FirField): IrFieldSymbol? { return fieldCache[field] } - fun getCachedIrFieldStaticFakeOverrideByDeclaration(field: FirField): IrField? { + fun getCachedIrFieldStaticFakeOverrideSymbolByDeclaration(field: FirField): IrFieldSymbol? { val ownerLookupTag = field.containingClassLookupTag() ?: return null return fieldStaticOverrideCache[FieldStaticOverrideKey(ownerLookupTag, field.name)] } @@ -688,7 +689,7 @@ class Fir2IrDeclarationStorage( if (constructorProperty != null) { val irProperty = getOrCreateIrProperty(constructorProperty, irClass) val backingField = irProperty.backingField!! - fieldCache[field] = backingField + fieldCache[field] = backingField.symbol return backingField } } @@ -711,9 +712,9 @@ class Fir2IrDeclarationStorage( val containingClassLookupTag = (irParent as IrClass?)?.classId?.toLookupTag() val staticFakeOverrideKey = getFieldStaticFakeOverrideKey(field, containingClassLookupTag) if (staticFakeOverrideKey == null) { - fieldCache[field] = irField + fieldCache[field] = irField.symbol } else { - fieldStaticOverrideCache[staticFakeOverrideKey] = irField + fieldStaticOverrideCache[staticFakeOverrideKey] = irField.symbol } return irField } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index 34b1b5cdbf7..a2117abee52 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -95,7 +95,8 @@ class Fir2IrVisitor( override fun visitField(field: FirField, data: Any?): IrField = whileAnalysing(session, field) { if (field.isSynthetic) { - return declarationStorage.getCachedIrDelegateOrBackingField(field)!!.apply { + @OptIn(UnsafeDuringIrConstructionAPI::class) + return declarationStorage.getCachedIrDelegateOrBackingFieldSymbol(field)!!.owner.apply { // If this is a property backing field, then it has no separate initializer, // so we shouldn't convert it if (correspondingPropertySymbol == null) { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt index 43c9eaa5261..985281db2dc 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt @@ -152,7 +152,7 @@ class FakeOverrideGenerator( if (!propertyOrFieldSymbol.isStatic) return@processPropertiesByName createFakeOverriddenIfNeeded( firClass, irClass, isLocal, propertyOrFieldSymbol, - { field, _, _ -> declarationStorage.getCachedIrFieldStaticFakeOverrideByDeclaration(field)?.symbol }, + { field, _, _ -> declarationStorage.getCachedIrFieldStaticFakeOverrideSymbolByDeclaration(field) }, { field, irParent, _, _ -> declarationStorage.getOrCreateIrField(field, irParent) },