[FIR2IR] Add Fir2IrCommonMemberStorage, get rid of merge in Fir2Ir storages

Extract DescriptorSignatureComposerStub and WrappedDescriptorSignatureComposer to separate classes

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

@@ -10,15 +10,10 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade
-import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
+import org.jetbrains.kotlin.fir.backend.*
-import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrResult
-import org.jetbrains.kotlin.fir.backend.IrBuiltInsOverFir
 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
 
@@ -42,9 +37,7 @@ class LowLevelFirAnalyzerFacade(
     override fun runResolution(): List<FirFile> = shouldNotBeCalled()
     override fun convertToIr(
         fir2IrExtensions: Fir2IrExtensions,
-        signatureComposer: FirBasedSignatureComposer,
+        commonMemberStorage: Fir2IrCommonMemberStorage,
-        symbolTable: SymbolTable,
-        dependentComponents: List<Fir2IrComponents>,
         irBuiltIns: IrBuiltInsOverFir?
     ): Fir2IrResult = shouldNotBeCalled()
 }

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

@@ -10,7 +10,6 @@ import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.backend.common.CompilationException
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
-import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
 import org.jetbrains.kotlin.backend.wasm.compileToLoweredIr
 import org.jetbrains.kotlin.backend.wasm.compileWasm
 import org.jetbrains.kotlin.backend.wasm.dce.eliminateDeadDeclarations
@@ -43,6 +42,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.backend.Fir2IrCommonMemberStorage
 import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
 import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
@@ -73,7 +73,6 @@ import org.jetbrains.kotlin.ir.backend.js.ic.CacheUpdater
 import org.jetbrains.kotlin.ir.backend.js.ic.DirtyFileState
 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
@@ -582,7 +581,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
             moduleDescriptor
         }
 
-        val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+        val commonMemberStorage = Fir2IrCommonMemberStorage(
             generateSignatures = false,
             signatureComposerCreator = null,
             manglerCreator = { FirJvmKotlinMangler() } // TODO: replace with potentially simpler JS version
@@ -598,9 +597,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
             IrGenerationExtension.getInstances(environmentForJS.project),
             generateSignatures = false,
             kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance, // TODO: consider passing externally
-            signatureComposer = signatureComposer,
+            commonMemberStorage = commonMemberStorage,
-            symbolTable = symbolTable,
-            dependentComponents = emptyList(),
             initializedIrBuiltIns = null
         ).also {
             (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }

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

@@ -17,11 +17,9 @@ 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
-import org.jetbrains.kotlin.ir.util.SymbolTable
 
 data class FirResult(
     val platformOutput: ModuleCompilerAnalyzedOutput,
@@ -41,7 +39,7 @@ fun FirResult.convertToIrAndActualize(
 ): Fir2IrResult {
     val result: Fir2IrResult
 
-    val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+    val commonMemberStorage = Fir2IrCommonMemberStorage(
         generateSignatures = linkViaSignatures,
         signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
         manglerCreator = { FirJvmKotlinMangler() }
@@ -52,18 +50,14 @@ fun FirResult.convertToIrAndActualize(
             fir2IrExtensions,
             irGeneratorExtensions,
             linkViaSignatures = linkViaSignatures,
-            signatureComposer = signatureComposer,
+            commonMemberStorage = commonMemberStorage,
-            symbolTable = symbolTable,
-            dependentComponents = emptyList(),
             irBuiltIns = null
         )
         result = platformOutput.convertToIr(
             fir2IrExtensions,
             irGeneratorExtensions,
             linkViaSignatures = linkViaSignatures,
-            signatureComposer = signatureComposer,
+            commonMemberStorage = commonMemberStorage,
-            symbolTable = symbolTable,
-            dependentComponents = listOf(commonIrOutput.components),
             irBuiltIns = commonIrOutput.components.irBuiltIns
         )
         IrActualizer.actualize(
@@ -75,9 +69,7 @@ fun FirResult.convertToIrAndActualize(
             fir2IrExtensions,
             irGeneratorExtensions,
             linkViaSignatures = linkViaSignatures,
-            signatureComposer = signatureComposer,
+            commonMemberStorage = commonMemberStorage,
-            symbolTable = symbolTable,
-            dependentComponents = emptyList(),
             irBuiltIns = null
         )
     }
@@ -89,9 +81,7 @@ private fun ModuleCompilerAnalyzedOutput.convertToIr(
     fir2IrExtensions: Fir2IrExtensions,
     irGeneratorExtensions: Collection<IrGenerationExtension>,
     linkViaSignatures: Boolean,
-    signatureComposer: FirBasedSignatureComposer,
+    commonMemberStorage: Fir2IrCommonMemberStorage,
-    symbolTable: SymbolTable,
-    dependentComponents: List<Fir2IrComponents>,
     irBuiltIns: IrBuiltInsOverFir?
 ): Fir2IrResult {
     return Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(
@@ -102,9 +92,7 @@ private fun ModuleCompilerAnalyzedOutput.convertToIr(
         irGeneratorExtensions,
         kotlinBuiltIns = DefaultBuiltIns.Instance, // TODO: consider passing externally
         generateSignatures = linkViaSignatures,
-        signatureComposer = signatureComposer,
+        commonMemberStorage = commonMemberStorage,
-        symbolTable = symbolTable,
-        dependentComponents = dependentComponents,
         initializedIrBuiltIns = irBuiltIns
     )
 }

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

@@ -0,0 +1,34 @@
+/*
+ * 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.descriptors.ClassDescriptor
+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
+
+class DescriptorSignatureComposerStub : IdSignatureComposer {
+    override fun composeSignature(descriptor: DeclarationDescriptor): IdSignature? {
+        return null
+    }
+
+    override fun composeEnumEntrySignature(descriptor: ClassDescriptor): IdSignature? {
+        return null
+    }
+
+    override fun composeFieldSignature(descriptor: PropertyDescriptor): IdSignature? {
+        return null
+    }
+
+    override fun composeAnonInitSignature(descriptor: ClassDescriptor): IdSignature? {
+        return null
+    }
+
+    override fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit) {
+        body()
+    }
+}

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

@@ -40,11 +40,11 @@ import org.jetbrains.kotlin.utils.addToStdlib.runUnless
 
 class Fir2IrClassifierStorage(
     private val components: Fir2IrComponents,
-    private val dependentStorages: List<Fir2IrClassifierStorage>
+    commonMemberStorage: Fir2IrCommonMemberStorage
 ) : Fir2IrComponents by components {
     private val firProvider = session.firProvider
 
-    private val classCache: MutableMap<FirRegularClass, IrClass> = merge { it.classCache }
+    private val classCache: MutableMap<FirRegularClass, IrClass> = commonMemberStorage.classCache
 
     private val localClassesCreatedOnTheFly: MutableMap<FirClass, IrClass> = mutableMapOf()
 
@@ -52,29 +52,19 @@ class Fir2IrClassifierStorage(
 
     private val typeAliasCache: MutableMap<FirTypeAlias, IrTypeAlias> = mutableMapOf()
 
-    private val typeParameterCache: MutableMap<FirTypeParameter, IrTypeParameter> = merge { it.typeParameterCache }
+    private val typeParameterCache: MutableMap<FirTypeParameter, IrTypeParameter> = commonMemberStorage.typeParameterCache
 
     private val typeParameterCacheForSetter: MutableMap<FirTypeParameter, IrTypeParameter> = mutableMapOf()
 
-    private val enumEntryCache: MutableMap<FirEnumEntry, IrEnumEntry> = merge { it.enumEntryCache }
+    private val enumEntryCache: MutableMap<FirEnumEntry, IrEnumEntry> = commonMemberStorage.enumEntryCache
 
     private val fieldsForContextReceivers: MutableMap<IrClass, List<IrField>> = mutableMapOf()
 
     private val localStorage: Fir2IrLocalClassStorage = Fir2IrLocalClassStorage(
-        // Merge is necessary here to be able to serialize local classes from common code in expression codegen
+        // Using existing cache is necessary here to be able to serialize local classes from common code in expression codegen
-        dependentStorages.map { it.localStorage }.fold(mutableMapOf()) { result, storage ->
+        commonMemberStorage.localClassCache
-            result.putAll(storage.localClassCache)
-            result
-        }
     )
 
-    private fun <K, V> merge(mapFunc: (Fir2IrClassifierStorage) -> MutableMap<K, V>): MutableMap<K, V> {
-        return dependentStorages.map { mapFunc(it) }.fold(mutableMapOf()) { result, map ->
-            result.putAll(map)
-            result
-        }
-    }
-
     private fun FirTypeRef.toIrType(typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT): IrType =
         with(typeConverter) { toIrType(typeContext) }
 

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

@@ -0,0 +1,51 @@
+/*
+ * 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.fir.declarations.*
+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.IdSignatureComposer
+import org.jetbrains.kotlin.ir.util.SymbolTable
+import java.util.concurrent.ConcurrentHashMap
+
+class Fir2IrCommonMemberStorage(
+    generateSignatures: Boolean,
+    signatureComposerCreator: (() -> IdSignatureComposer)?,
+    manglerCreator: () -> FirMangler
+) {
+    val signatureComposer: FirBasedSignatureComposer
+
+    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 classCache: MutableMap<FirRegularClass, IrClass> = mutableMapOf()
+
+    val typeParameterCache: MutableMap<FirTypeParameter, IrTypeParameter> = mutableMapOf()
+
+    val enumEntryCache: MutableMap<FirEnumEntry, IrEnumEntry> = mutableMapOf()
+
+    val localClassCache: MutableMap<FirClass, IrClass> = mutableMapOf()
+
+    val functionCache: ConcurrentHashMap<FirFunction, IrSimpleFunction> = ConcurrentHashMap()
+
+    val propertyCache: ConcurrentHashMap<FirProperty, IrProperty> = ConcurrentHashMap()
+
+    val fakeOverridesInClass: MutableMap<IrClass, MutableMap<FirCallableDeclaration, FirCallableDeclaration>> = mutableMapOf()
+}

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

@@ -15,12 +15,8 @@ import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.config.AnalysisFlags
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.backend.generators.*
-import org.jetbrains.kotlin.fir.backend.generators.DataClassMembersGenerator
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.declarations.utils.isSynthetic
@@ -30,18 +26,16 @@ import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.generatedMembers
 import org.jetbrains.kotlin.fir.extensions.generatedNestedClassifiers
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
-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
 import org.jetbrains.kotlin.ir.interpreter.checker.EvaluationMode
 import org.jetbrains.kotlin.ir.interpreter.checker.IrConstTransformer
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.KotlinMangler
+import org.jetbrains.kotlin.ir.util.NaiveSourceBasedFileEntryImpl
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.psi.KtFile
 
@@ -430,23 +424,6 @@ 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,
@@ -460,23 +437,27 @@ class Fir2IrConverter(
             irGenerationExtensions: Collection<IrGenerationExtension>,
             generateSignatures: Boolean,
             kotlinBuiltIns: KotlinBuiltIns,
-            signatureComposer: FirBasedSignatureComposer,
+            commonMemberStorage: Fir2IrCommonMemberStorage,
-            symbolTable: SymbolTable,
-            dependentComponents: List<Fir2IrComponents>,
             initializedIrBuiltIns: IrBuiltInsOverFir?
         ): Fir2IrResult {
             val moduleDescriptor = FirModuleDescriptor(session, kotlinBuiltIns)
             val components = Fir2IrComponentsStorage(
-                session, scopeSession, symbolTable, irFactory, signatureComposer, fir2IrExtensions, generateSignatures
+                session,
+                scopeSession,
+                commonMemberStorage.symbolTable,
+                irFactory,
+                commonMemberStorage.signatureComposer,
+                fir2IrExtensions,
+                generateSignatures
             )
             val converter = Fir2IrConverter(moduleDescriptor, components)
 
             components.converter = converter
 
-            val classifierStorage = Fir2IrClassifierStorage(components, dependentComponents.map { it.classifierStorage })
+            val classifierStorage = Fir2IrClassifierStorage(components, commonMemberStorage)
             components.classifierStorage = classifierStorage
             components.delegatedMemberGenerator = DelegatedMemberGenerator(components)
-            val declarationStorage = Fir2IrDeclarationStorage(components, moduleDescriptor, dependentComponents.map { it.declarationStorage })
+            val declarationStorage = Fir2IrDeclarationStorage(components, moduleDescriptor, commonMemberStorage)
             components.declarationStorage = declarationStorage
             components.visibilityConverter = visibilityConverter
             val typeConverter = Fir2IrTypeConverter(components)
@@ -499,7 +480,7 @@ class Fir2IrConverter(
             val irProvider = FirIrProvider(components)
             components.irProviders = listOf(irProvider)
 
-            fir2IrExtensions.registerDeclarations(symbolTable)
+            fir2IrExtensions.registerDeclarations(commonMemberStorage.symbolTable)
 
             val irModuleFragment = IrModuleFragmentImpl(moduleDescriptor, irBuiltIns)
 
@@ -517,36 +498,3 @@ class Fir2IrConverter(
         }
     }
 }
-
-private class WrappedDescriptorSignatureComposer(
-    private val delegate: IdSignatureComposer,
-    private val firComposer: Fir2IrSignatureComposer
-) : IdSignatureComposer by delegate {
-    override fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit) {
-        firComposer.withFileSignature(fileSignature) {
-            delegate.withFileSignature(fileSignature, body)
-        }
-    }
-}
-
-private class DescriptorSignatureComposerStub : IdSignatureComposer {
-    override fun composeSignature(descriptor: DeclarationDescriptor): IdSignature? {
-        return null
-    }
-
-    override fun composeEnumEntrySignature(descriptor: ClassDescriptor): IdSignature? {
-        return null
-    }
-
-    override fun composeFieldSignature(descriptor: PropertyDescriptor): IdSignature? {
-        return null
-    }
-
-    override fun composeAnonInitSignature(descriptor: ClassDescriptor): IdSignature? {
-        return null
-    }
-
-    override fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit) {
-        body()
-    }
-}

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

@@ -65,7 +65,7 @@ import java.util.concurrent.ConcurrentHashMap
 class Fir2IrDeclarationStorage(
     private val components: Fir2IrComponents,
     private val moduleDescriptor: FirModuleDescriptor,
-    dependentStorages: List<Fir2IrDeclarationStorage>
+    commonMemberStorage: Fir2IrCommonMemberStorage
 ) : Fir2IrComponents by components {
 
     private val firProvider = session.firProvider
@@ -78,13 +78,13 @@ class Fir2IrDeclarationStorage(
 
     private val scriptCache: ConcurrentHashMap<FirScript, IrScript> = ConcurrentHashMap()
 
-    private val functionCache: ConcurrentHashMap<FirFunction, IrSimpleFunction> = merge(dependentStorages) { it.functionCache }
+    private val functionCache: ConcurrentHashMap<FirFunction, IrSimpleFunction> = commonMemberStorage.functionCache
 
     private val constructorCache: ConcurrentHashMap<FirConstructor, IrConstructor> = ConcurrentHashMap()
 
     private val initializerCache: ConcurrentHashMap<FirAnonymousInitializer, IrAnonymousInitializer> = ConcurrentHashMap()
 
-    private val propertyCache: ConcurrentHashMap<FirProperty, IrProperty> = merge(dependentStorages) { it.propertyCache }
+    private val propertyCache: ConcurrentHashMap<FirProperty, IrProperty> = commonMemberStorage.propertyCache
 
     // interface A { /* $1 */ fun foo() }
     // interface B : A {
@@ -101,13 +101,11 @@ class Fir2IrDeclarationStorage(
     // so remember that in class B there's a fake override $2 for real $1.
     //
     // Thus, we may obtain it by fakeOverridesInClass[ir(B)][fir(A::foo)] -> fir(B::foo)
+    //
+    // Note: reusing is necessary here, because sometimes (see testFakeOverridesInPlatformModule)
+    // we have to match fake override in platform class with overridden fake overrides in common class
     private val fakeOverridesInClass: MutableMap<IrClass, MutableMap<FirCallableDeclaration, FirCallableDeclaration>> =
-        dependentStorages.map { it.fakeOverridesInClass }.fold(mutableMapOf()) { result, map ->
+        commonMemberStorage.fakeOverridesInClass
-            // Note: merge is necessary here, because sometimes (see testFakeOverridesInPlatformModule)
-            // we have to match fake override in platform class with overridden fake overrides in common class
-            result.putAll(map)
-            result
-        }
 
     // For pure fields (from Java) only
     private val fieldToPropertyCache: ConcurrentHashMap<Pair<FirField, IrDeclarationParent>, IrProperty> = ConcurrentHashMap()
@@ -122,16 +120,6 @@ class Fir2IrDeclarationStorage(
 
     private val localStorage: Fir2IrLocalCallableStorage by threadLocal { Fir2IrLocalCallableStorage() }
 
-    private fun <K, V> merge(
-        dependentStorages: List<Fir2IrDeclarationStorage>,
-        mapFunc: (Fir2IrDeclarationStorage) -> ConcurrentHashMap<K, V>
-    ): ConcurrentHashMap<K, V> {
-        return dependentStorages.map { mapFunc(it) }.fold(ConcurrentHashMap()) { result, map ->
-            result.putAll(map)
-            result
-        }
-    }
-
     private fun areCompatible(firFunction: FirFunction, irFunction: IrFunction): Boolean {
         if (firFunction is FirSimpleFunction && irFunction is IrSimpleFunction) {
             if (irFunction.name != firFunction.name) return false

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

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.backend
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.ir.declarations.IrClass
 
-class Fir2IrLocalClassStorage(internal val localClassCache: MutableMap<FirClass, IrClass> = mutableMapOf()) {
+class Fir2IrLocalClassStorage(private val localClassCache: MutableMap<FirClass, IrClass> = mutableMapOf()) {
     operator fun get(localClass: FirClass): IrClass? {
         return localClassCache[localClass]
     }

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

@@ -0,0 +1,20 @@
+/*
+ * 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.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.util.IdSignatureComposer
+
+class WrappedDescriptorSignatureComposer(
+    private val delegate: IdSignatureComposer,
+    private val firComposer: Fir2IrSignatureComposer
+) : IdSignatureComposer by delegate {
+    override fun withFileSignature(fileSignature: IdSignature.FileSignature, body: () -> Unit) {
+        firComposer.withFileSignature(fileSignature) {
+            delegate.withFileSignature(fileSignature, body)
+        }
+    }
+}

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

@@ -17,10 +17,7 @@ import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade
 import org.jetbrains.kotlin.fir.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
+import org.jetbrains.kotlin.fir.backend.*
-import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrResult
-import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
 import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProvider
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -118,7 +115,7 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
     val libraries = resolveJsLibraries(module, testServices, configuration)
     val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices)
 
-    val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+    val commonMemberStorage = Fir2IrCommonMemberStorage(
         generateSignatures = false,
         signatureComposerCreator = null,
         manglerCreator = { FirJvmKotlinMangler() } // TODO: replace with potentially simpler JS version
@@ -134,9 +131,7 @@ fun AbstractFirAnalyzerFacade.convertToJsIr(
         irGeneratorExtensions,
         generateSignatures = false,
         kotlinBuiltIns = builtIns ?: DefaultBuiltIns.Instance, // TODO: consider passing externally,
-        signatureComposer = signatureComposer,
+        commonMemberStorage = commonMemberStorage,
-        symbolTable = symbolTable,
-        dependentComponents = emptyList(),
         initializedIrBuiltIns = null
     ).also {
         (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = dependencies }

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

@@ -13,11 +13,10 @@ import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 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.Fir2IrCommonMemberStorage
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
-import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.IrBuiltInsOverFir
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
@@ -48,8 +47,6 @@ class Fir2IrResultsConverter(
         module: TestModule,
         inputArtifact: FirOutputArtifact
     ): IrBackendInput {
-        val isMppSupported = module.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects)
-
         val compilerConfigurationProvider = testServices.compilerConfigurationProvider
         val configuration = compilerConfigurationProvider.getCompilerConfiguration(module)
 
@@ -69,14 +66,14 @@ class Fir2IrResultsConverter(
 
         val phaseConfig = configuration.get(CLIConfigurationKeys.PHASE_CONFIG)
 
-        val componentsMap = mutableMapOf<String, Fir2IrComponents>()
         val dependentIrParts = mutableListOf<JvmIrCodegenFactory.JvmIrBackendInput>()
         lateinit var mainIrPart: JvmIrCodegenFactory.JvmIrBackendInput
+        lateinit var mainModuleComponents: Fir2IrComponents
 
         val generateSignatures =
             (inputArtifact.partsForDependsOnModules.last().firAnalyzerFacade as? FirAnalyzerFacade)?.generateSignatures == true
 
-        val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+        val commonMemberStorage = Fir2IrCommonMemberStorage(
             generateSignatures = generateSignatures,
             signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
             manglerCreator = { FirJvmKotlinMangler() }
@@ -84,17 +81,9 @@ class Fir2IrResultsConverter(
         var irBuiltIns: IrBuiltInsOverFir? = null
 
         for ((index, firOutputPart) in inputArtifact.partsForDependsOnModules.withIndex()) {
-            val dependentComponents = mutableListOf<Fir2IrComponents>()
-            if (isMppSupported) {
-                for (dependency in firOutputPart.module.dependsOnDependencies) {
-                    dependentComponents.add(componentsMap[dependency.moduleName]!!)
-                }
-            }
-
             val (irModuleFragment, components, pluginContext) = firOutputPart.firAnalyzerFacade.convertToIr(
-                fir2IrExtensions, signatureComposer, symbolTable, dependentComponents, irBuiltIns
+                fir2IrExtensions, commonMemberStorage, irBuiltIns
             )
-            componentsMap[firOutputPart.module.name] = components
             irBuiltIns = components.irBuiltIns
 
             val irPart = JvmIrCodegenFactory.JvmIrBackendInput(
@@ -111,12 +100,11 @@ class Fir2IrResultsConverter(
             if (index < inputArtifact.partsForDependsOnModules.size - 1) {
                 dependentIrParts.add(irPart)
             } else {
+                mainModuleComponents = components
                 mainIrPart = irPart
             }
         }
 
-        val mainModuleComponents = componentsMap[module.name]!!
-
         val codegenFactory = JvmIrCodegenFactory(configuration, phaseConfig)
         val generationState = GenerationState.Builder(
             project, ClassBuilderFactories.TEST,

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

@@ -32,7 +32,7 @@ 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.Fir2IrCommonMemberStorage
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
@@ -128,7 +128,7 @@ object GenerationUtils {
         )
         val fir2IrExtensions = JvmFir2IrExtensions(configuration, JvmIrDeserializerImpl(), JvmIrMangler)
 
-        val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+        val commonMemberStorage = Fir2IrCommonMemberStorage(
             generateSignatures = firAnalyzerFacade.generateSignatures,
             signatureComposerCreator = { JvmIdSignatureDescriptor(JvmDescriptorMangler(null)) },
             manglerCreator = { FirJvmKotlinMangler() }
@@ -136,9 +136,7 @@ object GenerationUtils {
 
         val (moduleFragment, components, pluginContext) = firAnalyzerFacade.convertToIr(
             fir2IrExtensions,
-            signatureComposer = signatureComposer,
+            commonMemberStorage,
-            symbolTable = symbolTable,
-            dependentComponents = emptyList(),
             irBuiltIns = null
         )
         val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext

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

@@ -21,10 +21,8 @@ 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.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
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.sourceFiles.LightTreeFile
 
@@ -36,9 +34,7 @@ abstract class AbstractFirAnalyzerFacade {
 
     abstract fun convertToIr(
         fir2IrExtensions: Fir2IrExtensions,
-        signatureComposer: FirBasedSignatureComposer,
+        commonMemberStorage: Fir2IrCommonMemberStorage,
-        symbolTable: SymbolTable,
-        dependentComponents: List<Fir2IrComponents>,
         irBuiltIns: IrBuiltInsOverFir?
     ): Fir2IrResult
 }
@@ -107,9 +103,7 @@ class FirAnalyzerFacade(
 
     override fun convertToIr(
         fir2IrExtensions: Fir2IrExtensions,
-        signatureComposer: FirBasedSignatureComposer,
+        commonMemberStorage: Fir2IrCommonMemberStorage,
-        symbolTable: SymbolTable,
-        dependentComponents: List<Fir2IrComponents>,
         irBuiltIns: IrBuiltInsOverFir?
     ): Fir2IrResult {
         if (_scopeSession == null) runResolution()
@@ -124,9 +118,7 @@ class FirAnalyzerFacade(
             irGeneratorExtensions,
             generateSignatures,
             kotlinBuiltIns = DefaultBuiltIns.Instance, // TODO: consider passing externally,
-            signatureComposer = signatureComposer,
+            commonMemberStorage = commonMemberStorage,
-            symbolTable = symbolTable,
-            dependentComponents = dependentComponents,
             initializedIrBuiltIns = irBuiltIns
         )
     }

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

@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.library.metadata.KlibMetadataFactories
-import org.jetbrains.kotlin.library.unresolvedDependencies
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
 internal val KlibFactories = KlibMetadataFactories(::KonanBuiltIns, DynamicTypeDeserializer, PlatformDependentTypeTransformer.None)
@@ -71,7 +70,7 @@ internal fun PhaseContext.fir2Ir(
         moduleDescriptor.setDependencies(ArrayList(dependencies))
     }
 
-    val (signatureComposer, symbolTable) = Fir2IrConverter.createSignatureComposerAndSymbolTable(
+    val commonMemberStorage = Fir2IrCommonMemberStorage(
         generateSignatures = false,
         signatureComposerCreator = null,
         manglerCreator = { FirJvmKotlinMangler() } // TODO: replace with potentially simpler JS version
@@ -87,9 +86,7 @@ internal fun PhaseContext.fir2Ir(
             IrGenerationExtension.getInstances(config.project),
             generateSignatures = false,
             kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance, // TODO: consider passing externally
-            signatureComposer = signatureComposer,
+            commonMemberStorage = commonMemberStorage,
-            symbolTable = symbolTable,
-            dependentComponents = emptyList(),
             initializedIrBuiltIns = null
     ).also {
         (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }