[FIR2IR] Use single SymbolTable and SignatureComposer for all MPP modules

Merge createModuleFragmentWithSignaturesIfNeeded and createModuleFragmentWithoutSignatures
into the createModuleFragmentWithSignaturesIfNeeded

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.backend.Fir2IrResult
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestFile
@@ -40,8 +41,9 @@ class LowLevelFirAnalyzerFacade(
     override fun runResolution(): List<FirFile> = shouldNotBeCalled()
     override fun convertToIr(
         fir2IrExtensions: Fir2IrExtensions,
-        dependentComponents: List<Fir2IrComponents>,
+        signatureComposer: FirBasedSignatureComposer,
-        symbolTable: SymbolTable?
+        symbolTable: SymbolTable,
+        dependentComponents: List<Fir2IrComponents>
     ): Fir2IrResult = shouldNotBeCalled()
 }
 

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
-import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.Services
@@ -76,10 +75,10 @@ import org.jetbrains.kotlin.ir.backend.js.ic.JsExecutableProducer
 import org.jetbrains.kotlin.ir.backend.js.ic.ModuleArtifact
 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.backend.js.transformers.irToJs.CompilationOutputsBuilt
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.JsCodeGenerator
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
-import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.CompilationOutputsBuilt
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
@@ -555,7 +554,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         // FIR2IR
 
         val fir2IrExtensions = Fir2IrExtensions.Default
-        val signaturer = IdSignatureDescriptor(JsManglerDesc)
         val commonFirFiles = session.moduleData.dependsOnDependencies
             .map { it.session }
             .filter { it.kind == FirSession.Kind.Source }
@@ -584,19 +582,25 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
             moduleDescriptor
         }
 
+        val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+            generateSignatures = false,
+            signatureComposerCreator = null,
+            manglerCreator = { FirJvmKotlinMangler() } // TODO: replace with potentially simpler JS version
+        )
+
         val fir2irResult = Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(
             session, scopeSession, firFiles + commonFirFiles,
-            configuration.languageVersionSettings, signaturer,
+            configuration.languageVersionSettings,
             fir2IrExtensions,
-            FirJvmKotlinMangler(), // TODO: replace with potentially simpler JS version
             JsManglerIr, IrFactoryImpl,
             Fir2IrVisibilityConverter.Default,
             Fir2IrJvmSpecialAnnotationSymbolProvider(), // TODO: replace with appropriate (probably empty) implementation
             IrGenerationExtension.getInstances(environmentForJS.project),
             generateSignatures = false,
             kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance, // TODO: consider passing externally
-            dependentComponents = emptyList(),
+            signatureComposer = signatureComposer,
-            currentSymbolTable = null
+            symbolTable = symbolTable,
+            dependentComponents = emptyList()
         ).also {
             (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }
         }

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.backend.jvm.FirJvmVisibilityConverter
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
@@ -43,20 +44,28 @@ fun FirResult.convertToIrAndActualize(
 ): Fir2IrResult {
     val result: Fir2IrResult
 
+    val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+        generateSignatures = linkViaSignatures,
+        signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
+        manglerCreator = { FirJvmKotlinMangler() }
+    )
+
     if (commonOutput != null) {
         val commonIrOutput = commonOutput.convertToIr(
             fir2IrExtensions,
             irGeneratorExtensions,
             linkViaSignatures = linkViaSignatures,
-            dependentComponents = emptyList(),
+            signatureComposer = signatureComposer,
-            currentSymbolTable = null
+            symbolTable = symbolTable,
+            dependentComponents = emptyList()
         )
         result = platformOutput.convertToIr(
             fir2IrExtensions,
             irGeneratorExtensions,
             linkViaSignatures = linkViaSignatures,
-            dependentComponents = listOf(commonIrOutput.components),
+            signatureComposer = signatureComposer,
-            currentSymbolTable = commonIrOutput.components.symbolTable
+            symbolTable = symbolTable,
+            dependentComponents = listOf(commonIrOutput.components)
         )
         IrActualizer.actualize(
             result.irModuleFragment,
@@ -67,8 +76,9 @@ fun FirResult.convertToIrAndActualize(
             fir2IrExtensions,
             irGeneratorExtensions,
             linkViaSignatures = linkViaSignatures,
-            dependentComponents = emptyList(),
+            signatureComposer = signatureComposer,
-            currentSymbolTable = null
+            symbolTable = symbolTable,
+            dependentComponents = emptyList()
         )
     }
 
@@ -79,34 +89,20 @@ private fun ModuleCompilerAnalyzedOutput.convertToIr(
     fir2IrExtensions: Fir2IrExtensions,
     irGeneratorExtensions: Collection<IrGenerationExtension>,
     linkViaSignatures: Boolean,
-    dependentComponents: List<Fir2IrComponents>,
+    signatureComposer: FirBasedSignatureComposer,
-    currentSymbolTable: SymbolTable?
+    symbolTable: SymbolTable,
+    dependentComponents: List<Fir2IrComponents>
 ): Fir2IrResult {
-    if (linkViaSignatures) {
+    return Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(
-        val signaturer = JvmIdSignatureDescriptor(mangler = JvmDescriptorMangler(mainDetector = null))
+        session, scopeSession, fir,
-        return Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(
+        session.languageVersionSettings, fir2IrExtensions,
-            session, scopeSession, fir,
+        JvmIrMangler, IrFactoryImpl, FirJvmVisibilityConverter,
-            session.languageVersionSettings, signaturer, fir2IrExtensions,
+        Fir2IrJvmSpecialAnnotationSymbolProvider(),
-            FirJvmKotlinMangler(),
+        irGeneratorExtensions,
-            JvmIrMangler, IrFactoryImpl, FirJvmVisibilityConverter,
+        kotlinBuiltIns = DefaultBuiltIns.Instance, // TODO: consider passing externally
-            Fir2IrJvmSpecialAnnotationSymbolProvider(),
+        generateSignatures = linkViaSignatures,
-            irGeneratorExtensions,
+        signatureComposer = signatureComposer,
-            kotlinBuiltIns = DefaultBuiltIns.Instance, // TODO: consider passing externally
+        symbolTable = symbolTable,
-            generateSignatures = true,
+        dependentComponents = dependentComponents
-            dependentComponents = dependentComponents,
+    )
-            currentSymbolTable = currentSymbolTable
-        )
-    } else {
-        return Fir2IrConverter.createModuleFragmentWithoutSignatures(
-            session, scopeSession, fir,
-            session.languageVersionSettings, fir2IrExtensions,
-            FirJvmKotlinMangler(),
-            JvmIrMangler, IrFactoryImpl, FirJvmVisibilityConverter,
-            Fir2IrJvmSpecialAnnotationSymbolProvider(),
-            irGeneratorExtensions,
-            kotlinBuiltIns = DefaultBuiltIns.Instance, // TODO: consider passing externally,
-            dependentComponents = dependentComponents,
-            currentSymbolTable = currentSymbolTable
-        )
-    }
 }

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

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.fir.signaturer.FirMangler
 import org.jetbrains.kotlin.fir.symbols.lazyDeclarationResolver
 import org.jetbrains.kotlin.ir.PsiIrFileEntry
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrModuleFragmentImpl
 import org.jetbrains.kotlin.ir.interpreter.IrInterpreter
@@ -426,14 +427,29 @@ class Fir2IrConverter(
             }
         }
 
+        fun createSignatureComposerAndSymbolTable(
+            generateSignatures: Boolean,
+            signatureComposerCreator: (() -> IdSignatureComposer)?,
+            manglerCreator: () -> FirMangler,
+        ): Pair<FirBasedSignatureComposer, SymbolTable> {
+            val signaturer = if (generateSignatures && signatureComposerCreator != null)
+                signatureComposerCreator()
+            else
+                DescriptorSignatureComposerStub()
+            val signatureComposer = FirBasedSignatureComposer(manglerCreator())
+            val symbolTable = SymbolTable(
+                signaturer = WrappedDescriptorSignatureComposer(signaturer, signatureComposer),
+                irFactory = IrFactoryImpl
+            )
+            return Pair(signatureComposer, symbolTable)
+        }
+
         fun createModuleFragmentWithSignaturesIfNeeded(
             session: FirSession,
             scopeSession: ScopeSession,
             firFiles: List<FirFile>,
             languageVersionSettings: LanguageVersionSettings,
-            signaturer: IdSignatureComposer,
             fir2IrExtensions: Fir2IrExtensions,
-            mangler: FirMangler,
             irMangler: KotlinMangler.IrMangler,
             irFactory: IrFactory,
             visibilityConverter: Fir2IrVisibilityConverter,
@@ -441,83 +457,8 @@ class Fir2IrConverter(
             irGenerationExtensions: Collection<IrGenerationExtension>,
             generateSignatures: Boolean,
             kotlinBuiltIns: KotlinBuiltIns,
-            dependentComponents: List<Fir2IrComponents>,
-            currentSymbolTable: SymbolTable?
-        ): Fir2IrResult {
-            if (!generateSignatures) {
-                return createModuleFragmentWithoutSignatures(
-                    session, scopeSession, firFiles, languageVersionSettings,
-                    fir2IrExtensions, mangler, irMangler, irFactory,
-                    visibilityConverter, specialSymbolProvider, irGenerationExtensions,
-                    kotlinBuiltIns, dependentComponents, currentSymbolTable
-                )
-            }
-            val signatureComposer = FirBasedSignatureComposer(
-                mangler,
-                dependentComposers = dependentComponents.map { it.signatureComposer as FirBasedSignatureComposer }
-            )
-            val symbolTable = createSymbolTable(signaturer, signatureComposer, irFactory, currentSymbolTable)
-            return createModuleFragmentWithSymbolTable(
-                session, scopeSession, firFiles, languageVersionSettings,
-                fir2IrExtensions, irMangler, irFactory, visibilityConverter,
-                specialSymbolProvider, irGenerationExtensions, signatureComposer,
-                symbolTable, generateSignatures = true, kotlinBuiltIns = kotlinBuiltIns, dependentComponents = dependentComponents
-            )
-        }
-
-        fun createModuleFragmentWithoutSignatures(
-            session: FirSession,
-            scopeSession: ScopeSession,
-            firFiles: List<FirFile>,
-            languageVersionSettings: LanguageVersionSettings,
-            fir2IrExtensions: Fir2IrExtensions,
-            mangler: FirMangler,
-            irMangler: KotlinMangler.IrMangler,
-            irFactory: IrFactory,
-            visibilityConverter: Fir2IrVisibilityConverter,
-            specialSymbolProvider: Fir2IrSpecialSymbolProvider,
-            irGenerationExtensions: Collection<IrGenerationExtension>,
-            kotlinBuiltIns: KotlinBuiltIns,
-            dependentComponents: List<Fir2IrComponents>,
-            currentSymbolTable: SymbolTable?
-        ): Fir2IrResult {
-            val signatureComposer = FirBasedSignatureComposer(mangler, dependentComposers = dependentComponents.map { it.signatureComposer as FirBasedSignatureComposer })
-            val signaturer = DescriptorSignatureComposerStub()
-            val symbolTable = createSymbolTable(signaturer, signatureComposer, irFactory, currentSymbolTable)
-            return createModuleFragmentWithSymbolTable(
-                session, scopeSession, firFiles, languageVersionSettings,
-                fir2IrExtensions, irMangler, irFactory, visibilityConverter,
-                specialSymbolProvider, irGenerationExtensions, signatureComposer,
-                symbolTable, generateSignatures = false, kotlinBuiltIns = kotlinBuiltIns, dependentComponents = dependentComponents
-            )
-        }
-
-        private fun createSymbolTable(
-            signaturer: IdSignatureComposer,
-            signatureComposer: FirBasedSignatureComposer,
-            irFactory: IrFactory,
-            currentSymbolTable: SymbolTable?
-        ): SymbolTable =
-            currentSymbolTable ?: SymbolTable(
-                signaturer = WrappedDescriptorSignatureComposer(signaturer, signatureComposer),
-                irFactory = irFactory
-            )
-
-        private fun createModuleFragmentWithSymbolTable(
-            session: FirSession,
-            scopeSession: ScopeSession,
-            firFiles: List<FirFile>,
-            languageVersionSettings: LanguageVersionSettings,
-            fir2IrExtensions: Fir2IrExtensions,
-            irMangler: KotlinMangler.IrMangler,
-            irFactory: IrFactory,
-            visibilityConverter: Fir2IrVisibilityConverter,
-            specialSymbolProvider: Fir2IrSpecialSymbolProvider,
-            irGenerationExtensions: Collection<IrGenerationExtension>,
             signatureComposer: FirBasedSignatureComposer,
             symbolTable: SymbolTable,
-            generateSignatures: Boolean,
-            kotlinBuiltIns: KotlinBuiltIns,
             dependentComponents: List<Fir2IrComponents>
         ): Fir2IrResult {
             val moduleDescriptor = FirModuleDescriptor(session, kotlinBuiltIns)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt

@@ -23,10 +23,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
 // @NoMutableState -- we'll restore this annotation once we get rid of withFileSignature().
-class FirBasedSignatureComposer(
+class FirBasedSignatureComposer(override val mangler: FirMangler) : Fir2IrSignatureComposer {
-    override val mangler: FirMangler,
-    dependentComposers: List<FirBasedSignatureComposer> = emptyList()
-) : Fir2IrSignatureComposer {
     private var fileSignature: IdSignature.FileSignature? = null
 
     override fun withFileSignature(sig: IdSignature.FileSignature, body: () -> Unit) {
@@ -37,11 +34,7 @@ class FirBasedSignatureComposer(
 
     private data class FirDeclarationWithParentId(val declaration: FirDeclaration, val classId: ClassId?)
 
-    private val signatureCache: MutableMap<FirDeclarationWithParentId, IdSignature.CommonSignature> =
+    private val signatureCache = mutableMapOf<FirDeclarationWithParentId, IdSignature.CommonSignature>()
-        dependentComposers.map { it.signatureCache }.fold(mutableMapOf()) { result, map ->
-            result.putAll(map)
-            result
-        }
 
     inner class SignatureBuilder : FirVisitor<Unit, Any?>() {
         var hashId: Long? = null

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.test.frontend.fir
 
-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.CompilerConfiguration
@@ -36,7 +35,6 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.ir.backend.js.JsFactories
 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.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
@@ -111,7 +109,6 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
     testServices: TestServices
 ): Fir2IrResult {
     this as FirAnalyzerFacade
-    val signaturer = IdSignatureDescriptor(JsManglerDesc)
     val commonFirFiles = session.moduleData.dependsOnDependencies
         .map { it.session }
         .filter { it.kind == FirSession.Kind.Source }
@@ -121,19 +118,25 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
     val libraries = resolveJsLibraries(module, testServices, configuration)
     val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices)
 
+    val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+        generateSignatures = false,
+        signatureComposerCreator = null,
+        manglerCreator = { FirJvmKotlinMangler() } // TODO: replace with potentially simpler JS version
+    )
+
     return Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(
         session, scopeSession, firFiles + commonFirFiles,
-        languageVersionSettings, signaturer,
+        languageVersionSettings,
         fir2IrExtensions,
-        FirJvmKotlinMangler(), // TODO: replace with potentially simpler JS version
         JsManglerIr, IrFactoryImpl,
         Fir2IrVisibilityConverter.Default,
         Fir2IrJvmSpecialAnnotationSymbolProvider(), // TODO: replace with appropriate (probably empty) implementation
         irGeneratorExtensions,
         generateSignatures = false,
         kotlinBuiltIns = builtIns ?: DefaultBuiltIns.Instance, // TODO: consider passing externally,
-        dependentComponents = emptyList(),
+        signatureComposer = signatureComposer,
-        currentSymbolTable = null
+        symbolTable = symbolTable,
+        dependentComponents = emptyList()
     ).also {
         (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = dependencies }
     }

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.test.frontend.fir
 
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.backend.jvm.JvmIrDeserializerImpl
+import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
@@ -14,13 +15,16 @@ import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.fir.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
+import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
+import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
 import org.jetbrains.kotlin.fir.backend.jvm.JvmFir2IrExtensions
 import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
-import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
@@ -68,7 +72,15 @@ class Fir2IrResultsConverter(
         val dependentIrParts = mutableListOf<JvmIrCodegenFactory.JvmIrBackendInput>()
         lateinit var mainIrPart: JvmIrCodegenFactory.JvmIrBackendInput
 
-        var currentSymbolTable: SymbolTable? = null
+        val generateSignatures =
+            (inputArtifact.partsForDependsOnModules.last().firAnalyzerFacade as? FirAnalyzerFacade)?.generateSignatures == true
+
+        val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+            generateSignatures = generateSignatures,
+            signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
+            manglerCreator = { FirJvmKotlinMangler() }
+        )
+
         for ((index, firOutputPart) in inputArtifact.partsForDependsOnModules.withIndex()) {
             val dependentComponents = mutableListOf<Fir2IrComponents>()
             if (isMppSupported) {
@@ -78,9 +90,8 @@ class Fir2IrResultsConverter(
             }
 
             val (irModuleFragment, components, pluginContext) = firOutputPart.firAnalyzerFacade.convertToIr(
-                fir2IrExtensions, dependentComponents, currentSymbolTable
+                fir2IrExtensions, signatureComposer, symbolTable, dependentComponents, irBuiltIns
             )
-            currentSymbolTable = components.symbolTable
             componentsMap[firOutputPart.module.name] = components
 
             val irPart = JvmIrCodegenFactory.JvmIrBackendInput(

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.backend.jvm.JvmIrDeserializerImpl
+import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.GroupingMessageCollector
@@ -31,10 +32,13 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.fir.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.FirTestSessionFactoryHelper
+import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
+import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
 import org.jetbrains.kotlin.fir.backend.jvm.JvmFir2IrExtensions
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
+import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KtFile
@@ -123,10 +127,18 @@ object GenerationUtils {
             generateSignatures = false
         )
         val fir2IrExtensions = JvmFir2IrExtensions(configuration, JvmIrDeserializerImpl(), JvmIrMangler)
+
+        val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+            generateSignatures = firAnalyzerFacade.generateSignatures,
+            signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
+            manglerCreator = { FirJvmKotlinMangler() }
+        )
+
         val (moduleFragment, components, pluginContext) = firAnalyzerFacade.convertToIr(
             fir2IrExtensions,
+            signatureComposer = signatureComposer,
+            symbolTable = symbolTable,
             dependentComponents = emptyList(),
-            symbolTable = null
         )
         val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext
 

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirAnalyzerFacade.kt

@@ -6,18 +6,13 @@
 package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
-import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
-import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
+import org.jetbrains.kotlin.fir.backend.*
-import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
-import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrResult
 import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProvider
-import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmVisibilityConverter
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -26,7 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
-import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
+import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.util.SymbolTable
@@ -41,8 +36,9 @@ abstract class AbstractFirAnalyzerFacade {
 
     abstract fun convertToIr(
         fir2IrExtensions: Fir2IrExtensions,
-        dependentComponents: List<Fir2IrComponents>,
+        signatureComposer: FirBasedSignatureComposer,
-        symbolTable: SymbolTable?
+        symbolTable: SymbolTable,
+        dependentComponents: List<Fir2IrComponents>
     ): Fir2IrResult
 }
 
@@ -110,25 +106,25 @@ class FirAnalyzerFacade(
 
     override fun convertToIr(
         fir2IrExtensions: Fir2IrExtensions,
-        dependentComponents: List<Fir2IrComponents>,
+        signatureComposer: FirBasedSignatureComposer,
-        symbolTable: SymbolTable?
+        symbolTable: SymbolTable,
+        dependentComponents: List<Fir2IrComponents>
     ): Fir2IrResult {
         if (_scopeSession == null) runResolution()
-        val mangler = JvmDescriptorMangler(null)
-        val signaturer = JvmIdSignatureDescriptor(mangler)
 
         return Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(
             session, _scopeSession!!, firFiles!!,
-            languageVersionSettings, signaturer,
+            languageVersionSettings,
             fir2IrExtensions,
-            FirJvmKotlinMangler(), JvmIrMangler, IrFactoryImpl,
+            JvmIrMangler, IrFactoryImpl,
             FirJvmVisibilityConverter,
             Fir2IrJvmSpecialAnnotationSymbolProvider(),
             irGeneratorExtensions,
             generateSignatures,
             kotlinBuiltIns = DefaultBuiltIns.Instance, // TODO: consider passing externally,
-            dependentComponents = dependentComponents,
+            signatureComposer = signatureComposer,
-            currentSymbolTable = symbolTable
+            symbolTable = symbolTable,
+            dependentComponents = dependentComponents
         )
     }
 }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt

@@ -2,7 +2,6 @@ package org.jetbrains.kotlin.backend.konan
 
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.common.serialization.metadata.DynamicTypeDeserializer
-import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
 import org.jetbrains.kotlin.backend.konan.driver.PhaseContext
 import org.jetbrains.kotlin.backend.konan.driver.phases.Fir2IrOutput
 import org.jetbrains.kotlin.backend.konan.driver.phases.FirOutput
@@ -38,7 +37,6 @@ internal fun PhaseContext.fir2Ir(
         input: FirOutput.Full,
 ): Fir2IrOutput {
     val fir2IrExtensions = Fir2IrExtensions.Default
-    val signaturer = IdSignatureDescriptor(KonanManglerDesc)
     val commonFirFiles = input.session.moduleData.dependsOnDependencies
             .map { it.session }
             .filter { it.kind == FirSession.Kind.Source }
@@ -73,19 +71,25 @@ internal fun PhaseContext.fir2Ir(
         moduleDescriptor.setDependencies(ArrayList(dependencies))
     }
 
+    val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+        generateSignatures = false,
+        signatureComposerCreator = null,
+        manglerCreator = { FirJvmKotlinMangler() } // TODO: replace with potentially simpler JS version
+    )
+
     val fir2irResult = Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(
             input.session, input.scopeSession, input.firFiles + commonFirFiles,
-            configuration.languageVersionSettings, signaturer,
+            configuration.languageVersionSettings,
             fir2IrExtensions,
-            FirJvmKotlinMangler(), // TODO: replace with potentially simpler Konan version
             KonanManglerIr, IrFactoryImpl,
             Fir2IrVisibilityConverter.Default,
             Fir2IrJvmSpecialAnnotationSymbolProvider(), // TODO: replace with appropriate (probably empty) implementation
             IrGenerationExtension.getInstances(config.project),
             generateSignatures = false,
             kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance, // TODO: consider passing externally
-            dependentComponents = emptyList(),
+            signatureComposer = signatureComposer,
-            currentSymbolTable = null
+            symbolTable = symbolTable,
+            dependentComponents = emptyList()
     ).also {
         (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }
     }