Refactor test utilties to reuse GenerationState construction

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJvmBackend.kt

@@ -6,14 +6,10 @@
 package org.jetbrains.kotlin.checkers
 
 import org.jetbrains.kotlin.analyzer.AnalysisResult
-import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
-import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
-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.DefaultCodegenFactory
-import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
-import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.GenerationUtils
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.context.ModuleContext
@@ -36,12 +32,7 @@ abstract class AbstractDiagnosticsTestWithJvmBackend : AbstractDiagnosticsTest()
             )
 
         val generationState =
-            GenerationState.Builder(
-                project, ClassBuilderFactories.TEST, analysisResult.moduleDescriptor, analysisResult.bindingContext,
-                files, environment.configuration
-            ).setupGenerationState().build()
-
-        KotlinCodegenFacade.compileCorrectFiles(generationState)
+            GenerationUtils.generateFiles(project, files, environment.configuration, ClassBuilderFactories.TEST, analysisResult)
 
         for (diagnostic in generationState.collectedExtraJvmDiagnostics.all()) {
             moduleTrace.report(diagnostic)
@@ -51,23 +42,12 @@ abstract class AbstractDiagnosticsTestWithJvmBackend : AbstractDiagnosticsTest()
 
     // DO NOT use FE-based diagnostics for JVM signature conflict
     override fun shouldSkipJvmSignatureDiagnostics(groupedByModule: Map<TestModule?, List<TestFile>>): Boolean = true
-
-    protected abstract fun GenerationState.Builder.setupGenerationState(): GenerationState.Builder
 }
 
-abstract class AbstractDiagnosticsTestWithOldJvmBackend : AbstractDiagnosticsTestWithJvmBackend() {
-
-    override fun GenerationState.Builder.setupGenerationState(): GenerationState.Builder =
-        codegenFactory(DefaultCodegenFactory).isIrBackend(false)
-}
+abstract class AbstractDiagnosticsTestWithOldJvmBackend : AbstractDiagnosticsTestWithJvmBackend()
 
 abstract class AbstractDiagnosticsTestWithJvmIrBackend : AbstractDiagnosticsTestWithJvmBackend() {
-
-    override fun GenerationState.Builder.setupGenerationState(): GenerationState.Builder =
-        codegenFactory(
-            JvmIrCodegenFactory(
-                environment.configuration.get(CLIConfigurationKeys.PHASE_CONFIG)
-                    ?: PhaseConfig(jvmPhases)
-            )
-        ).isIrBackend(true)
-}
+    override fun updateConfiguration(configuration: CompilerConfiguration) {
+        configuration.put(JVMConfigurationKeys.IR, true)
+    }
+}

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

@@ -21,6 +21,7 @@ import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.TestsCompiletimeError
+import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
@@ -169,6 +170,17 @@ object GenerationUtils {
             )
         analysisResult.throwIfError()
 
+        return generateFiles(project, files, configuration, classBuilderFactory, analysisResult)
+    }
+
+    fun generateFiles(
+        project: Project,
+        files: List<KtFile>,
+        configuration: CompilerConfiguration,
+        classBuilderFactory: ClassBuilderFactory,
+        analysisResult: AnalysisResult,
+        configureGenerationState: GenerationState.Builder.() -> Unit = {},
+    ): GenerationState {
         /* Currently Kapt3 only works with the old JVM backend, so disable IR for everything except actual bytecode generation. */
         val isIrBackend =
             classBuilderFactory.classBuilderMode == ClassBuilderMode.FULL && configuration.getBoolean(JVMConfigurationKeys.IR)
@@ -179,7 +191,7 @@ object GenerationUtils {
             if (isIrBackend)
                 JvmIrCodegenFactory(configuration.get(CLIConfigurationKeys.PHASE_CONFIG) ?: PhaseConfig(jvmPhases))
             else DefaultCodegenFactory
-        ).isIrBackend(isIrBackend).build()
+        ).isIrBackend(isIrBackend).apply(configureGenerationState).build()
         if (analysisResult.shouldGenerateCode) {
             KotlinCodegenFacade.compileCorrectFiles(generationState)
         }