[IR] Store manglers used for signature computation in IrBackendInput

We will need them in signature dump tests later.

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt

@@ -26,11 +26,7 @@ import org.jetbrains.kotlin.diagnostics.impl.PendingDiagnosticsCollectorWithSupp
 import org.jetbrains.kotlin.fir.BinaryModuleData
 import org.jetbrains.kotlin.fir.DependencyListForCliModule
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.backend.ConstValueProviderImpl
-import org.jetbrains.kotlin.fir.backend.Fir2IrConfiguration
-import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
-import org.jetbrains.kotlin.fir.backend.extractFirDeclarations
+import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.backend.js.FirJsKotlinMangler
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
@@ -43,6 +39,7 @@ import org.jetbrains.kotlin.fir.session.KlibIcData
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider
 import org.jetbrains.kotlin.ir.backend.js.*
+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.util.IrMessageLogger
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
@@ -146,9 +143,9 @@ fun transformFirToIr(
                 .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
         ),
         IrGenerationExtension.getInstances(moduleStructure.project),
-        signatureComposerCreator = null,
+        signatureComposer = DescriptorSignatureComposerStub(JsManglerDesc),
         irMangler = JsManglerIr,
-        firManglerCreator = ::FirJsKotlinMangler,
+        firMangler = FirJsKotlinMangler(),
         visibilityConverter = Fir2IrVisibilityConverter.Default,
         kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance,
         diagnosticReporter = diagnosticsReporter,

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

@@ -11,7 +11,6 @@ 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.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.*
@@ -19,7 +18,6 @@ import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProv
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
 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.FirMangler
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
@@ -53,21 +51,30 @@ fun FirResult.convertToIrAndActualizeForJvm(
     fir2IrExtensions,
     fir2IrConfiguration,
     irGeneratorExtensions,
-    signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
+    signatureComposer = signatureComposerForJvmFir2Ir(fir2IrConfiguration.linkViaSignatures),
     irMangler = JvmIrMangler,
-    firManglerCreator = { FirJvmKotlinMangler() },
+    firMangler = FirJvmKotlinMangler(),
     visibilityConverter = FirJvmVisibilityConverter,
     diagnosticReporter = diagnosticReporter,
     kotlinBuiltIns = DefaultBuiltIns.Instance,
 )
 
+fun signatureComposerForJvmFir2Ir(generateSignatures: Boolean): IdSignatureComposer {
+    val mangler = JvmDescriptorMangler(null)
+    return if (generateSignatures) {
+        JvmIdSignatureDescriptor(mangler)
+    } else {
+        DescriptorSignatureComposerStub(mangler)
+    }
+}
+
 fun FirResult.convertToIrAndActualize(
     fir2IrExtensions: Fir2IrExtensions,
     fir2IrConfiguration: Fir2IrConfiguration,
     irGeneratorExtensions: Collection<IrGenerationExtension>,
-    signatureComposerCreator: (() -> IdSignatureComposer)?,
+    signatureComposer: IdSignatureComposer,
     irMangler: KotlinMangler.IrMangler,
-    firManglerCreator: () -> FirMangler,
+    firMangler: FirMangler,
     visibilityConverter: Fir2IrVisibilityConverter,
     kotlinBuiltIns: KotlinBuiltIns,
     diagnosticReporter: DiagnosticReporter,
@@ -76,11 +83,7 @@ fun FirResult.convertToIrAndActualize(
     val fir2IrResult: Fir2IrResult
     val actualizationResult: IrActualizedResult?
 
-    val commonMemberStorage = Fir2IrCommonMemberStorage(
-        generateSignatures = fir2IrConfiguration.linkViaSignatures,
-        signatureComposerCreator = signatureComposerCreator,
-        manglerCreator = firManglerCreator
-    )
+    val commonMemberStorage = Fir2IrCommonMemberStorage(signatureComposer, firMangler)
 
     when (outputs.size) {
         0 -> error("No modules found")

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

@@ -10,8 +10,12 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.IdSignatureComposer
+import org.jetbrains.kotlin.ir.util.KotlinMangler
 
-class DescriptorSignatureComposerStub : IdSignatureComposer {
+/**
+ * A dummy signature composer that returns `null` for all declaration descriptors.
+ */
+class DescriptorSignatureComposerStub(override val mangler: KotlinMangler.DescriptorMangler) : IdSignatureComposer {
     override fun composeSignature(descriptor: DeclarationDescriptor): IdSignature? {
         return null
     }
@@ -31,4 +35,4 @@ class DescriptorSignatureComposerStub : IdSignatureComposer {
     override fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit) {
         body()
     }
-}
+}

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

@@ -10,31 +10,20 @@ import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.fir.signaturer.FirMangler
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
-import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.IdSignatureComposer
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import java.util.concurrent.ConcurrentHashMap
 
 class Fir2IrCommonMemberStorage(
-    generateSignatures: Boolean,
-    signatureComposerCreator: (() -> IdSignatureComposer)?,
-    manglerCreator: () -> FirMangler
+    signatureComposer: IdSignatureComposer,
+    firMangler: FirMangler
 ) {
-    val signatureComposer: FirBasedSignatureComposer
+    val firSignatureComposer = FirBasedSignatureComposer(firMangler)
 
-    val symbolTable: SymbolTable
-
-    init {
-        val signaturer = if (generateSignatures && signatureComposerCreator != null)
-            signatureComposerCreator()
-        else
-            DescriptorSignatureComposerStub()
-        signatureComposer = FirBasedSignatureComposer(manglerCreator())
-        symbolTable = SymbolTable(
-            signaturer = WrappedDescriptorSignatureComposer(signaturer, signatureComposer),
-            irFactory = IrFactoryImpl
-        )
-    }
+    val symbolTable = SymbolTable(
+        signaturer = WrappedDescriptorSignatureComposer(signatureComposer, firSignatureComposer),
+        irFactory = IrFactoryImpl
+    )
 
     val classCache: MutableMap<FirRegularClass, IrClass> = mutableMapOf()
 

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

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.AnalysisFlags
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.backend.generators.*
 import org.jetbrains.kotlin.fir.declarations.*
@@ -462,7 +461,7 @@ class Fir2IrConverter(
                 scopeSession,
                 commonMemberStorage.symbolTable,
                 irFactory,
-                commonMemberStorage.signatureComposer,
+                commonMemberStorage.firSignatureComposer,
                 fir2IrExtensions,
                 fir2IrConfiguration,
             )

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt

@@ -658,4 +658,6 @@ interface IdSignatureComposer {
     fun composeAnonInitSignature(descriptor: ClassDescriptor): IdSignature?
 
     fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit)
+
+    val mangler: KotlinMangler.DescriptorMangler
 }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureDescriptor.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.ir.util.IdSignatureComposer
 import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 
-open class IdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMangler) : IdSignatureComposer {
+open class IdSignatureDescriptor(override val mangler: KotlinMangler.DescriptorMangler) : IdSignatureComposer {
 
     protected open fun createSignatureBuilder(type: SpecialDeclarationType): DescriptorBasedSignatureBuilder = DescriptorBasedSignatureBuilder(type)
 
@@ -198,4 +198,4 @@ open class IdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMa
     override fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit) {
         body()
     }
-}
+}

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

@@ -12,9 +12,11 @@ import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
+import org.jetbrains.kotlin.fir.signaturer.FirMangler
 import org.jetbrains.kotlin.ir.backend.js.KotlinFileSerializedData
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
+import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.test.model.BackendKinds
 import org.jetbrains.kotlin.test.model.ResultingArtifact
@@ -26,11 +28,40 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
 
     abstract val irModuleFragment: IrModuleFragment
 
-    /*
+    /**
      * Here plugin context can be used as a service for inspecting resulting IR module
      */
     abstract val irPluginContext: IrPluginContext
 
+    /**
+     * The mangler instance that was used to build declaration signatures from (possibly deserialized) K1 descriptors for this backend.
+     *
+     * This instance can be used to verify signatures in tests.
+     *
+     * @see org.jetbrains.kotlin.backend.common.serialization.mangle.descriptor.DescriptorMangleComputer
+     * @see org.jetbrains.kotlin.ir.util.IdSignature
+     */
+    abstract val descriptorMangler: KotlinMangler.DescriptorMangler
+
+    /**
+     * The mangler instance that was used to build declaration signatures from IR declarations for this backend.
+     *
+     * @see org.jetbrains.kotlin.backend.common.serialization.mangle.ir.IrMangleComputer
+     * @see org.jetbrains.kotlin.ir.util.IdSignature
+     */
+    abstract val irMangler: KotlinMangler.IrMangler
+
+    /**
+     * The mangler instance that was used to build declaration signatures from K2 (FIR) declarations for this backend, or `null` if
+     * this artifact was compiled using the classic frontend.
+     *
+     * This instance can be used to verify signatures in tests.
+     *
+     * @see org.jetbrains.kotlin.fir.backend.FirMangleComputer
+     * @see org.jetbrains.kotlin.ir.util.IdSignature
+     */
+    abstract val firMangler: FirMangler?
+
     data class JsIrBackendInput(
         val mainModuleFragment: IrModuleFragment,
         val dependentModuleFragments: List<IrModuleFragment>,
@@ -40,7 +71,10 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         val expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>, // TODO: abstract from descriptors
         val diagnosticsCollector: BaseDiagnosticsCollector,
         val hasErrors: Boolean,
-        val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment
+        override val descriptorMangler: KotlinMangler.DescriptorMangler,
+        override val irMangler: KotlinMangler.IrMangler,
+        override val firMangler: FirMangler?,
+        val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment,
     ) : IrBackendInput() {
         override val irModuleFragment: IrModuleFragment
             get() = mainModuleFragment
@@ -51,7 +85,10 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         val codegenFactory: JvmIrCodegenFactory,
         val dependentInputs: List<JvmIrCodegenFactory.JvmIrBackendInput>,
         val backendInput: JvmIrCodegenFactory.JvmIrBackendInput,
-        val sourceFiles: List<KtSourceFile>
+        val sourceFiles: List<KtSourceFile>,
+        override val descriptorMangler: KotlinMangler.DescriptorMangler,
+        override val irMangler: KotlinMangler.IrMangler,
+        override val firMangler: FirMangler?,
     ) : IrBackendInput() {
         override val irModuleFragment: IrModuleFragment
             get() = backendInput.irModuleFragment

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

@@ -16,8 +16,11 @@ import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr
+import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
+import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.js.config.ErrorTolerancePolicy
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.test.TargetBackend
@@ -71,7 +74,10 @@ class ClassicFrontend2IrConverter(
             codegenFactory,
             dependentInputs = emptyList(),
             conversionResult,
-            sourceFiles = emptyList()
+            sourceFiles = emptyList(),
+            descriptorMangler = conversionResult.symbolTable.signaturer.mangler,
+            irMangler = JvmIrMangler,
+            firMangler = null,
         )
     }
 
@@ -111,7 +117,10 @@ class ClassicFrontend2IrConverter(
             icData,
             expectDescriptorToSymbol = expectDescriptorToSymbol,
             diagnosticsCollector = DiagnosticReporterFactory.createReporter(),
-            hasErrors
+            hasErrors,
+            descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler,
+            irMangler = JsManglerIr,
+            firMangler = null,
         ) { file, _ ->
             metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor)
         }

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

@@ -7,6 +7,7 @@ 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
@@ -31,9 +32,11 @@ 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.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
+import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary
 import org.jetbrains.kotlin.library.unresolvedDependencies
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -42,9 +45,7 @@ import org.jetbrains.kotlin.test.model.BackendKinds
 import org.jetbrains.kotlin.test.model.Frontend2BackendConverter
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestServices
-import org.jetbrains.kotlin.test.services.compilerConfigurationProvider
-import org.jetbrains.kotlin.test.services.jsLibraryProvider
+import org.jetbrains.kotlin.test.services.*
 import org.jetbrains.kotlin.utils.metadataVersion
 
 class Fir2IrJsResultsConverter(
@@ -67,11 +68,9 @@ class Fir2IrJsResultsConverter(
         lateinit var mainPluginContext: IrPluginContext
         var irBuiltIns: IrBuiltInsOverFir? = null
 
-        val commonMemberStorage = Fir2IrCommonMemberStorage(
-            generateSignatures = false,
-            signatureComposerCreator = null,
-            manglerCreator = ::FirJsKotlinMangler
-        )
+        val commonMemberStorage = Fir2IrCommonMemberStorage(IdSignatureDescriptor(JsManglerDesc), FirJsKotlinMangler())
+
+        val irMangler = JsManglerIr
 
         for ((index, part) in inputArtifact.partsForDependsOnModules.withIndex()) {
             val (irModuleFragment, components, pluginContext) =
@@ -82,7 +81,9 @@ class Fir2IrJsResultsConverter(
                     configuration,
                     testServices,
                     commonMemberStorage,
-                    irBuiltIns
+                    irBuiltIns,
+                    irMangler,
+                    generateSignatures = true,
                 )
             irBuiltIns = components.irBuiltIns
             mainPluginContext = pluginContext
@@ -112,7 +113,10 @@ class Fir2IrJsResultsConverter(
             configuration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList(),
             expectDescriptorToSymbol = mutableMapOf(),
             diagnosticsCollector = DiagnosticReporterFactory.createReporter(),
-            hasErrors = inputArtifact.hasErrors
+            hasErrors = inputArtifact.hasErrors,
+            descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
+            irMangler = irMangler,
+            firMangler = commonMemberStorage.firSignatureComposer.mangler,
         ) { file, irActualizedResult ->
             val (firFile, components) = firFilesAndComponentsBySourceFile[file]
                 ?: error("cannot find FIR file by source file ${file.name} (${file.path})")
@@ -142,7 +146,9 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
     configuration: CompilerConfiguration,
     testServices: TestServices,
     commonMemberStorage: Fir2IrCommonMemberStorage,
-    irBuiltIns: IrBuiltInsOverFir?
+    irBuiltIns: IrBuiltInsOverFir?,
+    irMangler: KotlinMangler.IrMangler,
+    generateSignatures: Boolean
 ): Fir2IrResult {
     this as FirAnalyzerFacade
     // TODO: consider avoiding repeated libraries resolution
@@ -151,7 +157,7 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
 
     val fir2IrConfiguration = Fir2IrConfiguration(
         languageVersionSettings = configuration.languageVersionSettings,
-        linkViaSignatures = false,
+        linkViaSignatures = generateSignatures,
         evaluatedConstTracker = configuration
             .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
     )
@@ -159,7 +165,7 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
         session, scopeSession, firFiles.toList(),
         fir2IrExtensions,
         fir2IrConfiguration,
-        JsManglerIr, IrFactoryImpl,
+        irMangler, IrFactoryImpl,
         Fir2IrVisibilityConverter.Default,
         Fir2IrJvmSpecialAnnotationSymbolProvider(), // TODO: replace with appropriate (probably empty) implementation
         irGeneratorExtensions,

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

@@ -7,7 +7,6 @@ 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
@@ -22,8 +21,8 @@ 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.pipeline.signatureComposerForJvmFir2Ir
 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.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
@@ -66,7 +65,8 @@ class Fir2IrJvmResultsConverter(
         val compilerConfigurationProvider = testServices.compilerConfigurationProvider
         val configuration = compilerConfigurationProvider.getCompilerConfiguration(module)
 
-        val fir2IrExtensions = JvmFir2IrExtensions(configuration, JvmIrDeserializerImpl(), JvmIrMangler)
+        val irMangler = JvmIrMangler
+        val fir2IrExtensions = JvmFir2IrExtensions(configuration, JvmIrDeserializerImpl(), irMangler)
 
         // Create and initialize the module and its dependencies
         val project = compilerConfigurationProvider.getProject(module)
@@ -89,11 +89,7 @@ class Fir2IrJvmResultsConverter(
         val firAnalyzerFacade = inputArtifact.partsForDependsOnModules.last().firAnalyzerFacade as? FirAnalyzerFacade
         val generateSignatures = firAnalyzerFacade?.fir2IrConfiguration?.linkViaSignatures == true
 
-        val commonMemberStorage = Fir2IrCommonMemberStorage(
-            generateSignatures = generateSignatures,
-            signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
-            manglerCreator = { FirJvmKotlinMangler() }
-        )
+        val commonMemberStorage = Fir2IrCommonMemberStorage(signatureComposerForJvmFir2Ir(generateSignatures), FirJvmKotlinMangler())
         var irBuiltIns: IrBuiltInsOverFir? = null
 
         for ((index, firOutputPart) in inputArtifact.partsForDependsOnModules.withIndex()) {
@@ -136,7 +132,10 @@ class Fir2IrJvmResultsConverter(
             codegenFactory,
             dependentIrParts,
             mainIrPart,
-            sourceFiles
+            sourceFiles,
+            descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler,
+            irMangler = irMangler,
+            firMangler = commonMemberStorage.firSignatureComposer.mangler,
         )
     }
 }

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

@@ -16,7 +16,6 @@ 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
@@ -39,8 +38,8 @@ 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.pipeline.signatureComposerForJvmFir2Ir
 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
@@ -125,7 +124,7 @@ object GenerationUtils {
             session,
             Fir2IrConfiguration(
                 languageVersionSettings = configuration.languageVersionSettings,
-                linkViaSignatures = false,
+                linkViaSignatures = configuration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES),
                 evaluatedConstTracker = configuration
                     .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
             ),
@@ -137,9 +136,8 @@ object GenerationUtils {
         val fir2IrExtensions = JvmFir2IrExtensions(configuration, JvmIrDeserializerImpl(), JvmIrMangler)
 
         val commonMemberStorage = Fir2IrCommonMemberStorage(
-            generateSignatures = firAnalyzerFacade.fir2IrConfiguration.linkViaSignatures,
-            signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
-            manglerCreator = { FirJvmKotlinMangler() }
+            signatureComposerForJvmFir2Ir(firAnalyzerFacade.fir2IrConfiguration.linkViaSignatures),
+            FirJvmKotlinMangler(),
         )
 
         val (moduleFragment, components, pluginContext) = firAnalyzerFacade.convertToIr(

generators/interpreter/GenerateInterpreterMap.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.IdSignatureComposer
+import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi2ir.descriptors.IrBuiltInsOverDescriptors
@@ -319,6 +320,9 @@ private fun getIrBuiltIns(): IrBuiltIns {
         override fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit) {
             body()
         }
+
+        override val mangler: KotlinMangler.DescriptorMangler
+            get() = throw UnsupportedOperationException("Mangler is unavailable")
     }
     val symbolTable = SymbolTable(signaturer, IrFactoryImpl)
     val typeTranslator = TypeTranslatorImpl(symbolTable, languageSettings, moduleDescriptor)

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

@@ -82,9 +82,9 @@ internal fun PhaseContext.fir2Ir(
                             .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
             ),
             IrGenerationExtension.getInstances(config.project),
-            signatureComposerCreator = null,
+            signatureComposer = DescriptorSignatureComposerStub(KonanManglerDesc),
             irMangler = KonanManglerIr,
-            firManglerCreator = { FirNativeKotlinMangler() },
+            firMangler = FirNativeKotlinMangler(),
             visibilityConverter = Fir2IrVisibilityConverter.Default,
             diagnosticReporter = diagnosticsReporter,
             kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance,

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

@@ -8,7 +8,7 @@ import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 
-class KonanIdSignaturer(private val mangler: KotlinMangler.DescriptorMangler) : IdSignatureDescriptor(mangler) {
+class KonanIdSignaturer(mangler: KotlinMangler.DescriptorMangler) : IdSignatureDescriptor(mangler) {
 
     override fun createSignatureBuilder(type: SpecialDeclarationType): DescriptorBasedSignatureBuilder =
             KonanDescriptorBasedSignatureBuilder(type)
@@ -60,4 +60,4 @@ class KonanIdSignaturer(private val mangler: KotlinMangler.DescriptorMangler) :
             markInteropDeclaration(descriptor)
         }
     }
-}
+}