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.
2023-09-17 00:14:28 +02:00
parent 72b5123fc8
commit 9943c7078c
7 changed files with 56 additions and 60 deletions
@@ -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) ||
-            type == null ||
-            !state.getConfiguration().getBoolean(JVMConfigurationKeys.EMIT_JVM_TYPE_ANNOTATIONS)) {
+        if (isAccessor(annotated) || type == null || !state.getConfig().getEmitJvmTypeAnnotations()) {
            return;
        }

@@ -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)
 }
@@ -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)) {
-                    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)}"
-                                )
-                            }
+                if (!context.config.emitJvmTypeAnnotations) return

-                            override fun visitTypeAnnotation(descr: String, path: TypePath?, visible: Boolean): AnnotationVisitor {
-                                return visitor(
-                                    TypeReference.newTypeParameterBoundReference(boundType, index, superIndex).value,
-                                    path,
-                                    descr,
-                                    visible
-                                )
-                            }
-                        }.generateTypeAnnotations(typeParameterContainer, superType)
-                    }
+                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 {
+                            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
        }
@@ -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)
 }
@@ -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 {
-    return configuration.getBoolean(JVMConfigurationKeys.ENABLE_IR_INLINER)
-}
+internal fun JvmBackendContext.irInlinerIsEnabled(): Boolean =
+    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))
-            FileLoweringPass.Empty
-        else
-            ExpectDeclarationRemover(context)
+        if (context.config.useFir) FileLoweringPass.Empty
+        else ExpectDeclarationRemover(context)
    },
    name = "ExpectDeclarationsRemoving",
    description = "Remove expect declaration from module fragment"
@@ -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)) {
-            AddSuperQualifierToJavaFieldAccessLowering
-        } else {
-            FileLoweringPass.Empty
-        }
+        if (context.config.useFir) AddSuperQualifierToJavaFieldAccessLowering
+        else FileLoweringPass.Empty
    },
    name = "AddSuperQualifierToJavaFieldAccess",
    description = "Make `\$delegate` methods for optimized delegated properties static",
@@ -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(
-    ::createLowering,
+internal val externalPackageParentPatcherPhase = makeIrModulePhase<JvmBackendContext>(
+    { 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())