[FIR2IR] Move opt-ins to IrSymbolInternals closer to actual usages of symbol.owner

^KT-60924

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt

@@ -79,9 +79,9 @@ class Fir2IrBuiltIns(
         return session.symbolProvider.getClassLikeSymbolByClassId(id) as? FirRegularClassSymbol
     }
 
-    @OptIn(IrSymbolInternals::class)
     private fun IrClassSymbol.toConstructorCall(firSymbol: FirRegularClassSymbol? = null): IrConstructorCallImpl? {
         val constructorSymbol = if (firSymbol == null) {
+            @OptIn(IrSymbolInternals::class)
             owner.declarations.firstIsInstance<IrConstructor>().symbol
         } else {
             val firConstructorSymbol = firSymbol.unsubstitutedScope().getDeclaredConstructors().singleOrNull() ?: return null

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.toLookupTag
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
@@ -69,7 +68,6 @@ class Fir2IrClassifierStorage(
 
     // ------------------------------------ preprocessing ------------------------------------
 
-    @OptIn(IrSymbolInternals::class)
     fun preCacheBuiltinClasses() {
         fun getResolvedClass(classId: ClassId): FirRegularClass? {
             // toSymbol() can return null when using an old stdlib that's missing some types
@@ -84,6 +82,8 @@ class Fir2IrClassifierStorage(
 
         for ((classId, irBuiltinSymbol) in typeConverter.classIdToSymbolMap) {
             val firClass = getResolvedClass(classId) ?: continue
+
+            @OptIn(IrSymbolInternals::class)
             val irClass = irBuiltinSymbol.owner
             classCache[firClass] = irClass
             classifiersGenerator.processClassHeader(firClass, irClass)
@@ -93,6 +93,8 @@ class Fir2IrClassifierStorage(
             // toSymbol() can return null when using an old stdlib that's missing some types
             val firClass = getResolvedClass(primitiveArrayId) ?: continue
             val irType = typeConverter.classIdToTypeMap[primitiveClassId]
+
+            @OptIn(IrSymbolInternals::class)
             val irClass = irBuiltIns.primitiveArrayForType[irType]!!.owner
             classCache[firClass] = irClass
             classifiersGenerator.processClassHeader(firClass, irClass)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt

@@ -268,7 +268,6 @@ class Fir2IrDeclarationStorage(
         return getCachedIrFunction(function, fakeOverrideOwnerLookupTag = null) { signatureComposer.composeSignature(function) }
     }
 
-    @OptIn(IrSymbolInternals::class)
     fun getCachedIrFunction(
         function: FirSimpleFunction,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag?,
@@ -283,6 +282,7 @@ class Fir2IrDeclarationStorage(
             functionCache,
             signatureCalculator
         ) { signature ->
+            @OptIn(IrSymbolInternals::class)
             symbolTable.referenceSimpleFunctionIfAny(signature)?.owner
         }
         return cachedIrCallable
@@ -360,13 +360,13 @@ class Fir2IrDeclarationStorage(
 
     // ------------------------------------ constructors ------------------------------------
 
-    @OptIn(IrSymbolInternals::class)
     fun getCachedIrConstructor(
         constructor: FirConstructor,
         signatureCalculator: () -> IdSignature? = { null }
     ): IrConstructor? {
         return constructorCache[constructor] ?: signatureCalculator()?.let { signature ->
             symbolTable.referenceConstructorIfAny(signature)?.let { irConstructorSymbol ->
+                @OptIn(IrSymbolInternals::class)
                 val irConstructor = irConstructorSymbol.owner
                 constructorCache[constructor] = irConstructor
                 irConstructor
@@ -537,7 +537,6 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    @OptIn(IrSymbolInternals::class)
     fun getIrPropertySymbol(
         firPropertySymbol: FirPropertySymbol,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag? = null,
@@ -571,11 +570,14 @@ class Fir2IrDeclarationStorage(
         )
 
         val originalSymbol = fakeOverrideOwnerLookupTag.getIrCallableSymbol()
+
+        @OptIn(IrSymbolInternals::class)
         val originalProperty = originalSymbol.owner as IrProperty
 
         fun IrProperty.isIllegalFakeOverride(): Boolean {
             if (!isFakeOverride) return false
             val overriddenSymbols = overriddenSymbols
+            @OptIn(IrSymbolInternals::class)
             return overriddenSymbols.isEmpty() || overriddenSymbols.any { it.owner.isIllegalFakeOverride() }
         }
 
@@ -600,7 +602,6 @@ class Fir2IrDeclarationStorage(
         }
     }
 
-    @OptIn(IrSymbolInternals::class)
     fun getCachedIrProperty(
         property: FirProperty,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag?,
@@ -614,6 +615,7 @@ class Fir2IrDeclarationStorage(
             propertyCache,
             signatureCalculator
         ) { signature ->
+            @OptIn(IrSymbolInternals::class)
             symbolTable.referencePropertyIfAny(signature)?.owner
         }
     }
@@ -899,7 +901,6 @@ class Fir2IrDeclarationStorage(
         return map?.get(callableDeclaration.asFakeOverrideKey())
     }
 
-    @OptIn(IrSymbolInternals::class)
     fun getIrFunctionSymbol(
         firFunctionSymbol: FirFunctionSymbol<*>,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag? = null,
@@ -935,6 +936,7 @@ class Fir2IrDeclarationStorage(
                     },
                 ) as IrFunctionSymbol
                 if (unmatchedOwner && fakeOverrideOwnerLookupTag is ConeClassLookupTagWithFixedSymbol) {
+                    @OptIn(IrSymbolInternals::class)
                     val originalFunction = originalSymbol.owner as IrSimpleFunction
                     fakeOverrideOwnerLookupTag.findIrFakeOverride(fir.name, originalFunction) as IrFunctionSymbol? ?: originalSymbol
                 } else {
@@ -1276,7 +1278,6 @@ class Fir2IrDeclarationStorage(
         )
     }
 
-    @OptIn(IrSymbolInternals::class)
     private fun areCompatible(firFunction: FirFunction, irFunction: IrFunction): Boolean {
         if (firFunction is FirSimpleFunction && irFunction is IrSimpleFunction) {
             if (irFunction.name != firFunction.name) return false
@@ -1291,6 +1292,7 @@ class Fir2IrDeclarationStorage(
                                 firType is ConeTypeParameterType
                             }
                             is IrClassSymbol -> {
+                                @OptIn(IrSymbolInternals::class)
                                 val irClass = irClassifierSymbol.owner
                                 firType is ConeClassLikeType && irClass.name == firType.lookupTag.name
                             }

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

@@ -55,12 +55,12 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I
 
     private val bodiesInfo = mutableListOf<DeclarationBodyInfo>()
 
-    @OptIn(IrSymbolInternals::class)
     fun generateBodies() {
         for ((declaration, irField, delegateToSymbol, delegateToLookupTag) in bodiesInfo) {
             val callTypeCanBeNullable = Fir2IrImplicitCastInserter.typeCanBeEnhancedOrFlexibleNullable(delegateToSymbol.fir.returnTypeRef.coneType.fullyExpandedType(session))
             when (declaration) {
                 is IrSimpleFunction -> {
+                    @OptIn(IrSymbolInternals::class)
                     val member = declarationStorage.getIrFunctionSymbol(
                         delegateToSymbol as FirNamedFunctionSymbol, delegateToLookupTag
                     ).owner as? IrSimpleFunction ?: continue
@@ -68,6 +68,7 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I
                     declaration.body = body
                 }
                 is IrProperty -> {
+                    @OptIn(IrSymbolInternals::class)
                     val member = declarationStorage.getIrPropertySymbol(
                         delegateToSymbol as FirPropertySymbol, delegateToLookupTag
                     ).owner as? IrProperty ?: continue

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt

@@ -149,7 +149,6 @@ class Fir2IrLazyClass(
             .also(converter::bindFakeOverridesOrPostpone)
     }
 
-    @OptIn(IrSymbolInternals::class)
     override val declarations: MutableList<IrDeclaration> by lazyVar(lock) {
         val result = mutableListOf<IrDeclaration>()
         // NB: it's necessary to take all callables from scope,
@@ -157,6 +156,7 @@ class Fir2IrLazyClass(
         val scope = fir.unsubstitutedScope()
         scope.processDeclaredConstructors {
             if (shouldBuildStub(it.fir)) {
+                @OptIn(IrSymbolInternals::class)
                 result += declarationStorage.getIrConstructorSymbol(it).owner
             }
         }
@@ -166,6 +166,7 @@ class Fir2IrLazyClass(
                 val declaration = it.fir as? FirRegularClass ?: return@processClassifiersByName
                 if (declaration.classId.outerClassId == fir.classId && shouldBuildStub(declaration)) {
                     val nestedSymbol = classifierStorage.getOrCreateIrClass(declaration.symbol).symbol
+                    @OptIn(IrSymbolInternals::class)
                     result += nestedSymbol.owner
                 }
             }
@@ -174,6 +175,7 @@ class Fir2IrLazyClass(
         if (fir.classKind == ClassKind.ENUM_CLASS) {
             for (declaration in fir.declarations) {
                 if (declaration is FirEnumEntry && shouldBuildStub(declaration)) {
+                    @OptIn(IrSymbolInternals::class)
                     result += declarationStorage.getIrValueSymbol(declaration.symbol).owner as IrDeclaration
                 }
             }
@@ -191,6 +193,7 @@ class Fir2IrLazyClass(
                         if (it.isAbstractMethodOfAny()) {
                             return@processFunctionsByName
                         }
+                        @OptIn(IrSymbolInternals::class)
                         result += declarationStorage.getIrFunctionSymbol(it).owner
                     }
                 }
@@ -199,6 +202,7 @@ class Fir2IrLazyClass(
                     if (!shouldBuildStub(it.fir)) return@processPropertiesByName
                     if (it is FirPropertySymbol && (it.isStatic || it.dispatchReceiverClassLookupTagOrNull() == ownerLookupTag)) {
                         result.addIfNotNull(
+                            @OptIn(IrSymbolInternals::class)
                             declarationStorage.getIrPropertySymbol(it).owner as? IrDeclaration
                         )
                     }