diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt index e58c5886da0..de24cd4f58f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt +++ b/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().symbol } else { val firConstructorSymbol = firSymbol.unsubstitutedScope().getDeclaredConstructors().singleOrNull() ?: return null 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 c993baf52df..c365224d74b 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 @@ -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) 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 5ee4e3c4542..91d9c4416a3 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 @@ -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 } 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 2e68cd24afd..b3ed7f2ff7a 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 @@ -55,12 +55,12 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I private val bodiesInfo = mutableListOf() - @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 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 01e8c828524..7eecd65505f 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 @@ -149,7 +149,6 @@ class Fir2IrLazyClass( .also(converter::bindFakeOverridesOrPostpone) } - @OptIn(IrSymbolInternals::class) override val declarations: MutableList by lazyVar(lock) { val result = mutableListOf() // 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 ) }