[FIR2IR] Add Fir2IrComponents context receiver to standalone helper functions

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.caches.getValue
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.buildFile
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
+import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isJava
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -57,12 +58,10 @@ import org.jetbrains.kotlin.ir.util.functions
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.psi.KtQualifiedExpression
 import org.jetbrains.kotlin.psi.psiUtil.startOffsetSkippingComments
 import org.jetbrains.kotlin.types.ConstantValueKind
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 internal fun <T : IrElement> FirElement.convertWithOffsets(
     f: (startOffset: Int, endOffset: Int) -> T
@@ -128,9 +127,8 @@ class ConversionTypeContext internal constructor(
     }
 }
 
+context(Fir2IrComponents)
 fun FirClassifierSymbol<*>.toSymbol(
-    session: FirSession,
-    classifierStorage: Fir2IrClassifierStorage,
     typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT,
     handleAnnotations: ((List<FirAnnotation>) -> Unit)? = null
 ): IrClassifierSymbol {
@@ -142,7 +140,7 @@ fun FirClassifierSymbol<*>.toSymbol(
             handleAnnotations?.invoke(fir.expandedTypeRef.annotations)
             val coneClassLikeType = fir.expandedTypeRef.coneType as ConeClassLikeType
             coneClassLikeType.lookupTag.toSymbol(session)
-                ?.toSymbol(session, classifierStorage, typeContext, handleAnnotations)
+                ?.toSymbol(typeContext, handleAnnotations)
                 ?: classifierStorage.getIrClassSymbolForNotFoundClass(coneClassLikeType.lookupTag)
         }
         is FirClassSymbol -> {
@@ -152,31 +150,26 @@ fun FirClassifierSymbol<*>.toSymbol(
     }
 }
 
+context(Fir2IrComponents)
 private fun FirBasedSymbol<*>.toSymbolForCall(
     dispatchReceiver: FirExpression,
-    session: FirSession,
-    classifierStorage: Fir2IrClassifierStorage,
-    declarationStorage: Fir2IrDeclarationStorage,
     preferGetter: Boolean,
     explicitReceiver: FirExpression? = null,
     isDelegate: Boolean = false
-) = when (this) {
+): IrSymbol? = when (this) {
     is FirCallableSymbol<*> -> unwrapCallRepresentative().toSymbolForCall(
         dispatchReceiver,
-        declarationStorage,
         preferGetter,
         explicitReceiver,
         isDelegate
     )
-    is FirClassifierSymbol<*> -> toSymbol(session, classifierStorage)
+    is FirClassifierSymbol<*> -> toSymbol()
     else -> error("Unknown symbol: $this")
 }
 
+context(Fir2IrComponents)
 fun FirReference.toSymbolForCall(
     dispatchReceiver: FirExpression,
-    session: FirSession,
-    classifierStorage: Fir2IrClassifierStorage,
-    declarationStorage: Fir2IrDeclarationStorage,
     conversionScope: Fir2IrConversionScope,
     preferGetter: Boolean = true,
     explicitReceiver: FirExpression? = null, // Actual only for callable references
@@ -186,9 +179,6 @@ fun FirReference.toSymbolForCall(
         is FirResolvedNamedReference ->
             resolvedSymbol.toSymbolForCall(
                 dispatchReceiver,
-                session,
-                classifierStorage,
-                declarationStorage,
                 preferGetter,
                 explicitReceiver,
                 isDelegate
@@ -196,9 +186,6 @@ fun FirReference.toSymbolForCall(
         is FirErrorNamedReference ->
             candidateSymbol?.toSymbolForCall(
                 dispatchReceiver,
-                session,
-                classifierStorage,
-                declarationStorage,
                 preferGetter,
                 explicitReceiver,
                 isDelegate
@@ -218,9 +205,9 @@ fun FirReference.toSymbolForCall(
     }
 }
 
+context(Fir2IrComponents)
 private fun FirCallableSymbol<*>.toSymbolForCall(
     dispatchReceiver: FirExpression,
-    declarationStorage: Fir2IrDeclarationStorage,
     preferGetter: Boolean,
     explicitReceiver: FirExpression? = null,
     isDelegate: Boolean = false
@@ -254,7 +241,7 @@ private fun FirCallableSymbol<*>.toSymbolForCall(
                             ?: throw AssertionError("Written synthetic property must have a setter")
                     }
                     delegateSymbol.unwrapCallRepresentative()
-                        .toSymbolForCall(dispatchReceiver, declarationStorage, preferGetter, isDelegate = false)
+                        .toSymbolForCall(dispatchReceiver, preferGetter, isDelegate = false)
                 } ?: declarationStorage.getIrPropertySymbol(this)
             }
         }
@@ -336,6 +323,7 @@ internal tailrec fun FirCallableSymbol<*>.unwrapSubstitutionAndIntersectionOverr
     return this
 }
 
+context(Fir2IrComponents)
 internal tailrec fun FirCallableSymbol<*>.unwrapCallRepresentative(root: FirCallableSymbol<*> = this): FirCallableSymbol<*> {
     val fir = fir
     if (fir is FirConstructor) {
@@ -363,10 +351,9 @@ internal tailrec fun FirCallableSymbol<*>.unwrapCallRepresentative(root: FirCall
     return overriddenSymbol.unwrapCallRepresentative(this)
 }
 
+context(Fir2IrComponents)
 internal fun FirSimpleFunction.processOverriddenFunctionSymbols(
     containingClass: FirClass,
-    session: FirSession,
-    scopeSession: ScopeSession,
     processor: (FirNamedFunctionSymbol) -> Unit
 ) {
     val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
@@ -381,17 +368,12 @@ internal fun FirSimpleFunction.processOverriddenFunctionSymbols(
     }
 }
 
-internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(
-    containingClass: FirClass,
-    session: FirSession,
-    scopeSession: ScopeSession,
-    declarationStorage: Fir2IrDeclarationStorage,
-    fakeOverrideGenerator: FakeOverrideGenerator,
-): List<IrSimpleFunctionSymbol> {
-    val superClasses = containingClass.getSuperTypesAsIrClasses(declarationStorage) ?: return emptyList()
+context(Fir2IrComponents)
+internal fun FirSimpleFunction.generateOverriddenFunctionSymbols(containingClass: FirClass): List<IrSimpleFunctionSymbol> {
+    val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList()
     val overriddenSet = mutableSetOf<IrSimpleFunctionSymbol>()
 
-    processOverriddenFunctionSymbols(containingClass, session, scopeSession) {
+    processOverriddenFunctionSymbols(containingClass) {
         for (overridden in fakeOverrideGenerator.getOverriddenSymbolsInSupertypes(it, superClasses)) {
             overriddenSet += overridden
         }
@@ -432,19 +414,17 @@ fun FirTypeScope.processOverriddenPropertiesFromSuperClasses(
         processor(unwrapped)
     }
 
-private fun FirClass.getSuperTypesAsIrClasses(
-    declarationStorage: Fir2IrDeclarationStorage
-): Set<IrClass>? {
+context(Fir2IrComponents)
+private fun FirClass.getSuperTypesAsIrClasses(): Set<IrClass>? {
     val irClass =
         declarationStorage.classifierStorage.getIrClassSymbol(symbol).owner as? IrClass ?: return null
 
     return irClass.superTypes.mapNotNull { it.classifierOrNull?.owner as? IrClass }.toSet()
 }
 
+context(Fir2IrComponents)
 internal fun FirProperty.processOverriddenPropertySymbols(
     containingClass: FirClass,
-    session: FirSession,
-    scopeSession: ScopeSession,
     processor: (FirPropertySymbol) -> Unit
 ): List<IrPropertySymbol> {
     val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
@@ -462,17 +442,12 @@ internal fun FirProperty.processOverriddenPropertySymbols(
     return overriddenSet.toList()
 }
 
-internal fun FirProperty.generateOverriddenPropertySymbols(
-    containingClass: FirClass,
-    session: FirSession,
-    scopeSession: ScopeSession,
-    declarationStorage: Fir2IrDeclarationStorage,
-    fakeOverrideGenerator: FakeOverrideGenerator,
-): List<IrPropertySymbol> {
-    val superClasses = containingClass.getSuperTypesAsIrClasses(declarationStorage) ?: return emptyList()
+context(Fir2IrComponents)
+internal fun FirProperty.generateOverriddenPropertySymbols(containingClass: FirClass): List<IrPropertySymbol> {
+    val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList()
     val overriddenSet = mutableSetOf<IrPropertySymbol>()
 
-    processOverriddenPropertySymbols(containingClass, session, scopeSession) {
+    processOverriddenPropertySymbols(containingClass) {
         for (overridden in fakeOverrideGenerator.getOverriddenSymbolsInSupertypes(it, superClasses)) {
             overriddenSet += overridden
         }
@@ -481,18 +456,12 @@ internal fun FirProperty.generateOverriddenPropertySymbols(
     return overriddenSet.toList()
 }
 
-internal fun FirProperty.generateOverriddenAccessorSymbols(
-    containingClass: FirClass,
-    isGetter: Boolean,
-    session: FirSession,
-    scopeSession: ScopeSession,
-    declarationStorage: Fir2IrDeclarationStorage,
-    fakeOverrideGenerator: FakeOverrideGenerator,
-): List<IrSimpleFunctionSymbol> {
+context(Fir2IrComponents)
+internal fun FirProperty.generateOverriddenAccessorSymbols(containingClass: FirClass, isGetter: Boolean): List<IrSimpleFunctionSymbol> {
     val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = true)
     scope.processPropertiesByName(name) {}
     val overriddenSet = mutableSetOf<IrSimpleFunctionSymbol>()
-    val superClasses = containingClass.getSuperTypesAsIrClasses(declarationStorage) ?: return emptyList()
+    val superClasses = containingClass.getSuperTypesAsIrClasses() ?: return emptyList()
 
     scope.processOverriddenPropertiesFromSuperClasses(symbol, containingClass) {
         if (it.fir.visibility == Visibilities.Private) {
@@ -548,8 +517,8 @@ internal fun FirReference.statementOrigin(): IrStatementOrigin? {
     }
 }
 
+context(Fir2IrComponents)
 internal fun IrDeclarationParent.declareThisReceiverParameter(
-    symbolTable: SymbolTable,
     thisType: IrType,
     thisOrigin: IrDeclarationOrigin,
     startOffset: Int = this.startOffset,
@@ -644,11 +613,11 @@ fun Fir2IrComponents.computeValueClassRepresentation(klass: FirRegularClass): Va
     }
 }
 
-fun FirRegularClass.getIrSymbolsForSealedSubclasses(components: Fir2IrComponents): List<IrClassSymbol> {
-    val session = components.session
+context(Fir2IrComponents)
+fun FirRegularClass.getIrSymbolsForSealedSubclasses(): List<IrClassSymbol> {
     val symbolProvider = session.symbolProvider
     return getSealedClassInheritors(session).mapNotNull {
-        symbolProvider.getClassLikeSymbolByClassId(it)?.toSymbol(session, components.classifierStorage)
+        symbolProvider.getClassLikeSymbolByClassId(it)?.toSymbol()
     }.filterIsInstance<IrClassSymbol>()
 }
 

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

@@ -53,7 +53,7 @@ class Fir2IrBuiltIns(
 
     private fun annotationSymbolById(id: ClassId): IrClassSymbol? =
         provider?.getClassSymbolById(id) ?: session.symbolProvider.getClassLikeSymbolByClassId(id)?.toSymbol(
-            session, classifierStorage, ConversionTypeContext.DEFAULT
+            ConversionTypeContext.DEFAULT
         ) as? IrClassSymbol
 
     private fun IrClassSymbol.toConstructorCall(): IrConstructorCallImpl =

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

@@ -86,7 +86,6 @@ class Fir2IrClassifierStorage(
             IrSimpleTypeImpl(getIrTypeParameterSymbol(it.symbol, ConversionTypeContext.DEFAULT), false, emptyList(), emptyList())
         }
         thisReceiver = declareThisReceiverParameter(
-            symbolTable,
             thisType = IrSimpleTypeImpl(symbol, false, typeArguments, emptyList()),
             thisOrigin = IrDeclarationOrigin.INSTANCE_RECEIVER
         )

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

@@ -365,7 +365,6 @@ class Fir2IrDeclarationStorage(
                             Name.identifier("\$this\$$suffix")
                         } ?: SpecialNames.THIS
                         declareThisReceiverParameter(
-                            symbolTable,
                             thisType = receiverTypeRef.toIrType(typeContext),
                             thisOrigin = thisOrigin,
                             startOffset = startOffset,
@@ -378,7 +377,6 @@ class Fir2IrDeclarationStorage(
                 val isLocal = function is FirSimpleFunction && function.isLocal
                 if (function !is FirAnonymousFunction && containingClass != null && !isStatic && !isLocal) {
                     dispatchReceiverParameter = declareThisReceiverParameter(
-                        symbolTable,
                         thisType = containingClass.thisReceiver?.type ?: error("No this receiver"),
                         thisOrigin = thisOrigin
                     )
@@ -388,7 +386,6 @@ class Fir2IrDeclarationStorage(
                 val outerClass = containingClass?.parentClassOrNull
                 if (containingClass?.isInner == true && outerClass != null) {
                     dispatchReceiverParameter = declareThisReceiverParameter(
-                        symbolTable,
                         thisType = outerClass.thisReceiver!!.type,
                         thisOrigin = thisOrigin
                     )
@@ -728,7 +725,7 @@ class Fir2IrDeclarationStorage(
                 }
                 if (correspondingProperty is Fir2IrLazyProperty && correspondingProperty.containingClass != null && !isFakeOverride && thisReceiverOwner != null) {
                     this.overriddenSymbols = correspondingProperty.fir.generateOverriddenAccessorSymbols(
-                        correspondingProperty.containingClass, !isSetter, session, scopeSession, declarationStorage, fakeOverrideGenerator
+                        correspondingProperty.containingClass, !isSetter
                     )
                 }
             }

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

@@ -114,7 +114,7 @@ class Fir2IrTypeConverter(
 
                 val irSymbol =
                     getBuiltInClassSymbol(classId)
-                        ?: lookupTag.toSymbol(session)?.toSymbol(session, classifierStorage, typeContext) {
+                        ?: lookupTag.toSymbol(session)?.toSymbol(typeContext) {
                             typeAnnotations += with(annotationGenerator) { it.toIrAnnotations() }
                         }
                         ?: (lookupTag as? ConeClassLikeLookupTag)?.let(classifierStorage::getIrClassSymbolForNotFoundClass)

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

@@ -164,7 +164,7 @@ class Fir2IrVisitor(
         }
         val irClass = classifierStorage.getCachedIrClass(regularClass)!!
         if (regularClass.isSealed) {
-            irClass.sealedSubclasses = regularClass.getIrSymbolsForSealedSubclasses(components)
+            irClass.sealedSubclasses = regularClass.getIrSymbolsForSealedSubclasses()
         }
         return conversionScope.withParent(irClass) {
             conversionScope.withContainingFirClass(regularClass) {

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

@@ -82,8 +82,10 @@ class CallAndReferenceGenerator(
         }
 
         val symbol = callableReferenceAccess.calleeReference.toSymbolForCall(
-            callableReferenceAccess.dispatchReceiver, session, classifierStorage, declarationStorage, conversionScope,
-            explicitReceiver = callableReferenceAccess.explicitReceiver, isDelegate = isDelegate
+            callableReferenceAccess.dispatchReceiver,
+            conversionScope,
+            explicitReceiver = callableReferenceAccess.explicitReceiver,
+            isDelegate = isDelegate
         )
         // val x by y ->
         //   val `x$delegate` = y
@@ -283,9 +285,6 @@ class CallAndReferenceGenerator(
             val calleeReference = qualifiedAccess.calleeReference
             val symbol = calleeReference.toSymbolForCall(
                 dispatchReceiver,
-                session,
-                classifierStorage,
-                declarationStorage,
                 conversionScope
             )
             return qualifiedAccess.convertWithOffsets { startOffset, endOffset ->
@@ -363,7 +362,7 @@ class CallAndReferenceGenerator(
             val type = irBuiltIns.unitType
             val calleeReference = variableAssignment.calleeReference
             val symbol = calleeReference.toSymbolForCall(
-                variableAssignment.dispatchReceiver, session, classifierStorage, declarationStorage, conversionScope, preferGetter = false
+                variableAssignment.dispatchReceiver, conversionScope, preferGetter = false
             )
             val origin = variableAssignment.getIrAssignmentOrigin()
             return variableAssignment.convertWithOffsets { startOffset, endOffset ->
@@ -530,7 +529,7 @@ class CallAndReferenceGenerator(
             if (classSymbol != null) {
                 IrGetObjectValueImpl(
                     startOffset, endOffset, irType,
-                    classSymbol.toSymbol(this.session, this.classifierStorage) as IrClassSymbol
+                    classSymbol.toSymbol() as IrClassSymbol
                 )
             } else {
                 IrErrorCallExpressionImpl(

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

@@ -195,9 +195,7 @@ internal class ClassMemberGenerator(
                 declarationStorage.leaveScope(irFunction)
             }
             if (irFunction is IrSimpleFunction && firFunction is FirSimpleFunction && containingClass != null) {
-                irFunction.overriddenSymbols = firFunction.generateOverriddenFunctionSymbols(
-                    containingClass, session, scopeSession, declarationStorage, fakeOverrideGenerator
-                )
+                irFunction.overriddenSymbols = firFunction.generateOverriddenFunctionSymbols(containingClass)
             }
         }
         return irFunction
@@ -209,9 +207,7 @@ internal class ClassMemberGenerator(
         val propertyType = property.returnTypeRef.toIrType()
         irProperty.initializeBackingField(property, initializerExpression = initializer ?: delegate)
         if (containingClass != null) {
-            irProperty.overriddenSymbols = property.generateOverriddenPropertySymbols(
-                containingClass, session, scopeSession, declarationStorage, fakeOverrideGenerator
-            )
+            irProperty.overriddenSymbols = property.generateOverriddenPropertySymbols(containingClass)
         }
         irProperty.getter?.setPropertyAccessorContent(
             property, property.getter, irProperty, propertyType,
@@ -310,9 +306,7 @@ internal class ClassMemberGenerator(
                 }
             }
             if (containingClass != null) {
-                this.overriddenSymbols = property.generateOverriddenAccessorSymbols(
-                    containingClass, isGetter, session, scopeSession, declarationStorage, fakeOverrideGenerator
-                )
+                this.overriddenSymbols = property.generateOverriddenAccessorSymbols(containingClass, isGetter)
             }
 
         }

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

@@ -57,7 +57,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING
  * fir own logic that traverses class hierarchies in fir elements. Also, this one creates and passes IR elements, instead of providing how
  * to declare them, to [DataClassMembersGenerator].
  */
-class DataClassMembersGenerator(val components: Fir2IrComponents) {
+class DataClassMembersGenerator(val components: Fir2IrComponents) : Fir2IrComponents by components {
 
     fun generateSingleFieldValueClassMembers(klass: FirClass, irClass: IrClass): List<FirDeclaration> =
         MyDataClassMethodsGenerator(irClass, klass.symbol.toLookupTag(), IrDeclarationOrigin.GENERATED_SINGLE_FIELD_VALUE_CLASS_MEMBER)
@@ -155,7 +155,6 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) {
 
         fun generateDispatchReceiverParameter(irFunction: IrFunction) =
             irFunction.declareThisReceiverParameter(
-                components.symbolTable,
                 irClass.defaultType,
                 origin,
                 UNDEFINED_OFFSET,

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

@@ -213,7 +213,7 @@ class DelegatedMemberGenerator(
         val baseSymbols = mutableListOf<FirNamedFunctionSymbol>()
         // the overridden symbols should be collected only after all fake overrides for all superclases are created and bound to their
         // overridden symbols, otherwise in some cases they will be left in inconsistent state leading to the errors in IR
-        delegateOverride.processOverriddenFunctionSymbols(firSubClass, session, scopeSession) {
+        delegateOverride.processOverriddenFunctionSymbols(firSubClass) {
             baseSymbols.add(it)
         }
         baseFunctionSymbols[delegateFunction] = baseSymbols
@@ -294,7 +294,7 @@ class DelegatedMemberGenerator(
         // the overridden symbols should be collected only after all fake overrides for all superclases are created and bound to their
         // overridden symbols, otherwise in some cases they will be left in inconsistent state leading to the errors in IR
         val baseSymbols = mutableListOf<FirPropertySymbol>()
-        firDelegateProperty.processOverriddenPropertySymbols(firSubClass, session, scopeSession) {
+        firDelegateProperty.processOverriddenPropertySymbols(firSubClass) {
             baseSymbols.add(it)
         }
         basePropertySymbols[delegateProperty] = baseSymbols
@@ -304,18 +304,14 @@ class DelegatedMemberGenerator(
         getter.overriddenSymbols =
             firDelegateProperty.generateOverriddenAccessorSymbols(
                 firSubClass,
-                isGetter = true,
-                session,
-                scopeSession,
-                declarationStorage,
-                fakeOverrideGenerator
+                isGetter = true
             )
         annotationGenerator.generate(getter, firDelegateProperty)
         if (delegateProperty.isVar) {
             val setter = delegateProperty.setter!!
             setter.overriddenSymbols =
                 firDelegateProperty.generateOverriddenAccessorSymbols(
-                    firSubClass, isGetter = false, session, scopeSession, declarationStorage, fakeOverrideGenerator
+                    firSubClass, isGetter = false
                 )
             annotationGenerator.generate(setter, firDelegateProperty)
         }
@@ -325,6 +321,8 @@ class DelegatedMemberGenerator(
 
     companion object {
         private val PLATFORM_DEPENDENT_CLASS_ID = ClassId.topLevel(FqName("kotlin.internal.PlatformDependent"))
+
+        context(Fir2IrComponents)
         private fun <S : FirCallableSymbol<D>, D : FirCallableDeclaration> S.unwrapDelegateTarget(
             subClassLookupTag: ConeClassLikeLookupTag,
             firField: FirField,

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

@@ -96,7 +96,7 @@ abstract class AbstractFir2IrLazyFunction<F : FirCallableDeclaration>(
 
     protected fun createThisReceiverParameter(thisType: IrType): IrValueParameter {
         declarationStorage.enterScope(this)
-        return declareThisReceiverParameter(symbolTable, thisType, origin).apply {
+        return declareThisReceiverParameter(thisType, origin).apply {
             declarationStorage.leaveScope(this@AbstractFir2IrLazyFunction)
         }
     }

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

@@ -110,7 +110,7 @@ class Fir2IrLazyClass(
 
     override var sealedSubclasses: List<IrClassSymbol> by lazyVar(lock) {
         if (fir.isSealed) {
-            fir.getIrSymbolsForSealedSubclasses(components)
+            fir.getIrSymbolsForSealedSubclasses()
         } else {
             emptyList()
         }
@@ -125,7 +125,6 @@ class Fir2IrLazyClass(
             )
         }
         val receiver = declareThisReceiverParameter(
-            symbolTable,
             thisType = IrSimpleTypeImpl(symbol, hasQuestionMark = false, arguments = typeArguments, annotations = emptyList()),
             thisOrigin = IrDeclarationOrigin.INSTANCE_RECEIVER
         )

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

@@ -86,7 +86,6 @@ class Fir2IrLazyConstructor(
         if (containingClass?.isInner == true && outerClass != null) {
             declarationStorage.enterScope(this)
             declareThisReceiverParameter(
-                symbolTable,
                 thisType = outerClass.thisReceiver!!.type,
                 thisOrigin = origin
             ).apply {

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

@@ -229,13 +229,7 @@ class Fir2IrLazyProperty(
 
     override var overriddenSymbols: List<IrPropertySymbol> by lazyVar(lock) {
         if (containingClass == null) return@lazyVar emptyList()
-        fir.generateOverriddenPropertySymbols(
-            containingClass,
-            session,
-            scopeSession,
-            declarationStorage,
-            fakeOverrideGenerator
-        )
+        fir.generateOverriddenPropertySymbols(containingClass)
     }
 
     override var metadata: MetadataSource?

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

@@ -106,14 +106,7 @@ class Fir2IrLazyPropertyAccessor(
 
     override var overriddenSymbols: List<IrSimpleFunctionSymbol> by lazyVar(lock) {
         if (firParentClass == null) return@lazyVar emptyList()
-        firParentProperty.generateOverriddenAccessorSymbols(
-            firParentClass,
-            !isSetter,
-            session,
-            scopeSession,
-            declarationStorage,
-            fakeOverrideGenerator
-        )
+        firParentProperty.generateOverriddenAccessorSymbols(firParentClass, !isSetter)
     }
 
     override val initialSignatureFunction: IrFunction? by lazy {

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

@@ -94,7 +94,7 @@ class Fir2IrLazySimpleFunction(
             )
             fakeOverrideGenerator.getOverriddenSymbolsForFakeOverride(this)?.let { return@lazyVar it }
         }
-        fir.generateOverriddenFunctionSymbols(firParent, session, scopeSession, declarationStorage, fakeOverrideGenerator)
+        fir.generateOverriddenFunctionSymbols(firParent)
     }
 
     override val initialSignatureFunction: IrFunction? by lazy {