[Test] Remove duplicating code from ClassicFrontend2IrConverter

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -40,7 +40,23 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.CleanableBindingContext
 
 class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory {
+    data class JvmIrBackendInput(
+        val state: GenerationState,
+        val irModuleFragment: IrModuleFragment,
+        val symbolTable: SymbolTable,
+        val sourceManager: PsiSourceManager,
+        val phaseConfig: PhaseConfig,
+        val irProviders: List<IrProvider>,
+        val extensions: JvmGeneratorExtensions,
+        val backendExtension: JvmBackendExtension,
+    )
+
     override fun generateModule(state: GenerationState, files: Collection<KtFile>) {
+        val input = convertToIr(state, files)
+        doGenerateFilesInternal(input)
+    }
+
+    fun convertToIr(state: GenerationState, files: Collection<KtFile>): JvmIrBackendInput {
         val extensions = JvmGeneratorExtensions()
         val mangler = JvmManglerDesc(MainFunctionDetector(state.bindingContext, state.languageVersionSettings))
         val psi2ir = Psi2IrTranslator(state.languageVersionSettings, Psi2IrConfiguration())
@@ -116,23 +132,20 @@ class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory
                 ?: error("BindingContext should be cleanable in JVM IR to avoid leaking memory: ${state.originalFrontendBindingContext}")
             originalBindingContext.clear()
         }
-
+        return JvmIrBackendInput(
-        doGenerateFilesInternal(
+            state,
-            state, irModuleFragment, psi2irContext.symbolTable, psi2irContext.sourceManager, phaseConfig,
+            irModuleFragment,
-            irProviders, extensions, JvmBackendExtension.Default,
+            symbolTable,
+            psi2irContext.sourceManager,
+            phaseConfig,
+            irProviders,
+            extensions,
+            JvmBackendExtension.Default,
         )
     }
 
-    fun doGenerateFilesInternal(
+    fun doGenerateFilesInternal(input: JvmIrBackendInput) {
-        state: GenerationState,
+        val (state, irModuleFragment, symbolTable, sourceManager, phaseConfig, irProviders, extensions, backendExtension) = input
-        irModuleFragment: IrModuleFragment,
-        symbolTable: SymbolTable,
-        sourceManager: PsiSourceManager,
-        phaseConfig: PhaseConfig,
-        irProviders: List<IrProvider>,
-        extensions: JvmGeneratorExtensions,
-        backendExtension: JvmBackendExtension,
-    ) {
         val context = JvmBackendContext(
             state, sourceManager, irModuleFragment.irBuiltins, irModuleFragment,
             symbolTable, phaseConfig, extensions, backendExtension
@@ -179,13 +192,20 @@ class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory
         extensions: JvmGeneratorExtensions,
         backendExtension: JvmBackendExtension,
     ) {
-        irModuleFragment.irBuiltins.functionFactory = IrFunctionFactory(irModuleFragment.irBuiltins, symbolTable)
+        val irProviders = configureBuiltInsAndgenerateIrProvidersInFrontendIRMode(irModuleFragment, symbolTable, extensions)
-        val irProviders = generateTypicalIrProviderList(
-            irModuleFragment.descriptor, irModuleFragment.irBuiltins, symbolTable, extensions = extensions
-        )
-
         doGenerateFilesInternal(
-            state, irModuleFragment, symbolTable, sourceManager, phaseConfig, irProviders, extensions, backendExtension,
+            JvmIrBackendInput(state, irModuleFragment, symbolTable, sourceManager, phaseConfig, irProviders, extensions, backendExtension)
+        )
+    }
+
+    fun configureBuiltInsAndgenerateIrProvidersInFrontendIRMode(
+        irModuleFragment: IrModuleFragment,
+        symbolTable: SymbolTable,
+        extensions: JvmGeneratorExtensions
+    ): List<IrProvider> {
+        irModuleFragment.irBuiltins.functionFactory = IrFunctionFactory(irModuleFragment.irBuiltins, symbolTable)
+        return generateTypicalIrProviderList(
+            irModuleFragment.descriptor, irModuleFragment.irBuiltins, symbolTable, extensions = extensions
         )
     }
 }

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

@@ -5,27 +5,13 @@
 
 package org.jetbrains.kotlin.test.backend.ir
 
-import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
+import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
-import org.jetbrains.kotlin.backend.jvm.JvmBackendExtension
-import org.jetbrains.kotlin.backend.jvm.JvmGeneratorExtensions
-import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.linkage.IrProvider
-import org.jetbrains.kotlin.ir.util.SymbolTable
-import org.jetbrains.kotlin.psi2ir.PsiSourceManager
 import org.jetbrains.kotlin.test.model.BackendKinds
 import org.jetbrains.kotlin.test.model.ResultingArtifact
 
 // IR backend (JVM, JS, Native)
 data class IrBackendInput(
-    val state: GenerationState,
+    val backendInput: JvmIrCodegenFactory.JvmIrBackendInput
-    val irModuleFragment: IrModuleFragment,
-    val symbolTable: SymbolTable,
-    val sourceManager: PsiSourceManager,
-    val phaseConfig: PhaseConfig,
-    val irProviders: List<IrProvider>,
-    val extensions: JvmGeneratorExtensions,
-    val backendExtension: JvmBackendExtension,
 ) : ResultingArtifact.BackendInput<IrBackendInput>() {
     override val kind: BackendKinds.IrBackend
         get() = BackendKinds.IrBackend

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

@@ -16,19 +16,9 @@ class JvmIrBackendFacade(
         module: TestModule,
         inputArtifact: IrBackendInput
     ): BinaryArtifacts.Jvm {
-        val (state, irModuleFragment, symbolTable, sourceManager, phaseConfig, irProviders, extensions, backendExtension) = inputArtifact
+        val state = inputArtifact.backendInput.state
-
         val codegenFactory = state.codegenFactory as JvmIrCodegenFactory
-        codegenFactory.doGenerateFilesInternal(
+        codegenFactory.doGenerateFilesInternal(inputArtifact.backendInput)
-            state,
-            irModuleFragment,
-            symbolTable,
-            sourceManager,
-            phaseConfig,
-            irProviders,
-            extensions,
-            backendExtension,
-        )
         state.factory.done()
 
         return BinaryArtifacts.Jvm(state.factory)

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

@@ -5,33 +5,12 @@
 
 package org.jetbrains.kotlin.test.frontend.classic
 
-import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
-import org.jetbrains.kotlin.backend.common.extensions.IrPluginContextImpl
-import org.jetbrains.kotlin.backend.common.ir.BuiltinSymbolsBase
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
-import org.jetbrains.kotlin.backend.jvm.*
+import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
-import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor
+import org.jetbrains.kotlin.backend.jvm.jvmPhases
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
-import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin
-import org.jetbrains.kotlin.idea.MainFunctionDetector
-import org.jetbrains.kotlin.ir.backend.jvm.serialization.EmptyLoggingContext
-import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrLinker
-import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
-import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
-import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory
-import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
-import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
-import org.jetbrains.kotlin.ir.util.SymbolTable
-import org.jetbrains.kotlin.ir.util.TypeTranslator
-import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
-import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
 import org.jetbrains.kotlin.test.model.BackendKinds
 import org.jetbrains.kotlin.test.model.Frontend2BackendConverter
@@ -57,98 +36,14 @@ class ClassicFrontend2IrConverter(
 
         val files = psiFiles.values.toList()
         val phaseConfig = configuration.get(CLIConfigurationKeys.PHASE_CONFIG) ?: PhaseConfig(jvmPhases)
+        val codegenFactory = JvmIrCodegenFactory(phaseConfig)
         val state = GenerationState.Builder(
             project, ClassBuilderFactories.TEST, analysisResult.moduleDescriptor, analysisResult.bindingContext,
             files, configuration
-        ).codegenFactory(
+        ).codegenFactory(codegenFactory)
-            JvmIrCodegenFactory(phaseConfig)
+            .isIrBackend(true)
-        ).isIrBackend(true).build()
+            .build()
 
-        val extensions = JvmGeneratorExtensions()
+        return IrBackendInput(codegenFactory.convertToIr(state, files))
-        val mangler = JvmManglerDesc(MainFunctionDetector(state.bindingContext, state.languageVersionSettings))
-        val psi2ir = Psi2IrTranslator(state.languageVersionSettings, Psi2IrConfiguration())
-        val symbolTable = SymbolTable(JvmIdSignatureDescriptor(mangler), IrFactoryImpl, JvmNameProvider)
-        val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext, symbolTable, extensions)
-        val pluginExtensions = IrGenerationExtension.getInstances(state.project)
-        val functionFactory = IrFunctionFactory(psi2irContext.irBuiltIns, symbolTable)
-        psi2irContext.irBuiltIns.functionFactory = functionFactory
-
-        val stubGenerator = DeclarationStubGenerator(
-            psi2irContext.moduleDescriptor, symbolTable, psi2irContext.irBuiltIns.languageVersionSettings, extensions
-        )
-        val frontEndContext = object : TranslationPluginContext {
-            override val moduleDescriptor: ModuleDescriptor
-                get() = psi2irContext.moduleDescriptor
-            override val bindingContext: BindingContext
-                get() = psi2irContext.bindingContext
-            override val symbolTable: ReferenceSymbolTable
-                get() = symbolTable
-            override val typeTranslator: TypeTranslator
-                get() = psi2irContext.typeTranslator
-            override val irBuiltIns: IrBuiltIns
-                get() = psi2irContext.irBuiltIns
-        }
-        val irLinker = JvmIrLinker(
-            psi2irContext.moduleDescriptor,
-            EmptyLoggingContext,
-            psi2irContext.irBuiltIns,
-            symbolTable,
-            functionFactory,
-            frontEndContext,
-            stubGenerator,
-            mangler
-        )
-
-        val pluginContext by lazy {
-            psi2irContext.run {
-                val symbols = BuiltinSymbolsBase(irBuiltIns, moduleDescriptor.builtIns, symbolTable.lazyWrapper)
-                IrPluginContextImpl(
-                    moduleDescriptor, bindingContext, languageVersionSettings, symbolTable, typeTranslator, irBuiltIns, irLinker, symbols
-                )
-            }
-        }
-
-        for (extension in pluginExtensions) {
-            psi2ir.addPostprocessingStep { moduleFragment ->
-                val old = stubGenerator.unboundSymbolGeneration
-                try {
-                    stubGenerator.unboundSymbolGeneration = true
-                    extension.generate(moduleFragment, pluginContext)
-                } finally {
-                    stubGenerator.unboundSymbolGeneration = old
-                }
-            }
-        }
-
-        val dependencies = psi2irContext.moduleDescriptor.allDependencyModules.map {
-            val kotlinLibrary = (it.getCapability(KlibModuleOrigin.CAPABILITY) as? DeserializedKlibModuleOrigin)?.library
-            irLinker.deserializeIrModuleHeader(it, kotlinLibrary)
-        }
-        val irProviders = listOf(irLinker)
-
-        val irModuleFragment = psi2ir.generateModuleFragment(
-            psi2irContext,
-            files,
-            irProviders,
-            pluginExtensions,
-            expectDescriptorToSymbol = null
-        )
-        irLinker.postProcess()
-
-        stubGenerator.unboundSymbolGeneration = true
-
-        // We need to compile all files we reference in Klibs
-        irModuleFragment.files.addAll(dependencies.flatMap { it.files })
-
-        return IrBackendInput(
-            state,
-            irModuleFragment,
-            symbolTable,
-            psi2irContext.sourceManager,
-            phaseConfig,
-            irProviders,
-            extensions,
-            JvmBackendExtension.Default,
-        )
     }
 }

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

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory
-import org.jetbrains.kotlin.ir.util.generateTypicalIrProviderList
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
@@ -77,19 +76,23 @@ class Fir2IrResultsConverter(
         ).build()
 
         irModuleFragment.irBuiltins.functionFactory = IrFunctionFactory(irModuleFragment.irBuiltins, symbolTable)
-        val irProviders = generateTypicalIrProviderList(
+        val irProviders = codegenFactory.configureBuiltInsAndgenerateIrProvidersInFrontendIRMode(
-            irModuleFragment.descriptor, irModuleFragment.irBuiltins, symbolTable, extensions = extensions
+            irModuleFragment,
+            symbolTable,
+            extensions
         )
 
         return IrBackendInput(
-            generationState,
+            JvmIrCodegenFactory.JvmIrBackendInput(
-            irModuleFragment,
+                generationState,
-            symbolTable,
+                irModuleFragment,
-            sourceManager,
+                symbolTable,
-            phaseConfig,
+                sourceManager,
-            irProviders,
+                phaseConfig,
-            extensions,
+                irProviders,
-            FirJvmBackendExtension(inputArtifact.session, components)
+                extensions,
+                FirJvmBackendExtension(inputArtifact.session, components)
+            )
         )
     }
 }