diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java index f3ea860cc90..2a5a2ee7341 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java @@ -295,7 +295,7 @@ public class ClosureCodegen extends MemberCodegen { 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; }); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt index a5b8410bfae..8bbff74a7c1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CodeFragmentCodegen.kt +++ b/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() { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 22cf95ae393..fcde87f8b00 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/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 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 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()); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index 296a136e8b6..b37dcf967dd 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/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; }); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt index dc7abfd0e38..06a3cf917eb 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/InterfaceImplBodyCodegen.kt +++ b/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() { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt index 090def488c2..04848ca1d60 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt +++ b/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) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt index 67189586f90..34da5ddd2aa 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassPartCodegen.kt +++ b/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) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java index 092c82c44f8..d73a061b63d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java @@ -107,7 +107,7 @@ public class PackagePartCodegen extends MemberCodegen { protected void generateKotlinMetadataAnnotation() { Pair 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(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt index 93d0b4967ff..b7c78fbf4b8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt +++ b/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 { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java index d6f33474679..a7d39dd7c75 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/SamWrapperCodegen.java +++ b/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); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt index 92947040e52..723daefb86f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt +++ b/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) } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt index a6035bcbbce..df5d53dd6f6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt +++ b/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)) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt index 307d207bd18..befe14e66b2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/codegenUtil.kt +++ b/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 diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt index ae1847d55e3..1361244385b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt +++ b/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, ) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt index 31b3fbb9461..dbc7047542e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt +++ b/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() diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt index 859fcdf06d4..425f914d4a6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineIntrinsicsSupport.kt +++ b/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 { + override val config: JvmBackendConfig + get() = state.config + override fun putClassInstance(v: InstructionAdapter, type: KotlinType) { DescriptorAsmUtil.putJavaLangClassInstance(v, state.typeMapper.mapType(type), type, state.typeMapper) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt index 2aff91ca18c..b9df3fd1bb8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt +++ b/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 diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt index 39caba8e266..04424c965da 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt +++ b/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( interface IntrinsicsSupport { - val state: GenerationState + val config: JvmBackendConfig fun putClassInstance(v: InstructionAdapter, type: KT) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt index 1db86d45b02..5280284914c 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/typeOf.kt @@ -84,7 +84,7 @@ private fun 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()) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java index 13bda66e5f5..73436bd009f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/when/MappingClassesForWhenByEnumCodegen.java +++ b/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()); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt index cadf38a989a..cad6ff3606d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt +++ b/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()) - if (!state.config.metadataVersion.isAtLeast(1, 5, 0)) { + av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, config.metadataVersion.toArray()) + 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) { - writeKotlinMetadata(cb, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0) { _ -> +fun writeSyntheticClassMetadata(cb: ClassBuilder, config: JvmBackendConfig, publicAbi: Boolean) { + writeKotlinMetadata(cb, config, KotlinClassHeader.Kind.SYNTHETIC_CLASS, publicAbi, 0) { _ -> // Do nothing } } diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt index 7dbe0cdb24e..ed483771121 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt +++ b/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 ) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt index b45157a6df1..e41b23dbac0 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt +++ b/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() 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 diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt index 6807b38228f..4128791539b 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/CoroutineCodegen.kt +++ b/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 = 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) { diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index 279ffd4a45f..1d6df640918 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/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, - state.config.unifiedNullChecks, + config.languageVersionSettings, + config.unifiedNullChecks, ) return IrInlineCodegen(this, state, callee, signature, mappings, sourceCompiler, reifiedTypeInliner) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt index 28a44bf49c7..c2f95aed97b 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt +++ b/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? { - 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 diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt index ae340edf9b3..14ba742119f 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt +++ b/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 { - 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) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt index 7aeac31f8f7..56a9992b360 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt +++ b/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)) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt index 15f864f49b0..138133bf859 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt +++ b/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 { diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt index 881fb7044d0..860381d6b61 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrCheckNotNull.kt +++ b/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() diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ApiVersionIsAtLeastEvaluationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ApiVersionIsAtLeastEvaluationLowering.kt index da416334fb8..c2a0e066d6f 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ApiVersionIsAtLeastEvaluationLowering.kt +++ b/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 { - 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) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt index c49446a228c..b44d3067a60 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt +++ b/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) { diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumExternalEntriesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumExternalEntriesLowering.kt index 6a842239cdf..97739c7494d 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/EnumExternalEntriesLowering.kt +++ b/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) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt index 65968fffd5c..16f44dc976c 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FileClassLowering.kt +++ b/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 diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt index ad535fb4882..57fdcb02f17 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FunctionReferenceLowering.kt +++ b/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) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt index 307db5d8225..e9a54044c2a 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/GenerateMultifileFacades.kt @@ -51,7 +51,7 @@ internal val generateMultifileFacadesPhase = makeCustomPhase= ApiVersion.KOTLIN_1_4 + context.config.languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 } override fun visitGetField(expression: IrGetField): IrExpression { diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInventNamesForLocalClasses.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInventNamesForLocalClasses.kt index 5dd9e4f39be..633f9db6fe4 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInventNamesForLocalClasses.kt +++ b/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) { diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt index e668192b44b..6075b03c876 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOverloadsAnnotationLowering.kt +++ b/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 diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt index 6fd352e6a46..e47eb072f1d 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt +++ b/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 = diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmSingleAbstractMethodLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmSingleAbstractMethodLowering.kt index 2773f5514bb..ce95b6b598c 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmSingleAbstractMethodLowering.kt +++ b/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 } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmTailrecLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmTailrecLowering.kt index 0a9874131a5..e22053f2c41 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmTailrecLowering.kt +++ b/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 diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/MainMethodGenerationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/MainMethodGenerationLowering.kt index ea51c9b941f..59bd8403dcd 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/MainMethodGenerationLowering.kt +++ b/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 -> diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt index ee4eeea9ade..b337feefc75 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ObjectClassLowering.kt +++ b/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 { diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PolymorphicSignatureLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PolymorphicSignatureLowering.kt index 7088bf9aaec..cac65f0149c 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PolymorphicSignatureLowering.kt +++ b/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, 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)) } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/indy/LambdaMetafactoryArguments.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/indy/LambdaMetafactoryArguments.kt index f0fbd1a8dff..cd019244ade 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/indy/LambdaMetafactoryArguments.kt +++ b/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 ) { - private val isJavaSamConversionWithEqualsHashCode = - context.state.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode) + context.config.languageVersionSettings.supportsFeature(LanguageFeature.JavaSamConversionEqualsHashCode) /** * @see java.lang.invoke.LambdaMetafactory diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt index 21d752d99d5..1cbf1b5414c 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/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) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt index 18d540ed2c2..6111d306b06 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt @@ -38,7 +38,7 @@ class MemoizedInlineClassReplacements( val originalFunctionForMethodReplacement: MutableMap = 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 ) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt index 8c9fe3ad920..4008abba421 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt +++ b/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, diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt index 20e9b1fa726..e95c44616a6 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt +++ b/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 { - if (!state.languageVersionSettings.supportsFeature(LanguageFeature.NewCapturedReceiverFieldNamingConvention)) { +fun IrFunction.extensionReceiverName(config: JvmBackendConfig): String { + if (!config.languageVersionSettings.supportsFeature(LanguageFeature.NewCapturedReceiverFieldNamingConvention)) { return AsmUtil.RECEIVER_PARAMETER_NAME } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt index 0bb0bd5b537..b92927a5295 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt +++ b/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 ) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt index 7914c201101..5721e68fb33 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt +++ b/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 diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt index 251ca523500..7d257b29306 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt +++ b/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, diff --git a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt index ee5fbfeb510..13e73e2f375 100644 --- a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableCodegenExtension.kt +++ b/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) diff --git a/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt b/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt index 6aa38d75852..6e45701231e 100644 --- a/plugins/kotlinx-serialization/kotlinx-serialization.backend/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt +++ b/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