[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

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)
     }
 
 }

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")

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 {
+    fun getOrCreateIrClass(firClassSymbol: FirClassSymbol<*>): IrClass {
-        return getOrCreateIrClass(firClassSymbol).symbol
-    }
-
-    private 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) {

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 <reified S : IrSymbol, reified D : IrOverridableDeclaration<S>> ConeClassLookupTagWithFixedSymbol.findIrFakeOverride(
         name: Name, originalDeclaration: IrOverridableDeclaration<S>
     ): 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

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? {

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 {

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)
+                classifierStorage.getOrCreateIrClass((firDeclaration as FirRegularClass).symbol)
-                @OptIn(IrSymbolInternals::class)
-                classifierStorage.getIrClassSymbol((firDeclaration as FirRegularClass).symbol).owner
             }
             SymbolKind.ENUM_ENTRY_SYMBOL -> classifierStorage.getIrEnumEntry(
                 firDeclaration as FirEnumEntry, parent as IrClass

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)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt

@@ -283,7 +283,7 @@ class CallAndReferenceGenerator(
         val coneSuperType = superTypeRef.coneTypeSafe<ConeClassLikeType>() ?: 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
     }

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<IrSimpleFunctionSymbol>()
-    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<IrPropertySymbol> {
-    val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList()
+    val superClasses = containingClass.getSuperTypesAsIrClasses()
     val overriddenSet = mutableSetOf<IrPropertySymbol>()
 
     processOverriddenPropertySymbols(containingClass) {
@@ -554,7 +553,7 @@ internal fun FirProperty.generateOverriddenPropertySymbols(containingClass: FirC
 
 context(Fir2IrComponents)
 internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(containingClass: FirClass): List<IrSimpleFunctionSymbol> {
-    val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList()
+    val superClasses = containingClass.getSuperTypesAsIrClasses()
     val overriddenSet = mutableSetOf<IrSimpleFunctionSymbol>()
 
     processOverriddenFunctionSymbols(containingClass) {
@@ -569,9 +568,8 @@ internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(containingClass
 
 context(Fir2IrComponents)
 @OptIn(IrSymbolInternals::class)
-private fun FirClass.getSuperTypesAsIrClasses(): Set<IrClass>? {
+private fun FirClass.getSuperTypesAsIrClasses(): Set<IrClass> {
-    val irClass =
+    val irClass = declarationStorage.classifierStorage.getOrCreateIrClass(symbol)
-        declarationStorage.classifierStorage.getIrClassSymbol(symbol).owner as? IrClass ?: return null
 
     return irClass.superTypes.mapNotNull { it.classifierOrNull?.owner as? IrClass }.toSet()
 }

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
                 }
             }