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.GenerationUtils
-import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
+import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.codegen.state.GenerationState
+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(
+            GenerationUtils.generateFiles(project, files, environment.configuration, ClassBuilderFactories.TEST, analysisResult)
-                project, ClassBuilderFactories.TEST, analysisResult.moduleDescriptor, analysisResult.bindingContext,
-                files, environment.configuration
-            ).setupGenerationState().build()
-
-        KotlinCodegenFacade.compileCorrectFiles(generationState)
 
         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() {
+abstract class AbstractDiagnosticsTestWithOldJvmBackend : AbstractDiagnosticsTestWithJvmBackend()
-
-    override fun GenerationState.Builder.setupGenerationState(): GenerationState.Builder =
-        codegenFactory(DefaultCodegenFactory).isIrBackend(false)
-}
 
 abstract class AbstractDiagnosticsTestWithJvmIrBackend : AbstractDiagnosticsTestWithJvmBackend() {
-
+    override fun updateConfiguration(configuration: CompilerConfiguration) {
-    override fun GenerationState.Builder.setupGenerationState(): GenerationState.Builder =
+        configuration.put(JVMConfigurationKeys.IR, true)
-        codegenFactory(
+    }
-            JvmIrCodegenFactory(
+}
-                environment.configuration.get(CLIConfigurationKeys.PHASE_CONFIG)
-                    ?: PhaseConfig(jvmPhases)
-            )
-        ).isIrBackend(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)
         }

idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/DebuggerTestCompilerFacility.kt

@@ -15,16 +15,12 @@ import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.newvfs.ArchiveFileSystem
 import com.intellij.psi.PsiManager
-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.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.cli.common.output.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.findMainClass
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CodegenTestUtil
-import org.jetbrains.kotlin.codegen.DefaultCodegenFactory
+import org.jetbrains.kotlin.codegen.GenerationUtils
-import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -170,25 +166,13 @@ class DebuggerTestCompilerFacility(
         val analysisResult = resolutionFacade.analyzeWithAllCompilerChecks(files)
         analysisResult.throwIfError()
 
-        val moduleDescriptor = resolutionFacade.moduleDescriptor
-        val bindingContext = analysisResult.bindingContext
-
         val configuration = CompilerConfiguration()
         configuration.put(JVMConfigurationKeys.JVM_TARGET, jvmTarget)
         configuration.put(JVMConfigurationKeys.IR, useIrBackend)
 
-        val state = GenerationState.Builder(project, ClassBuilderFactories.BINARIES, moduleDescriptor, bindingContext, files, configuration)
+        val state = GenerationUtils.generateFiles(project, files, configuration, ClassBuilderFactories.BINARIES, analysisResult) {
-            .generateDeclaredClassFilter(GenerationState.GenerateClassFilter.GENERATE_ALL)
+            generateDeclaredClassFilter(GenerationState.GenerateClassFilter.GENERATE_ALL)
-            .codegenFactory(
+        }
-                if (useIrBackend) {
-                    JvmIrCodegenFactory(PhaseConfig(jvmPhases))
-                } else {
-                    DefaultCodegenFactory
-                }
-            )
-            .build()
-
-        KotlinCodegenFacade.compileCorrectFiles(state)
 
         val extraDiagnostics = state.collectedExtraJvmDiagnostics
         if (!extraDiagnostics.isEmpty()) {
@@ -198,7 +182,7 @@ class DebuggerTestCompilerFacility(
 
         state.factory.writeAllTo(classesDir)
 
-        return findMainClass(bindingContext, resolutionFacade.getLanguageVersionSettings(), files)?.asString()
+        return findMainClass(analysisResult.bindingContext, resolutionFacade.getLanguageVersionSettings(), files)?.asString()
             ?: error("Cannot find main class name")
     }