JVM: add more flags to JvmBackendConfig

And use them instead of CompilerConfiguration, to reduce dependencies of
backend on the whole compiler (as opposed to just backend)
configuration.

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

@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper;
-import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
@@ -715,9 +714,7 @@ public abstract class AnnotationCodegen {
     }
 
     private void generateTypeAnnotations(@NotNull Annotated annotated, @Nullable KotlinType type) {
-        if (isAccessor(annotated) ||
+        if (isAccessor(annotated) || type == null || !state.getConfig().getEmitJvmTypeAnnotations()) {
-            type == null ||
-            !state.getConfiguration().getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) {
             return;
         }
 

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

@@ -102,4 +102,12 @@ class JvmBackendConfig(configuration: CompilerConfiguration) {
     val oldInnerClassesLogic: Boolean = configuration.getBoolean(JVMConfigurationKeys.OLD_INNER_CLASSES_LOGIC)
 
     val supportMultiFieldValueClasses: Boolean = languageVersionSettings.supportsFeature(LanguageFeature.ValueClasses)
+
+    val enableDebugMode: Boolean = configuration.getBoolean(JVMConfigurationKeys.ENABLE_DEBUG_MODE)
+
+    val enableIrInliner: Boolean = configuration.getBoolean(JVMConfigurationKeys.ENABLE_IR_INLINER)
+
+    val useFir: Boolean = configuration.getBoolean(CommonConfigurationKeys.USE_FIR)
+
+    val emitJvmTypeAnnotations: Boolean = configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)
 }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt

@@ -21,13 +21,15 @@ import org.jetbrains.annotations.Nullable
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
 import org.jetbrains.kotlin.backend.jvm.JvmSymbols
-import org.jetbrains.kotlin.backend.jvm.ir.*
+import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound
+import org.jetbrains.kotlin.backend.jvm.ir.isInlineClassType
+import org.jetbrains.kotlin.backend.jvm.ir.isOptionalAnnotationClass
+import org.jetbrains.kotlin.backend.jvm.ir.isWithFlexibleNullability
 import org.jetbrains.kotlin.backend.jvm.mapping.mapClass
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.TypeAnnotationCollector
 import org.jetbrains.kotlin.codegen.TypePathInfo
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
 import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
@@ -311,29 +313,29 @@ abstract class AnnotationCodegen(
                     }
                 }.genAnnotations(typeParameter, null, null)
 
-                if (context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) {
+                if (!context.config.emitJvmTypeAnnotations) return
-                    var superInterfaceIndex = 1
-                    typeParameter.superTypes.forEach { superType ->
-                        val isClassOrTypeParameter = !superType.isInterface() && !superType.isAnnotation()
-                        val superIndex = if (isClassOrTypeParameter) 0 else superInterfaceIndex++
-                        object : AnnotationCodegen(classCodegen, true) {
-                            override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor {
-                                throw RuntimeException(
-                                    "Error during generation: only type annotations should be presented on type parameters bounds: " +
-                                            "${ir2string(typeParameter)} in ${ir2string(typeParameter)}"
-                                )
-                            }
 
-                            override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor {
+                var superInterfaceIndex = 1
-                                return visitor(
+                typeParameter.superTypes.forEach { superType ->
-                                    TypeReference.newTypeParameterBoundReference(boundType, index, superIndex).value,
+                    val isClassOrTypeParameter = !superType.isInterface() && !superType.isAnnotation()
-                                    path,
+                    val superIndex = if (isClassOrTypeParameter) 0 else superInterfaceIndex++
-                                    descr,
+                    object : AnnotationCodegen(classCodegen, true) {
-                                    visible
+                        override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor {
-                                )
+                            throw RuntimeException(
-                            }
+                                "Error during generation: only type annotations should be presented on type parameters bounds: " +
-                        }.generateTypeAnnotations(typeParameterContainer, superType)
+                                        "${ir2string(typeParameter)} in ${ir2string(typeParameter)}"
-                    }
+                            )
+                        }
+
+                        override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor {
+                            return visitor(
+                                TypeReference.newTypeParameterBoundReference(boundType, index, superIndex).value,
+                                path,
+                                descr,
+                                visible
+                            )
+                        }
+                    }.generateTypeAnnotations(typeParameterContainer, superType)
                 }
             }
         }
@@ -398,7 +400,7 @@ abstract class AnnotationCodegen(
         type: IrType?
     ) {
         if ((annotated as? IrDeclaration)?.origin == JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR ||
-            type == null || !context.state.configuration.getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)
+            type == null || !context.config.emitJvmTypeAnnotations
         ) {
             return
         }

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt

@@ -7,11 +7,13 @@ package org.jetbrains.kotlin.backend.jvm.codegen
 
 import org.jetbrains.kotlin.backend.jvm.InlineClassAbi
 import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
-import org.jetbrains.kotlin.backend.jvm.ir.*
+import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound
+import org.jetbrains.kotlin.backend.jvm.ir.hasContinuation
+import org.jetbrains.kotlin.backend.jvm.ir.isReadOfCrossinline
+import org.jetbrains.kotlin.backend.jvm.ir.suspendFunctionOriginal
 import org.jetbrains.kotlin.backend.jvm.unboxInlineClass
 import org.jetbrains.kotlin.codegen.ClassBuilder
 import org.jetbrains.kotlin.codegen.coroutines.CoroutineTransformerMethodVisitor
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
@@ -19,7 +21,10 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.types.*
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.allOverridden
+import org.jetbrains.kotlin.ir.util.file
+import org.jetbrains.kotlin.ir.util.isSuspend
+import org.jetbrains.kotlin.ir.util.parentAsClass
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmBackendErrors
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Type
@@ -66,7 +71,7 @@ internal fun MethodNode.acceptWithStateMachine(
         internalNameForDispatchReceiver = classCodegen.type.internalName,
         putContinuationParameterToLvt = false,
         initialVarsCountByType = varsCountByType,
-        shouldOptimiseUnusedVariables = !context.configuration.getBoolean(JVMConfigurationKeys.ENABLE_DEBUG_MODE)
+        shouldOptimiseUnusedVariables = !context.config.enableDebugMode
     )
     accept(visitor)
 }

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/JvmLoweringPhases.kt

@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.backend.common.phaser.*
 import org.jetbrains.kotlin.backend.jvm.ir.constantValue
 import org.jetbrains.kotlin.backend.jvm.ir.shouldContainSuspendMarkers
 import org.jetbrains.kotlin.backend.jvm.lower.*
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.ir.IrElement
@@ -58,9 +56,8 @@ private fun makeCheckParentsPhase(): SameTypeNamedCompilerPhase<CommonBackendCon
     )
 }
 
-internal fun JvmBackendContext.irInlinerIsEnabled(): Boolean {
+internal fun JvmBackendContext.irInlinerIsEnabled(): Boolean =
-    return configuration.getBoolean(JVMConfigurationKeys.ENABLE_IR_INLINER)
+    config.enableIrInliner
-}
 
 private class PatchDeclarationParents : FileLoweringPass {
     override fun lower(irFile: IrFile) {
@@ -101,10 +98,8 @@ private val arrayConstructorPhase = makeIrFilePhase(
 
 internal val expectDeclarationsRemovingPhase = makeIrModulePhase(
     { context: JvmBackendContext ->
-        if (context.state.configuration.getBoolean(CommonConfigurationKeys.USE_FIR))
+        if (context.config.useFir) FileLoweringPass.Empty
-            FileLoweringPass.Empty
+        else ExpectDeclarationRemover(context)
-        else
-            ExpectDeclarationRemover(context)
     },
     name = "ExpectDeclarationsRemoving",
     description = "Remove expect declaration from module fragment"

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AddSuperQualifierToJavaFieldAccessLowering.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.backend.jvm.lower
 import org.jetbrains.kotlin.backend.common.FileLoweringPass
 import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
 import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrField
@@ -24,11 +23,8 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 
 internal val addSuperQualifierToJavaFieldAccessPhase = makeIrFilePhase(
     { context ->
-        if (context.state.configuration.getBoolean(CommonConfigurationKeys.USE_FIR)) {
+        if (context.config.useFir) AddSuperQualifierToJavaFieldAccessLowering
-            AddSuperQualifierToJavaFieldAccessLowering
+        else FileLoweringPass.Empty
-        } else {
-            FileLoweringPass.Empty
-        }
     },
     name = "AddSuperQualifierToJavaFieldAccess",
     description = "Make `\$delegate` methods for optimized delegated properties static",

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ExternalPackageParentPatcherLowering.kt

@@ -5,12 +5,10 @@
 
 package org.jetbrains.kotlin.backend.jvm.lower
 
-import org.jetbrains.kotlin.backend.common.CommonBackendContext
 import org.jetbrains.kotlin.backend.common.FileLoweringPass
 import org.jetbrains.kotlin.backend.common.phaser.makeIrModulePhase
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmFileFacadeClass
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
@@ -20,20 +18,15 @@ import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.load.kotlin.FacadeClassSource
 
-internal val externalPackageParentPatcherPhase = makeIrModulePhase(
+internal val externalPackageParentPatcherPhase = makeIrModulePhase<JvmBackendContext>(
-    ::createLowering,
+    { context ->
+        if (context.config.useFir) ExternalPackageParentPatcherLowering(context)
+        else FileLoweringPass.Empty
+    },
     name = "ExternalPackageParentPatcherLowering",
     description = "Replace parent from package fragment to FileKt class for top-level callables (K2 only)"
 )
 
-private fun createLowering(context: CommonBackendContext): FileLoweringPass {
-    require(context is JvmBackendContext)
-    return when (context.configuration[CommonConfigurationKeys.USE_FIR]) {
-        true -> ExternalPackageParentPatcherLowering(context)
-        false, null -> FileLoweringPass.Empty
-    }
-}
-
 class ExternalPackageParentPatcherLowering(val context: JvmBackendContext) : FileLoweringPass {
     override fun lower(irFile: IrFile) {
         irFile.acceptVoid(Visitor())