Backend: remove codegen factory from generation state

use it explicitly. This is a step in attempt to abstract dependencies
on PSI in the GenerationState and related places.

compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.psi.KtFile;
 import java.util.Collection;
 
 public class KotlinCodegenFacade {
-    public static void compileCorrectFiles(@NotNull GenerationState state) {
+    public static void compileCorrectFiles(@NotNull GenerationState state, CodegenFactory codegenFactory) {
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
         state.beforeCompile();
@@ -33,11 +33,11 @@ public class KotlinCodegenFacade {
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
         CodegenFactory.IrConversionInput psi2irInput = CodegenFactory.IrConversionInput.Companion.fromGenerationState(state);
-        CodegenFactory.BackendInput backendInput = state.getCodegenFactory().convertToIr(psi2irInput);
+        CodegenFactory.BackendInput backendInput = codegenFactory.convertToIr(psi2irInput);
 
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled();
 
-        state.getCodegenFactory().generateModule(state, backendInput);
+        codegenFactory.generateModule(state, backendInput);
 
         CodegenFactory.Companion.doCheckCancelled(state);
         state.getFactory().done();

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -62,7 +62,6 @@ class GenerationState private constructor(
     val files: List<KtFile>,
     val configuration: CompilerConfiguration,
     val generateDeclaredClassFilter: GenerateClassFilter,
-    val codegenFactory: CodegenFactory,
     val targetId: TargetId?,
     moduleName: String?,
     val outDirectory: File?,
@@ -86,10 +85,6 @@ class GenerationState private constructor(
         fun generateDeclaredClassFilter(v: GenerateClassFilter) =
             apply { generateDeclaredClassFilter = v }
 
-        private var codegenFactory: CodegenFactory = DefaultCodegenFactory
-        fun codegenFactory(v: CodegenFactory) =
-            apply { codegenFactory = v }
-
         private var targetId: TargetId? = null
         fun targetId(v: TargetId?) =
             apply { targetId = v }
@@ -135,7 +130,7 @@ class GenerationState private constructor(
         fun build() =
             GenerationState(
                 project, builderFactory, module, bindingContext, files, configuration,
-                generateDeclaredClassFilter, codegenFactory, targetId,
+                generateDeclaredClassFilter, targetId,
                 moduleName, outDirectory, onIndependentPartCompilationEnd, wantsDiagnostics,
                 jvmBackendClassResolver, isIrBackend, ignoreErrors,
                 diagnosticReporter ?: DiagnosticReporterFactory.createReporter(),

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt

@@ -310,8 +310,6 @@ object FirKotlinToJvmBytecodeCompiler {
             (projectEnvironment as VfsBasedProjectEnvironment).project, ClassBuilderFactories.BINARIES,
             moduleFragment.descriptor, dummyBindingContext, ktFiles,
             moduleConfiguration
-        ).codegenFactory(
-            codegenFactory
         ).withModule(
             module
         ).onIndependentPartCompilationEnd(

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -133,7 +133,7 @@ object KotlinToJVMBytecodeCompiler {
         val outputs = ArrayList<GenerationState>(chunk.size)
 
         for (input in codegenInputs) {
-            outputs += runCodegen(input, input.state, result.bindingContext, diagnosticsReporter, environment.configuration)
+            outputs += runCodegen(input, input.state, codegenFactory, result.bindingContext, diagnosticsReporter, environment.configuration)
         }
 
         return writeOutputs(environment.project, projectConfiguration, chunk, outputs, mainClassFqName)
@@ -206,7 +206,7 @@ object KotlinToJVMBytecodeCompiler {
             environment, environment.configuration, result, environment.getSourceFiles(), null, codegenFactory, backendInput,
             diagnosticsReporter
         )
-        return runCodegen(input, input.state, result.bindingContext, diagnosticsReporter, environment.configuration)
+        return runCodegen(input, input.state, codegenFactory, result.bindingContext, diagnosticsReporter, environment.configuration)
     }
 
     private fun convertToIr(environment: KotlinCoreEnvironment, result: AnalysisResult): Pair<CodegenFactory, CodegenFactory.BackendInput> {
@@ -321,7 +321,6 @@ object KotlinToJVMBytecodeCompiler {
             sourceFiles,
             configuration
         )
-            .codegenFactory(codegenFactory)
             .withModule(module)
             .onIndependentPartCompilationEnd(createOutputFilesFlushingCallbackIfPossible(configuration))
             .diagnosticReporter(diagnosticsReporter)
@@ -343,6 +342,7 @@ object KotlinToJVMBytecodeCompiler {
     private fun runCodegen(
         codegenInput: CodegenFactory.CodegenInput,
         state: GenerationState,
+        codegenFactory: CodegenFactory,
         bindingContext: BindingContext,
         diagnosticsReporter: BaseDiagnosticsCollector,
         configuration: CompilerConfiguration,
@@ -352,7 +352,7 @@ object KotlinToJVMBytecodeCompiler {
         val performanceManager = configuration[CLIConfigurationKeys.PERF_MANAGER]
 
         performanceManager?.notifyIRGenerationStarted()
-        state.codegenFactory.invokeCodegen(codegenInput)
+        codegenFactory.invokeCodegen(codegenInput)
 
         CodegenFactory.doCheckCancelled(state)
         state.factory.done()

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt

@@ -222,8 +222,6 @@ fun generateCodeFromIr(
         (environment.projectEnvironment as VfsBasedProjectEnvironment).project, ClassBuilderFactories.BINARIES,
         input.irModuleFragment.descriptor, dummyBindingContext, emptyList()/* !! */,
         input.configuration
-    ).codegenFactory(
-        codegenFactory
     ).targetId(
         input.targetId
     ).moduleName(

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicJvmBackendFacade.kt

@@ -39,9 +39,9 @@ class ClassicJvmBackendFacade(
             analysisResult.bindingContext,
             psiFiles.toList(),
             configuration
-        ).codegenFactory(DefaultCodegenFactory).build()
+        ).build()
 
-        KotlinCodegenFacade.compileCorrectFiles(generationState)
+        KotlinCodegenFacade.compileCorrectFiles(generationState, DefaultCodegenFactory)
         javaCompilerFacade.compileJavaFiles(module, configuration, generationState.factory)
         return BinaryArtifacts.Jvm(generationState.factory)
     }

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.test.backend.ir
 
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
+import org.jetbrains.kotlin.codegen.CodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.backend.js.KotlinFileSerializedData
@@ -33,6 +34,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
 
     data class JvmIrBackendInput(
         val state: GenerationState,
+        val codegenFactory: JvmIrCodegenFactory,
         val backendInput: JvmIrCodegenFactory.JvmIrBackendInput
     ) : IrBackendInput() {
         override val irModuleFragment: IrModuleFragment

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

@@ -28,9 +28,8 @@ class JvmIrBackendFacade(
             "JvmIrBackendFacade expects IrBackendInput.JvmIrBackendInput as input"
         }
         val state = inputArtifact.state
-        val codegenFactory = state.codegenFactory as JvmIrCodegenFactory
         try {
-            codegenFactory.generateModule(state, inputArtifact.backendInput)
+            inputArtifact.codegenFactory.generateModule(state, inputArtifact.backendInput)
         } catch (e: BackendException) {
             if (CodegenTestDirectives.IGNORE_ERRORS in module.directives) {
                 return null

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

@@ -57,14 +57,14 @@ class ClassicFrontend2IrConverter(
         val state = GenerationState.Builder(
             project, ClassBuilderFactories.TEST, analysisResult.moduleDescriptor, analysisResult.bindingContext,
             files, configuration
-        ).codegenFactory(codegenFactory)
+        ).isIrBackend(true)
-            .isIrBackend(true)
             .ignoreErrors(CodegenTestDirectives.IGNORE_ERRORS in module.directives)
             .diagnosticReporter(DiagnosticReporterFactory.createReporter())
             .build()
 
         return IrBackendInput.JvmIrBackendInput(
             state,
+            codegenFactory,
             codegenFactory.convertToIr(CodegenFactory.IrConversionInput.fromGenerationState(state))
         )
     }

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

@@ -64,8 +64,6 @@ class Fir2IrResultsConverter(
             project, ClassBuilderFactories.TEST,
             container.get(), dummyBindingContext, ktFiles,
             configuration
-        ).codegenFactory(
-            codegenFactory
         ).isIrBackend(
             true
         ).jvmBackendClassResolver(
@@ -76,6 +74,7 @@ class Fir2IrResultsConverter(
 
         return IrBackendInput.JvmIrBackendInput(
             generationState,
+            codegenFactory,
             JvmIrCodegenFactory.JvmIrBackendInput(
                 irModuleFragment,
                 symbolTable,

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

@@ -125,8 +125,6 @@ object GenerationUtils {
 
         val generationState = GenerationState.Builder(
             project, classBuilderFactory, moduleFragment.descriptor, dummyBindingContext, files, configuration
-        ).codegenFactory(
-            codegenFactory
         ).isIrBackend(
             true
         ).jvmBackendClassResolver(
@@ -191,13 +189,14 @@ object GenerationUtils {
         val generationState = GenerationState.Builder(
             project, classBuilderFactory, analysisResult.moduleDescriptor, analysisResult.bindingContext,
             files, configuration
-        ).codegenFactory(
-            if (isIrBackend)
-                JvmIrCodegenFactory(configuration, configuration.get(CLIConfigurationKeys.PHASE_CONFIG))
-            else DefaultCodegenFactory
         ).isIrBackend(isIrBackend).apply(configureGenerationState).build()
         if (analysisResult.shouldGenerateCode) {
-            KotlinCodegenFacade.compileCorrectFiles(generationState)
+            KotlinCodegenFacade.compileCorrectFiles(
+                generationState,
+                if (isIrBackend)
+                    JvmIrCodegenFactory(configuration, configuration.get(CLIConfigurationKeys.PHASE_CONFIG))
+                else DefaultCodegenFactory
+            )
         }
         return generationState
     }

plugins/jvm-abi-gen/src/org/jetbrains/kotlin/jvm/abi/JvmAbiAnalysisHandlerExtension.kt

@@ -13,10 +13,7 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
-import org.jetbrains.kotlin.codegen.ClassBuilder
+import org.jetbrains.kotlin.codegen.*
-import org.jetbrains.kotlin.codegen.ClassBuilderFactory
-import org.jetbrains.kotlin.codegen.ClassBuilderMode
-import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.compilerRunner.OutputItemsCollector
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
@@ -76,7 +73,7 @@ class JvmAbiAnalysisHandlerExtension(
             files.toList(),
             compilerConfiguration
         ).targetId(targetId).build()
-        KotlinCodegenFacade.compileCorrectFiles(generationState)
+        KotlinCodegenFacade.compileCorrectFiles(generationState, DefaultCodegenFactory)
 
         val outputDir = compilerConfiguration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)!!
         val outputs = ArrayList<AbiOutput>()

plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt

@@ -277,15 +277,15 @@ abstract class AbstractKapt3Extension(
             compilerConfiguration
         ).targetId(targetId)
             .isIrBackend(isIrBackend)
-            .codegenFactory(
+            .build()
+
+        val (classFilesCompilationTime) = measureTimeMillis {
+            KotlinCodegenFacade.compileCorrectFiles(
+                generationState,
                 if (isIrBackend)
                     JvmIrCodegenFactory(compilerConfiguration, compilerConfiguration.get(CLIConfigurationKeys.PHASE_CONFIG))
                 else DefaultCodegenFactory
             )
-            .build()
-
-        val (classFilesCompilationTime) = measureTimeMillis {
-            KotlinCodegenFacade.compileCorrectFiles(generationState)
         }
 
         val compiledClasses = builderFactory.compiledClasses

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/KJvmReplCompilerBase.kt

@@ -197,7 +197,6 @@ open class KJvmReplCompilerBase<AnalyzerT : ReplCodeAnalyzerBase>(
             sourceFiles,
             compilationState.environment.configuration
         )
-            .codegenFactory(codegenFactory)
             .build()
 
         codegenFactory.generateModule(

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/ScriptJvmCompilerImpls.kt

@@ -246,16 +246,17 @@ private fun generate(
         analysisResult.bindingContext,
         sourceFiles,
         kotlinCompilerConfiguration
-    ).codegenFactory(
-        if (kotlinCompilerConfiguration.getBoolean(JVMConfigurationKeys.IR))
-            JvmIrCodegenFactory(
-                kotlinCompilerConfiguration,
-                kotlinCompilerConfiguration.get(CLIConfigurationKeys.PHASE_CONFIG),
-            ) else DefaultCodegenFactory
     ).diagnosticReporter(
         diagnosticsReporter
     ).build().also {
-        KotlinCodegenFacade.compileCorrectFiles(it)
+        KotlinCodegenFacade.compileCorrectFiles(
+            it,
+            if (kotlinCompilerConfiguration.getBoolean(JVMConfigurationKeys.IR))
+                JvmIrCodegenFactory(
+                    kotlinCompilerConfiguration,
+                    kotlinCompilerConfiguration.get(CLIConfigurationKeys.PHASE_CONFIG),
+                ) else DefaultCodegenFactory
+        )
         FirDiagnosticsCompilerResultsReporter.reportToMessageCollector(
             diagnosticsReporter,
             messageCollector,