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 762ad11e8fd..aac257790a7 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.getOrCreateIrClass(symbol).symbol.descriptor) + return listOf(components.classifierStorage.getIrClassSymbol(symbol).descriptor) } } diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmElementAwareStringTable.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmElementAwareStringTable.kt index 9bb708f2879..cd70ce990a3 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmElementAwareStringTable.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmElementAwareStringTable.kt @@ -23,9 +23,10 @@ class FirJvmElementAwareStringTable( private val localPoppedUpClasses: List, nameResolver: JvmNameResolver? = null ) : JvmStringTable(nameResolver), FirElementAwareStringTable { - override fun getLocalClassIdReplacement(firClass: FirClass): ClassId = - components.classifierStorage.getCachedIrClass(firClass)?.getLocalClassIdReplacement() - ?: throw AssertionError("not a local class: ${firClass.symbol.classId}") + override fun getLocalClassIdReplacement(firClass: FirClass): ClassId { + // TODO: should call getCachedIrLocalClass, see KT-66018 + return components.classifierStorage.getIrClass(firClass).getLocalClassIdReplacement() + } private fun IrClass.getLocalClassIdReplacement(): ClassId { // This convoluted implementation aims to reproduce K1 behaviour (see JvmCodegenStringTable::getLocalClassIdReplacement). 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 107bbfffdb2..5b8e96833bf 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 @@ -188,7 +188,7 @@ fun FirClassifierSymbol<*>.toSymbol( } is FirClassSymbol -> { - classifierStorage.getOrCreateIrClass(this).symbol + classifierStorage.getIrClassSymbol(this) } else -> error("Unknown symbol: $this") @@ -914,4 +914,4 @@ val incOrDeclSourceKindToIrStatementOrigin = mapOf( KtFakeSourceElementKind.DesugaredPostfixDec to IrStatementOrigin.POSTFIX_DECR, KtFakeSourceElementKind.DesugaredPrefixIncSecondGetReference to IrStatementOrigin.PREFIX_INCR, KtFakeSourceElementKind.DesugaredPrefixDecSecondGetReference to IrStatementOrigin.PREFIX_DECR -) \ No newline at end of file +) 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 010458da60c..aee7cb1159b 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 @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.backend import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.backend.generators.isExternalParent import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression @@ -26,13 +27,14 @@ import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.util.IdSignature import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.SpecialNames +import org.jetbrains.kotlin.utils.addToStdlib.runIf class Fir2IrClassifierStorage( private val components: Fir2IrComponents, commonMemberStorage: Fir2IrCommonMemberStorage, private val conversionScope: Fir2IrConversionScope, ) : Fir2IrComponents by components { - private val classCache: MutableMap = commonMemberStorage.classCache + private val classCache: MutableMap = commonMemberStorage.classCache private val typeAliasCache: MutableMap = mutableMapOf() @@ -61,7 +63,7 @@ class Fir2IrClassifierStorage( */ @DelicateDeclarationStorageApi fun forEachCachedDeclarationSymbol(block: (IrSymbol) -> Unit) { - classCache.values.forEach { block(it.symbol) } + classCache.values.forEach { block(it) } typeAliasCache.values.forEach { block(it.symbol) } enumEntryCache.values.forEach { block(it.symbol) } fieldsForContextReceivers.values.forEach { fields -> @@ -195,58 +197,62 @@ class Fir2IrClassifierStorage( if (regularClass.visibility == Visibilities.Local) { localStorage[regularClass] = irClass } else { - classCache[regularClass] = irClass + classCache[regularClass] = irClass.symbol } } - fun getCachedIrClass(klass: FirClass): IrClass? { - return if (klass is FirAnonymousObject || klass is FirRegularClass && klass.visibility == Visibilities.Local) { - localStorage[klass] - } else { - classCache[klass] - } - } - - fun findIrClass(lookupTag: ConeClassLikeLookupTag): IrClass? { - return if (lookupTag.classId.isLocal) { - getCachedLocalClass(lookupTag) - } else { - val firSymbol = lookupTag.toSymbol(session) - if (firSymbol is FirClassSymbol) { - getOrCreateIrClass(firSymbol) - } else { - null - } - } - } - - private fun getCachedLocalClass(lookupTag: ConeClassLikeLookupTag): IrClass? { - return localStorage[lookupTag.toSymbol(session)!!.fir as FirClass] - } - - fun getOrCreateIrClass(firClassSymbol: FirClassSymbol<*>): IrClass { - val firClass = firClassSymbol.fir - classifierStorage.getCachedIrClass(firClass)?.let { return it } + /** + * FIR2IR looks over all non-local source classes and creates IR for them using [createAndCacheIrClass] + * This means that after this phase all classes are either created and bound to their symbols or external classes, + * which are created and bound at the first access anyway + * + * So, unlike callable declarations, it's safe to expose an API, which returns not just IrClassSymbol, but IrClass itself + * + * But on the first FIR2IR stage this API should not be used + */ + fun getIrClass(firClass: FirClass): IrClass { + getCachedIrClass(firClass)?.let { return it } if (firClass is FirAnonymousObject || firClass is FirRegularClass && firClass.visibility == Visibilities.Local) { return createAndCacheLocalIrClassOnTheFly(firClass) } - firClass as FirRegularClass - val classId = firClassSymbol.classId + require(firClass is FirRegularClass) + val symbol = createClassSymbol(signature = null) + val classId = firClass.symbol.classId val parentId = classId.outerClassId val parentClass = parentId?.let { session.symbolProvider.getClassLikeSymbolByClassId(it) } - val irParent = declarationStorage.findIrParent(classId.packageFqName, parentClass?.toLookupTag(), firClassSymbol, firClass.origin)!! + val irParent = declarationStorage.findIrParent(classId.packageFqName, parentClass?.toLookupTag(), firClass.symbol, 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 } - - val symbol = createClassSymbol(signature = null) + classCache[firClass] = symbol + check(irParent.isExternalParent()) { "Source classes should be created separately before referencing" } val irClass = lazyDeclarationsGenerator.createIrLazyClass(firClass, irParent, symbol) - classCache[firClass] = irClass // NB: this is needed to prevent recursions in case of self bounds irClass.prepareTypeParameters() return irClass + } + fun getIrClass(lookupTag: ConeClassLikeLookupTag): IrClass? { + val firClassSymbol = lookupTag.toSymbol(session) as? FirClassSymbol<*> ?: return null + return getIrClass(firClassSymbol.fir) + } + + fun getCachedIrLocalClass(klass: FirClass): IrClass? { + return runIf(klass is FirAnonymousObject || klass is FirRegularClass && klass.visibility == Visibilities.Local) { + localStorage[klass] + } + } + + private fun getCachedIrClass(klass: FirClass): IrClass? { + @OptIn(UnsafeDuringIrConstructionAPI::class) + return getCachedIrLocalClass(klass) ?: classCache[klass]?.owner + } + + fun getIrClassSymbol(firClassSymbol: FirClassSymbol<*>): IrClassSymbol { + return getIrClass(firClassSymbol.fir).symbol + } + + fun getIrClassSymbol(lookupTag: ConeClassLikeLookupTag): IrClassSymbol? { + return getIrClass(lookupTag)?.symbol } fun getFieldsWithContextReceiversForClass(irClass: IrClass, klass: FirClass): List { @@ -328,7 +334,7 @@ class Fir2IrClassifierStorage( fun getIrAnonymousObjectForEnumEntry(anonymousObject: FirAnonymousObject, name: Name, irParent: IrClass?): IrClass { localStorage[anonymousObject]?.let { return it } - val irAnonymousObject = classifierStorage.createAndCacheAnonymousObject(anonymousObject, Visibilities.Private, name, irParent) + val irAnonymousObject = createAndCacheAnonymousObject(anonymousObject, Visibilities.Private, name, irParent) classifiersGenerator.processClassHeader(anonymousObject, irAnonymousObject) return irAnonymousObject } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCommonMemberStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCommonMemberStorage.kt index 999a71e8ea6..01b47946914 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCommonMemberStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCommonMemberStorage.kt @@ -26,7 +26,7 @@ class Fir2IrCommonMemberStorage(firMangler: FirMangler) { val symbolTable = SymbolTable(signaturer = null, irFactory = IrFactoryImpl) - val classCache: MutableMap = mutableMapOf() + val classCache: MutableMap = mutableMapOf() val typeParameterCache: MutableMap = mutableMapOf() diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt index 9458a532dda..e1c6cc4f24d 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt @@ -434,13 +434,12 @@ class Fir2IrConverter( private fun registerClassAndNestedClasses(klass: FirClass, parent: IrDeclarationParent): IrClass { // Local classes might be referenced before they declared (see usages of Fir2IrClassifierStorage.createLocalIrClassOnTheFly) // So, we only need to set its parent properly - val irClass = - classifierStorage.getCachedIrClass(klass)?.apply { - this.parent = parent - } ?: when (klass) { - is FirRegularClass -> classifierStorage.createAndCacheIrClass(klass, parent) - is FirAnonymousObject -> classifierStorage.createAndCacheAnonymousObject(klass, irParent = parent) - } + val irClass = classifierStorage.getCachedIrLocalClass(klass)?.apply { + this.parent = parent + } ?: when (klass) { + is FirRegularClass -> classifierStorage.createAndCacheIrClass(klass, parent) + is FirAnonymousObject -> classifierStorage.createAndCacheAnonymousObject(klass, irParent = parent) + } registerNestedClasses(klass, irClass) return irClass } @@ -463,7 +462,7 @@ class Fir2IrConverter( private fun processClassAndNestedClassHeaders(klass: FirClass) { classifiersGenerator.processClassHeader(klass) processNestedClassHeaders(klass) - val irClass = classifierStorage.getCachedIrClass(klass)!! + val irClass = classifierStorage.getIrClass(klass)!! /* * This is needed to preserve the source order of declarations in the class * IrClass should contain declarations in the source order, but creating of nested IrClass automatically adds created class to the list @@ -522,7 +521,7 @@ class Fir2IrConverter( val isInLocalClass = containingClass != null && (containingClass !is FirRegularClass || containingClass.isLocal) when (declaration) { is FirRegularClass -> { - val irClass = classifierStorage.getCachedIrClass(declaration)!! + val irClass = classifierStorage.getIrClass(declaration)!! addDeclarationToParentIfNeeded(irClass) processClassMembers(declaration, irClass) } 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 238444dcc47..94133a648c3 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 @@ -410,7 +410,7 @@ class Fir2IrDeclarationStorage( else -> shouldNotBeCalled() } requireNotNull(containingClassLookupTag) { "Containing class not found for ${callable.render()}"} - return classifierStorage.findIrClass(containingClassLookupTag)?.symbol + return classifierStorage.getIrClassSymbol(containingClassLookupTag) ?: error("IR class for $containingClassLookupTag not found") } @@ -994,7 +994,7 @@ class Fir2IrDeclarationStorage( return when (val firDeclaration = firVariableSymbol.fir) { is FirEnumEntry -> { classifierStorage.getCachedIrEnumEntry(firDeclaration)?.let { return it.symbol } - val irParentClass = firDeclaration.containingClassLookupTag()?.let { classifierStorage.findIrClass(it) }!! + val irParentClass = firDeclaration.containingClassLookupTag()?.let { classifierStorage.getIrClass(it) }!! val containingFile = firProvider.getFirCallableContainerFile(firVariableSymbol) @@ -1247,9 +1247,9 @@ class Fir2IrDeclarationStorage( } private fun generateLazyFakeOverrides(name: Name, fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag?) { - val firClassSymbol = fakeOverrideOwnerLookupTag?.toSymbol(session) as? FirClassSymbol + val firClassSymbol = fakeOverrideOwnerLookupTag?.toSymbol(session) as? FirClassSymbol<*> if (firClassSymbol != null) { - val irClass = classifierStorage.getOrCreateIrClass(firClassSymbol) + val irClass = classifierStorage.getIrClass(firClassSymbol.fir) if (irClass is Fir2IrLazyClass) { irClass.getFakeOverridesByName(name) } @@ -1427,7 +1427,9 @@ class Fir2IrDeclarationStorage( firOrigin: FirDeclarationOrigin ): IrDeclarationParent? { if (parentLookupTag != null) { - return classifierStorage.findIrClass(parentLookupTag) + // At this point all source classes should be already created and bound to symbols + @OptIn(UnsafeDuringIrConstructionAPI::class) + return classifierStorage.getIrClassSymbol(parentLookupTag)?.owner } 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 7097cc3be21..4efeecdaf1d 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 @@ -74,7 +74,7 @@ class Fir2IrPluginContext( override fun referenceClass(classId: ClassId): IrClassSymbol? { val firSymbol = symbolProvider.getClassLikeSymbolByClassId(classId) as? FirClassSymbol<*> ?: return null - return components.classifierStorage.getOrCreateIrClass(firSymbol).symbol + return components.classifierStorage.getIrClassSymbol(firSymbol) } 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 f9f4afccb1a..f70d875d0d7 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 @@ -191,7 +191,7 @@ class Fir2IrVisitor( if (regularClass.visibility == Visibilities.Local) { val irParent = conversionScope.parentFromStack() // NB: for implicit types it is possible that local class is already cached - val irClass = classifierStorage.getCachedIrClass(regularClass)?.apply { this.parent = irParent } + val irClass = classifierStorage.getIrClass(regularClass)?.apply { this.parent = irParent } if (irClass != null) { conversionScope.withParent(irClass) { memberGenerator.convertClassContent(irClass, regularClass) @@ -200,7 +200,7 @@ class Fir2IrVisitor( } converter.processLocalClassAndNestedClasses(regularClass, irParent) } - val irClass = classifierStorage.getCachedIrClass(regularClass)!! + val irClass = classifierStorage.getIrClass(regularClass)!! if (regularClass.isSealed) { irClass.sealedSubclasses = regularClass.getIrSymbolsForSealedSubclasses() } @@ -350,7 +350,7 @@ class Fir2IrVisitor( ) { val irParent = conversionScope.parentFromStack() // NB: for implicit types it is possible that anonymous object is already cached - val irAnonymousObject = classifierStorage.getCachedIrClass(anonymousObject)?.apply { this.parent = irParent } + val irAnonymousObject = classifierStorage.getCachedIrLocalClass(anonymousObject)?.apply { this.parent = irParent } ?: converter.processLocalClassAndNestedClasses(anonymousObject, irParent) conversionScope.withParent(irAnonymousObject) { @@ -711,7 +711,7 @@ class Fir2IrVisitor( // We anyway can use 'else' branch as fallback, but // this is an additional check of FIR2IR invariants // (source classes should be already built when we analyze bodies) - classifierStorage.getCachedIrClass(firClass)!!.symbol + classifierStorage.getIrClass(firClass)!!.symbol } else { /* * The only case when we can refer to non-source this is resolution to companion object of parent @@ -729,7 +729,7 @@ class Fir2IrVisitor( * val x: Int = foo() // this: Base.Companion * ) : Base() */ - classifierStorage.getOrCreateIrClass(firClassSymbol).symbol + classifierStorage.getIrClassSymbol(firClassSymbol) } if (firClass.classKind.isObject && shouldGenerateReceiverAsSingletonReference(irClassSymbol)) { @@ -1560,7 +1560,7 @@ class Fir2IrVisitor( is FirResolvedQualifier -> { when (val symbol = argument.symbol) { is FirClassSymbol -> { - classifierStorage.getOrCreateIrClass(symbol).symbol + classifierStorage.getIrClassSymbol(symbol) } is FirTypeAliasSymbol -> { symbol.fir.fullyExpandedConeType(session).toIrClassSymbol() @@ -1594,7 +1594,7 @@ class Fir2IrVisitor( private fun ConeClassLikeType?.toIrClassSymbol(): IrClassSymbol? = (this?.lookupTag?.toSymbol(session) as? FirClassSymbol<*>)?.let { - classifierStorage.getOrCreateIrClass(it).symbol + classifierStorage.getIrClassSymbol(it) } private fun convertToArrayLiteral( 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 41145f7cf20..a5634dda85f 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 @@ -92,7 +92,7 @@ class FirIrProvider(val components: Fir2IrComponents) : IrProvider { val scope = with(components) { firClass.unsubstitutedScope() } fun findIrClass(firClass: FirRegularClass): IrClass { - val irClassSymbol = classifierStorage.getOrCreateIrClass(firClass.symbol).symbol + val irClassSymbol = classifierStorage.getIrClassSymbol(firClass.symbol) return getDeclaration(irClassSymbol) as IrClass } @@ -176,7 +176,7 @@ class FirIrProvider(val components: Fir2IrComponents) : IrProvider { return when (kind) { SymbolKind.CLASS_SYMBOL -> { - classifierStorage.getOrCreateIrClass((firDeclaration as FirRegularClass).symbol) + shouldNotBeCalled() } SymbolKind.ENUM_ENTRY_SYMBOL -> classifierStorage.getOrCreateIrEnumEntry( 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 518a0ecce55..2d6ce4d90f5 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 @@ -596,7 +596,7 @@ class IrBuiltInsOverFir( private fun loadClassSafe(classId: ClassId): IrClassSymbol? { val firClassSymbol = symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol ?: return null - return components.classifierStorage.getOrCreateIrClass(firClassSymbol).symbol + return components.classifierStorage.getIrClassSymbol(firClassSymbol) } @OptIn(UnsafeDuringIrConstructionAPI::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 acc85f46bd9..a5e40422f82 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 @@ -285,7 +285,7 @@ class CallAndReferenceGenerator( val coneSuperType = superTypeRef.coneTypeSafe() ?: return null val firClassSymbol = coneSuperType.fullyExpandedType(session).lookupTag.toSymbol(session) as? FirClassSymbol<*> if (firClassSymbol != null) { - return classifierStorage.getOrCreateIrClass(firClassSymbol).symbol + return classifierStorage.getIrClassSymbol(firClassSymbol) } return null } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt index 8173cfe4867..a33e3d10594 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/ClassMemberGenerator.kt @@ -82,7 +82,7 @@ internal class ClassMemberGenerator( declaration is FirConstructor && declaration.isPrimary -> { } declaration is FirRegularClass && declaration.visibility == Visibilities.Local -> { - val irNestedClass = classifierStorage.getCachedIrClass(declaration)!! + val irNestedClass = classifierStorage.getIrClass(declaration) irNestedClass.parent = irClass conversionScope.withParent(irNestedClass) { convertClassContent(irNestedClass, declaration) @@ -101,7 +101,7 @@ internal class ClassMemberGenerator( dataClassMembersGenerator.generateBodiesForMultiFieldValueClassMembers(klass, irClass) } if (irClass.isData) { - dataClassMembersGenerator.generateBodiesForDataClassMembers(klass, irClass) + dataClassMembersGenerator.generateBodiesForDataClassMembers(klass, irClass) } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt index 64590e3afaf..b5cb113f75c 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt @@ -337,7 +337,7 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I // dispatch receiver of the target method. Therefore, we need to check if a cast must be inserted. val superFunctionDispatchReceiverType = originalFirDeclaration.dispatchReceiverType val superFunctionDispatchReceiverLookupTag = (superFunctionDispatchReceiverType as? ConeClassLikeType)?.lookupTag - val superFunctionParentSymbol = superFunctionDispatchReceiverLookupTag?.let { classifierStorage.findIrClass(it)?.symbol } + val superFunctionParentSymbol = superFunctionDispatchReceiverLookupTag?.let { classifierStorage.getIrClassSymbol(it) } dispatchReceiver = if (superFunctionParentSymbol == null || irField.type.isSubtypeOfClass(superFunctionParentSymbol)) { getField } else { 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 014565363a2..1d653dd29a2 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 @@ -593,7 +593,7 @@ class FakeOverrideGenerator( @OptIn(UnsafeDuringIrConstructionAPI::class) val overriddenContainingIrClass = - declarationStorage.classifierStorage.getOrCreateIrClass(overriddenContainingClass.symbol).symbol.owner + declarationStorage.classifierStorage.getIrClassSymbol(overriddenContainingClass.symbol).owner return superClasses.mapNotNull { superClass -> if (superClass == overriddenContainingIrClass || @@ -733,9 +733,8 @@ internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(containingClass } context(Fir2IrComponents) +@OptIn(UnsafeDuringIrConstructionAPI::class) private fun FirClass.getSuperTypesAsIrClasses(): Set { - val irClass = declarationStorage.classifierStorage.getOrCreateIrClass(symbol) - - @OptIn(UnsafeDuringIrConstructionAPI::class) + val irClass = declarationStorage.classifierStorage.getIrClassSymbol(symbol).owner return irClass.superTypes.mapNotNull { it.classifierOrNull?.owner as? IrClass }.toSet() } 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 d15d857d2c4..1340a5a185a 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 @@ -108,7 +108,7 @@ class Fir2IrClassifiersGenerator(val components: Fir2IrComponents) : Fir2IrCompo return irClass } - fun processClassHeader(klass: FirClass, irClass: IrClass = classifierStorage.getCachedIrClass(klass)!!): IrClass { + fun processClassHeader(klass: FirClass, irClass: IrClass = classifierStorage.getIrClass(klass)): IrClass { irClass.declareTypeParameters(klass) irClass.setThisReceiver(klass.typeParameters) irClass.declareSupertypes(klass) @@ -221,8 +221,7 @@ class Fir2IrClassifiersGenerator(val components: Fir2IrComponents) : Fir2IrCompo val irClass = if (classOrLocalParent === klass) { result } else { - classifierStorage.getCachedIrClass(klass) - ?: error("Assuming that all nested classes of ${classOrLocalParent.classId.asString()} should already be cached") + classifierStorage.getIrClass(klass) } return LocalIrClassInfo(irClass, classOrLocalParent, result) } 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 93fed22c6fd..54cecae5572 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 @@ -173,7 +173,7 @@ class Fir2IrLazyClass( scope.processClassifiersByName(name) { val declaration = it.fir as? FirRegularClass ?: return@processClassifiersByName if (declaration.classId.outerClassId == fir.classId && shouldBuildStub(declaration)) { - result += classifierStorage.getOrCreateIrClass(declaration.symbol) + result += classifierStorage.getIrClassSymbol(declaration.symbol).owner } } }