From e7b95d12884338f65c9e88b1eec48210e86399e6 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 12 Sep 2023 15:11:52 +0300 Subject: [PATCH] [FIR2IR] Replace `getIrClassSymbol` with `getOrCreateIrClass` in Fir2IrClassifierStorage Effectively, `getIrClassSymbol` always created `IrClass` if it was needed and returned its symbol. So to avoid potentially unsafe access of `IrClassSymbol.owner` it's more convenient to return directly `IrClass` ^KT-60924 --- .../fir/backend/jvm/FirJvmBackendClassResolver.kt | 2 +- .../kotlin/fir/backend/ConversionUtils.kt | 2 +- .../kotlin/fir/backend/Fir2IrClassifierStorage.kt | 6 +----- .../kotlin/fir/backend/Fir2IrDeclarationStorage.kt | 6 ++---- .../kotlin/fir/backend/Fir2IrPluginContext.kt | 2 +- .../jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt | 6 +++--- .../jetbrains/kotlin/fir/backend/FirIrProvider.kt | 6 ++---- .../kotlin/fir/backend/IrBuiltInsOverFir.kt | 2 +- .../generators/CallAndReferenceGenerator.kt | 2 +- .../backend/generators/FakeOverrideGenerator.kt | 14 ++++++-------- .../jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt | 2 +- 11 files changed, 20 insertions(+), 30 deletions(-) diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmBackendClassResolver.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmBackendClassResolver.kt index aac257790a7..762ad11e8fd 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmBackendClassResolver.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmBackendClassResolver.kt @@ -21,7 +21,7 @@ class FirJvmBackendClassResolver(val components: Fir2IrComponents) : JvmBackendC val symbol = components.session.symbolProvider.getClassLikeSymbolByClassId(type.classId) ?: return emptyList() require(symbol is FirClassSymbol<*>) - return listOf(components.classifierStorage.getIrClassSymbol(symbol).descriptor) + return listOf(components.classifierStorage.getOrCreateIrClass(symbol).symbol.descriptor) } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt index 0a8b3b64877..2d3ef9b301e 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt @@ -152,7 +152,7 @@ fun FirClassifierSymbol<*>.toSymbol( } is FirClassSymbol -> { - classifierStorage.getIrClassSymbol(this) + classifierStorage.getOrCreateIrClass(this).symbol } else -> error("Unknown symbol: $this") diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt index 1ff087177db..c993baf52df 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt @@ -228,11 +228,7 @@ class Fir2IrClassifierStorage( return localStorage[lookupTag.toSymbol(session)!!.fir as FirClass] } - fun getIrClassSymbol(firClassSymbol: FirClassSymbol<*>): IrClassSymbol { - return getOrCreateIrClass(firClassSymbol).symbol - } - - private fun getOrCreateIrClass(firClassSymbol: FirClassSymbol<*>): IrClass { + fun getOrCreateIrClass(firClassSymbol: FirClassSymbol<*>): IrClass { val firClass = firClassSymbol.fir classifierStorage.getCachedIrClass(firClass)?.let { return it } if (firClass is FirAnonymousObject || firClass is FirRegularClass && firClass.visibility == Visibilities.Local) { 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 ee57dbaadfd..df429dc6d1d 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 @@ -1068,11 +1068,10 @@ class Fir2IrDeclarationStorage( return null } - @OptIn(IrSymbolInternals::class) private fun generateLazyFakeOverrides(name: Name, fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag?) { val firClassSymbol = fakeOverrideOwnerLookupTag?.toSymbol(session) as? FirClassSymbol if (firClassSymbol != null) { - val irClass = classifierStorage.getIrClassSymbol(firClassSymbol).owner + val irClass = classifierStorage.getOrCreateIrClass(firClassSymbol) if (irClass is Fir2IrLazyClass) { irClass.getFakeOverridesByName(name) } @@ -1305,12 +1304,11 @@ class Fir2IrDeclarationStorage( } } - @OptIn(IrSymbolInternals::class) private inline fun > ConeClassLookupTagWithFixedSymbol.findIrFakeOverride( name: Name, originalDeclaration: IrOverridableDeclaration ): IrSymbol? { val dispatchReceiverIrClass = - classifierStorage.getIrClassSymbol(toSymbol(session) as FirClassSymbol).owner + classifierStorage.getOrCreateIrClass(toSymbol(session) as FirClassSymbol) return dispatchReceiverIrClass.declarations.find { it is D && it.isFakeOverride && it.name == name && it.overrides(originalDeclaration) }?.symbol diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrPluginContext.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrPluginContext.kt index bab9dc9f63e..6f16eda551e 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrPluginContext.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrPluginContext.kt @@ -77,7 +77,7 @@ class Fir2IrPluginContext( override fun referenceClass(classId: ClassId): IrClassSymbol? { val firSymbol = symbolProvider.getClassLikeSymbolByClassId(classId) as? FirClassSymbol<*> ?: return null - return components.classifierStorage.getIrClassSymbol(firSymbol) + return components.classifierStorage.getOrCreateIrClass(firSymbol).symbol } override fun referenceTypeAlias(classId: ClassId): IrTypeAliasSymbol? { 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 0a95cbe6ecb..21bf943d2ad 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 @@ -723,7 +723,7 @@ class Fir2IrVisitor( * val x: Int = foo() // this: Base.Companion * ) : Base() */ - classifierStorage.getIrClassSymbol(firClassSymbol) + classifierStorage.getOrCreateIrClass(firClassSymbol).symbol } if (firClass.classKind.isObject && shouldGenerateReceiverAsSingletonReference(irClassSymbol)) { @@ -1533,7 +1533,7 @@ class Fir2IrVisitor( is FirResolvedQualifier -> { when (val symbol = argument.symbol) { is FirClassSymbol -> { - classifierStorage.getIrClassSymbol(symbol) + classifierStorage.getOrCreateIrClass(symbol).symbol } is FirTypeAliasSymbol -> { symbol.fir.fullyExpandedConeType(session).toIrClassSymbol() @@ -1567,7 +1567,7 @@ class Fir2IrVisitor( private fun ConeClassLikeType?.toIrClassSymbol(): IrClassSymbol? = (this?.lookupTag?.toSymbol(session) as? FirClassSymbol<*>)?.let { - classifierStorage.getIrClassSymbol(it) + classifierStorage.getOrCreateIrClass(it).symbol } private fun convertToArrayLiteral(arrayLiteral: FirArrayLiteral): IrVararg { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirIrProvider.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirIrProvider.kt index 75f1d83397e..aa6b4d9f24f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirIrProvider.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirIrProvider.kt @@ -88,7 +88,7 @@ class FirIrProvider(val components: Fir2IrComponents) : IrProvider { val scope = with(components) { firClass.unsubstitutedScope() } fun findIrClass(firClass: FirRegularClass): IrClass { - val irClassSymbol = classifierStorage.getIrClassSymbol(firClass.symbol) + val irClassSymbol = classifierStorage.getOrCreateIrClass(firClass.symbol).symbol return getDeclaration(irClassSymbol) as IrClass } @@ -164,9 +164,7 @@ class FirIrProvider(val components: Fir2IrComponents) : IrProvider { return when (kind) { SymbolKind.CLASS_SYMBOL -> { - // TODO: effectively call getIrClassSymbol should be replaced with getOrCreateClass (KT-61348) - @OptIn(IrSymbolInternals::class) - classifierStorage.getIrClassSymbol((firDeclaration as FirRegularClass).symbol).owner + classifierStorage.getOrCreateIrClass((firDeclaration as FirRegularClass).symbol) } SymbolKind.ENUM_ENTRY_SYMBOL -> classifierStorage.getIrEnumEntry( firDeclaration as FirEnumEntry, parent as IrClass diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt index bdfef1b9dc1..a7e7b519ef4 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt @@ -561,7 +561,7 @@ class IrBuiltInsOverFir( private fun loadClassSafe(classId: ClassId): IrClassSymbol? { val firClassSymbol = symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol ?: return null - return components.classifierStorage.getIrClassSymbol(firClassSymbol) + return components.classifierStorage.getOrCreateIrClass(firClassSymbol).symbol } @OptIn(IrSymbolInternals::class) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index ee99991a7a6..d2a901780d9 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -283,7 +283,7 @@ class CallAndReferenceGenerator( val coneSuperType = superTypeRef.coneTypeSafe() ?: return null val firClassSymbol = coneSuperType.fullyExpandedType(session).lookupTag.toSymbol(session) as? FirClassSymbol<*> if (firClassSymbol != null) { - return classifierStorage.getIrClassSymbol(firClassSymbol) + return classifierStorage.getOrCreateIrClass(firClassSymbol).symbol } return 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 705289872f1..4577d3a0180 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 @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.backend.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.* -import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertiesScope import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.scopes.* @@ -427,7 +426,7 @@ class FakeOverrideGenerator( overridden.containingClassLookupTag()?.toSymbol(session)?.fir as? FirClass ?: return emptyList() val overriddenContainingIrClass = - declarationStorage.classifierStorage.getIrClassSymbol(overriddenContainingClass.symbol).owner as? IrClass + declarationStorage.classifierStorage.getOrCreateIrClass(overriddenContainingClass.symbol).symbol.owner as? IrClass ?: return emptyList() return superClasses.mapNotNull { superClass -> @@ -513,7 +512,7 @@ internal fun FirProperty.generateOverriddenAccessorSymbols(containingClass: FirC val scope = containingClass.unsubstitutedScope() scope.processPropertiesByName(name) {} val overriddenSet = mutableSetOf() - val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList() + val superClasses = containingClass.getSuperTypesAsIrClasses() scope.processOverriddenPropertiesFromSuperClasses(symbol, containingClass) { overriddenSymbol -> if (!session.visibilityChecker.isVisibleForOverriding( @@ -539,7 +538,7 @@ internal fun FirProperty.generateOverriddenAccessorSymbols(containingClass: FirC context(Fir2IrComponents) internal fun FirProperty.generateOverriddenPropertySymbols(containingClass: FirClass): List { - val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList() + val superClasses = containingClass.getSuperTypesAsIrClasses() val overriddenSet = mutableSetOf() processOverriddenPropertySymbols(containingClass) { @@ -554,7 +553,7 @@ internal fun FirProperty.generateOverriddenPropertySymbols(containingClass: FirC context(Fir2IrComponents) internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(containingClass: FirClass): List { - val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList() + val superClasses = containingClass.getSuperTypesAsIrClasses() val overriddenSet = mutableSetOf() processOverriddenFunctionSymbols(containingClass) { @@ -569,9 +568,8 @@ internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(containingClass context(Fir2IrComponents) @OptIn(IrSymbolInternals::class) -private fun FirClass.getSuperTypesAsIrClasses(): Set? { - val irClass = - declarationStorage.classifierStorage.getIrClassSymbol(symbol).owner as? IrClass ?: return null +private fun FirClass.getSuperTypesAsIrClasses(): Set { + val irClass = declarationStorage.classifierStorage.getOrCreateIrClass(symbol) return irClass.superTypes.mapNotNull { it.classifierOrNull?.owner as? IrClass }.toSet() } 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 4c0f725a5ca..01e8c828524 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 @@ -165,7 +165,7 @@ class Fir2IrLazyClass( scope.processClassifiersByName(name) { val declaration = it.fir as? FirRegularClass ?: return@processClassifiersByName if (declaration.classId.outerClassId == fir.classId && shouldBuildStub(declaration)) { - val nestedSymbol = classifierStorage.getIrClassSymbol(declaration.symbol) + val nestedSymbol = classifierStorage.getOrCreateIrClass(declaration.symbol).symbol result += nestedSymbol.owner } }