[FIR2IR] Make convertAndActualize method the only entrypoint to fir2ir

Fir2Ir conversion consists of multiple steps with complex logic (like
  conversion of each module, actualization, plugins application, constant
  evaluation), and to ensure that they all are executed correctly it's
  convenient to have the single entry point for all this machinery

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

@@ -73,7 +73,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         override val descriptorMangler: KotlinMangler.DescriptorMangler,
         override val irMangler: KotlinMangler.IrMangler,
         override val firMangler: FirMangler?,
-        val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment,
+        val serializeSingleFile: (KtSourceFile) -> ProtoBuf.PackageFragment,
     ) : IrBackendInput()
 
     data class JsIrDeserializedFromKlibBackendInput(
@@ -99,7 +99,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         override val descriptorMangler: KotlinMangler.DescriptorMangler,
         override val irMangler: KotlinMangler.IrMangler,
         override val firMangler: FirMangler?,
-        val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment,
+        val serializeSingleFile: (KtSourceFile) -> ProtoBuf.PackageFragment,
     ) : IrBackendInput()
 
     class JvmIrBackendInput(

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

@@ -117,7 +117,7 @@ class ClassicFrontend2IrConverter(
             descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler,
             irMangler = JsManglerIr,
             firMangler = null,
-        ) { file, _ ->
+        ) { file ->
             metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor)
         }
     }
@@ -159,7 +159,7 @@ class ClassicFrontend2IrConverter(
             descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler,
             irMangler = JsManglerIr,
             firMangler = null,
-        ) { file, _ ->
+        ) { file ->
             metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor)
         }
     }

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

@@ -6,22 +6,24 @@
 package org.jetbrains.kotlin.test.frontend.fir
 
 import org.jetbrains.kotlin.KtSourceFile
-import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
+import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.constant.EvaluatedConstTracker
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.backend.js.FirJsKotlinMangler
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
+import org.jetbrains.kotlin.fir.pipeline.FirResult
 import org.jetbrains.kotlin.fir.pipeline.ModuleCompilerAnalyzedOutput
+import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
 import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension
 import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -30,7 +32,6 @@ import org.jetbrains.kotlin.ir.backend.js.getSerializedData
 import org.jetbrains.kotlin.ir.backend.js.incrementalDataProvider
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
 import org.jetbrains.kotlin.library.unresolvedDependencies
@@ -70,65 +71,62 @@ class Fir2IrJsResultsConverter(
         inputArtifact: FirOutputArtifact
     ): IrBackendInput {
         val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module)
-
-        lateinit var mainIrPart: IrModuleFragment
-        val dependentIrParts = mutableListOf<IrModuleFragment>()
         val sourceFiles = mutableListOf<KtSourceFile>()
         val firFilesAndComponentsBySourceFile = mutableMapOf<KtSourceFile, Pair<FirFile, Fir2IrComponents>>()
-        lateinit var mainPluginContext: IrPluginContext
-        var irBuiltIns: IrBuiltInsOverFir? = null
-
-        val commonMemberStorage = Fir2IrCommonMemberStorage(IdSignatureDescriptor(JsManglerDesc), FirJsKotlinMangler())
 
         val irMangler = JsManglerIr
         val diagnosticReporter = DiagnosticReporterFactory.createReporter()
 
-        for ((index, part) in inputArtifact.partsForDependsOnModules.withIndex()) {
-            val (irModuleFragment, components, pluginContext) =
-                part.firAnalyzerFacade.result.outputs.single().convertToJsIr(
-                    testServices,
-                    module,
-                    configuration,
-                    diagnosticReporter,
-                    commonMemberStorage,
-                    irBuiltIns,
-                )
-            irBuiltIns = components.irBuiltIns
-            mainPluginContext = pluginContext
+        val libraries = resolveLibraries(configuration, getAllJsDependenciesPaths(module, testServices))
+        val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices)
 
-            if (index < inputArtifact.partsForDependsOnModules.size - 1) {
-                dependentIrParts.add(irModuleFragment)
-            } else {
-                mainIrPart = irModuleFragment
-            }
-
-            sourceFiles.addAll(part.firFiles.mapNotNull { it.value.sourceFile })
-
-            for (firFile in part.firFiles.values) {
-                firFilesAndComponentsBySourceFile[firFile.sourceFile!!] = firFile to components
+        val fir2IrConfiguration = Fir2IrConfiguration(
+            languageVersionSettings = configuration.languageVersionSettings,
+            diagnosticReporter = diagnosticReporter,
+            linkViaSignatures = true,
+            evaluatedConstTracker = configuration
+                .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
+            inlineConstTracker = null,
+            expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
+            allowNonCachedDeclarations = false,
+            useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr()
+        )
+
+        val fir2irResult = inputArtifact.toFirResult().convertToIrAndActualize(
+            Fir2IrExtensions.Default,
+            fir2IrConfiguration,
+            module.irGenerationExtensions(testServices),
+            IdSignatureDescriptor(JsManglerDesc),
+            JsManglerIr,
+            FirJsKotlinMangler(),
+            Fir2IrVisibilityConverter.Default,
+            builtIns ?: DefaultBuiltIns.Instance, // TODO: consider passing externally,
+            ::IrTypeSystemContextImpl
+        ) { firPart, irPart ->
+            sourceFiles.addAll(firPart.fir.mapNotNull { it.sourceFile })
+            for (firFile in firPart.fir) {
+                firFilesAndComponentsBySourceFile[firFile.sourceFile!!] = firFile to irPart.components
             }
+        }.also {
+            (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = dependencies }
         }
 
         val metadataVersion = configuration.metadataVersion(module.languageVersionSettings.languageVersion)
 
-        var actualizedExpectDeclarations: Set<FirDeclaration>? = null
-
-        val result = IrBackendInput.JsIrBackendInput(
-            mainIrPart,
-            mainPluginContext,
+        return IrBackendInput.JsIrBackendInput(
+            fir2irResult.irModuleFragment,
+            fir2irResult.pluginContext,
             sourceFiles,
             configuration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList(),
             diagnosticReporter = diagnosticReporter,
             hasErrors = inputArtifact.hasErrors,
-            descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
+            descriptorMangler = fir2irResult.components.symbolTable.signaturer.mangler,
             irMangler = irMangler,
-            firMangler = commonMemberStorage.firSignatureComposer.mangler,
-        ) { file, irActualizedResult ->
+            firMangler = fir2irResult.components.signatureComposer.mangler,
+        ) { file ->
             val (firFile, components) = firFilesAndComponentsBySourceFile[file]
                 ?: error("cannot find FIR file by source file ${file.name} (${file.path})")
-            if (actualizedExpectDeclarations == null && irActualizedResult != null) {
-                actualizedExpectDeclarations = irActualizedResult.actualizedExpectDeclarations.extractFirDeclarations()
-            }
+            val actualizedExpectDeclarations = fir2irResult.irActualizedResult?.actualizedExpectDeclarations?.extractFirDeclarations()
             serializeSingleFirFile(
                 firFile,
                 components.session,
@@ -143,45 +141,6 @@ class Fir2IrJsResultsConverter(
                 configuration.languageVersionSettings,
             )
         }
-        return result
-    }
-}
-
-fun ModuleCompilerAnalyzedOutput.convertToJsIr(
-    testServices: TestServices,
-    module: TestModule,
-    configuration: CompilerConfiguration,
-    diagnosticReporter: DiagnosticReporter,
-    commonMemberStorage: Fir2IrCommonMemberStorage,
-    irBuiltIns: IrBuiltInsOverFir?
-): Fir2IrResult {
-    // TODO: consider avoiding repeated libraries resolution
-    val libraries = resolveLibraries(configuration, getAllJsDependenciesPaths(module, testServices))
-    val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices)
-
-    val fir2IrConfiguration = Fir2IrConfiguration(
-        languageVersionSettings = configuration.languageVersionSettings,
-        diagnosticReporter = diagnosticReporter,
-        linkViaSignatures = true,
-        evaluatedConstTracker = configuration
-            .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
-        inlineConstTracker = null,
-        expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
-        allowNonCachedDeclarations = false,
-        useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr()
-    )
-
-    return convertToIr(
-        Fir2IrExtensions.Default,
-        fir2IrConfiguration,
-        commonMemberStorage,
-        irBuiltIns,
-        JsManglerIr,
-        Fir2IrVisibilityConverter.Default,
-        builtIns ?: DefaultBuiltIns.Instance, // TODO: consider passing externally,
-        ::IrTypeSystemContextImpl
-    ).also {
-        (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = dependencies }
     }
 }
 
@@ -216,3 +175,14 @@ private fun loadResolvedLibraries(
         }
     } to builtInsModule
 }
+
+fun TestModule.irGenerationExtensions(testServices: TestServices): Collection<IrGenerationExtension> {
+    return IrGenerationExtension.getInstances(testServices.compilerConfigurationProvider.getProject(this))
+}
+
+fun FirOutputArtifact.toFirResult(): FirResult {
+    val outputs = partsForDependsOnModules.map {
+        ModuleCompilerAnalyzedOutput(it.session, it.firAnalyzerFacade.scopeSession, it.firFiles.values.toList())
+    }
+    return FirResult(outputs)
+}

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

@@ -20,14 +20,12 @@ import org.jetbrains.kotlin.constant.EvaluatedConstTracker
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.backend.Fir2IrCommonMemberStorage
-import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.Fir2IrConfiguration
-import org.jetbrains.kotlin.fir.backend.IrBuiltInsOverFir
 import org.jetbrains.kotlin.fir.backend.jvm.*
+import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
 import org.jetbrains.kotlin.fir.pipeline.signatureComposerForJvmFir2Ir
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
@@ -86,57 +84,46 @@ class Fir2IrJvmResultsConverter(
 
         val phaseConfig = configuration.get(CLIConfigurationKeys.PHASE_CONFIG)
 
-        val dependentIrParts = mutableListOf<IrModuleFragment>()
-        lateinit var backendInput: JvmIrCodegenFactory.JvmIrBackendInput
-        lateinit var mainModuleComponents: Fir2IrComponents
-
         val generateSignatures = compilerConfigurationProvider.getCompilerConfiguration(module)
             .getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES)
         val commonMemberStorage = Fir2IrCommonMemberStorage(signatureComposerForJvmFir2Ir(generateSignatures), FirJvmKotlinMangler())
-        var irBuiltIns: IrBuiltInsOverFir? = null
         val diagnosticReporter = DiagnosticReporterFactory.createReporter()
 
-        for ((index, firOutputPart) in inputArtifact.partsForDependsOnModules.withIndex()) {
-            val compilerConfiguration = compilerConfigurationProvider.getCompilerConfiguration(module)
-            val fir2IrConfiguration = Fir2IrConfiguration(
-                languageVersionSettings = module.languageVersionSettings,
-                diagnosticReporter = diagnosticReporter,
-                linkViaSignatures = compilerConfiguration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES),
-                evaluatedConstTracker = compilerConfiguration
-                    .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
-                inlineConstTracker = compilerConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
-                expectActualTracker = compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
-                allowNonCachedDeclarations = false,
-                useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(),
-            )
-            val (irModuleFragment, components, pluginContext) = firOutputPart.firAnalyzerFacade.result.outputs.single().convertToIr(
-                fir2IrExtensions,
-                fir2IrConfiguration,
-                commonMemberStorage,
-                irBuiltIns,
-                irMangler,
-                FirJvmVisibilityConverter,
-                DefaultBuiltIns.Instance,
-                typeContextProvider = ::JvmIrTypeSystemContext,
-            )
-            irBuiltIns = components.irBuiltIns
+        val compilerConfiguration = compilerConfigurationProvider.getCompilerConfiguration(module)
+        val fir2IrConfiguration = Fir2IrConfiguration(
+            languageVersionSettings = module.languageVersionSettings,
+            diagnosticReporter = diagnosticReporter,
+            linkViaSignatures = compilerConfiguration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES),
+            evaluatedConstTracker = compilerConfiguration
+                .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
+            inlineConstTracker = compilerConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+            expectActualTracker = compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
+            allowNonCachedDeclarations = false,
+            useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(),
+        )
 
-            if (index < inputArtifact.partsForDependsOnModules.size - 1) {
-                dependentIrParts.add(irModuleFragment)
-            } else {
-                mainModuleComponents = components
-                backendInput = JvmIrCodegenFactory.JvmIrBackendInput(
-                    irModuleFragment,
-                    components.symbolTable,
-                    phaseConfig,
-                    components.irProviders,
-                    fir2IrExtensions,
-                    FirJvmBackendExtension(components, actualizedExpectDeclarations = null),
-                    pluginContext,
-                    notifyCodegenStart = {},
-                )
-            }
-        }
+        val fir2irResult = inputArtifact.toFirResult().convertToIrAndActualize(
+            fir2IrExtensions,
+            fir2IrConfiguration,
+            module.irGenerationExtensions(testServices),
+            signatureComposerForJvmFir2Ir(generateSignatures),
+            irMangler,
+            FirJvmKotlinMangler(),
+            FirJvmVisibilityConverter,
+            DefaultBuiltIns.Instance,
+            ::JvmIrTypeSystemContext
+        )
+
+        val backendInput = JvmIrCodegenFactory.JvmIrBackendInput(
+            fir2irResult.irModuleFragment,
+            fir2irResult.components.symbolTable,
+            phaseConfig,
+            fir2irResult.components.irProviders,
+            fir2IrExtensions,
+            FirJvmBackendExtension(fir2irResult.components, actualizedExpectDeclarations = null),
+            fir2irResult.pluginContext,
+            notifyCodegenStart = {},
+        )
 
         val codegenFactory = JvmIrCodegenFactory(configuration, phaseConfig)
         val generationState = GenerationState.Builder(
@@ -145,12 +132,12 @@ class Fir2IrJvmResultsConverter(
         ).isIrBackend(
             true
         ).jvmBackendClassResolver(
-            FirJvmBackendClassResolver(mainModuleComponents)
+            FirJvmBackendClassResolver(fir2irResult.components)
         ).diagnosticReporter(
             diagnosticReporter
         ).build()
 
-        val result = IrBackendInput.JvmIrBackendInput(
+        return IrBackendInput.JvmIrBackendInput(
             generationState,
             codegenFactory,
             backendInput,
@@ -159,7 +146,5 @@ class Fir2IrJvmResultsConverter(
             irMangler = irMangler,
             firMangler = commonMemberStorage.firSignatureComposer.mangler,
         )
-
-        return result
     }
 }

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

@@ -6,25 +6,21 @@
 package org.jetbrains.kotlin.test.frontend.fir
 
 import org.jetbrains.kotlin.KtSourceFile
-import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.constant.EvaluatedConstTracker
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.backend.js.FirJsKotlinMangler
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
-import org.jetbrains.kotlin.fir.pipeline.ModuleCompilerAnalyzedOutput
+import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
 import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension
 import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile
 import org.jetbrains.kotlin.incremental.components.LookupTracker
@@ -33,7 +29,6 @@ import org.jetbrains.kotlin.ir.backend.js.getSerializedData
 import org.jetbrains.kotlin.ir.backend.js.incrementalDataProvider
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
 import org.jetbrains.kotlin.library.unresolvedDependencies
@@ -74,49 +69,53 @@ class Fir2IrWasmResultsConverter(
     ): IrBackendInput {
         val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module)
 
-        lateinit var mainIrPart: IrModuleFragment
-        val dependentIrParts = mutableListOf<IrModuleFragment>()
         val sourceFiles = mutableListOf<KtSourceFile>()
         val firFilesAndComponentsBySourceFile = mutableMapOf<KtSourceFile, Pair<FirFile, Fir2IrComponents>>()
-        lateinit var mainPluginContext: IrPluginContext
-        var irBuiltIns: IrBuiltInsOverFir? = null
 
-        val commonMemberStorage = Fir2IrCommonMemberStorage(IdSignatureDescriptor(JsManglerDesc), FirJsKotlinMangler())
         val diagnosticReporter = DiagnosticReporterFactory.createReporter()
 
-        for ((index, part) in inputArtifact.partsForDependsOnModules.withIndex()) {
-            val (irModuleFragment, components, pluginContext) =
-                part.firAnalyzerFacade.result.outputs.single().convertToWasmIr(
-                    testServices,
-                    module,
-                    configuration,
-                    diagnosticReporter,
-                    commonMemberStorage,
-                    irBuiltIns,
-                )
-            irBuiltIns = components.irBuiltIns
-            mainPluginContext = pluginContext
+        // TODO: consider avoiding repeated libraries resolution
+        val libraries = resolveWasmLibraries(module, testServices, configuration)
+        val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices)
 
-            if (index < inputArtifact.partsForDependsOnModules.size - 1) {
-                dependentIrParts.add(irModuleFragment)
-            } else {
-                mainIrPart = irModuleFragment
-            }
-
-            sourceFiles.addAll(part.firFiles.mapNotNull { it.value.sourceFile })
-
-            for (firFile in part.firFiles.values) {
-                firFilesAndComponentsBySourceFile[firFile.sourceFile!!] = firFile to components
+        val fir2IrConfiguration = Fir2IrConfiguration(
+            languageVersionSettings = configuration.languageVersionSettings,
+            diagnosticReporter = diagnosticReporter,
+            linkViaSignatures = true,
+            evaluatedConstTracker = configuration
+                .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
+            inlineConstTracker = null,
+            expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
+            allowNonCachedDeclarations = false,
+            useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(),
+        )
+
+        val fir2irResult = inputArtifact.toFirResult().convertToIrAndActualize(
+            Fir2IrExtensions.Default,
+            fir2IrConfiguration,
+            module.irGenerationExtensions(testServices),
+            IdSignatureDescriptor(JsManglerDesc),
+            JsManglerIr,
+            FirJsKotlinMangler(),
+            Fir2IrVisibilityConverter.Default,
+            builtIns ?: DefaultBuiltIns.Instance, // TODO: consider passing externally,
+            ::IrTypeSystemContextImpl
+        ) { firPart, irPart ->
+            sourceFiles.addAll(firPart.fir.mapNotNull { it.sourceFile })
+            for (firFile in firPart.fir) {
+                firFilesAndComponentsBySourceFile[firFile.sourceFile!!] = firFile to irPart.components
             }
+        }.also {
+            (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = dependencies }
         }
 
+
+        val commonMemberStorage = Fir2IrCommonMemberStorage(IdSignatureDescriptor(JsManglerDesc), FirJsKotlinMangler())
         val metadataVersion = configuration.metadataVersion(module.languageVersionSettings.languageVersion)
 
-        var actualizedExpectDeclarations: Set<FirDeclaration>? = null
-
         return IrBackendInput.WasmBackendInput(
-            mainIrPart,
-            mainPluginContext,
+            fir2irResult.irModuleFragment,
+            fir2irResult.pluginContext,
             sourceFiles,
             configuration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList(),
             diagnosticReporter = diagnosticReporter,
@@ -124,12 +123,11 @@ class Fir2IrWasmResultsConverter(
             descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
             irMangler = JsManglerIr,
             firMangler = commonMemberStorage.firSignatureComposer.mangler,
-        ) { file, irActualizedResult ->
+        ) { file ->
             val (firFile, components) = firFilesAndComponentsBySourceFile[file]
                 ?: error("cannot find FIR file by source file ${file.name} (${file.path})")
-            if (actualizedExpectDeclarations == null && irActualizedResult != null) {
-                actualizedExpectDeclarations = irActualizedResult.actualizedExpectDeclarations.extractFirDeclarations()
-            }
+
+            val actualizedExpectDeclarations = fir2irResult.irActualizedResult?.actualizedExpectDeclarations?.extractFirDeclarations()
             serializeSingleFirFile(
                 firFile,
                 components.session,
@@ -147,44 +145,6 @@ class Fir2IrWasmResultsConverter(
     }
 }
 
-fun ModuleCompilerAnalyzedOutput.convertToWasmIr(
-    testServices: TestServices,
-    module: TestModule,
-    configuration: CompilerConfiguration,
-    diagnosticReporter: DiagnosticReporter,
-    commonMemberStorage: Fir2IrCommonMemberStorage,
-    irBuiltIns: IrBuiltInsOverFir?
-): Fir2IrResult {
-    // TODO: consider avoiding repeated libraries resolution
-    val libraries = resolveWasmLibraries(module, testServices, configuration)
-    val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices)
-
-    val fir2IrConfiguration = Fir2IrConfiguration(
-        languageVersionSettings = configuration.languageVersionSettings,
-        diagnosticReporter = diagnosticReporter,
-        linkViaSignatures = true,
-        evaluatedConstTracker = configuration
-            .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
-        inlineConstTracker = null,
-        expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
-        allowNonCachedDeclarations = false,
-        useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(),
-    )
-
-    return convertToIr(
-        Fir2IrExtensions.Default,
-        fir2IrConfiguration,
-        commonMemberStorage,
-        irBuiltIns,
-        JsManglerIr,
-        Fir2IrVisibilityConverter.Default,
-        builtIns ?: DefaultBuiltIns.Instance, // TODO: consider passing externally
-        typeContextProvider = ::IrTypeSystemContextImpl,
-    ).also {
-        (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = dependencies }
-    }
-}
-
 private fun loadResolvedLibraries(
     resolvedLibraries: List<KotlinResolvedLibrary>,
     languageVersionSettings: LanguageVersionSettings,