Move usages of createPhaseConfig up to cli & test modules

compiler/cli/build.gradle.kts

@@ -14,6 +14,7 @@ dependencies {
     compile(project(":compiler:backend-common"))
     compile(project(":compiler:backend"))
     compile(project(":compiler:backend.jvm"))
+    compile(project(":compiler:ir.backend.common"))
     compile(project(":compiler:light-classes"))
     compile(project(":compiler:serialization"))
     compile(project(":compiler:plugin-api"))

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

@@ -31,7 +31,9 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.asJava.FilteredJvmDiagnostics
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection
 import org.jetbrains.kotlin.backend.common.output.SimpleOutputFileCollection
+import org.jetbrains.kotlin.backend.common.phaser.createPhaseConfig
 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.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.checkKotlinPackageUsage
@@ -434,6 +436,7 @@ object KotlinToJVMBytecodeCompiler {
         sourceFiles: List<KtFile>,
         module: Module?
     ): GenerationState {
+        val isIR = configuration.getBoolean(JVMConfigurationKeys.IR)
         val generationState = GenerationState.Builder(
             environment.project,
             ClassBuilderFactories.BINARIES,
@@ -442,7 +445,7 @@ object KotlinToJVMBytecodeCompiler {
             sourceFiles,
             configuration
         )
-            .codegenFactory(if (configuration.getBoolean(JVMConfigurationKeys.IR)) JvmIrCodegenFactory else DefaultCodegenFactory)
+            .codegenFactory(if (isIR) JvmIrCodegenFactory(createPhaseConfig(jvmPhases, configuration)) else DefaultCodegenFactory)
             .withModule(module)
             .onIndependentPartCompilationEnd(createOutputFilesFlushingCallbackIfPossible(configuration))
             .build()

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/phaser/PhaseConfig.kt

@@ -10,12 +10,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 
 fun createPhaseConfig(compoundPhase: CompilerPhase<*, *, *>, config: CompilerConfiguration): PhaseConfig {
-    val phases = compoundPhase.getNamedSubphases().fold(mutableMapOf<String, AnyNamedPhase>()) { acc, (_, phase) ->
+    val phases = compoundPhase.toPhaseMap()
-        check(phase.name !in acc) { "Duplicate phase name '${phase.name}'"}
-        acc[phase.name] = phase
-        acc
-    }
-
     val enabled = computeEnabled(phases, config).toMutableSet()
     val verbose = phaseSetFromConfiguration(phases, config, CommonConfigurationKeys.VERBOSE_PHASES)
 
@@ -37,6 +32,25 @@ fun createPhaseConfig(compoundPhase: CompilerPhase<*, *, *>, config: CompilerCon
     return PhaseConfig(compoundPhase, phases, enabled, verbose, toDumpStateBefore, toDumpStateAfter, toValidateStateBefore, toValidateStateAfter, needProfiling, checkConditions, checkStickyConditions)
 }
 
+fun createDefaultPhaseConfig(compoundPhase: CompilerPhase<*, *, *>): PhaseConfig {
+    val phases = compoundPhase.toPhaseMap()
+    val enabled = phases.values.toMutableSet()
+
+    return PhaseConfig(
+        compoundPhase, phases, enabled, emptySet(), emptySet(), emptySet(), emptySet(), emptySet(),
+        needProfiling = false,
+        checkConditions = false,
+        checkStickyConditions = false
+    )
+}
+
+private fun CompilerPhase<*, *, *>.toPhaseMap(): MutableMap<String, AnyNamedPhase> =
+    getNamedSubphases().fold(mutableMapOf()) { acc, (_, phase) ->
+        check(phase.name !in acc) { "Duplicate phase name '${phase.name}'"}
+        acc[phase.name] = phase
+        acc
+    }
+
 private fun computeEnabled(
     phases: MutableMap<String, AnyNamedPhase>,
     config: CompilerConfiguration

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.backend.common.descriptors.KnownPackageFragmentDescr
 import org.jetbrains.kotlin.backend.common.ir.Ir
 import org.jetbrains.kotlin.backend.common.ir.Symbols
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
-import org.jetbrains.kotlin.backend.common.phaser.createPhaseConfig
 import org.jetbrains.kotlin.backend.js.JsDeclarationFactory
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -34,7 +33,10 @@ import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.types.classifierOrFail
 import org.jetbrains.kotlin.ir.types.impl.IrDynamicTypeImpl
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.SymbolTable
+import org.jetbrains.kotlin.ir.util.getPropertyGetter
+import org.jetbrains.kotlin.ir.util.getPropertySetter
+import org.jetbrains.kotlin.ir.util.kotlinPackageFqn
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
@@ -45,12 +47,12 @@ class JsIrBackendContext(
     override val irBuiltIns: IrBuiltIns,
     val symbolTable: SymbolTable,
     irModuleFragment: IrModuleFragment,
-    override val configuration: CompilerConfiguration
+    override val configuration: CompilerConfiguration,
+    val phaseConfig: PhaseConfig
 ) : CommonBackendContext {
 
     override val builtIns = module.builtIns
 
-    val phaseConfig = createPhaseConfig(jsPhases, configuration)
     override var inVerbosePhase: Boolean = false
 
     val externalNestedClasses = mutableListOf<IrClass>()

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.ir.backend.js
 
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.LoggingContext
+import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.common.phaser.invokeToplevel
 import org.jetbrains.kotlin.backend.common.serialization.DeserializationStrategy
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
@@ -82,6 +83,7 @@ fun compile(
     project: Project,
     files: List<KtFile>,
     configuration: CompilerConfiguration,
+    phaseConfig: PhaseConfig,
     compileMode: CompilationMode,
     immediateDependencies: List<KlibModuleRef>,
     allDependencies: List<KlibModuleRef>,
@@ -167,7 +169,7 @@ fun compile(
         return TranslationResult.CompiledKlib
     }
 
-    val context = JsIrBackendContext(moduleDescriptor, irBuiltIns, symbolTable, moduleFragment, configuration)
+    val context = JsIrBackendContext(moduleDescriptor, irBuiltIns, symbolTable, moduleFragment, configuration, phaseConfig)
 
     deserializedModuleFragments.forEach {
         ExternalDependenciesGenerator(

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.backend.common.CommonBackendContext
 import org.jetbrains.kotlin.backend.common.ir.Ir
 import org.jetbrains.kotlin.backend.common.ir.Symbols
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
-import org.jetbrains.kotlin.backend.common.phaser.createPhaseConfig
 import org.jetbrains.kotlin.backend.jvm.descriptors.JvmDeclarationFactory
 import org.jetbrains.kotlin.backend.jvm.descriptors.JvmSharedVariablesManager
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -31,7 +30,9 @@ class JvmBackendContext(
     val state: GenerationState,
     val psiSourceManager: PsiSourceManager,
     override val irBuiltIns: IrBuiltIns,
-    irModuleFragment: IrModuleFragment, symbolTable: SymbolTable
+    irModuleFragment: IrModuleFragment,
+    symbolTable: SymbolTable,
+    val phaseConfig: PhaseConfig
 ) : CommonBackendContext {
     override val builtIns = state.module.builtIns
     override val declarationFactory: JvmDeclarationFactory = JvmDeclarationFactory(state)
@@ -39,7 +40,6 @@ class JvmBackendContext(
 
     override val ir = JvmIr(irModuleFragment, symbolTable)
 
-    val phaseConfig = createPhaseConfig(jvmPhases, state.configuration)
     override var inVerbosePhase: Boolean = false
 
     override val configuration get() = state.configuration

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.backend.jvm
 
+import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -14,22 +15,28 @@ import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 import org.jetbrains.kotlin.psi2ir.generators.GeneratorContext
 
 object JvmBackendFacade {
-    fun doGenerateFiles(files: Collection<KtFile>, state: GenerationState, errorHandler: CompilationErrorHandler) {
+    fun doGenerateFiles(
+        files: Collection<KtFile>,
+        state: GenerationState,
+        errorHandler: CompilationErrorHandler,
+        phaseConfig: PhaseConfig
+    ) {
         val psi2ir = Psi2IrTranslator(state.languageVersionSettings)
         val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext, extensions = JvmGeneratorExtensions)
         val irModuleFragment = psi2ir.generateModuleFragment(psi2irContext, files)
 
-        doGenerateFilesInternal(state, errorHandler, irModuleFragment, psi2irContext)
+        doGenerateFilesInternal(state, errorHandler, irModuleFragment, psi2irContext, phaseConfig)
     }
 
     internal fun doGenerateFilesInternal(
         state: GenerationState,
         errorHandler: CompilationErrorHandler,
         irModuleFragment: IrModuleFragment,
-        psi2irContext: GeneratorContext
+        psi2irContext: GeneratorContext,
+        phaseConfig: PhaseConfig
     ) {
         val jvmBackendContext = JvmBackendContext(
-            state, psi2irContext.sourceManager, psi2irContext.irBuiltIns, irModuleFragment, psi2irContext.symbolTable
+            state, psi2irContext.sourceManager, psi2irContext.irBuiltIns, irModuleFragment, psi2irContext.symbolTable, phaseConfig
         )
         //TODO
         ExternalDependenciesGenerator(

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.backend.jvm
 
+import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.context.PackageContext
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -25,7 +26,7 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 
-object JvmIrCodegenFactory : CodegenFactory {
+class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory {
 
     override fun generateModule(state: GenerationState, files: Collection<KtFile?>, errorHandler: CompilationErrorHandler) {
         assert(!files.any { it == null })
@@ -33,7 +34,7 @@ object JvmIrCodegenFactory : CodegenFactory {
         val psi2ir = Psi2IrTranslator(state.languageVersionSettings)
         val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext, extensions = JvmGeneratorExtensions)
         val irModuleFragment = psi2ir.generateModuleFragment(psi2irContext, files as Collection<KtFile>)
-        JvmBackendFacade.doGenerateFilesInternal(state, errorHandler, irModuleFragment, psi2irContext)
+        JvmBackendFacade.doGenerateFilesInternal(state, errorHandler, irModuleFragment, psi2irContext, phaseConfig)
     }
 
     override fun createPackageCodegen(state: GenerationState, files: Collection<KtFile>, fqName: FqName): PackageCodegen {
@@ -41,7 +42,7 @@ object JvmIrCodegenFactory : CodegenFactory {
 
         return object : PackageCodegen {
             override fun generate(errorHandler: CompilationErrorHandler) {
-                JvmBackendFacade.doGenerateFiles(files, state, errorHandler)
+                JvmBackendFacade.doGenerateFiles(files, state, errorHandler, phaseConfig)
             }
 
             override fun generateClassOrObject(classOrObject: KtClassOrObject, packagePartContext: PackageContext) {

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

@@ -54,7 +54,7 @@ private val propertiesPhase = makeIrFilePhase(
     stickyPostconditions = setOf((PropertiesLowering)::checkNoProperties)
 )
 
-internal val jvmPhases = namedIrFilePhase(
+val jvmPhases = namedIrFilePhase(
     name = "IrLowering",
     description = "IR lowering",
     lower = expectDeclarationsRemovingPhase then

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

@@ -18,7 +18,9 @@ package org.jetbrains.kotlin.codegen
 
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.TestsCompiletimeError
+import org.jetbrains.kotlin.backend.common.phaser.createPhaseConfig
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
+import org.jetbrains.kotlin.backend.jvm.jvmPhases
 import org.jetbrains.kotlin.cli.common.output.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace
@@ -74,7 +76,8 @@ object GenerationUtils {
             files.first().project, classBuilderFactory, analysisResult.moduleDescriptor, analysisResult.bindingContext,
             files, configuration
         ).codegenFactory(
-            if (configuration.getBoolean(JVMConfigurationKeys.IR)) JvmIrCodegenFactory else DefaultCodegenFactory
+            if (configuration.getBoolean(JVMConfigurationKeys.IR)) JvmIrCodegenFactory(createPhaseConfig(jvmPhases, configuration))
+            else DefaultCodegenFactory
         ).build()
         if (analysisResult.shouldGenerateCode) {
             KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)

idea/idea-jvm/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.kt

@@ -22,7 +22,9 @@ import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.wm.ToolWindow
 import com.intellij.util.Alarm
 import org.jetbrains.kotlin.analyzer.common.CommonPlatform
+import org.jetbrains.kotlin.backend.common.phaser.createDefaultPhaseConfig
 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.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler
@@ -318,7 +320,7 @@ class KotlinBytecodeToolWindow(private val myProject: Project, private val toolW
                 .generateDeclaredClassFilter(generateClassFilter)
                 .codegenFactory(
                     if (configuration.getBoolean(JVMConfigurationKeys.IR))
-                        JvmIrCodegenFactory
+                        JvmIrCodegenFactory(createDefaultPhaseConfig(jvmPhases))
                     else
                         DefaultCodegenFactory
                 )

js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateIrRuntime.kt

@@ -9,11 +9,13 @@ import com.intellij.openapi.Disposable
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiManager
+import org.jetbrains.kotlin.backend.common.phaser.createPhaseConfig
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.ir.backend.js.CompilationMode
 import org.jetbrains.kotlin.ir.backend.js.compile
+import org.jetbrains.kotlin.ir.backend.js.jsPhases
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.test.JsIrTestRuntime
 import org.jetbrains.kotlin.psi.KtFile
@@ -57,10 +59,12 @@ fun main() {
 
 
     fun buildKlib(sources: List<String>, outputPath: String) {
+        val configuration = buildConfiguration(environment)
         compile(
             project = environment.project,
             files = sources.map(::createPsiFile),
-            configuration = buildConfiguration(environment),
+            configuration = configuration,
+            phaseConfig = createPhaseConfig(jsPhases, configuration),
             compileMode = CompilationMode.KLIB,
             immediateDependencies = emptyList(),
             allDependencies = emptyList(),
@@ -70,4 +74,4 @@ fun main() {
 
     buildKlib(JsIrTestRuntime.FULL.sources, fullRuntimeKlibPath)
     buildKlib(JsIrTestRuntime.DEFAULT.sources, defaultRuntimeKlibPath)
-}
+}

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt

@@ -5,11 +5,9 @@
 
 package org.jetbrains.kotlin.js.test
 
+import org.jetbrains.kotlin.backend.common.phaser.createPhaseConfig
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.ir.backend.js.CompilationMode
+import org.jetbrains.kotlin.ir.backend.js.*
-import org.jetbrains.kotlin.ir.backend.js.KlibModuleRef
-import org.jetbrains.kotlin.ir.backend.js.TranslationResult
-import org.jetbrains.kotlin.ir.backend.js.compile
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
 import org.jetbrains.kotlin.js.facade.MainCallParameters
@@ -112,6 +110,7 @@ abstract class BasicIrBoxTest(
             project = config.project,
             files = filesToCompile,
             configuration = config.configuration,
+            phaseConfig = createPhaseConfig(jsPhases, config.configuration),
             compileMode = if (isMainModule) CompilationMode.JS else CompilationMode.KLIB,
             immediateDependencies = dependencies,
             allDependencies = allDependencies,