JVM: reduce usages of GenerationState in favor of JvmBackendConfig

To help in decoupling JVM IR from the old JVM backend.
2023-09-16 23:49:47 +02:00
parent c3010dd599
commit 72b5123fc8
55 changed files with 106 additions and 104 deletions
@@ -23,6 +23,8 @@ import org.jetbrains.kotlin.codegen.VersionIndependentOpcodes
 import org.jetbrains.kotlin.codegen.addRecordComponent
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.codegen.writeKotlinMetadata
 import org.jetbrains.kotlin.config.JvmAnalysisFlags
 import org.jetbrains.kotlin.config.JvmTarget
@@ -83,7 +85,8 @@ class ClassCodegen private constructor(
    }

    val smap = context.getSourceMapper(irClass)
-    private val state get() = context.state
+    private val state: GenerationState get() = context.state
+    private val config: JvmBackendConfig = context.config

    private val innerClasses = mutableSetOf<IrClass>()
    val typeMapper =
@@ -112,15 +115,15 @@ class ClassCodegen private constructor(
    private val jvmSignatureClashDetector = JvmSignatureClashDetector(this)

    private val visitor = state.factory.newVisitor(irClass.descriptorOrigin, type, irClass.fileParent.loadSourceFilesInfo()).apply {
-        val signature = typeMapper.mapClassSignature(irClass, type, context.state.classBuilderMode.generateBodies)
+        val signature = typeMapper.mapClassSignature(irClass, type, state.classBuilderMode.generateBodies)
        // Ensure that the backend only produces class names that would be valid in the frontend for JVM.
-        if (context.state.classBuilderMode.generateBodies && signature.hasInvalidName()) {
+        if (state.classBuilderMode.generateBodies && signature.hasInvalidName()) {
            throw IllegalStateException("Generating class with invalid name '${type.className}': ${irClass.dump()}")
        }
        defineClass(
            irClass.psiElement,
-            state.config.classFileVersion,
-            irClass.getFlags(context.state.languageVersionSettings),
+            config.classFileVersion,
+            irClass.getFlags(config.languageVersionSettings),
            signature.name,
            signature.javaGenericSignature,
            signature.superclassName,
@@ -150,9 +153,9 @@ class ClassCodegen private constructor(
        if (shouldSkipCodeGenerationAccordingToGenerationFilter()) return

        // Generate PermittedSubclasses attribute for sealed class.
-        if (state.languageVersionSettings.supportsFeature(LanguageFeature.JvmPermittedSubclassesAttributeForSealed) &&
+        if (config.languageVersionSettings.supportsFeature(LanguageFeature.JvmPermittedSubclassesAttributeForSealed) &&
            irClass.modality == Modality.SEALED &&
-            state.config.target >= JvmTarget.JVM_17
+            config.target >= JvmTarget.JVM_17
        ) {
            generatePermittedSubclasses()
        }
@@ -203,7 +206,7 @@ class ClassCodegen private constructor(
        generateKotlinMetadataAnnotation()

        if (withinInline || !smap.isTrivial) {
-            visitor.visitSMAP(smap, !context.state.languageVersionSettings.supportsFeature(LanguageFeature.CorrectSourceMappingSyntax))
+            visitor.visitSMAP(smap, !config.languageVersionSettings.supportsFeature(LanguageFeature.CorrectSourceMappingSyntax))
        } else {
            smap.sourceInfo!!.sourceFileName?.let {
                visitor.visitSource(it, null)
@@ -214,7 +217,7 @@ class ClassCodegen private constructor(

        generateInnerAndOuterClasses()

-        visitor.done(state.config.generateSmapCopyToAnnotation)
+        visitor.done(config.generateSmapCopyToAnnotation)
        jvmSignatureClashDetector.reportErrors()
    }

@@ -282,8 +285,8 @@ class ClassCodegen private constructor(

        val isMultifileClassOrPart = kind == KotlinClassHeader.Kind.MULTIFILE_CLASS || kind == KotlinClassHeader.Kind.MULTIFILE_CLASS_PART

-        var extraFlags = JvmBackendExtension.Default.generateMetadataExtraFlags(state.config.abiStability)
-        if (isMultifileClassOrPart && state.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts)) {
+        var extraFlags = JvmBackendExtension.Default.generateMetadataExtraFlags(config.abiStability)
+        if (isMultifileClassOrPart && config.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts)) {
            extraFlags = extraFlags or JvmAnnotationNames.METADATA_MULTIFILE_PARTS_INHERIT_FLAG
        }
        if (metadata is MetadataSource.Script) {
@@ -303,7 +306,7 @@ class ClassCodegen private constructor(
        val isPublicAbi = irClass.symbol in context.publicAbiSymbols || irClass.isInlineSamWrapper ||
                type.isAnonymousClass && irClass.isInPublicInlineScope

-        writeKotlinMetadata(visitor, state, kind, isPublicAbi, extraFlags) { av ->
+        writeKotlinMetadata(visitor, context.config, kind, isPublicAbi, extraFlags) { av ->
            if (metadata != null) {
                metadataSerializer.serialize(metadata)?.let { (proto, stringTable) ->
                    DescriptorAsmUtil.writeAnnotationData(av, proto, stringTable)
@@ -346,7 +349,7 @@ class ClassCodegen private constructor(
            if (field.origin == IrDeclarationOrigin.PROPERTY_DELEGATE) null
            else methodSignatureMapper.mapFieldSignature(field)
        val fieldName = field.name.asString()
-        val flags = field.computeFieldFlags(context, state.languageVersionSettings)
+        val flags = field.computeFieldFlags(context, config.languageVersionSettings)
        val fv = visitor.newField(
            field.descriptorOrigin, flags, fieldName, fieldType.descriptor,
            fieldSignature, (field.initializer?.expression as? IrConst<*>)?.value
@@ -33,8 +33,7 @@ internal fun MethodNode.acceptWithStateMachine(
    obtainContinuationClassBuilder: () -> ClassBuilder,
 ) {
    val context = classCodegen.context
-    val state = context.state
-    val languageVersionSettings = state.languageVersionSettings
+    val languageVersionSettings = context.config.languageVersionSettings
    assert(languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)) { "Experimental coroutines are unsupported in JVM_IR backend" }

    val lineNumber = if (irFunction.startOffset >= 0) {
@@ -28,8 +28,9 @@ import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner.OperationKind.SAFE
 import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics
 import org.jetbrains.kotlin.codegen.pseudoInsns.fakeAlwaysFalseIfeq
 import org.jetbrains.kotlin.codegen.pseudoInsns.fixStackAndJump
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.diagnostics.BackendErrors
 import org.jetbrains.kotlin.ir.IrElement
@@ -153,7 +154,8 @@ class ExpressionCodegen(
    val typeMapper = classCodegen.typeMapper
    val methodSignatureMapper = classCodegen.methodSignatureMapper

-    val state = context.state
+    val state: GenerationState = context.state
+    val config: JvmBackendConfig = context.config

    override val visitor: InstructionAdapter
        get() = mv
@@ -217,7 +219,7 @@ class ExpressionCodegen(
        mv.visitCode()
        val startLabel = markNewLabel()
        val info = BlockInfo()
-        if (context.state.classBuilderMode.generateBodies) {
+        if (state.classBuilderMode.generateBodies) {
            if (irFunction.isMultifileBridge()) {
                // Multifile bridges need to have line number 1 to be filtered out by the intellij debugging filters.
                mv.visitLineNumber(1, startLabel)
@@ -281,7 +283,7 @@ class ExpressionCodegen(
    }

    private fun generateNonNullAssertions() {
-        if (state.config.isParamAssertionsDisabled)
+        if (config.isParamAssertionsDisabled)
            return

        if ((DescriptorVisibilities.isPrivate(irFunction.visibility) && !shouldGenerateNonNullAssertionsForPrivateFun(irFunction)) ||
@@ -341,7 +343,7 @@ class ExpressionCodegen(
        if (!expandedType.isNullable() && !isPrimitive(asmType)) {
            mv.load(findLocalIndex(param.symbol), asmType)
            mv.aconst(param.name.asString())
-            val methodName = if (state.config.unifiedNullChecks) "checkNotNullParameter" else "checkParameterIsNotNull"
+            val methodName = if (config.unifiedNullChecks) "checkNotNullParameter" else "checkParameterIsNotNull"
            mv.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, methodName, "(Ljava/lang/Object;Ljava/lang/String;)V", false)
        }
    }
@@ -371,7 +373,7 @@ class ExpressionCodegen(
            getNameForReceiverParameter(
                irFunction.toIrBasedDescriptor(),
                state.bindingContext,
-                context.configuration.languageVersionSettings
+                context.config.languageVersionSettings
            )
        } else {
            param.name.asString()
@@ -985,7 +987,7 @@ class ExpressionCodegen(
    }

    private fun generateGlobalReturnFlagIfPossible(expression: IrExpression, label: String) {
-        if (state.config.isInlineDisabled) {
+        if (config.isInlineDisabled) {
            context.ktDiagnosticReporter.at(expression, irFunction).report(BackendErrors.NON_LOCAL_RETURN_IN_DISABLED_INLINE)
            genThrow(mv, "java/lang/UnsupportedOperationException", "Non-local returns are not allowed with inlining disabled")
        } else {
@@ -1444,7 +1446,7 @@ class ExpressionCodegen(

        val gapEnd = afterJumpLabel ?: endOfFinallyCode
        tryWithFinallyInfo.gaps.add(gapStart to gapEnd)
-        if (state.languageVersionSettings.supportsFeature(LanguageFeature.ProperFinally)) {
+        if (config.languageVersionSettings.supportsFeature(LanguageFeature.ProperFinally)) {
            for (it in nestedTryWithoutFinally) {
                it.gaps.add(gapStart to gapEnd)
            }
@@ -1581,8 +1583,8 @@ class ExpressionCodegen(
            mappings,
            IrInlineIntrinsicsSupport(classCodegen, element, irFunction.fileParent),
            context.typeSystem,
-            state.languageVersionSettings,
-            state.config.unifiedNullChecks,
+            config.languageVersionSettings,
+            config.unifiedNullChecks,
        )

        return IrInlineCodegen(this, state, callee, signature, mappings, sourceCompiler, reifiedTypeInliner)
@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.backend.jvm.mapping.mapTypeAsDeclaration
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.codegen.visitAnnotableParameterCount
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
@@ -71,7 +72,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg
        val methodVisitor: MethodVisitor = wrapWithMaxLocalCalc(methodNode)

        if (context.config.generateParametersMetadata && !isSynthetic) {
-            generateParameterNames(irFunction, methodVisitor, context.state)
+            generateParameterNames(irFunction, methodVisitor, context.config)
        }

        if (irFunction.isWithAnnotations) {
@@ -211,7 +212,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg
    }

    private fun getThrownExceptions(function: IrFunction): List<String>? {
-        if (context.state.languageVersionSettings.supportsFeature(LanguageFeature.DoNotGenerateThrowsForDelegatedKotlinMembers) &&
+        if (context.config.languageVersionSettings.supportsFeature(LanguageFeature.DoNotGenerateThrowsForDelegatedKotlinMembers) &&
            function.origin == IrDeclarationOrigin.DELEGATED_MEMBER
        ) return null

@@ -335,9 +336,9 @@ private fun IrValueParameter.isSyntheticMarkerParameter(): Boolean =
    origin == IrDeclarationOrigin.DEFAULT_CONSTRUCTOR_MARKER ||
            origin == JvmLoweredDeclarationOrigin.SYNTHETIC_MARKER_PARAMETER

-private fun generateParameterNames(irFunction: IrFunction, mv: MethodVisitor, state: GenerationState) {
+private fun generateParameterNames(irFunction: IrFunction, mv: MethodVisitor, config: JvmBackendConfig) {
    irFunction.extensionReceiverParameter?.let {
-        mv.visitParameter(irFunction.extensionReceiverName(state), 0)
+        mv.visitParameter(irFunction.extensionReceiverName(config), 0)
    }
    for (irParameter in irFunction.valueParameters) {
        // A construct emitted by a Java compiler must be marked as synthetic if it does not correspond to a construct declared
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.backend.jvm.ir.getCallableReferenceTopLevelFlag
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner
-import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.descriptors.toIrBasedKotlinType
 import org.jetbrains.kotlin.ir.expressions.IrExpression
@@ -41,8 +41,8 @@ class IrInlineIntrinsicsSupport(
    private val reportErrorsOn: IrExpression,
    private val containingFile: IrFile,
 ) : ReifiedTypeInliner.IntrinsicsSupport<IrType> {
-    override val state: GenerationState
-        get() = classCodegen.context.state
+    override val config: JvmBackendConfig
+        get() = classCodegen.context.config

    // todo: this likely need to be moved up as IrInlineIntrinsicsSupport is recreated every time in getOrCreateCallGenerator
    private val pluginExtensions = IrGenerationExtension.getInstances(classCodegen.context.state.project)
@@ -195,7 +195,7 @@ class PrimitiveComparison(
        val b = right.accept(codegen, data).materializedAt(parameterType, right.type)

        val useNonIEEE754Comparison =
-            !codegen.context.state.languageVersionSettings.supportsFeature(LanguageFeature.ProperIeee754Comparisons)
+            !codegen.context.config.languageVersionSettings.supportsFeature(LanguageFeature.ProperIeee754Comparisons)
                    && (parameterType == Type.FLOAT_TYPE || parameterType == Type.DOUBLE_TYPE)
                    && (left.isSmartcastFromHigherThanNullable(codegen.context) || right.isSmartcastFromHigherThanNullable(codegen.context))

@@ -189,7 +189,7 @@ class Ieee754Equals(val operandType: Type) : IntrinsicMethod() {
        val arg1isNullable = arg1Type.isNullable()

        val useNonIEEE754Comparison =
-            !classCodegen.context.state.languageVersionSettings.supportsFeature(LanguageFeature.ProperIeee754Comparisons)
+            !classCodegen.context.config.languageVersionSettings.supportsFeature(LanguageFeature.ProperIeee754Comparisons)
                    && (arg0.isSmartcastFromHigherThanNullable(classCodegen.context) || arg1.isSmartcastFromHigherThanNullable(classCodegen.context))

        return when {
@@ -31,7 +31,7 @@ object IrCheckNotNull : IntrinsicMethod() {

    private fun ExpressionCodegen.checkTopValueForNull() {
        mv.dup()
-        if (state.config.unifiedNullChecks) {
+        if (config.unifiedNullChecks) {
            mv.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "checkNotNull", "(Ljava/lang/Object;)V", false)
        } else {
            val ifNonNullLabel = Label()