[IR] Don't use linker fake override builder in Ir actualizer

Now, it uses fake override builder from in Fir2IrComponents.
It would also allow using it in lazy classes in the future.

^KT-61934

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt

@@ -168,10 +168,9 @@ fun FirResult.convertToIrAndActualize(
                 actualizerTypeContextProvider(fir2IrResult.irModuleFragment.irBuiltins),
                 fir2IrConfiguration.languageVersionSettings,
                 commonMemberStorage.symbolTable,
-                irMangler,
+                fir2IrResult.components.irOverridingUtil,
-                Fir2IrConverter.friendModulesMap(outputs.last().session),
                 fir2IrConfiguration.useIrFakeOverrideBuilder,
-                fir2IrConfiguration.expectActualTracker
+                fir2IrConfiguration.expectActualTracker,
             )
         }
     }
@@ -192,4 +191,3 @@ fun IrPluginContext.applyIrGenerationExtensions(irModuleFragment: IrModuleFragme
         extension.generate(irModuleFragment, this)
     }
 }
-

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.ir.IrLock
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.linkage.IrProvider
+import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
 import org.jetbrains.kotlin.ir.util.SymbolTable
 
 interface Fir2IrComponents {
@@ -42,6 +43,7 @@ interface Fir2IrComponents {
     val callGenerator: CallAndReferenceGenerator
     val fakeOverrideGenerator: FakeOverrideGenerator
     val delegatedMemberGenerator: DelegatedMemberGenerator
+    val irOverridingUtil: IrOverridingUtil
 
     val extensions: Fir2IrExtensions
     val configuration: Fir2IrConfiguration

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

@@ -10,9 +10,11 @@ import org.jetbrains.kotlin.fir.backend.generators.*
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrLock
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.linkage.IrProvider
+import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
 import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.ir.util.SymbolTable
 
@@ -23,6 +25,7 @@ class Fir2IrComponentsStorage(
     override val extensions: Fir2IrExtensions,
     override val configuration: Fir2IrConfiguration,
     override val visibilityConverter: Fir2IrVisibilityConverter,
+    irOverridingUtilProvider: (IrBuiltIns) -> IrOverridingUtil,
     moduleDescriptor: FirModuleDescriptor,
     commonMemberStorage: Fir2IrCommonMemberStorage,
     irMangler: KotlinMangler.IrMangler,
@@ -46,6 +49,7 @@ class Fir2IrComponentsStorage(
         this, configuration.languageVersionSettings, moduleDescriptor, irMangler
     )
     override val builtIns: Fir2IrBuiltIns = Fir2IrBuiltIns(this, specialSymbolProvider)
+    override val irOverridingUtil: IrOverridingUtil = irOverridingUtilProvider(irBuiltIns)
 
     override val irProviders: List<IrProvider> = listOf(FirIrProvider(this))
 

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.overrides.IrOverridingUtil
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.ir.symbols.impl.IrConstructorPublicSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionPublicSymbolImpl
@@ -556,6 +557,13 @@ class Fir2IrConverter(
             val moduleDescriptor = FirModuleDescriptor(session, kotlinBuiltIns)
             val components = Fir2IrComponentsStorage(
                 session, scopeSession, irFactory, fir2IrExtensions, fir2IrConfiguration, visibilityConverter,
+                { irBuiltins ->
+                    IrOverridingUtil(
+                        typeContextProvider(irBuiltins),
+                        Fir2IrFakeOverrideStrategy(friendModulesMap(session), commonMemberStorage.symbolTable, irMangler),
+                        externalOverridabilityConditions = emptyList(), // TODO: KT-61370, KT-61804.
+                    )
+                },
                 moduleDescriptor, commonMemberStorage, irMangler, specialSymbolProvider, initializedIrBuiltIns
             )
 
@@ -575,13 +583,7 @@ class Fir2IrConverter(
             )
 
             if (fir2IrConfiguration.useIrFakeOverrideBuilder) {
-                FakeOverrideRebuilder(
+                FakeOverrideRebuilder(commonMemberStorage.symbolTable, components.irOverridingUtil).rebuildFakeOverrides(irModuleFragment)
-                    commonMemberStorage.symbolTable,
-                    irMangler,
-                    typeContextProvider(components.irBuiltIns),
-                    irModuleFragment,
-                    friendModulesMap(session)
-                ).rebuildFakeOverrides()
             }
 
             return Fir2IrResult(irModuleFragment, components, moduleDescriptor)

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.backend
+
+import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
+import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.declarations.IrFunctionWithLateBinding
+import org.jetbrains.kotlin.ir.declarations.IrPropertyWithLateBinding
+import org.jetbrains.kotlin.ir.linkage.partial.IrUnimplementedOverridesStrategy.ProcessAsFakeOverrides
+import org.jetbrains.kotlin.ir.overrides.FakeOverrideBuilderStrategy
+import org.jetbrains.kotlin.ir.symbols.impl.IrPropertyPublicSymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionPublicSymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
+import org.jetbrains.kotlin.ir.util.KotlinMangler
+import org.jetbrains.kotlin.ir.util.SymbolTable
+
+
+internal class Fir2IrFakeOverrideStrategy(
+    friendModules: Map<String, List<String>>,
+    val symbolTable: SymbolTable,
+    val mangler: KotlinMangler.IrMangler
+) : FakeOverrideBuilderStrategy(
+    friendModules = friendModules,
+    unimplementedOverridesStrategy = ProcessAsFakeOverrides
+) {
+    private val publicIdSignatureComputer = PublicIdSignatureComputer(mangler)
+    override fun linkFunctionFakeOverride(function: IrFunctionWithLateBinding, manglerCompatibleMode: Boolean) {
+        with(mangler) {
+            if (function.isExported(manglerCompatibleMode)) {
+                val signature = publicIdSignatureComputer.composePublicIdSignature(function, manglerCompatibleMode)
+                symbolTable.declareSimpleFunction(
+                    signature,
+                    { IrSimpleFunctionPublicSymbolImpl(signature, descriptor = null) },
+                    { function.acquireSymbol(it) }
+                )
+            } else {
+                function.acquireSymbol(IrSimpleFunctionSymbolImpl())
+            }
+        }
+    }
+
+    override fun linkPropertyFakeOverride(property: IrPropertyWithLateBinding, manglerCompatibleMode: Boolean) {
+        with(mangler) {
+            if (property.isExported(manglerCompatibleMode)) {
+                // The signature composer expects getter/setter correspondingPropertySymbol to be set correctly.
+                // But we don't have any property symbol for now. To work around this problem, we are creating a temporary one,
+                // and throw it away after computing signature.
+                val tempSymbol = IrPropertySymbolImpl(null).apply { bind(property) }
+                property.getter?.let { it.correspondingPropertySymbol = tempSymbol }
+                property.setter?.let { it.correspondingPropertySymbol = tempSymbol }
+                val signature = publicIdSignatureComputer.composePublicIdSignature(property, manglerCompatibleMode)
+                property.getter?.let { it.correspondingPropertySymbol = null }
+                property.setter?.let { it.correspondingPropertySymbol = null }
+                symbolTable.declareProperty(
+                    signature,
+                    { IrPropertyPublicSymbolImpl(signature, descriptor = null) },
+                    { property.acquireSymbol(it) }
+                )
+            } else {
+                property.acquireSymbol(IrPropertySymbolImpl())
+            }
+        }
+
+        property.getter?.let {
+            it.correspondingPropertySymbol = property.symbol
+            linkFunctionFakeOverride(
+                it as? IrFunctionWithLateBinding ?: error("Unexpected fake override getter: $it"),
+                manglerCompatibleMode
+            )
+        }
+        property.setter?.let {
+            it.correspondingPropertySymbol = property.symbol
+            linkFunctionFakeOverride(
+                it as? IrFunctionWithLateBinding ?: error("Unexpected fake override setter: $it"),
+                manglerCompatibleMode
+            )
+        }
+    }
+
+    override fun inFile(file: IrFile?, block: () -> Unit) {
+        publicIdSignatureComputer.inFile(file?.symbol, block)
+    }
+}

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/FakeOverrideRebuilder.kt

@@ -5,10 +5,6 @@
 
 package org.jetbrains.kotlin.backend.common.actualizer
 
-import org.jetbrains.kotlin.backend.common.linkage.partial.PartialLinkageSupportForLinker
-import org.jetbrains.kotlin.backend.common.overrides.FileLocalAwareLinker
-import org.jetbrains.kotlin.backend.common.overrides.IrLinkerFakeOverrideProvider
-import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyDeclarationBase
@@ -16,13 +12,11 @@ import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
 import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
+import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 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.impl.IrPropertySymbolImpl
-import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
-import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.ir.types.getClass
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
@@ -58,11 +52,7 @@ import org.jetbrains.kotlin.utils.newHashSetWithExpectedSize
  */
 class FakeOverrideRebuilder(
     val symbolTable: SymbolTable,
-    val mangler: KotlinMangler.IrMangler,
+    val irOverridingUtil: IrOverridingUtil,
-    typeSystemContext: IrTypeSystemContext,
-    val irModule: IrModuleFragment,
-    // TODO: drop this argument in favor of using [IrModuleDescriptor::shouldSeeInternalsOf] in FakeOverrideBuilder KT-61384
-    friendModules: Map<String, List<String>>
 ) {
     private val removedFakeOverrides = mutableMapOf<IrClassSymbol, List<IrSymbol>>()
     private val processedClasses = hashSetOf<IrClass>()
@@ -70,17 +60,8 @@ class FakeOverrideRebuilder(
     // Map from the old fake override symbol to the new (rebuilt) symbol.
     private val fakeOverrideMap = hashMapOf<IrSymbol, IrSymbol>()
 
-    private val fakeOverrideBuilder = IrLinkerFakeOverrideProvider(
-        LocalFakeOverridesStorage(),
-        symbolTable,
-        mangler,
-        typeSystemContext,
-        friendModules,
-        PartialLinkageSupportForLinker.DISABLED,
-        externalOverridabilityConditions = emptyList(), // TODO: KT-61370, KT-61804.
-    )
 
-    fun rebuildFakeOverrides() {
+    fun rebuildFakeOverrides(irModule: IrModuleFragment) {
         irModule.acceptVoid(RemoveFakeOverridesVisitor(removedFakeOverrides, symbolTable))
         for (clazz in removedFakeOverrides.keys) {
             rebuildClassFakeOverrides(clazz.owner)
@@ -134,7 +115,7 @@ class FakeOverrideRebuilder(
         for (c in irClass.superTypes) {
             c.getClass()?.let { rebuildClassFakeOverrides(it) }
         }
-        fakeOverrideBuilder.buildFakeOverridesForSingleClass(irClass, CompatibilityMode.CURRENT)
+        irOverridingUtil.buildFakeOverridesForClass(irClass, false)
 
         val overriddenMap = mutableMapOf<IrSymbol, IrSymbol>()
 
@@ -170,27 +151,6 @@ class FakeOverrideRebuilder(
     }
 }
 
-private class LocalFakeOverridesStorage : FileLocalAwareLinker {
-    val funStorage = mutableMapOf<Pair<IrDeclaration, IdSignature>, IrSimpleFunctionSymbolImpl>()
-    val propertyStorage = mutableMapOf<Pair<IrDeclaration, IdSignature>, IrPropertySymbol>()
-    override fun tryReferencingSimpleFunctionByLocalSignature(
-        parent: IrDeclaration,
-        idSignature: IdSignature,
-    ): IrSimpleFunctionSymbol? {
-        if (idSignature.isPubliclyVisible) return null
-        return funStorage.getOrPut(parent to idSignature) {
-            IrSimpleFunctionSymbolImpl()
-        }
-    }
-
-    override fun tryReferencingPropertyByLocalSignature(parent: IrDeclaration, idSignature: IdSignature): IrPropertySymbol? {
-        if (idSignature.isPubliclyVisible) return null
-        return propertyStorage.getOrPut(parent to idSignature) {
-            IrPropertySymbolImpl()
-        }
-    }
-}
-
 private class RemoveFakeOverridesVisitor(
     val removedOverrides: MutableMap<IrClassSymbol, List<IrSymbol>>,
     val symbolTable: SymbolTable

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.ir.util.*
@@ -26,9 +27,7 @@ object IrActualizer {
         typeSystemContext: IrTypeSystemContext,
         languageVersionSettings: LanguageVersionSettings,
         symbolTable: SymbolTable,
-        mangler: KotlinMangler.IrMangler,
+        irOverridingUtil: IrOverridingUtil,
-        // TODO: drop this argument in favor of using [IrModuleDescriptor::shouldSeeInternalsOf] in FakeOverrideBuilder KT-61384
-        friendModules: Map<String, List<String>>,
         useIrFakeOverrideBuilder: Boolean,
         expectActualTracker: ExpectActualTracker?
     ): IrActualizedResult {
@@ -80,7 +79,7 @@ object IrActualizer {
 
         if (useIrFakeOverrideBuilder) {
             //   8. Rebuild fake overrides from stretch, as they could become invalid during actualization
-            FakeOverrideRebuilder(symbolTable, mangler, typeSystemContext, mainFragment, friendModules).rebuildFakeOverrides()
+            FakeOverrideRebuilder(symbolTable, irOverridingUtil).rebuildFakeOverrides(mainFragment)
         }
 
         return IrActualizedResult(removedExpectDeclarations)

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrActualizerAndPluginsFacade.kt

@@ -36,9 +36,8 @@ class IrActualizerAndPluginsFacade(
                 inputArtifact.diagnosticReporter,
                 typeSystemContext,
                 testServices.compilerConfigurationProvider.getCompilerConfiguration(module).languageVersionSettings,
-                inputArtifact.irPluginContext.symbolTable as SymbolTable, // TODO: it's strange place to get it.
+                inputArtifact.fir2IrComponents!!.symbolTable,
-                inputArtifact.irMangler,
+                inputArtifact.fir2IrComponents!!.irOverridingUtil,
-                mapOf(module.name to module.friendDependencies.map { it.moduleName }),
                 useIrFakeOverrideBuilder = CodegenTestDirectives.ENABLE_IR_FAKE_OVERRIDE_GENERATION in module.directives,
                 expectActualTracker = null,
             )

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.FirMangler
 import org.jetbrains.kotlin.ir.backend.js.KotlinFileSerializedData
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -66,6 +67,11 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
      */
     abstract val firMangler: FirMangler?
 
+    /**
+     * Instance of fir2IrComponents that generated by Fir2Ir or null if this artifact was compiled using the classic frontend.
+     */
+    abstract val fir2IrComponents: Fir2IrComponents?
+
     /**
      * Results of actualization, came from IrActulizer
      *
@@ -87,6 +93,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         override val descriptorMangler: KotlinMangler.DescriptorMangler,
         override val irMangler: KotlinMangler.IrMangler,
         override val firMangler: FirMangler?,
+        override val fir2IrComponents: Fir2IrComponents?,
         override var irActualizerResult: IrActualizedResult? = null,
         val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment,
     ) : IrBackendInput()
@@ -99,6 +106,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         override val descriptorMangler: KotlinMangler.DescriptorMangler,
         override val irMangler: KotlinMangler.IrMangler,
         override val firMangler: FirMangler?,
+        override val fir2IrComponents: Fir2IrComponents?
     ) : IrBackendInput() {
 
         override val kind: BackendKind<IrBackendInput>
@@ -119,6 +127,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         override val irMangler: KotlinMangler.IrMangler,
         override val firMangler: FirMangler?,
         override var irActualizerResult: IrActualizedResult? = null,
+        override val fir2IrComponents: Fir2IrComponents?,
         val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment,
     ) : IrBackendInput()
 
@@ -132,6 +141,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         override val irMangler: KotlinMangler.IrMangler,
         override val firMangler: FirMangler?,
         override var irActualizerResult: IrActualizedResult? = null,
+        override val fir2IrComponents: Fir2IrComponents?,
     ) : IrBackendInput() {
         override val irModuleFragment: IrModuleFragment
             get() = backendInput.irModuleFragment
@@ -155,5 +165,6 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         override val irMangler: KotlinMangler.IrMangler,
         override val firMangler: FirMangler?,
         override var irActualizerResult: IrActualizedResult? = null,
+        override val fir2IrComponents: Fir2IrComponents?
     ) : IrBackendInput()
 }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt

@@ -79,6 +79,7 @@ class ClassicFrontend2IrConverter(
             descriptorMangler = conversionResult.symbolTable.signaturer.mangler,
             irMangler = JvmIrMangler,
             firMangler = null,
+            fir2IrComponents = null,
         )
     }
 
@@ -119,6 +120,7 @@ class ClassicFrontend2IrConverter(
             descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler,
             irMangler = JsManglerIr,
             firMangler = null,
+            fir2IrComponents = null,
         ) { file, _ ->
             metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor)
         }
@@ -162,6 +164,7 @@ class ClassicFrontend2IrConverter(
             descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler,
             irMangler = JsManglerIr,
             firMangler = null,
+            fir2IrComponents = null,
         ) { file, _ ->
             metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor)
         }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt

@@ -76,6 +76,7 @@ class Fir2IrJsResultsConverter(
         val sourceFiles = mutableListOf<KtSourceFile>()
         val firFilesAndComponentsBySourceFile = mutableMapOf<KtSourceFile, Pair<FirFile, Fir2IrComponents>>()
         lateinit var mainPluginContext: IrPluginContext
+        lateinit var mainComponents: Fir2IrComponents
         var irBuiltIns: IrBuiltInsOverFir? = null
 
         val commonMemberStorage = Fir2IrCommonMemberStorage(IdSignatureDescriptor(JsManglerDesc), FirJsKotlinMangler())
@@ -100,6 +101,7 @@ class Fir2IrJsResultsConverter(
                 dependentIrParts.add(irModuleFragment)
             } else {
                 mainIrPart = irModuleFragment
+                mainComponents = components
             }
 
             sourceFiles.addAll(part.firFiles.mapNotNull { it.value.sourceFile })
@@ -124,6 +126,7 @@ class Fir2IrJsResultsConverter(
             descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
             irMangler = irMangler,
             firMangler = commonMemberStorage.firSignatureComposer.mangler,
+            fir2IrComponents = mainComponents
         ) { file, irActualizedResult ->
             val (firFile, components) = firFilesAndComponentsBySourceFile[file]
                 ?: error("cannot find FIR file by source file ${file.name} (${file.path})")

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJvmResultsConverter.kt

@@ -159,6 +159,7 @@ class Fir2IrJvmResultsConverter(
             descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
             irMangler = irMangler,
             firMangler = commonMemberStorage.firSignatureComposer.mangler,
+            fir2IrComponents = mainModuleComponents
         )
 
         return result

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt

@@ -79,6 +79,7 @@ class Fir2IrWasmResultsConverter(
         val sourceFiles = mutableListOf<KtSourceFile>()
         val firFilesAndComponentsBySourceFile = mutableMapOf<KtSourceFile, Pair<FirFile, Fir2IrComponents>>()
         lateinit var mainPluginContext: IrPluginContext
+        lateinit var mainComponents: Fir2IrComponents
         var irBuiltIns: IrBuiltInsOverFir? = null
 
         val commonMemberStorage = Fir2IrCommonMemberStorage(IdSignatureDescriptor(JsManglerDesc), FirJsKotlinMangler())
@@ -101,6 +102,7 @@ class Fir2IrWasmResultsConverter(
                 dependentIrParts.add(irModuleFragment)
             } else {
                 mainIrPart = irModuleFragment
+                mainComponents = components
             }
 
             sourceFiles.addAll(part.firFiles.mapNotNull { it.value.sourceFile })
@@ -125,6 +127,7 @@ class Fir2IrWasmResultsConverter(
             descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
             irMangler = JsManglerIr,
             firMangler = commonMemberStorage.firSignatureComposer.mangler,
+            fir2IrComponents = mainComponents,
         ) { file, irActualizedResult ->
             val (firFile, components) = firFilesAndComponentsBySourceFile[file]
                 ?: error("cannot find FIR file by source file ${file.name} (${file.path})")

native/native.tests/tests/org/jetbrains/kotlin/konan/test/ClassicFrontend2NativeIrConverter.kt

@@ -133,6 +133,7 @@ class ClassicFrontend2NativeIrConverter(
             descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler,
             irMangler = KonanManglerIr,
             firMangler = null,
+            fir2IrComponents = null,
         )
     }