JVM: reduce usages of GenerationState in favor of JvmBackendConfig

To help in decoupling JVM IR from the old JVM backend.

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

@@ -295,7 +295,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
 
         boolean publicAbi = InlineUtil.isInPublicInlineScope(frontendFunDescriptor);
 
-        WriteAnnotationUtilKt.writeKotlinMetadata(v, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0, av -> {
+        WriteAnnotationUtilKt.writeKotlinMetadata(v, state.getConfig(), KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0, av -> {
             writeAnnotationData(av, serializer, functionProto);
             return Unit.INSTANCE;
         });

compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt

@@ -79,7 +79,7 @@ class CodeFragmentCodegen private constructor(
     }
 
     override fun generateKotlinMetadataAnnotation() {
-        writeSyntheticClassMetadata(v, state, false)
+        writeSyntheticClassMetadata(v, state.config, false)
     }
 
     private fun genConstructor() {

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

@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.codegen.when.SwitchCodegen;
 import org.jetbrains.kotlin.codegen.when.SwitchCodegenProvider;
 import org.jetbrains.kotlin.config.ApiVersion;
 import org.jetbrains.kotlin.config.JVMAssertionsMode;
-import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
@@ -2662,7 +2661,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         CallableMethod method = typeMapper.mapToCallableMethod(fd, superCall, null, resolvedCall);
 
         if (method.getAsmMethod().getName().contains("-") &&
-            !state.getConfiguration().getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME)
+            !state.getConfig().getUseOldManglingSchemeForFunctionsWithInlineClassesInSignatures()
         ) {
             Boolean classFileContainsMethod =
                     InlineClassesCodegenUtilKt.classFileContainsMethod(fd, state, method.getAsmMethod());
@@ -2890,7 +2889,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         JvmMethodSignature signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContext().getContextKind());
         if (signature.getAsmMethod().getName().contains("-") &&
-            !state.getConfiguration().getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME)
+            !state.getConfig().getUseOldManglingSchemeForFunctionsWithInlineClassesInSignatures()
         ) {
             Boolean classFileContainsMethod =
                     InlineClassesCodegenUtilKt.classFileContainsMethod(functionDescriptor, state, signature.getAsmMethod());

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

@@ -309,7 +309,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         boolean publicAbi = InlineUtil.isInPublicInlineScope(descriptor);
 
-        WriteAnnotationUtilKt.writeKotlinMetadata(v, state, KotlinClassHeader.Kind.CLASS, publicAbi, 0, av -> {
+        WriteAnnotationUtilKt.writeKotlinMetadata(v, state.getConfig(), KotlinClassHeader.Kind.CLASS, publicAbi, 0, av -> {
             writeAnnotationData(av, serializer, classProto);
             return Unit.INSTANCE;
         });

compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt

@@ -140,7 +140,7 @@ class InterfaceImplBodyCodegen(
     override fun generateKotlinMetadataAnnotation() {
         (v as InterfaceImplClassBuilder).stopCounting()
 
-        writeSyntheticClassMetadata(v, state, false)
+        writeSyntheticClassMetadata(v, state.config, false)
     }
 
     override fun done() {

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt

@@ -390,7 +390,7 @@ class MultifileClassCodegenImpl(
             facadeClassType: Type,
             kotlinPackageFqName: FqName
         ) {
-            writeKotlinMetadata(classBuilder, state, KotlinClassHeader.Kind.MULTIFILE_CLASS, false, flags) { av ->
+            writeKotlinMetadata(classBuilder, state.config, KotlinClassHeader.Kind.MULTIFILE_CLASS, false, flags) { av ->
                 val arv = av.visitArray(JvmAnnotationNames.METADATA_DATA_FIELD_NAME)
                 for (internalName in partInternalNames) {
                     arv.visit(null, internalName)

compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt

@@ -96,7 +96,7 @@ class MultifileClassPartCodegen(
 
         val extraFlags = if (shouldGeneratePartHierarchy) JvmAnnotationNames.METADATA_MULTIFILE_PARTS_INHERIT_FLAG else 0
 
-        writeKotlinMetadata(v, state, KotlinClassHeader.Kind.MULTIFILE_CLASS_PART, false, extraFlags) { av ->
+        writeKotlinMetadata(v, state.config, KotlinClassHeader.Kind.MULTIFILE_CLASS_PART, false, extraFlags) { av ->
             DescriptorAsmUtil.writeAnnotationData(av, serializer, packageProto)
             av.visit(JvmAnnotationNames.METADATA_MULTIFILE_CLASS_NAME_FIELD_NAME, facadeClassType.internalName)
 

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

@@ -107,7 +107,7 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
     protected void generateKotlinMetadataAnnotation() {
         Pair<DescriptorSerializer, ProtoBuf.Package> serializedPart = serializePackagePartMembers(this, packagePartType);
 
-        WriteAnnotationUtilKt.writeKotlinMetadata(v, state, KotlinClassHeader.Kind.FILE_FACADE, false, 0, av -> {
+        WriteAnnotationUtilKt.writeKotlinMetadata(v, state.getConfig(), KotlinClassHeader.Kind.FILE_FACADE, false, 0, av -> {
             writeAnnotationData(av, serializedPart.getFirst(), serializedPart.getSecond());
 
             FqName kotlinPackageFqName = element.getPackageFqName();

compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt

@@ -210,7 +210,7 @@ class PropertyReferenceCodegen(
     }
 
     override fun generateKotlinMetadataAnnotation() {
-        writeSyntheticClassMetadata(v, state, InlineUtil.isInPublicInlineScope(classDescriptor))
+        writeSyntheticClassMetadata(v, state.config, InlineUtil.isInPublicInlineScope(classDescriptor))
     }
 
     fun putInstanceOnStack(receiverValue: StackValue?): StackValue {

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

@@ -138,7 +138,7 @@ public class SamWrapperCodegen {
         );
         cv.visitSource(file.getName(), null);
 
-        WriteAnnotationUtilKt.writeSyntheticClassMetadata(cv, state, isInsideInline);
+        WriteAnnotationUtilKt.writeSyntheticClassMetadata(cv, state.getConfig(), isInsideInline);
 
         generateInnerClassInformation(file, asmType, cv);
 

compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.codegen.context.ScriptContext
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -71,10 +70,10 @@ class ScriptCodegen private constructor(
     override fun generateKotlinMetadataAnnotation() {
         val serializer = DescriptorSerializer.create(
             scriptDescriptor, JvmSerializerExtension(v.serializationBindings, state), null,
-            state.configuration.languageVersionSettings,
+            state.config.languageVersionSettings,
         )
         val classProto = serializer.classProto(scriptDescriptor).build()
-        writeKotlinMetadata(v, state, KotlinClassHeader.Kind.CLASS, false, JvmAnnotationNames.METADATA_SCRIPT_FLAG) { av ->
+        writeKotlinMetadata(v, state.config, KotlinClassHeader.Kind.CLASS, false, JvmAnnotationNames.METADATA_SCRIPT_FLAG) { av ->
             DescriptorAsmUtil.writeAnnotationData(av, serializer, classProto)
         }
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.backend.common.output.OutputFile
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
 import org.jetbrains.kotlin.load.kotlin.loadModuleMapping
 import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
@@ -51,7 +50,7 @@ fun JvmModuleProtoBuf.Module.Builder.addDataFromCompiledModule(
                 }.orEmpty()
 
     val serializer = DescriptorSerializer.createTopLevel(
-        JvmOptionalAnnotationSerializerExtension(stringTable), state.configuration.languageVersionSettings,
+        JvmOptionalAnnotationSerializerExtension(stringTable), state.config.languageVersionSettings,
     )
     for (descriptor in optionalAnnotationClassDescriptors) {
         addOptionalAnnotationClass(serializer.classProto(descriptor))

compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt

@@ -674,7 +674,7 @@ private fun generateLambdaForRunSuspend(
         visitEnd()
     }
 
-    writeSyntheticClassMetadata(lambdaBuilder, state, false)
+    writeSyntheticClassMetadata(lambdaBuilder, state.config, false)
 
     lambdaBuilder.done(state.config.generateSmapCopyToAnnotation)
     return lambdaBuilder.thisName

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt

@@ -701,7 +701,7 @@ class CoroutineCodegenForNamedFunction private constructor(
 
     override fun generateKotlinMetadataAnnotation() {
         val publicAbi = InlineUtil.isInPublicInlineScope(classDescriptor)
-        writeKotlinMetadata(v, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0) { av ->
+        writeKotlinMetadata(v, state.config, KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0) { av ->
             val serializer = DescriptorSerializer.createForLambda(
                 JvmSerializerExtension(v.serializationBindings, state), state.languageVersionSettings,
             )

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt

@@ -242,7 +242,7 @@ class AnonymousObjectTransformer(
         val publicAbi = inliningContext.callSiteInfo.isInPublicInlineScope
         writeKotlinMetadata(
             classBuilder,
-            state,
+            state.config,
             header.kind,
             publicAbi,
             header.extraInt and JvmAnnotationNames.METADATA_PUBLIC_ABI_FLAG.inv()

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.inline
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
@@ -27,9 +28,12 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.tree.FieldInsnNode
 
 class PsiInlineIntrinsicsSupport(
-    override val state: GenerationState,
+    private val state: GenerationState,
     private val reportErrorsOn: KtElement,
 ) : ReifiedTypeInliner.IntrinsicsSupport<KotlinType> {
+    override val config: JvmBackendConfig
+        get() = state.config
+
     override fun putClassInstance(v: InstructionAdapter, type: KotlinType) {
         DescriptorAsmUtil.putJavaLangClassInstance(v, state.typeMapper.mapType(type), type, state.typeMapper)
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.codegen.context.*
 import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
 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.incremental.KotlinLookupLocation
 import org.jetbrains.kotlin.psi.*
@@ -223,7 +222,7 @@ class PsiSourceCompilerForInline(
         // This is all available in the `Callable` passed to `PsiInlineCodegen.genCallInner`, but it's not forwarded through the inliner...
         var result = state.typeMapper.mapDefaultMethod(functionDescriptor, context.contextKind)
         if (result.name.contains("-") &&
-            !state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) &&
+            !state.config.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures &&
             classFileContainsMethod(functionDescriptor, state, result) == false
         ) {
             state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = true

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.codegen.generateIsCheck
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods
 import org.jetbrains.kotlin.codegen.optimization.common.intConstant
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
-import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
@@ -56,7 +56,7 @@ class ReifiedTypeInliner<KT : KotlinTypeMarker>(
 
 
     interface IntrinsicsSupport<KT : KotlinTypeMarker> {
-        val state: GenerationState
+        val config: JvmBackendConfig
 
         fun putClassInstance(v: InstructionAdapter, type: KT)
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt

@@ -84,7 +84,7 @@ private fun <KT : KotlinTypeMarker> TypeSystemCommonBackendContext.generateTypeO
         intrinsicsSupport.reportSuspendTypeUnsupported()
     }
 
-    if (intrinsicsSupport.state.config.stableTypeOf) {
+    if (intrinsicsSupport.config.stableTypeOf) {
         if (intrinsicsSupport.isMutableCollectionType(type)) {
             v.invokestatic(REFLECTION, "mutableCollectionType", Type.getMethodDescriptor(K_TYPE, K_TYPE), false)
         } else if (type.typeConstructor().isNothingConstructor()) {

compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java

@@ -58,7 +58,7 @@ public class MappingClassesForWhenByEnumCodegen {
         generateInitialization(cb, mappings);
 
         boolean publicAbi = mappings.stream().anyMatch(WhenByEnumsMapping::isPublicAbi);
-        WriteAnnotationUtilKt.writeSyntheticClassMetadata(cb, state, publicAbi);
+        WriteAnnotationUtilKt.writeSyntheticClassMetadata(cb, state.getConfig(), publicAbi);
 
         cb.done(state.getConfig().getGenerateSmapCopyToAnnotation());
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt

@@ -16,7 +16,7 @@
 
 package org.jetbrains.kotlin.codegen
 
-import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.config.JvmAnalysisFlags
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -26,19 +26,19 @@ import org.jetbrains.org.objectweb.asm.AnnotationVisitor
 
 fun writeKotlinMetadata(
     cb: ClassBuilder,
-    state: GenerationState,
+    config: JvmBackendConfig,
     kind: KotlinClassHeader.Kind,
     publicAbi: Boolean,
     extraFlags: Int,
     action: (AnnotationVisitor) -> Unit
 ) {
     val av = cb.newAnnotation(JvmAnnotationNames.METADATA_DESC, true)
-    av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, state.config.metadataVersion.toArray())
+    av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, config.metadataVersion.toArray())
-    if (!state.config.metadataVersion.isAtLeast(1, 5, 0)) {
+    if (!config.metadataVersion.isAtLeast(1, 5, 0)) {
         av.visit("bv", JvmBytecodeBinaryVersion.INSTANCE.toArray())
     }
     av.visit(JvmAnnotationNames.KIND_FIELD_NAME, kind.id)
-    var flags = extraFlags or generateLanguageVersionSettingsBasedMetadataFlags(state.languageVersionSettings)
+    var flags = extraFlags or generateLanguageVersionSettingsBasedMetadataFlags(config.languageVersionSettings)
     if (publicAbi) {
         flags = flags or JvmAnnotationNames.METADATA_PUBLIC_ABI_FLAG
     }
@@ -49,8 +49,8 @@ fun writeKotlinMetadata(
     av.visitEnd()
 }
 
-fun writeSyntheticClassMetadata(cb: ClassBuilder, state: GenerationState, publicAbi: Boolean) {
+fun writeSyntheticClassMetadata(cb: ClassBuilder, config: JvmBackendConfig, publicAbi: Boolean) {
-    writeKotlinMetadata(cb, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0) { _ ->
+    writeKotlinMetadata(cb, config, KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0) { _ ->
         // Do nothing
     }
 }

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt

@@ -62,7 +62,7 @@ fun makeFirMetadataSerializerForIrClass(
         approximator,
         makeElementSerializer(
             irClass.metadata, components.session, components.scopeSession, firSerializerExtension, approximator, parent,
-            context.state.configuration.languageVersionSettings,
+            context.config.languageVersionSettings,
         ),
         irActualizedResult
     )

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

@@ -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,
+            config.classFileVersion,
-            irClass.getFlags(context.state.languageVersionSettings),
+            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)
+        var extraFlags = JvmBackendExtension.Default.generateMetadataExtraFlags(config.abiStability)
-        if (isMultifileClassOrPart && state.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts)) {
+        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

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

@@ -33,8 +33,7 @@ internal fun MethodNode.acceptWithStateMachine(
     obtainContinuationClassBuilder: () -> ClassBuilder,
 ) {
     val context = classCodegen.context
-    val state = context.state
+    val languageVersionSettings = context.config.languageVersionSettings
-    val languageVersionSettings = state.languageVersionSettings
     assert(languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)) { "Experimental coroutines are unsupported in JVM_IR backend" }
 
     val lineNumber = if (irFunction.startOffset >= 0) {

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

@@ -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,
+            config.languageVersionSettings,
-            state.config.unifiedNullChecks,
+            config.unifiedNullChecks,
         )
 
         return IrInlineCodegen(this, state, callee, signature, mappings, sourceCompiler, reifiedTypeInliner)

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

@@ -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

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

@@ -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
+    override val config: JvmBackendConfig
-        get() = classCodegen.context.state
+        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)

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

@@ -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))
 

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

@@ -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 {

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

@@ -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()

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

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 internal class ApiVersionIsAtLeastEvaluationLowering(val context: JvmBackendContext) : FileLoweringPass,
     IrElementTransformer<ApiVersionIsAtLeastEvaluationLowering.Data> {
 
-    private val apiVersion = context.state.languageVersionSettings.apiVersion.version
+    private val apiVersion = context.config.languageVersionSettings.apiVersion.version
 
     data class Data(val currentFunction: IrFunction?, val isInsideInlinedBlock: Boolean)
 

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

@@ -89,7 +89,7 @@ private class EnumClassLowering(private val context: JvmBackendContext) : ClassL
     override fun lower(irClass: IrClass) {
         if (!irClass.isEnumClass) return
         // Also protected by API version check as it relies on EnumEntries in standard library
-        EnumClassTransformer(irClass, context.state.languageVersionSettings.supportsFeature(LanguageFeature.EnumEntries)).run()
+        EnumClassTransformer(irClass, context.config.languageVersionSettings.supportsFeature(LanguageFeature.EnumEntries)).run()
     }
 
     private inner class EnumClassTransformer(private val irClass: IrClass, private val supportsEnumEntries: Boolean) {

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

@@ -68,7 +68,7 @@ internal val enumExternalEntriesPhase = makeIrFilePhase(
 class EnumExternalEntriesLowering(private val context: JvmBackendContext) : FileLoweringPass, IrElementTransformerVoidWithContext() {
 
     override fun lower(irFile: IrFile) {
-        if (!context.state.languageVersionSettings.supportsFeature(LanguageFeature.EnumEntries)) {
+        if (!context.config.languageVersionSettings.supportsFeature(LanguageFeature.EnumEntries)) {
             return
         }
         irFile.transformChildrenVoid(this)

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

@@ -93,7 +93,7 @@ private class FileClassLowering(val context: JvmBackendContext) : FileLoweringPa
         val isMultifilePart = fileClassInfo.withJvmMultifileClass
 
         val onlyPrivateDeclarationsAndFeatureIsEnabled =
-            context.state.languageVersionSettings.supportsFeature(LanguageFeature.PackagePrivateFileClassesWithAllPrivateMembers) && fileClassMembers
+            context.config.languageVersionSettings.supportsFeature(LanguageFeature.PackagePrivateFileClassesWithAllPrivateMembers) && fileClassMembers
                 .all {
                     val isPrivate = it is IrDeclarationWithVisibility && DescriptorVisibilities.isPrivate(it.visibility)
                     val isInlineOnly = it.hasAnnotation(INLINE_ONLY_ANNOTATION_FQ_NAME)
@@ -101,7 +101,7 @@ private class FileClassLowering(val context: JvmBackendContext) : FileLoweringPa
                 }
 
         val fileClassOrigin =
-            if (!isMultifilePart || context.state.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts))
+            if (!isMultifilePart || context.config.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts))
                 IrDeclarationOrigin.FILE_CLASS
             else
                 IrDeclarationOrigin.SYNTHETIC_FILE_CLASS

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

@@ -75,10 +75,10 @@ internal class FunctionReferenceLowering(private val context: JvmBackendContext)
         context.config.lambdasScheme == JvmClosureGenerationScheme.INDY
 
     private val shouldGenerateLightweightLambdas =
-        shouldGenerateIndyLambdas && context.state.languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas)
+        shouldGenerateIndyLambdas && context.config.languageVersionSettings.supportsFeature(LanguageFeature.LightweightLambdas)
 
     private val isJavaSamConversionWithEqualsHashCode =
-        context.state.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode)
+        context.config.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode)
 
     override fun visitBlock(expression: IrBlock): IrExpression {
         if (!expression.origin.isLambda)

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

@@ -51,7 +51,7 @@ internal val generateMultifileFacadesPhase = makeCustomPhase<JvmBackendContext,
 
         // In -Xmultifile-parts-inherit mode, instead of generating "bridge" methods in the facade which call into parts,
         // we construct an inheritance chain such that all part members are present as fake overrides in the facade.
-        val shouldGeneratePartHierarchy = context.state.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts)
+        val shouldGeneratePartHierarchy = context.config.languageVersionSettings.getFlag(JvmAnalysisFlags.inheritMultifileParts)
         input.files.addAll(
             generateMultifileFacades(input, context, shouldGeneratePartHierarchy, functionDelegates)
         )

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

@@ -382,7 +382,7 @@ internal class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClas
             if (!isSingleFieldValueClass) return false
             // Before version 1.4, we cannot rely on the Result.equals-impl0 method
             return !isClassWithFqName(StandardNames.RESULT_FQ_NAME) ||
-                    context.state.languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4
+                    context.config.languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4
         }
 
     override fun visitGetField(expression: IrGetField): IrExpression {

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

@@ -56,7 +56,7 @@ open class JvmInventNamesForLocalClasses(
     }
 
     override fun sanitizeNameIfNeeded(name: String): String {
-        return JvmCodegenUtil.sanitizeNameIfNeeded(name, context.state.languageVersionSettings)
+        return JvmCodegenUtil.sanitizeNameIfNeeded(name, context.config.languageVersionSettings)
     }
 
     override fun putLocalClassName(declaration: IrAttributeContainer, localClassName: String) {

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

@@ -132,7 +132,7 @@ private class JvmOverloadsAnnotationLowering(val context: JvmBackendContext) : C
                 name = oldFunction.name
                 visibility = oldFunction.visibility
                 modality =
-                    if (context.state.languageVersionSettings.supportsFeature(LanguageFeature.GenerateJvmOverloadsAsFinal)) Modality.FINAL
+                    if (context.config.languageVersionSettings.supportsFeature(LanguageFeature.GenerateJvmOverloadsAsFinal)) Modality.FINAL
                     else oldFunction.modality
                 returnType = oldFunction.returnType
                 isInline = oldFunction.isInline

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

@@ -218,7 +218,7 @@ class JvmPropertiesLowering(private val backendContext: JvmBackendContext) : IrE
 
         private fun JvmBackendContext.computeSyntheticMethodName(property: IrProperty, suffix: String): String {
             val baseName =
-                if (state.languageVersionSettings.supportsFeature(LanguageFeature.UseGetterNameForPropertyAnnotationsMethodOnJvm)) {
+                if (config.languageVersionSettings.supportsFeature(LanguageFeature.UseGetterNameForPropertyAnnotationsMethodOnJvm)) {
                     val getter = property.getter
                     if (getter != null) {
                         val needsMangling =

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

@@ -38,7 +38,7 @@ internal val singleAbstractMethodPhase = makeIrFilePhase(
 private class JvmSingleAbstractMethodLowering(context: JvmBackendContext) : SingleAbstractMethodLowering(context) {
 
     private val isJavaSamConversionWithEqualsHashCode =
-        context.state.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode)
+        context.config.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode)
 
     override val inInlineFunctionScope: Boolean
         get() = allScopes.any { (it.irElement as? IrDeclaration)?.isInPublicInlineScope == true }

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

@@ -10,14 +10,13 @@ import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmLoweredStatementOrigin
 import org.jetbrains.kotlin.backend.jvm.ir.defaultValue
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.types.IrType
 
 class JvmTailrecLowering(context: JvmBackendContext) : TailrecLowering(context) {
     override val useProperComputationOrderOfTailrecDefaultParameters: Boolean =
-        context.ir.context.configuration.languageVersionSettings.supportsFeature(LanguageFeature.ProperComputationOrderOfTailrecDefaultParameters)
+        context.config.languageVersionSettings.supportsFeature(LanguageFeature.ProperComputationOrderOfTailrecDefaultParameters)
 
     override fun followFunctionReference(reference: IrFunctionReference): Boolean =
         reference.origin == JvmLoweredStatementOrigin.INLINE_LAMBDA

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
 import org.jetbrains.kotlin.backend.jvm.ir.getJvmNameFromAnnotation
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
@@ -69,7 +68,7 @@ private class MainMethodGenerationLowering(private val context: JvmBackendContex
      *    ```
      */
     override fun lower(irClass: IrClass) {
-        if (!context.configuration.languageVersionSettings.supportsFeature(LanguageFeature.ExtendedMainConvention)) return
+        if (!context.config.languageVersionSettings.supportsFeature(LanguageFeature.ExtendedMainConvention)) return
         if (!irClass.isFileClass) return
 
         irClass.functions.find { it.isMainMethod() }?.let { mainMethod ->

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

@@ -66,7 +66,7 @@ private class ObjectClassLowering(val context: JvmBackendContext) : ClassLowerin
 
         // Mark object instance field as deprecated if the object visibility is private or protected,
         // and ProperVisibilityForCompanionObjectInstanceField language feature is not enabled.
-        if (!context.state.languageVersionSettings.supportsFeature(LanguageFeature.ProperVisibilityForCompanionObjectInstanceField) &&
+        if (!context.config.languageVersionSettings.supportsFeature(LanguageFeature.ProperVisibilityForCompanionObjectInstanceField) &&
             (irClass.visibility == DescriptorVisibilities.PRIVATE || irClass.visibility == DescriptorVisibilities.PROTECTED)
         ) {
             context.createJvmIrBuilder(irClass.symbol).run {

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

@@ -35,7 +35,7 @@ internal val polymorphicSignaturePhase = makeIrFilePhase(
 private class PolymorphicSignatureLowering(val context: JvmBackendContext) : IrElementTransformer<PolymorphicSignatureLowering.Data>,
     FileLoweringPass {
     override fun lower(irFile: IrFile) {
-        if (context.state.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature))
+        if (context.config.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature))
             irFile.transformChildren(this, Data(null))
     }
 

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

@@ -81,9 +81,8 @@ internal class LambdaMetafactoryArgumentsBuilder(
     private val context: JvmBackendContext,
     private val crossinlineLambdas: Set<IrSimpleFunction>
 ) {
-
     private val isJavaSamConversionWithEqualsHashCode =
-        context.state.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode)
+        context.config.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode)
 
     /**
      * @see java.lang.invoke.LambdaMetafactory

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

@@ -111,7 +111,7 @@ class JvmBackendContext(
 
     override val mapping: Mapping = DefaultMapping()
 
-    val ktDiagnosticReporter = KtDiagnosticReporterWithImplicitIrBasedContext(state.diagnosticReporter, state.languageVersionSettings)
+    val ktDiagnosticReporter = KtDiagnosticReporterWithImplicitIrBasedContext(state.diagnosticReporter, config.languageVersionSettings)
 
     override val ir = JvmIr(this.symbolTable)
 

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

@@ -38,7 +38,7 @@ class MemoizedInlineClassReplacements(
     val originalFunctionForMethodReplacement: MutableMap<IrFunction, IrFunction> = ConcurrentHashMap()
 
     private val mangleCallsToJavaMethodsWithValueClasses =
-        context.state.languageVersionSettings.supportsFeature(LanguageFeature.MangleCallsToJavaMethodsWithValueClasses)
+        context.config.languageVersionSettings.supportsFeature(LanguageFeature.MangleCallsToJavaMethodsWithValueClasses)
 
     /**
      * Get a replacement for a function or a constructor.
@@ -165,7 +165,7 @@ class MemoizedInlineClassReplacements(
             dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1)
             extensionReceiverParameter = function.extensionReceiverParameter?.copyTo(
                 // The function's name will be mangled, so preserve the old receiver name.
-                this, index = -1, name = Name.identifier(function.extensionReceiverName(context.state))
+                this, index = -1, name = Name.identifier(function.extensionReceiverName(context.config))
             )
             contextReceiverParametersCount = function.contextReceiverParametersCount
             valueParameters = function.valueParameters.mapIndexed { index, parameter ->
@@ -200,7 +200,7 @@ class MemoizedInlineClassReplacements(
             }
             function.extensionReceiverParameter?.let {
                 newValueParameters += it.copyTo(
-                    this, index = newValueParameters.size, name = Name.identifier(function.extensionReceiverName(context.state)),
+                    this, index = newValueParameters.size, name = Name.identifier(function.extensionReceiverName(context.config)),
                     origin = IrDeclarationOrigin.MOVED_EXTENSION_RECEIVER
                 )
             }

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

@@ -140,7 +140,7 @@ class MemoizedMultiFieldValueClassReplacements(
         newFlattenedParameters.addAll(contextReceivers)
         sourceFunction.extensionReceiverParameter?.let {
             val newParameters = it.grouped(
-                sourceFunction.extensionReceiverName(context.state),
+                sourceFunction.extensionReceiverName(context.config),
                 substitutionMap,
                 targetFunction,
                 IrDeclarationOrigin.MOVED_EXTENSION_RECEIVER,

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

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.codegen.ASSERTIONS_DISABLED_FIELD_NAME
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.mangleNameIfNeeded
-import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.codegen.state.JvmBackendConfig
 import org.jetbrains.kotlin.config.JvmDefaultMode
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
@@ -504,8 +504,8 @@ val IrDeclaration.psiElement: PsiElement?
 val IrMemberAccessExpression<*>.psiElement: PsiElement?
     get() = (symbol.descriptor.original as? DeclarationDescriptorWithSource)?.psiElement
 
-fun IrFunction.extensionReceiverName(state: GenerationState): String {
+fun IrFunction.extensionReceiverName(config: JvmBackendConfig): String {
-    if (!state.languageVersionSettings.supportsFeature(LanguageFeature.NewCapturedReceiverFieldNamingConvention)) {
+    if (!config.languageVersionSettings.supportsFeature(LanguageFeature.NewCapturedReceiverFieldNamingConvention)) {
         return AsmUtil.RECEIVER_PARAMETER_NAME
     }
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt

@@ -107,7 +107,7 @@ open class IrTypeMapper(private val context: JvmBackendContext) : KotlinTypeMapp
 
         return JvmCodegenUtil.sanitizeNameIfNeeded(
             computeClassInternalNameAsString(irClass),
-            context.state.languageVersionSettings
+            context.config.languageVersionSettings
         )
     }
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt

@@ -104,7 +104,7 @@ class MethodSignatureMapper(private val context: JvmBackendContext, private val
     private fun IrType.isJavaLangRecord() = getClass()!!.hasEqualFqName(JAVA_LANG_RECORD_FQ_NAME)
 
     private fun mangleMemberNameIfRequired(name: String, function: IrSimpleFunction): String {
-        val newName = JvmCodegenUtil.sanitizeNameIfNeeded(name, context.state.languageVersionSettings)
+        val newName = JvmCodegenUtil.sanitizeNameIfNeeded(name, context.config.languageVersionSettings)
 
         val suffix = if (function.isTopLevel) {
             if (function.isInvisibleInMultifilePart()) function.parentAsClass.name.asString() else null

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt

@@ -34,7 +34,7 @@ class DescriptorMetadataSerializer(
 ) : MetadataSerializer {
     private val serializerExtension = JvmSerializerExtension(serializationBindings, context.state, context.defaultTypeMapper)
     private val serializer: DescriptorSerializer? = run {
-        val languageVersionSettings = context.state.configuration.languageVersionSettings
+        val languageVersionSettings = context.config.languageVersionSettings
         when (val metadata = irClass.metadata) {
             is DescriptorMetadataSource.Class -> DescriptorSerializer.create(
                 metadata.descriptor, serializerExtension, (parent as? DescriptorMetadataSerializer)?.serializer,

plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt

@@ -310,7 +310,7 @@ open class ParcelableCodegenExtension : ParcelableExtensionBase, ExpressionCodeg
         codegen.v.visitInnerClass(creatorAsmType.internalName, containerAsmType.internalName, "Creator", ACC_PUBLIC or ACC_STATIC)
         codegenForCreator.v.visitInnerClass(creatorAsmType.internalName, containerAsmType.internalName, "Creator", ACC_PUBLIC or ACC_STATIC)
 
-        writeSyntheticClassMetadata(classBuilderForCreator, codegen.state, InlineUtil.isInPublicInlineScope(parcelableClass))
+        writeSyntheticClassMetadata(classBuilderForCreator, codegen.state.config, InlineUtil.isInPublicInlineScope(parcelableClass))
 
         writeCreatorConstructor(codegenForCreator, creatorClass, creatorAsmType)
         writeNewArrayMethod(codegenForCreator, parcelableClass, parcelableCreatorClassType, creatorClass, parcelerObject)

plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt

@@ -772,7 +772,7 @@ internal fun createSingletonLambda(
         areturn(kSerializerType)
     }
 
-    writeSyntheticClassMetadata(lambdaClassBuilder, lambdaCodegen.state, false)
+    writeSyntheticClassMetadata(lambdaClassBuilder, lambdaCodegen.state.config, false)
     lambdaClassBuilder.done(lambdaCodegen.state.config.generateSmapCopyToAnnotation)
 
     return lambdaType