From 8ac4507a1fbcd74b11ab57cca1118438c8f8a15f Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Mon, 8 Nov 2021 15:35:00 +0300 Subject: [PATCH] FIR2IR: simplify/generify declaration caching code --- .../fir/backend/Fir2IrDeclarationStorage.kt | 100 +++++++++--------- .../generators/FakeOverrideGenerator.kt | 6 +- 2 files changed, 54 insertions(+), 52 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 b9b2edf185b..50f90e539c8 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 @@ -416,24 +416,13 @@ class Fir2IrDeclarationStorage( fun getCachedIrFunction( function: FirSimpleFunction, dispatchReceiverLookupTag: ConeClassLikeLookupTag?, - signatureCalculator: (FirSimpleFunction) -> IdSignature? + signatureCalculator: () -> IdSignature? ): IrSimpleFunction? { - return if (function.visibility == Visibilities.Local) { - localStorage.getLocalFunction(function) - } else { - val isFakeOverride = dispatchReceiverLookupTag != null && - dispatchReceiverLookupTag !is ConeClassLookupTagWithFixedSymbol && - dispatchReceiverLookupTag != function.containingClass() - val cached = if (isFakeOverride) null else functionCache[function] - cached ?: signatureCalculator(function)?.let { signature -> - symbolTable.referenceSimpleFunctionIfAny(signature)?.let { irFunctionSymbol -> - val irFunction = irFunctionSymbol.owner - if (!isFakeOverride) { - functionCache[function] = irFunction - } - irFunction - } - } + if (function.visibility == Visibilities.Local) { + return localStorage.getLocalFunction(function) + } + return getCachedIrCallable(function, dispatchReceiverLookupTag, functionCache, signatureCalculator) { signature -> + symbolTable.referenceSimpleFunctionIfAny(signature)?.owner } } @@ -554,9 +543,9 @@ class Fir2IrDeclarationStorage( fun getCachedIrConstructor( constructor: FirConstructor, - signatureCalculator: (FirConstructor) -> IdSignature? = { null } + signatureCalculator: () -> IdSignature? = { null } ): IrConstructor? { - return constructorCache[constructor] ?: signatureCalculator(constructor)?.let { signature -> + return constructorCache[constructor] ?: signatureCalculator()?.let { signature -> symbolTable.referenceConstructorIfAny(signature)?.let { irConstructorSymbol -> val irConstructor = irConstructorSymbol.owner constructorCache[constructor] = irConstructor @@ -894,19 +883,30 @@ class Fir2IrDeclarationStorage( fun getCachedIrProperty( property: FirProperty, dispatchReceiverLookupTag: ConeClassLikeLookupTag?, - signatureCalculator: (FirProperty) -> IdSignature? + signatureCalculator: () -> IdSignature? ): IrProperty? { - val isFakeOverride = dispatchReceiverLookupTag != null && - dispatchReceiverLookupTag !is ConeClassLookupTagWithFixedSymbol && - dispatchReceiverLookupTag != property.containingClass() - val cached = if (isFakeOverride) null else propertyCache[property] - return cached ?: signatureCalculator(property)?.let { signature -> - symbolTable.referencePropertyIfAny(signature)?.let { irPropertySymbol -> - val irProperty = irPropertySymbol.owner + return getCachedIrCallable(property, dispatchReceiverLookupTag, propertyCache, signatureCalculator) { signature -> + symbolTable.referencePropertyIfAny(signature)?.owner + } + } + + private inline fun getCachedIrCallable( + declaration: FC, + dispatchReceiverLookupTag: ConeClassLikeLookupTag?, + cache: MutableMap, + signatureCalculator: () -> IdSignature?, + referenceIfAny: (IdSignature) -> IC? + ): IC? { + val isFakeOverride = dispatchReceiverLookupTag != null && dispatchReceiverLookupTag != declaration.containingClass() + if (!isFakeOverride) { + cache[declaration]?.let { return it } + } + return signatureCalculator()?.let { signature -> + referenceIfAny(signature)?.let { irDeclaration -> if (!isFakeOverride) { - propertyCache[property] = irProperty + cache[declaration] = irDeclaration } - irProperty + irDeclaration } } } @@ -1165,14 +1165,12 @@ class Fir2IrDeclarationStorage( irFunction } ) as IrFunctionSymbol - if (dispatchReceiverLookupTag is ConeClassLookupTagWithFixedSymbol && unmatchedReceiver) { - val dispatchReceiverIrClass = - classifierStorage.getIrClassSymbol(dispatchReceiverLookupTag.toSymbol(session) as FirClassSymbol).owner - dispatchReceiverIrClass.declarations.find { - it is IrSimpleFunction && it.isFakeOverride && it.name == fir.name && - it.overrides(originalSymbol.owner as IrSimpleFunction) - }?.symbol as? IrFunctionSymbol - // Fallback for simple synthetic property + if (unmatchedReceiver && dispatchReceiverLookupTag is ConeClassLookupTagWithFixedSymbol) { + val originalFunction = originalSymbol.owner as IrSimpleFunction + dispatchReceiverLookupTag.findIrFakeOverride( + fir.name, originalFunction + ) as? IrFunctionSymbol + // Fallback for simple synthetic property ?: originalSymbol } else { originalSymbol @@ -1244,19 +1242,23 @@ class Fir2IrDeclarationStorage( return containingClassLookupTag.getIrCallableSymbol() } - return if (dispatchReceiverLookupTag is ConeClassLookupTagWithFixedSymbol && - dispatchReceiverLookupTag != containingClassLookupTag - ) { - val dispatchReceiverIrClass = - classifierStorage.getIrClassSymbol(dispatchReceiverLookupTag.toSymbol(session) as FirClassSymbol).owner - dispatchReceiverIrClass.declarations.find { - it is IrProperty && it.isFakeOverride && it.name == fir.name && it.overrides(originalProperty) - }?.symbol as IrPropertySymbol + return if (unmatchedReceiver && dispatchReceiverLookupTag is ConeClassLookupTagWithFixedSymbol) { + dispatchReceiverLookupTag.findIrFakeOverride(fir.name, originalProperty) as IrPropertySymbol } else { originalSymbol } } + private inline fun > ConeClassLookupTagWithFixedSymbol.findIrFakeOverride( + name: Name, originalDeclaration: IrOverridableDeclaration + ): IrSymbol? { + val dispatchReceiverIrClass = + classifierStorage.getIrClassSymbol(toSymbol(session) as FirClassSymbol).owner + return dispatchReceiverIrClass.declarations.find { + it is D && it.isFakeOverride && it.name == name && it.overrides(originalDeclaration) + }?.symbol + } + private fun generateLazyFakeOverrides(name: Name, dispatchReceiverLookupTag: ConeClassLikeLookupTag?) { val firClassSymbol = dispatchReceiverLookupTag?.toSymbol(session) as? FirClassSymbol if (firClassSymbol != null) { @@ -1274,15 +1276,15 @@ class Fir2IrDeclarationStorage( > getIrCallableSymbol( firSymbol: FS, dispatchReceiverLookupTag: ConeClassLikeLookupTag?, - getCachedIrDeclaration: (F, ConeClassLikeLookupTag?, (F) -> IdSignature?) -> I?, - createIrDeclaration: (IrDeclarationParent?, IrDeclarationOrigin) -> I, - createIrLazyDeclaration: (IdSignature, Fir2IrLazyClass, IrDeclarationOrigin) -> I, + getCachedIrDeclaration: (firDeclaration: F, dispatchReceiverLookupTag: ConeClassLikeLookupTag?, () -> IdSignature?) -> I?, + createIrDeclaration: (parent: IrDeclarationParent?, origin: IrDeclarationOrigin) -> I, + createIrLazyDeclaration: (signature: IdSignature, lazyOwner: Fir2IrLazyClass, origin: IrDeclarationOrigin) -> I, ): IrSymbol { val fir = firSymbol.fir as F val irParent by lazy { findIrParent(fir) } val signature by lazy { signatureComposer.composeSignature(fir, dispatchReceiverLookupTag) } synchronized(symbolTable.lock) { - getCachedIrDeclaration(fir, dispatchReceiverLookupTag) { + getCachedIrDeclaration(fir, dispatchReceiverLookupTag.takeIf { it !is ConeClassLookupTagWithFixedSymbol }) { // Parent calculation provokes declaration calculation for some members from IrBuiltIns @Suppress("UNUSED_EXPRESSION") irParent signature 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 e343a404bad..4c4fd97cc4b 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 @@ -184,9 +184,9 @@ class FakeOverrideGenerator( irClass: IrClass, isLocal: Boolean, originalSymbol: FirCallableSymbol<*>, - cachedIrDeclaration: (D, ConeClassLikeLookupTag?, (D) -> IdSignature?) -> I?, - createIrDeclaration: (D, irParent: IrClass, thisReceiverOwner: IrClass?, origin: IrDeclarationOrigin, isLocal: Boolean) -> I, - createFakeOverrideSymbol: (D, S) -> S, + cachedIrDeclaration: (firDeclaration: D, dispatchReceiverLookupTag: ConeClassLikeLookupTag?, () -> IdSignature?) -> I?, + createIrDeclaration: (firDeclaration: D, irParent: IrClass, thisReceiverOwner: IrClass?, origin: IrDeclarationOrigin, isLocal: Boolean) -> I, + createFakeOverrideSymbol: (firDeclaration: D, baseSymbol: S) -> S, baseSymbols: MutableMap>, result: MutableList, containsErrorTypes: (I) -> Boolean,