[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
2023-09-18 13:38:24 +02:00
parent 9fd057d7c3
commit ed7e458828
14 changed files with 136 additions and 63 deletions
@@ -168,10 +168,9 @@ fun FirResult.convertToIrAndActualize(
                actualizerTypeContextProvider(fir2IrResult.irModuleFragment.irBuiltins),
                fir2IrConfiguration.languageVersionSettings,
                commonMemberStorage.symbolTable,
-                irMangler,
-                Fir2IrConverter.friendModulesMap(outputs.last().session),
+                fir2IrResult.components.irOverridingUtil,
                fir2IrConfiguration.useIrFakeOverrideBuilder,
-                fir2IrConfiguration.expectActualTracker
+                fir2IrConfiguration.expectActualTracker,
            )
        }
    }
@@ -191,5 +190,4 @@ fun IrPluginContext.applyIrGenerationExtensions(irModuleFragment: IrModuleFragme
    for (extension in irGenerationExtensions) {
        extension.generate(irModuleFragment, this)
    }
-}
-
+}
@@ -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
@@ -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))

@@ -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(
-                    commonMemberStorage.symbolTable,
-                    irMangler,
-                    typeContextProvider(components.irBuiltIns),
-                    irModuleFragment,
-                    friendModulesMap(session)
-                ).rebuildFakeOverrides()
+                FakeOverrideRebuilder(commonMemberStorage.symbolTable, components.irOverridingUtil).rebuildFakeOverrides(irModuleFragment)
            }

            return Fir2IrResult(irModuleFragment, components, moduleDescriptor)
@@ -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)
+    }
+}
@@ -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,
-    typeSystemContext: IrTypeSystemContext,
-    val irModule: IrModuleFragment,
-    // TODO: drop this argument in favor of using [IrModuleDescriptor::shouldSeeInternalsOf] in FakeOverrideBuilder KT-61384
-    friendModules: Map<String, List<String>>
+    val irOverridingUtil: IrOverridingUtil,
 ) {
    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
@@ -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,
-        // TODO: drop this argument in favor of using [IrModuleDescriptor::shouldSeeInternalsOf] in FakeOverrideBuilder KT-61384
-        friendModules: Map<String, List<String>>,
+        irOverridingUtil: IrOverridingUtil,
        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)
@@ -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.irMangler,
-                mapOf(module.name to module.friendDependencies.map { it.moduleName }),
+                inputArtifact.fir2IrComponents!!.symbolTable,
+                inputArtifact.fir2IrComponents!!.irOverridingUtil,
                useIrFakeOverrideBuilder = CodegenTestDirectives.ENABLE_IR_FAKE_OVERRIDE_GENERATION in module.directives,
                expectActualTracker = null,
            )
@@ -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()
 }
@@ -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)
        }
@@ -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})")
@@ -159,6 +159,7 @@ class Fir2IrJvmResultsConverter(
            descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
            irMangler = irMangler,
            firMangler = commonMemberStorage.firSignatureComposer.mangler,
+            fir2IrComponents = mainModuleComponents
        )

        return result
@@ -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})")
@@ -133,6 +133,7 @@ class ClassicFrontend2NativeIrConverter(
            descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler,
            irMangler = KonanManglerIr,
            firMangler = null,
+            fir2IrComponents = null,
        )
    }