From 58e8dfc23bcf95fc202599c718e96e4963037ff2 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 31 Aug 2023 11:20:37 +0300 Subject: [PATCH] [FIR2IR] Remove or approve some of left usages of IrSymbol.owner --- .../kotlin/fir/backend/ConversionUtils.kt | 2 +- .../fir/backend/Fir2IrClassifierStorage.kt | 16 ++++++++++------ .../kotlin/fir/backend/Fir2IrConversionScope.kt | 5 ++++- .../kotlin/fir/backend/Fir2IrTypeConverter.kt | 2 +- .../generators/Fir2IrClassifiersGenerator.kt | 9 ++++----- 5 files changed, 20 insertions(+), 14 deletions(-) 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 d87a67f9e2b..db18cbc85dd 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 @@ -150,7 +150,7 @@ fun FirClassifierSymbol<*>.toSymbol( val coneClassLikeType = fir.expandedTypeRef.coneType as ConeClassLikeType coneClassLikeType.lookupTag.toSymbol(session) ?.toSymbol(typeOrigin, handleAnnotations) - ?: classifiersGenerator.createIrClassSymbolForNotFoundClass(coneClassLikeType.lookupTag) + ?: classifiersGenerator.createIrClassForNotFoundClass(coneClassLikeType.lookupTag).symbol } is FirClassSymbol -> { 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 0a1952dfcc2..25a3a47d044 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 @@ -198,14 +198,13 @@ class Fir2IrClassifierStorage( } } - @OptIn(IrSymbolInternals::class) fun findIrClass(lookupTag: ConeClassLikeLookupTag): IrClass? { return if (lookupTag.classId.isLocal) { getCachedLocalClass(lookupTag) } else { val firSymbol = lookupTag.toSymbol(session) if (firSymbol is FirClassSymbol) { - getIrClassSymbol(firSymbol).owner + getOrCreateIrClass(firSymbol) } else { null } @@ -217,10 +216,14 @@ class Fir2IrClassifierStorage( } fun getIrClassSymbol(firClassSymbol: FirClassSymbol<*>): IrClassSymbol { + return getOrCreateIrClass(firClassSymbol).symbol + } + + private fun getOrCreateIrClass(firClassSymbol: FirClassSymbol<*>): IrClass { val firClass = firClassSymbol.fir - classifierStorage.getCachedIrClass(firClass)?.let { return it.symbol } + classifierStorage.getCachedIrClass(firClass)?.let { return it } if (firClass is FirAnonymousObject || firClass is FirRegularClass && firClass.visibility == Visibilities.Local) { - return createAndCacheLocalIrClassOnTheFly(firClass).symbol + return createAndCacheLocalIrClassOnTheFly(firClass) } firClass as FirRegularClass val classId = firClassSymbol.classId @@ -229,14 +232,15 @@ class Fir2IrClassifierStorage( val irParent = declarationStorage.findIrParent(classId.packageFqName, parentClass?.toLookupTag(), firClassSymbol, firClass.origin)!! // firClass may be referenced by some parent's type parameters as a bound. In that case, getIrClassSymbol will be called recursively. - classifierStorage.getCachedIrClass(firClass)?.let { return it.symbol } + classifierStorage.getCachedIrClass(firClass)?.let { return it } val irClass = lazyDeclarationsGenerator.createIrLazyClass(firClass, irParent) classCache[firClass] = irClass // NB: this is needed to prevent recursions in case of self bounds (irClass as Fir2IrLazyClass).prepareTypeParameters() - return irClass.symbol + return irClass + } fun getFieldsWithContextReceiversForClass(irClass: IrClass, klass: FirClass): List { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt index e6c5e511046..00f5729a6b1 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt @@ -84,12 +84,14 @@ class Fir2IrConversionScope(val configuration: Fir2IrConfiguration) { error("Accessor of property ${property.render()} not found on parent stack") } - @OptIn(IrSymbolInternals::class) @Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER") inline fun findDeclarationInParentsStack(symbol: IrSymbol): @kotlin.internal.NoInfer D { + // This is an unsafe fast path for production if (!AbstractTypeChecker.RUN_SLOW_ASSERTIONS) { + @OptIn(IrSymbolInternals::class) return symbol.owner as D } + // With slow assertions the following code guarantees that taking owner from symbol is safe for (parent in parentStack.asReversed()) { if ((parent as? IrDeclaration)?.symbol == symbol) { return parent as D @@ -100,6 +102,7 @@ class Fir2IrConversionScope(val configuration: Fir2IrConfiguration) { * for which we have Fir2IrLazyClass in symbol */ if (configuration.allowNonCachedDeclarations) { + @OptIn(IrSymbolInternals::class) return symbol.owner as D } error("Declaration with symbol $symbol is not found in parents stack") diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt index 04ea6eab89b..f8362b627ab 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt @@ -124,7 +124,7 @@ class Fir2IrTypeConverter( ?: lookupTag.toSymbol(session)?.toSymbol(typeOrigin) { typeAnnotations += with(annotationGenerator) { it.toIrAnnotations() } } - ?: (lookupTag as? ConeClassLikeLookupTag)?.let(classifiersGenerator::createIrClassSymbolForNotFoundClass) + ?: (lookupTag as? ConeClassLikeLookupTag)?.let(classifiersGenerator::createIrClassForNotFoundClass)?.symbol ?: return createErrorType() when { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/Fir2IrClassifiersGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/Fir2IrClassifiersGenerator.kt index d6c5eb3093b..111e54dd9b7 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/Fir2IrClassifiersGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/Fir2IrClassifiersGenerator.kt @@ -456,8 +456,7 @@ class Fir2IrClassifiersGenerator(val components: Fir2IrComponents) : Fir2IrCompo } } - @OptIn(IrSymbolInternals::class) - fun createIrClassSymbolForNotFoundClass(classLikeLookupTag: ConeClassLikeLookupTag): IrClassSymbol { + fun createIrClassForNotFoundClass(classLikeLookupTag: ConeClassLikeLookupTag): IrClass { val classId = classLikeLookupTag.classId val signature = IdSignature.CommonSignature( packageFqName = classId.packageFqName.asString(), @@ -468,10 +467,10 @@ class Fir2IrClassifiersGenerator(val components: Fir2IrComponents) : Fir2IrCompo ) val parentId = classId.outerClassId - val parentClass = parentId?.let { createIrClassSymbolForNotFoundClass(it.toLookupTag()) } - val irParent = parentClass?.owner ?: declarationStorage.getIrExternalPackageFragment(classId.packageFqName) + val parentClass = parentId?.let { createIrClassForNotFoundClass(it.toLookupTag()) } + val irParent = parentClass ?: declarationStorage.getIrExternalPackageFragment(classId.packageFqName) - return symbolTable.referenceClass(signature, { IrClassPublicSymbolImpl(signature) }) { + return symbolTable.declareClassIfNotExists(signature, { IrClassPublicSymbolImpl(signature) }) { irFactory.createClass( startOffset = UNDEFINED_OFFSET, endOffset = UNDEFINED_OFFSET,