[FIR2IR] Explicitly opt-in to IrSymbolInternals at call-sites

^KT-60924

compiler/fir/fir2ir/build.gradle.kts

@@ -48,7 +48,6 @@ dependencies {
     testRuntimeOnly(jpsModelImpl())
 }
 
-optInToIrSymbolInternals()
 optInToObsoleteDescriptorBasedAPI()
 
 val generationRoot = projectDir.resolve("tests-gen")

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

@@ -180,6 +180,7 @@ private fun FirBasedSymbol<*>.toSymbolForCall(
 }
 
 context(Fir2IrComponents)
+@OptIn(IrSymbolInternals::class)
 fun FirReference.toSymbolForCall(
     dispatchReceiver: FirExpression,
     conversionScope: Fir2IrConversionScope,
@@ -464,6 +465,7 @@ fun FirTypeScope.processOverriddenPropertiesFromSuperClasses(
     }
 
 context(Fir2IrComponents)
+@OptIn(IrSymbolInternals::class)
 private fun FirClass.getSuperTypesAsIrClasses(): Set<IrClass>? {
     val irClass =
         declarationStorage.classifierStorage.getIrClassSymbol(symbol).owner as? IrClass ?: return null
@@ -510,6 +512,7 @@ internal fun FirProperty.generateOverriddenPropertySymbols(containingClass: FirC
 }
 
 context(Fir2IrComponents)
+@OptIn(IrSymbolInternals::class)
 internal fun FirProperty.generateOverriddenAccessorSymbols(containingClass: FirClass, isGetter: Boolean): List<IrSimpleFunctionSymbol> {
     val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true, memberRequiredPhase = null)
     scope.processPropertiesByName(name) {}
@@ -620,6 +623,7 @@ fun FirClass.irOrigin(firProvider: FirProvider): IrDeclarationOrigin = when {
     }
 }
 
+@OptIn(IrSymbolInternals::class)
 val IrType.isSamType: Boolean
     get() {
         val irClass = classOrNull ?: return false

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.packageFqName
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.getContainingFile
@@ -26,6 +25,7 @@ import org.jetbrains.kotlin.ir.declarations.nameWithPackage
 import org.jetbrains.kotlin.ir.expressions.IrConst
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -44,6 +44,7 @@ class Fir2IrAnnotationsFromPluginRegistrar(private val components: Fir2IrCompone
         return true
     }
 
+    @OptIn(IrSymbolInternals::class)
     override fun addMetadataVisibleAnnotationsToElement(declaration: IrDeclaration, annotations: List<IrConstructorCall>) {
         require(annotations.all { it.typeArgumentsCount == 0 && it.hasOnlySupportedAnnotationArgumentTypes() }) {
             "Saving annotations with arguments from IR to metadata is only supported for basic constants. See KT-58968"
@@ -105,6 +106,7 @@ class Fir2IrAnnotationsFromPluginRegistrar(private val components: Fir2IrCompone
         private val ClassId.topmostParentClassId: ClassId
             get() = parentClassId?.topmostParentClassId ?: this
 
+        @OptIn(IrSymbolInternals::class)
         private fun IrConstructorCall.toFirAnnotation(): FirAnnotation {
             val annotationClassId = this.symbol.owner.constructedClass.classId!!
             return buildAnnotation {

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.ir.declarations.IrConstructor
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.defaultType
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -79,6 +80,7 @@ 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) {
             owner.declarations.firstIsInstance<IrConstructor>().symbol

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

@@ -71,6 +71,7 @@ class Fir2IrClassifierStorage(
     private fun FirTypeRef.toIrType(typeOrigin: ConversionTypeOrigin = ConversionTypeOrigin.DEFAULT): IrType =
         with(typeConverter) { toIrType(typeOrigin) }
 
+    @OptIn(IrSymbolInternals::class)
     fun preCacheBuiltinClasses() {
         for ((classId, irBuiltinSymbol) in typeConverter.classIdToSymbolMap) {
             // toSymbol() can return null when using an old stdlib that's missing some types
@@ -582,6 +583,7 @@ class Fir2IrClassifierStorage(
         )
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun findIrClass(lookupTag: ConeClassLikeLookupTag): IrClass? {
         return if (lookupTag.classId.isLocal) {
             getCachedLocalClass(lookupTag)
@@ -670,6 +672,7 @@ class Fir2IrClassifierStorage(
         return irClass.symbol
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun getIrClassSymbolForNotFoundClass(classLikeLookupTag: ConeClassLikeLookupTag): IrClassSymbol {
         val classId = classLikeLookupTag.classId
         val signature = IdSignature.CommonSignature(

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

@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.ir.interpreter.IrInterpreterConfiguration
 import org.jetbrains.kotlin.ir.interpreter.IrInterpreterEnvironment
 import org.jetbrains.kotlin.ir.interpreter.checker.EvaluationMode
 import org.jetbrains.kotlin.ir.interpreter.transformer.transformConst
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.ir.util.NaiveSourceBasedFileEntryImpl
 import org.jetbrains.kotlin.ir.util.defaultType
@@ -239,6 +240,7 @@ class Fir2IrConverter(
         return irClass
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun processCodeFragmentMembers(
         codeFragment: FirCodeFragment,
         irClass: IrClass = classifierStorage.getCachedIrCodeFragment(codeFragment)!!

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

@@ -47,7 +47,6 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin.GeneratedByPlugi
 import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyClass
 import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.expressions.IrSyntheticBodyKind
 import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl
 import org.jetbrains.kotlin.ir.symbols.*
@@ -161,6 +160,7 @@ class Fir2IrDeclarationStorage(
 
     private val localStorage: Fir2IrLocalCallableStorage by threadLocal { Fir2IrLocalCallableStorage() }
 
+    @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
@@ -578,6 +578,7 @@ class Fir2IrDeclarationStorage(
         return getCachedIrFunction(function, fakeOverrideOwnerLookupTag = null) { signatureComposer.composeSignature(function) }
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun getCachedIrFunction(
         function: FirSimpleFunction,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag?,
@@ -753,6 +754,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun getCachedIrConstructor(
         constructor: FirConstructor,
         signatureCalculator: () -> IdSignature? = { null }
@@ -1161,6 +1163,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun getCachedIrProperty(
         property: FirProperty,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag?,
@@ -1564,6 +1567,7 @@ class Fir2IrDeclarationStorage(
         ) as IrConstructorSymbol
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun getIrFunctionSymbol(
         firFunctionSymbol: FirFunctionSymbol<*>,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag? = null,
@@ -1634,6 +1638,7 @@ class Fir2IrDeclarationStorage(
         return irFunction
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun getIrPropertySymbol(
         firPropertySymbol: FirPropertySymbol,
         fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag? = null,
@@ -1686,6 +1691,7 @@ class Fir2IrDeclarationStorage(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun createIrLazyProperty(
         fir: FirProperty,
         signature: IdSignature,
@@ -1725,6 +1731,7 @@ class Fir2IrDeclarationStorage(
         return irProperty
     }
 
+    @OptIn(IrSymbolInternals::class)
     private inline fun <reified S : IrSymbol, reified D : IrOverridableDeclaration<S>> ConeClassLookupTagWithFixedSymbol.findIrFakeOverride(
         name: Name, originalDeclaration: IrOverridableDeclaration<S>
     ): IrSymbol? {
@@ -1735,6 +1742,7 @@ class Fir2IrDeclarationStorage(
         }?.symbol
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun generateLazyFakeOverrides(name: Name, fakeOverrideOwnerLookupTag: ConeClassLikeLookupTag?) {
         val firClassSymbol = fakeOverrideOwnerLookupTag?.toSymbol(session) as? FirClassSymbol
         if (firClassSymbol != null) {

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

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.classId
 import org.jetbrains.kotlin.ir.util.parentAsClass
@@ -352,6 +353,7 @@ class Fir2IrImplicitCastInserter(
                 )
         }
 
+        @OptIn(IrSymbolInternals::class)
         internal fun implicitNotNullCast(original: IrExpression): IrTypeOperatorCall {
             // Cast type massage 1. Remove @EnhancedNullability
             // Cast type massage 2. Convert it to a non-null variant (in case of @FlexibleNullability)

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

@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.types.impl.IrErrorClassImpl
@@ -656,6 +657,7 @@ class Fir2IrVisitor(
                 !((scopeOwner is IrFunction || scopeOwner is IrProperty || scopeOwner is IrField) && (scopeOwner as IrDeclaration).parent == irClass) // Members of object
     }
 
+    @OptIn(IrSymbolInternals::class)
     override fun visitThisReceiverExpression(
         thisReceiverExpression: FirThisReceiverExpression,
         data: Any?

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
-import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.ir.declarations.*
@@ -24,7 +23,6 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
-@OptIn(SymbolInternals::class)
 class FirIrProvider(val fir2IrComponents: Fir2IrComponents) : IrProvider {
     private val symbolProvider = fir2IrComponents.session.symbolProvider
     private val declarationStorage = fir2IrComponents.declarationStorage
@@ -64,6 +62,7 @@ class FirIrProvider(val fir2IrComponents: Fir2IrComponents) : IrProvider {
         return getDeclarationForSignature(signature.nearestPublicSig(), kind)
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun getDeclarationForCommonSignature(signature: IdSignature.CommonSignature, kind: SymbolKind): IrDeclaration? {
         val packageFqName = FqName(signature.packageFqName)
         val nameSegments = signature.nameSegments

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

@@ -61,6 +61,7 @@ class IrBuiltInsOverFir(
 
     private val irSignatureBuilder = PublicIdSignatureComputer(irMangler)
 
+    @OptIn(IrSymbolInternals::class)
     override val booleanNotSymbol: IrSimpleFunctionSymbol by lazy {
         boolean.ensureLazyContentsCreated()
         booleanClass.owner.functions.first { it.name == OperatorNameConventions.NOT && it.returnType == booleanType }.symbol
@@ -122,6 +123,7 @@ class IrBuiltInsOverFir(
     override val booleanType: IrType get() = boolean.type
     override val booleanClass: IrClassSymbol get() = boolean.klass
 
+    @OptIn(IrSymbolInternals::class)
     private val char by createClass(kotlinIrPackage, IdSignatureValues._char) {
         configureSuperTypes(number)
         createStandardNumericAndCharMembers(charType)
@@ -201,6 +203,7 @@ class IrBuiltInsOverFir(
     override val stringType: IrType get() = string.type
 
     private val intrinsicConstAnnotationFqName = kotlinInternalPackage.child(Name.identifier("IntrinsicConstEvaluation"))
+    @OptIn(IrSymbolInternals::class)
     internal val intrinsicConst = kotlinInternalIrPackage.createClass(intrinsicConstAnnotationFqName).apply {
         owner.createConstructor()
         owner.finalizeClassDefinition()
@@ -222,7 +225,9 @@ class IrBuiltInsOverFir(
     }
     override val arrayClass: IrClassSymbol get() = array.klass
 
+    @OptIn(IrSymbolInternals::class)
     private val intRangeType by lazy { referenceClassByClassId(StandardClassIds.IntRange)!!.owner.defaultType }
+    @OptIn(IrSymbolInternals::class)
     private val longRangeType by lazy { referenceClassByClassId(StandardClassIds.LongRange)!!.owner.defaultType }
 
     private val annotation by loadClass(StandardClassIds.Annotation)
@@ -403,6 +408,7 @@ class IrBuiltInsOverFir(
     override var dataClassArrayMemberToStringSymbol: IrSimpleFunctionSymbol private set
 
     override var checkNotNullSymbol: IrSimpleFunctionSymbol private set
+    @OptIn(IrSymbolInternals::class)
     override val arrayOfNulls: IrSimpleFunctionSymbol by lazy {
         findFunctions(kotlinPackage, Name.identifier("arrayOfNulls")).first {
             it.owner.dispatchReceiverParameter == null && it.owner.valueParameters.size == 1 &&
@@ -502,6 +508,7 @@ class IrBuiltInsOverFir(
         }.toMap()
     }
 
+    @OptIn(IrSymbolInternals::class)
     override val unsignedArraysElementTypes: Map<IrClassSymbol, IrType?> by lazy {
         unsignedTypesToUnsignedArrays.map { (k,v) -> v to referenceClassByClassId(k.classId)?.owner?.defaultType }.toMap()
     }
@@ -516,33 +523,39 @@ class IrBuiltInsOverFir(
     private val enum by loadClass(StandardClassIds.Enum)
     override val enumClass: IrClassSymbol get() = enum.klass
 
+    @OptIn(IrSymbolInternals::class)
     override val intPlusSymbol: IrSimpleFunctionSymbol
         get() = intClass.functions.single {
             it.owner.name == OperatorNameConventions.PLUS && it.owner.valueParameters[0].type == intType
         }
 
+    @OptIn(IrSymbolInternals::class)
     override val intTimesSymbol: IrSimpleFunctionSymbol
         get() = intClass.functions.single {
             it.owner.name == OperatorNameConventions.TIMES && it.owner.valueParameters[0].type == intType
         }
 
+    @OptIn(IrSymbolInternals::class)
     override val intXorSymbol: IrSimpleFunctionSymbol
         get() = intClass.functions.single {
             it.owner.name == OperatorNameConventions.XOR && it.owner.valueParameters[0].type == intType
         }
 
+    @OptIn(IrSymbolInternals::class)
     override val extensionToString: IrSimpleFunctionSymbol by lazy {
         findFunctions(kotlinPackage, OperatorNameConventions.TO_STRING).single { function ->
             function.owner.extensionReceiverParameter?.let { receiver -> receiver.type == anyNType } ?: false
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     override val memberToString: IrSimpleFunctionSymbol by lazy {
         findBuiltInClassMemberFunctions(anyClass, OperatorNameConventions.TO_STRING).single { function ->
             function.owner.valueParameters.isEmpty()
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     override val extensionStringPlus: IrSimpleFunctionSymbol by lazy {
         findFunctions(kotlinPackage, OperatorNameConventions.PLUS).single { function ->
             val isStringExtension =
@@ -552,6 +565,7 @@ class IrBuiltInsOverFir(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     override val memberStringPlus: IrSimpleFunctionSymbol by lazy {
         findBuiltInClassMemberFunctions(stringClass, OperatorNameConventions.PLUS).single { function ->
             function.owner.valueParameters.size == 1 && function.owner.valueParameters[0].type == anyNType
@@ -578,6 +592,7 @@ class IrBuiltInsOverFir(
         return result
     }
 
+    @OptIn(IrSymbolInternals::class)
     override fun getNonBuiltInFunctionsByExtensionReceiver(
         name: Name, vararg packageNameSegments: String
     ): Map<IrClassifierSymbol, IrSimpleFunctionSymbol> =
@@ -585,6 +600,7 @@ class IrBuiltInsOverFir(
             fn.owner.extensionReceiverParameter?.type?.classifierOrNull
         }
 
+    @OptIn(IrSymbolInternals::class)
     override fun getNonBuiltinFunctionsByReturnType(
         name: Name, vararg packageNameSegments: String
     ): Map<IrClassifierSymbol, IrSimpleFunctionSymbol> =
@@ -597,18 +613,22 @@ class IrBuiltInsOverFir(
     private val suspendFunctionNMap = mutableMapOf<Int, IrClass>()
     private val kSuspendFunctionNMap = mutableMapOf<Int, IrClass>()
 
+    @OptIn(IrSymbolInternals::class)
     override fun functionN(arity: Int): IrClass = functionNMap.getOrPut(arity) {
         referenceClassByClassId(StandardClassIds.FunctionN(arity))!!.owner
     }
 
+    @OptIn(IrSymbolInternals::class)
     override fun kFunctionN(arity: Int): IrClass = kFunctionNMap.getOrPut(arity) {
         referenceClassByClassId(StandardClassIds.KFunctionN(arity))!!.owner
     }
 
+    @OptIn(IrSymbolInternals::class)
     override fun suspendFunctionN(arity: Int): IrClass = suspendFunctionNMap.getOrPut(arity) {
         referenceClassByClassId(StandardClassIds.SuspendFunctionN(arity))!!.owner
     }
 
+    @OptIn(IrSymbolInternals::class)
     override fun kSuspendFunctionN(arity: Int): IrClass = kSuspendFunctionNMap.getOrPut(arity) {
         referenceClassByClassId(StandardClassIds.KSuspendFunctionN(arity))!!.owner
     }
@@ -635,6 +655,7 @@ class IrBuiltInsOverFir(
         setOf(anyClass)
     }
 
+    @OptIn(IrSymbolInternals::class)
     override fun findBuiltInClassMemberFunctions(builtInClass: IrClassSymbol, name: Name): Iterable<IrSimpleFunctionSymbol> {
         require(builtInClass in builtInClasses)
         return builtInClass.functions.filter { it.owner.name == name }.asIterable()
@@ -660,6 +681,7 @@ class IrBuiltInsOverFir(
         private val generatedClass: IrClassSymbol,
         private var lazyContents: (IrClass.() -> Unit)?
     ) {
+        @OptIn(IrSymbolInternals::class)
         fun ensureLazyContentsCreated() {
             if (lazyContents != null) synchronized(this) {
                 lazyContents?.invoke(generatedClass.owner)
@@ -754,6 +776,7 @@ class IrBuiltInsOverFir(
         return components.classifierStorage.getIrClassSymbol(firClassSymbol)
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrType.getMaybeBuiltinClass(): IrClass? {
         val lhsClassFqName = classFqName!!
         return baseIrTypes.find { it.classFqName == lhsClassFqName }?.getClass()
@@ -996,6 +1019,7 @@ class IrBuiltInsOverFir(
         createMemberFunction(OperatorNameConventions.ITERATOR, iteratorType, isOperator = true)
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrClass.createProperty(
         propertyName: String, returnType: IrType,
         modality: Modality = Modality.FINAL,
@@ -1142,6 +1166,7 @@ class IrBuiltInsOverFir(
             finalizeClassDefinition()
         }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrClass.createCompanionObject(block: IrClass.() -> Unit = {}): IrClassSymbol =
         this.createClass(
             kotlinFqName.child(Name.identifier("Companion")), classKind = ClassKind.OBJECT, builderBlock = {

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

@@ -36,6 +36,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
@@ -134,6 +135,7 @@ internal class AdapterGenerator(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     internal fun generateAdaptedCallableReference(
         callableReferenceAccess: FirCallableReferenceAccess,
         explicitReceiverExpression: IrExpression?,
@@ -283,6 +285,7 @@ internal class AdapterGenerator(
     private fun IrValueDeclaration.toIrGetValue(startOffset: Int, endOffset: Int): IrGetValue =
         IrGetValueImpl(startOffset, endOffset, this.type, this.symbol)
 
+    @OptIn(IrSymbolInternals::class)
     private fun createAdapteeCallForCallableReference(
         callableReferenceAccess: FirCallableReferenceAccess,
         firAdaptee: FirFunction,

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

@@ -67,6 +67,7 @@ class CallAndReferenceGenerator(
     private fun ConeKotlinType.toIrType(): IrType =
         with(typeConverter) { toIrType(conversionScope.defaultConversionTypeOrigin()) }
 
+    @OptIn(IrSymbolInternals::class)
     fun convertToIrCallableReference(
         callableReferenceAccess: FirCallableReferenceAccess,
         explicitReceiverExpression: IrExpression?,
@@ -364,6 +365,7 @@ class CallAndReferenceGenerator(
         return IrGetValueImpl(startOffset, endOffset, type, injectedValue.irParameterSymbol, origin)
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun convertToIrCall(
         qualifiedAccess: FirQualifiedAccessExpression,
         typeRef: FirTypeRef,
@@ -575,6 +577,7 @@ class CallAndReferenceGenerator(
 
     internal fun findInjectedValue(calleeReference: FirReference) = extensions.findInjectedValue(calleeReference, conversionScope)
 
+    @OptIn(IrSymbolInternals::class)
     fun convertToIrSetCall(variableAssignment: FirVariableAssignment, explicitReceiverExpression: IrExpression?): IrExpression {
         try {
             val type = irBuiltIns.unitType
@@ -692,6 +695,7 @@ class CallAndReferenceGenerator(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrProperty.overriddenBackingFieldOrNull(): IrField? {
         return overriddenSymbols.firstNotNullOfOrNull {
             val owner = it.owner
@@ -699,6 +703,7 @@ class CallAndReferenceGenerator(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun convertToIrConstructorCall(annotation: FirAnnotation): IrExpression {
         val coneType = annotation.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>()
             ?.fullyExpandedType(session) as? ConeLookupTagBasedType
@@ -834,6 +839,7 @@ class CallAndReferenceGenerator(
         return Triple(valueParameters, argumentMapping, substitutor)
     }
 
+    @OptIn(IrSymbolInternals::class)
     internal fun IrExpression.applyCallArguments(
         statement: FirStatement?,
     ): IrExpression {
@@ -1045,6 +1051,7 @@ class CallAndReferenceGenerator(
         return this
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrExpression.applyImplicitIntegerCoercionIfNeeded(
         argument: FirExpression,
         parameter: FirValueParameter?
@@ -1154,6 +1161,7 @@ class CallAndReferenceGenerator(
             }
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrExpression.applyTypeArguments(
         typeArguments: List<FirTypeProjection>?,
         typeParameters: List<FirTypeParameter>?,
@@ -1207,6 +1215,7 @@ class CallAndReferenceGenerator(
             ?: explicitReceiverExpression
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrExpression.applyReceivers(
         qualifiedAccess: FirQualifiedAccessExpression,
         explicitReceiverExpression: IrExpression?,

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

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.constructedClassType
 import org.jetbrains.kotlin.ir.util.isSetter
@@ -98,6 +99,7 @@ internal class ClassMemberGenerator(
         declarationStorage.leaveScope(irClass)
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun <T : IrFunction> convertFunctionContent(irFunction: T, firFunction: FirFunction?, containingClass: FirClass?): T {
         conversionScope.withParent(irFunction) {
             if (firFunction != null) {
@@ -335,6 +337,7 @@ internal class ClassMemberGenerator(
         return this
     }
 
+    @OptIn(IrSymbolInternals::class)
     internal fun FirDelegatedConstructorCall.toIrDelegatingConstructorCall(): IrExpression {
         val constructedIrType = constructedTypeRef.toIrType()
         val referencedSymbol = calleeReference.toResolvedConstructorSymbol()

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.IrType
@@ -71,6 +72,7 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) : Fir2IrCompon
         val lookupTag: ConeClassLikeLookupTag,
         val origin: IrDeclarationOrigin
     ) {
+        @OptIn(IrSymbolInternals::class)
         private val irDataClassMembersGenerator = object : IrBasedDataClassMembersGenerator(
             IrGeneratorContextBase(components.irBuiltIns),
             components.symbolTable,

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrReturnImpl
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
 import org.jetbrains.kotlin.ir.util.SYNTHETIC_OFFSET
@@ -53,6 +54,7 @@ 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))
@@ -175,6 +177,7 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I
         return result?.unwrapSubstitutionOverrides()
     }
 
+    @OptIn(IrSymbolInternals::class)
     fun bindDelegatedMembersOverriddenSymbols(irClass: IrClass) {
         val superClasses by lazy(LazyThreadSafetyMode.NONE) {
             irClass.superTypes.mapNotNullTo(mutableSetOf()) { it.classifierOrNull?.owner as? IrClass }

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.parentAsClass
@@ -427,6 +428,7 @@ class FakeOverrideGenerator(
         ) { declarationStorage.getIrPropertySymbol(it) as IrPropertySymbol }
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun <I : IrDeclaration, S : IrSymbol, F : FirCallableSymbol<*>> getOverriddenSymbolsInSupertypes(
         declaration: I,
         baseSymbols: List<F>,
@@ -440,6 +442,7 @@ class FakeOverrideGenerator(
         }.distinct()
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun <F : FirCallableSymbol<*>, S : IrSymbol> getOverriddenSymbolsInSupertypes(
         overridden: F,
         superClasses: Set<IrClass>,
@@ -505,6 +508,7 @@ class FakeOverrideGenerator(
         }
     }
 
+    @OptIn(IrSymbolInternals::class)
     private fun IrProperty.setOverriddenSymbolsForProperty(
         declarationStorage: Fir2IrDeclarationStorage,
         isVar: Boolean,

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.getSimpleFunction
 
@@ -235,6 +236,7 @@ internal class OperatorExpressionGenerator(
     private fun IrExpression.negate(origin: IrStatementOrigin) =
         primitiveOp1(startOffset, endOffset, irBuiltIns.booleanNotSymbol, irBuiltIns.booleanType, origin, this)
 
+    @OptIn(IrSymbolInternals::class)
     private fun FirExpression.convertToIrExpression(
         comparisonInfo: PrimitiveConeNumericComparisonInfo?,
         isLeftType: Boolean

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

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.ir.declarations.lazy.IrMaybeDeserializedClass
 import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
@@ -149,6 +150,7 @@ 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,

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

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.isFacadeClass
 import org.jetbrains.kotlin.name.Name
@@ -112,6 +113,7 @@ class Fir2IrLazyPropertyAccessor(
         firParentProperty.generateOverriddenAccessorSymbols(firParentClass, !isSetter)
     }
 
+    @OptIn(IrSymbolInternals::class)
     override val initialSignatureFunction: IrFunction? by lazy {
         (fir as? FirSyntheticPropertyAccessor)?.delegate?.let { declarationStorage.getIrFunctionSymbol(it.symbol).owner }
     }

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.declarations.lazy.lazyVar
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
@@ -101,6 +102,7 @@ class Fir2IrLazySimpleFunction(
         fir.generateOverriddenFunctionSymbols(firParent)
     }
 
+    @OptIn(IrSymbolInternals::class)
     override val initialSignatureFunction: IrFunction? by lazy {
         (fir.initialSignatureAttr as? FirFunction)?.symbol?.let { declarationStorage.getIrFunctionSymbol(it).owner }?.takeIf { it !== this }
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/symbols/Fir2IrBindableSymbol.kt

@@ -10,15 +10,17 @@ import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.symbols.IrBindableSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.render
-import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 
 abstract class Fir2IrBindableSymbol<out D : DeclarationDescriptor, B : IrDeclaration>(
     override val signature: IdSignature,
 ) : IrBindableSymbol<D, B> {
 
     private var _owner: B? = null
+
+    @IrSymbolInternals
     override val owner: B
         get() = _owner ?: throw IllegalStateException("Symbol is unbound")
 
@@ -33,6 +35,7 @@ abstract class Fir2IrBindableSymbol<out D : DeclarationDescriptor, B : IrDeclara
     override val isBound: Boolean
         get() = _owner != null
 
+    @OptIn(IrSymbolInternals::class)
     @ObsoleteDescriptorBasedAPI
     override val descriptor: D
         @Suppress("UNCHECKED_CAST")
@@ -44,6 +47,7 @@ abstract class Fir2IrBindableSymbol<out D : DeclarationDescriptor, B : IrDeclara
 
     override var privateSignature: IdSignature? = null
 
+    @OptIn(IrSymbolInternals::class)
     override fun toString(): String {
         if (isBound) return owner.render()
         return "Unbound public symbol for $signature"