[FIR2IR] Remove or approve some of left usages of IrSymbol.owner

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

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

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 <reified D : IrDeclaration> 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")

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 {

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 createIrClassForNotFoundClass(classLikeLookupTag: ConeClassLikeLookupTag): IrClass {
-    fun createIrClassSymbolForNotFoundClass(classLikeLookupTag: ConeClassLikeLookupTag): IrClassSymbol {
         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 parentClass = parentId?.let { createIrClassForNotFoundClass(it.toLookupTag()) }
-        val irParent = parentClass?.owner ?: declarationStorage.getIrExternalPackageFragment(classId.packageFqName)
+        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,