Write "hasEnumEntries" flag into metadata when feature enabled

^KT-53929 Fixed

build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.incremental
 
 import com.intellij.psi.PsiJavaFile
 import com.intellij.util.io.DataExternalizer
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
 import org.jetbrains.kotlin.load.java.JavaClassesTracker
@@ -34,7 +35,8 @@ val CONVERTING_JAVA_CLASSES_TO_PROTO = PerformanceCounter.create("Converting Jav
 
 class JavaClassesTrackerImpl(
         private val cache: IncrementalJvmCache,
-        private val untrackedJavaClasses: Set<ClassId>
+        private val untrackedJavaClasses: Set<ClassId>,
+        private val languageVersionSettings: LanguageVersionSettings,
 ) : JavaClassesTracker {
     private val classToSourceSerialized: MutableMap<ClassId, SerializedJavaClassWithSource> = hashMapOf()
 
@@ -65,7 +67,7 @@ class JavaClassesTrackerImpl(
                     "Duplicated JavaClassDescriptor $classId reported to IC"
                 }
                 classToSourceSerialized[classId] = CONVERTING_JAVA_CLASSES_TO_PROTO.time {
-                    classDescriptor.convertToProto()
+                    classDescriptor.convertToProto(languageVersionSettings)
                 }
             }
         }
@@ -85,12 +87,14 @@ private val JavaClassDescriptor.javaSourceFile: File?
             ?.psi?.containingFile?.takeIf { it is PsiJavaFile }
             ?.virtualFile?.path?.let(::File)
 
-fun JavaClassDescriptor.convertToProto(): SerializedJavaClassWithSource {
+fun JavaClassDescriptor.convertToProto(languageVersionSettings: LanguageVersionSettings): SerializedJavaClassWithSource {
     val file = javaSourceFile.sure { "convertToProto should only be called for source based classes" }
 
     val extension = JavaClassesSerializerExtension()
     val classProto = try {
-        DescriptorSerializer.create(this, extension, null).classProto(this).build()
+        DescriptorSerializer.create(
+            this, extension, null, languageVersionSettings
+        ).classProto(this).build()
     } catch (e: Exception) {
         throw IllegalStateException(
             "Error during writing proto for descriptor: ${DescriptorRenderer.DEBUG_TEXT.render(this)}\n" +

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

@@ -284,7 +284,10 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
         v.getSerializationBindings().put(METHOD_FOR_FUNCTION, freeLambdaDescriptor, method);
 
         DescriptorSerializer serializer =
-                DescriptorSerializer.createForLambda(new JvmSerializerExtension(v.getSerializationBindings(), state));
+                DescriptorSerializer.createForLambda(
+                        new JvmSerializerExtension(v.getSerializationBindings(), state),
+                        state.getLanguageVersionSettings()
+                );
 
         ProtoBuf.Function.Builder builder = serializer.functionProto(freeLambdaDescriptor);
         if (builder == null) return;

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

@@ -129,7 +129,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 descriptor, extension,
                 parentCodegen instanceof ImplementationBodyCodegen
                 ? ((ImplementationBodyCodegen) parentCodegen).serializer
-                : DescriptorSerializer.createTopLevel(extension, null),
+                : DescriptorSerializer.createTopLevel(extension, state.getLanguageVersionSettings(), null),
+                state.getLanguageVersionSettings(),
                 state.getProject()
         );
 

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

@@ -127,7 +127,8 @@ public class PackagePartCodegen extends MemberCodegen<KtFile> {
         List<MemberDescriptor> members = CodegenUtil.getMemberDescriptorsToGenerate(codegen.element, codegen.bindingContext);
 
         JvmSerializerExtension extension = new JvmSerializerExtension(codegen.v.getSerializationBindings(), codegen.state);
-        DescriptorSerializer serializer = DescriptorSerializer.createTopLevel(extension, null);
+        DescriptorSerializer serializer = DescriptorSerializer.createTopLevel(
+                extension, codegen.state.getLanguageVersionSettings(), null);
         ProtoBuf.Package.Builder builder = serializer.packagePartProto(codegen.element.getPackageFqName(), members);
         extension.serializeJvmPackage(builder, packagePartType);
 

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

@@ -12,6 +12,7 @@ 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
@@ -68,7 +69,10 @@ class ScriptCodegen private constructor(
     override fun generateSyntheticPartsAfterBody() {}
 
     override fun generateKotlinMetadataAnnotation() {
-        val serializer = DescriptorSerializer.create(scriptDescriptor, JvmSerializerExtension(v.serializationBindings, state), null)
+        val serializer = DescriptorSerializer.create(
+            scriptDescriptor, JvmSerializerExtension(v.serializationBindings, state), null,
+            state.configuration.languageVersionSettings,
+        )
         val classProto = serializer.classProto(scriptDescriptor).build()
         writeKotlinMetadata(v, state, KotlinClassHeader.Kind.CLASS, false, JvmAnnotationNames.METADATA_SCRIPT_FLAG) { av ->
             DescriptorAsmUtil.writeAnnotationData(av, serializer, classProto)

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

@@ -7,6 +7,7 @@ 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
@@ -49,7 +50,9 @@ fun JvmModuleProtoBuf.Module.Builder.addDataFromCompiledModule(
                     }
                 }.orEmpty()
 
-    val serializer = DescriptorSerializer.createTopLevel(JvmOptionalAnnotationSerializerExtension(stringTable))
+    val serializer = DescriptorSerializer.createTopLevel(
+        JvmOptionalAnnotationSerializerExtension(stringTable), state.configuration.languageVersionSettings,
+    )
     for (descriptor in optionalAnnotationClassDescriptors) {
         addOptionalAnnotationClass(serializer.classProto(descriptor))
     }

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

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

compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt

@@ -143,7 +143,7 @@ class JvmSerializerExtension @JvmOverloads constructor(
 
         for (localVariable in localVariables) {
             val propertyDescriptor = createFreeFakeLocalPropertyDescriptor(localVariable, approximator)
-            val serializer = DescriptorSerializer.createForLambda(this)
+            val serializer = DescriptorSerializer.createForLambda(this, languageVersionSettings)
             proto.addExtension(extension, serializer.propertyProto(propertyDescriptor)?.build() ?: continue)
         }
     }

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.metadata.MetadataSerializer
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor
@@ -87,7 +88,8 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(Buil
         bindingContext: BindingContext,
         module: ModuleDescriptor,
         destDir: File,
-        project: Project?
+        project: Project?,
+        languageVersionSettings: LanguageVersionSettings,
     ) {
         destDir.deleteRecursively()
         if (!destDir.mkdirs()) {
@@ -101,7 +103,8 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(Buil
                 packageView.memberScope.getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) + createCloneable(module),
                 packageView.fragments.flatMap { fragment -> DescriptorUtils.getAllDescriptors(fragment.getMemberScope()) },
                 packageView.fqName,
-                File(destDir, BuiltInSerializerProtocol.getBuiltInsFilePath(packageView.fqName))
+                File(destDir, BuiltInSerializerProtocol.getBuiltInsFilePath(packageView.fqName)),
+                languageVersionSettings,
             ).run()
         }
     }

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -637,7 +637,8 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     firFile,
                     session,
                     scopeSession,
-                    FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable())
+                    FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()),
+                    configuration.languageVersionSettings,
                 )
             }
         }

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializer.kt

@@ -9,6 +9,8 @@ import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.JvmCodegenUtil
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -50,12 +52,16 @@ open class MetadataSerializer(
 
         performanceManager.notifyGenerationStarted()
         val destDir = checkNotNull(environment.destDir)
-        performSerialization(environment.getSourceFiles(), bindingContext, moduleDescriptor, destDir, environment.project)
+        performSerialization(
+            environment.getSourceFiles(), bindingContext, moduleDescriptor, destDir, environment.project,
+            environment.configuration.languageVersionSettings
+        )
         performanceManager.notifyGenerationFinished()
     }
 
     protected open fun performSerialization(
-        files: Collection<KtFile>, bindingContext: BindingContext, module: ModuleDescriptor, destDir: File, project: Project?
+        files: Collection<KtFile>, bindingContext: BindingContext, module: ModuleDescriptor, destDir: File, project: Project?,
+        languageVersionSettings: LanguageVersionSettings,
     ) {
         val packageTable = hashMapOf<FqName, PackageParts>()
 
@@ -89,14 +95,17 @@ open class MetadataSerializer(
                         val classDescriptor = bindingContext.get(BindingContext.CLASS, classOrObject)
                             ?: error("No descriptor found for class ${classOrObject.fqName}")
                         val destFile = File(destDir, getClassFilePath(ClassId(packageFqName, classDescriptor.name)))
-                        PackageSerializer(listOf(classDescriptor), emptyList(), packageFqName, destFile, project).run()
+                        PackageSerializer(
+                            listOf(classDescriptor), emptyList(), packageFqName, destFile,
+                            languageVersionSettings, project,
+                        ).run()
                     }
                 })
             }
 
             if (members.isNotEmpty()) {
                 val destFile = File(destDir, getPackageFilePath(packageFqName, file.name))
-                PackageSerializer(emptyList(), members, packageFqName, destFile, project).run()
+                PackageSerializer(emptyList(), members, packageFqName, destFile, languageVersionSettings, project).run()
 
                 packageTable.getOrPut(packageFqName) {
                     PackageParts(packageFqName.asString())
@@ -130,13 +139,14 @@ open class MetadataSerializer(
         private val members: Collection<DeclarationDescriptor>,
         private val packageFqName: FqName,
         private val destFile: File,
+        private val languageVersionSettings: LanguageVersionSettings,
         private val project: Project? = null
     ) {
         private val proto = ProtoBuf.PackageFragment.newBuilder()
         private val extension = createSerializerExtension()
 
         fun run() {
-            val serializer = DescriptorSerializer.createTopLevel(extension, project)
+            val serializer = DescriptorSerializer.createTopLevel(extension, languageVersionSettings, project)
             serializeClasses(classes, serializer, project)
             serializeMembers(members, serializer)
             serializeStringTable()
@@ -147,7 +157,7 @@ open class MetadataSerializer(
             for (descriptor in DescriptorSerializer.sort(classes)) {
                 if (descriptor !is ClassDescriptor || descriptor.kind == ClassKind.ENUM_ENTRY) continue
 
-                val serializer = DescriptorSerializer.create(descriptor, extension, parentSerializer, project)
+                val serializer = DescriptorSerializer.create(descriptor, extension, parentSerializer, languageVersionSettings, project)
                 serializeClasses(
                     descriptor.unsubstitutedInnerClassesScope.getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS),
                     serializer,

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.serialization
 
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -64,6 +65,7 @@ class FirElementSerializer private constructor(
     private val versionRequirementTable: MutableVersionRequirementTable?,
     private val serializeTypeTableToFunction: Boolean,
     private val typeApproximator: AbstractTypeApproximator,
+    private val languageVersionSettings: LanguageVersionSettings,
 ) {
     private val contractSerializer = FirContractSerializer()
 
@@ -94,6 +96,8 @@ class FirElementSerializer private constructor(
 
         val regularClass = klass as? FirRegularClass
         val modality = regularClass?.modality ?: Modality.FINAL
+
+        val hasEnumEntries = klass.classKind == ClassKind.ENUM_CLASS && languageVersionSettings.supportsFeature(LanguageFeature.EnumEntries)
         val flags = Flags.getClassFlags(
             klass.nonSourceAnnotations(session).isNotEmpty(),
             ProtoEnumFlags.visibility(regularClass?.let { normalizeVisibility(it) } ?: Visibilities.Local),
@@ -104,7 +108,8 @@ class FirElementSerializer private constructor(
             regularClass?.isExternal == true,
             regularClass?.isExpect == true,
             regularClass?.isInline == true,
-            regularClass?.isFun == true
+            regularClass?.isFun == true,
+            hasEnumEntries,
         )
         if (flags != builder.flags) {
             builder.flags = flags
@@ -880,7 +885,7 @@ class FirElementSerializer private constructor(
         FirElementSerializer(
             session, scopeSession, declaration, Interner(typeParameters), extension,
             typeTable, versionRequirementTable, serializeTypeTableToFunction = false,
-            typeApproximator
+            typeApproximator, languageVersionSettings
         )
 
     val stringTable: FirElementAwareStringTable
@@ -1010,12 +1015,14 @@ class FirElementSerializer private constructor(
             scopeSession: ScopeSession,
             extension: FirSerializerExtension,
             typeApproximator: AbstractTypeApproximator,
+            languageVersionSettings: LanguageVersionSettings,
         ): FirElementSerializer =
             FirElementSerializer(
                 session, scopeSession, null,
                 Interner(), extension, MutableTypeTable(), MutableVersionRequirementTable(),
                 serializeTypeTableToFunction = false,
-                typeApproximator
+                typeApproximator,
+                languageVersionSettings,
             )
 
         @JvmStatic
@@ -1024,12 +1031,14 @@ class FirElementSerializer private constructor(
             scopeSession: ScopeSession,
             extension: FirSerializerExtension,
             typeApproximator: AbstractTypeApproximator,
+            languageVersionSettings: LanguageVersionSettings,
         ): FirElementSerializer =
             FirElementSerializer(
                 session, scopeSession, null,
                 Interner(), extension, MutableTypeTable(),
                 versionRequirementTable = null, serializeTypeTableToFunction = true,
-                typeApproximator
+                typeApproximator,
+                languageVersionSettings,
             )
 
         @JvmStatic
@@ -1040,13 +1049,17 @@ class FirElementSerializer private constructor(
             extension: FirSerializerExtension,
             parentSerializer: FirElementSerializer?,
             typeApproximator: AbstractTypeApproximator,
+            languageVersionSettings: LanguageVersionSettings,
         ): FirElementSerializer {
             val parentClassId = klass.symbol.classId.outerClassId
             val parent = if (parentClassId != null && !parentClassId.isLocal) {
                 val parentClass = session.symbolProvider.getClassLikeSymbolByClassId(parentClassId)!!.fir as FirRegularClass
-                parentSerializer ?: create(session, scopeSession, parentClass, extension, null, typeApproximator)
+                parentSerializer ?: create(
+                    session, scopeSession, parentClass, extension, null, typeApproximator,
+                    languageVersionSettings,
+                )
             } else {
-                createTopLevel(session, scopeSession, extension, typeApproximator)
+                createTopLevel(session, scopeSession, extension, typeApproximator, languageVersionSettings)
             }
 
             // Calculate type parameter ids for the outer class beforehand, as it would've had happened if we were always
@@ -1065,7 +1078,8 @@ class FirElementSerializer private constructor(
                     MutableVersionRequirementTable()
                 },
                 serializeTypeTableToFunction = false,
-                typeApproximator
+                typeApproximator,
+                languageVersionSettings,
             )
             for (typeParameter in klass.typeParameters) {
                 if (typeParameter !is FirTypeParameter) continue

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/firKlibSerialization.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.serialization
 
 import org.jetbrains.kotlin.backend.common.serialization.metadata.buildKlibPackageFragment
 import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.classId
@@ -17,9 +18,14 @@ import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.serialization.SerializableStringTable
 
-fun serializeSingleFirFile(file: FirFile, session: FirSession, scopeSession: ScopeSession, serializerExtension: FirKLibSerializerExtension): ProtoBuf.PackageFragment {
+fun serializeSingleFirFile(
+    file: FirFile, session: FirSession, scopeSession: ScopeSession,
+    serializerExtension: FirKLibSerializerExtension,
+    languageVersionSettings: LanguageVersionSettings,
+): ProtoBuf.PackageFragment {
     val approximator = TypeApproximatorForMetadataSerializer(session)
-    val packageSerializer = FirElementSerializer.createTopLevel(session, scopeSession, serializerExtension, approximator)
+    val packageSerializer = FirElementSerializer.createTopLevel(session, scopeSession, serializerExtension, approximator,
+                                                                languageVersionSettings)
 
     // TODO: typealiases (see klib serializer)
     // TODO: split package fragment (see klib serializer)
@@ -30,7 +36,8 @@ fun serializeSingleFirFile(file: FirFile, session: FirSession, scopeSession: Sco
     fun List<FirDeclaration>.makeClassesProtoWithNested(): List<Pair<ProtoBuf.Class, Int>> =
         // TODO: filter out expects
         filterIsInstance<FirClass>().sortedBy { it.classId.asFqNameString() }.flatMap {
-            val classSerializer = FirElementSerializer.create(session, scopeSession, it, serializerExtension, null, approximator)
+            val classSerializer = FirElementSerializer.create(session, scopeSession, it, serializerExtension, null,
+                approximator, languageVersionSettings)
             val index = classSerializer.stringTable.getFqNameIndex(it)
             listOf(classSerializer.classProto(it).build() to index) + it.declarations.makeClassesProtoWithNested()
         }

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.JvmDefaultMode
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
@@ -18,6 +19,7 @@ import org.jetbrains.kotlin.fir.backend.FirMetadataSource
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
@@ -156,8 +158,9 @@ class FirJvmSerializerExtension(
         proto: BuilderType,
         extension: GeneratedMessageLite.GeneratedExtension<MessageType, List<ProtoBuf.Property>>
     ) {
+        val languageVersionSettings = session.languageVersionSettings
         for (localVariable in localDelegatedProperties) {
-            val serializer = FirElementSerializer.createForLambda(session, scopeSession,this, approximator)
+            val serializer = FirElementSerializer.createForLambda(session, scopeSession,this, approximator, languageVersionSettings)
             proto.addExtension(extension, serializer.propertyProto(localVariable)?.build() ?: continue)
         }
     }

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

@@ -61,7 +61,10 @@ fun makeFirMetadataSerializerForIrClass(
         serializationBindings,
         firSerializerExtension,
         approximator,
-        makeElementSerializer(irClass.metadata, components.session, components.scopeSession, firSerializerExtension, approximator, parent)
+        makeElementSerializer(
+            irClass.metadata, components.session, components.scopeSession, firSerializerExtension, approximator, parent,
+            context.state.configuration.languageVersionSettings,
+        )
     )
 }
 
@@ -102,7 +105,10 @@ fun makeLocalFirMetadataSerializerForMetadataSource(
         serializationBindings,
         firSerializerExtension,
         approximator,
-        makeElementSerializer(metadata, session, scopeSession, firSerializerExtension, approximator, parent)
+        makeElementSerializer(
+            metadata, session, scopeSession, firSerializerExtension, approximator, parent,
+            configuration.languageVersionSettings,
+        )
     )
 }
 
@@ -162,7 +168,8 @@ internal fun makeElementSerializer(
     scopeSession: ScopeSession,
     serializerExtension: FirJvmSerializerExtension,
     approximator: AbstractTypeApproximator,
-    parent: MetadataSerializer?
+    parent: MetadataSerializer?,
+    languageVersionSettings: LanguageVersionSettings
 ): FirElementSerializer? =
     when (metadata) {
         is FirMetadataSource.Class -> FirElementSerializer.create(
@@ -170,17 +177,20 @@ internal fun makeElementSerializer(
             metadata.fir,
             serializerExtension,
             (parent as? FirMetadataSerializer)?.serializer,
-            approximator
+            approximator,
+            languageVersionSettings,
         )
         is FirMetadataSource.File -> FirElementSerializer.createTopLevel(
             session, scopeSession,
             serializerExtension,
-            approximator
+            approximator,
+            languageVersionSettings,
         )
         is FirMetadataSource.Function -> FirElementSerializer.createForLambda(
             session, scopeSession,
             serializerExtension,
-            approximator
+            approximator,
+            languageVersionSettings,
         )
         else -> null
     }

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt

@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.IncrementalCompilation
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.config.Services
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.incremental.ClasspathChanges.ClasspathSnapshotDisabled
 import org.jetbrains.kotlin.incremental.ClasspathChanges.ClasspathSnapshotEnabled.IncrementalRun.NoChanges
 import org.jetbrains.kotlin.incremental.ClasspathChanges.ClasspathSnapshotEnabled.IncrementalRun.ToBeComputedByIncrementalCompiler
@@ -167,18 +168,22 @@ open class IncrementalJvmCompilerRunner(
 
     private var dirtyClasspathChanges: Collection<FqName> = emptySet()
 
-    private val psiFileProvider = object {
+    private val messageCollector = BufferingMessageCollector()
-        val messageCollector = BufferingMessageCollector()
+    private val compilerConfiguration: CompilerConfiguration by lazy {
+        val filterMessageCollector = FilteringMessageCollector(messageCollector) { !it.isError }
+        CompilerConfiguration().apply {
+            put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, filterMessageCollector)
+            configureJdkClasspathRoots()
+        }
+    }
 
+    private val psiFileProvider = object {
         fun javaFile(file: File): PsiFile? =
             psiFileFactory.createFileFromText(file.nameWithoutExtension, JavaLanguage.INSTANCE, file.readText())
 
         private val psiFileFactory: PsiFileFactory by lazy {
             val rootDisposable = Disposer.newDisposable()
-            val configuration = CompilerConfiguration()
+            val configuration = compilerConfiguration
-            val filterMessageCollector = FilteringMessageCollector(messageCollector, { !it.isError })
-            configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, filterMessageCollector)
-            configuration.configureJdkClasspathRoots()
             val environment = KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
             val project = environment.project
             PsiFileFactory.getInstance(project)
@@ -203,8 +208,8 @@ open class IncrementalJvmCompilerRunner(
         return try {
             calculateSourcesToCompileImpl(caches, changedFiles, args, messageCollector, classpathAbiSnapshots, withAbiSnapshot)
         } finally {
-            psiFileProvider.messageCollector.flush(messageCollector)
+            this.messageCollector.flush(messageCollector)
-            psiFileProvider.messageCollector.clear()
+            this.messageCollector.clear()
         }
     }
 
@@ -473,7 +478,10 @@ open class IncrementalJvmCompilerRunner(
             val incrementalComponents = IncrementalCompilationComponentsImpl(targetToCache)
             register(IncrementalCompilationComponents::class.java, incrementalComponents)
             if (usePreciseJavaTracking) {
-                val changesTracker = JavaClassesTrackerImpl(caches.platformCache, changedUntrackedJavaClasses.toSet())
+                val changesTracker = JavaClassesTrackerImpl(
+                    caches.platformCache, changedUntrackedJavaClasses.toSet(),
+                    compilerConfiguration.languageVersionSettings,
+                )
                 changedUntrackedJavaClasses.clear()
                 register(JavaClassesTracker::class.java, changesTracker)
             }

compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrSerializerImpl.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.backend.jvm.serialization.JvmIrSerializerSession
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JvmSerializeIrMode
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.util.irMessageLogger
@@ -38,6 +39,7 @@ class JvmIrSerializerImpl(private val configuration: CompilerConfiguration) : Jv
             declarationTable,
             mutableMapOf(),
             configuration.get(JVMConfigurationKeys.SERIALIZE_IR) ?: JvmSerializeIrMode.NONE,
-            fileClassFqName
+            fileClassFqName,
+            configuration.languageVersionSettings,
         )
 }

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.createFreeFakeLambdaDescriptor
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.ir.declarations.DescriptorMetadataSource
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
@@ -32,18 +33,25 @@ class DescriptorMetadataSerializer(
     parent: MetadataSerializer?
 ) : MetadataSerializer {
     private val serializerExtension = JvmSerializerExtension(serializationBindings, context.state, context.defaultTypeMapper)
-    private val serializer: DescriptorSerializer? =
+    private val serializer: DescriptorSerializer? = run {
+        val languageVersionSettings = context.state.configuration.languageVersionSettings
         when (val metadata = irClass.metadata) {
             is DescriptorMetadataSource.Class -> DescriptorSerializer.create(
-                metadata.descriptor, serializerExtension, (parent as? DescriptorMetadataSerializer)?.serializer, context.state.project
+                metadata.descriptor, serializerExtension, (parent as? DescriptorMetadataSerializer)?.serializer,
+                languageVersionSettings, context.state.project,
             )
             is DescriptorMetadataSource.Script -> DescriptorSerializer.create(
-                metadata.descriptor, serializerExtension, (parent as? DescriptorMetadataSerializer)?.serializer, context.state.project
+                metadata.descriptor, serializerExtension, (parent as? DescriptorMetadataSerializer)?.serializer,
+                languageVersionSettings, context.state.project,
             )
-            is DescriptorMetadataSource.File -> DescriptorSerializer.createTopLevel(serializerExtension, context.state.project)
+            is DescriptorMetadataSource.File -> DescriptorSerializer.createTopLevel(
-            is DescriptorMetadataSource.Function -> DescriptorSerializer.createForLambda(serializerExtension)
+                serializerExtension, languageVersionSettings,
+                context.state.project
+            )
+            is DescriptorMetadataSource.Function -> DescriptorSerializer.createForLambda(serializerExtension, languageVersionSettings)
             else -> null
         }
+    }
 
     override fun serialize(metadata: MetadataSource): Pair<MessageLite, JvmStringTable>? {
         val localDelegatedProperties = context.localDelegatedProperties[irClass.attributeOwnerId]

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.backend.common.serialization
 
 import org.jetbrains.kotlin.backend.common.serialization.encodings.*
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrSimpleTypeNullability
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrFileEntry
@@ -117,6 +118,7 @@ open class IrFileSerializer(
     private val declarationTable: DeclarationTable,
     private val expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>,
     private val compatibilityMode: CompatibilityMode,
+    private val languageVersionSettings: LanguageVersionSettings,
     private val bodiesOnlyForInlines: Boolean = false,
     private val skipExpects: Boolean = false,
     private val addDebugInfo: Boolean = true,
@@ -1228,7 +1230,7 @@ open class IrFileSerializer(
 
     private fun serializeIrClass(clazz: IrClass): ProtoClass {
         val proto = ProtoClass.newBuilder()
-            .setBase(serializeIrDeclarationBase(clazz, ClassFlags.encode(clazz)))
+            .setBase(serializeIrDeclarationBase(clazz, ClassFlags.encode(clazz, languageVersionSettings)))
             .setName(serializeName(clazz.name))
 
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/encodings/BinaryFlags.kt

@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.backend.common.serialization.encodings
 
 import org.jetbrains.kotlin.backend.common.serialization.IrFlags
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
@@ -33,15 +35,17 @@ value class ClassFlags(val flags: Long) {
     val isFun: Boolean get() = IrFlags.IS_FUN_INTERFACE.get(flags.toInt())
 
     companion object {
-        fun encode(clazz: IrClass): Long {
+        fun encode(clazz: IrClass, languageVersionSettings: LanguageVersionSettings): Long {
             return clazz.run {
                 val hasAnnotation = annotations.isNotEmpty()
                 val visibility = ProtoEnumFlags.descriptorVisibility(visibility.normalize())
                 val modality = ProtoEnumFlags.modality(modality)
                 val kind = ProtoEnumFlags.classKind(kind, isCompanion)
 
+                val hasEnumEntries = kind == ProtoBuf.Class.Kind.ENUM_CLASS &&
+                        languageVersionSettings.supportsFeature(LanguageFeature.EnumEntries)
                 val flags = IrFlags.getClassFlags(
-                    hasAnnotation, visibility, modality, kind, isInner, isData, isExternal, isExpect, isValue, isFun
+                    hasAnnotation, visibility, modality, kind, isInner, isData, isExternal, isExpect, isValue, isFun, hasEnumEntries
                 )
 
                 flags.toLong()

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/metadata/KlibMetadataSerializer.kt

@@ -58,7 +58,7 @@ abstract class KlibMetadataSerializer(
         )
         return SerializerContext(
             extension,
-            DescriptorSerializer.createTopLevel(extension, project)
+            DescriptorSerializer.createTopLevel(extension, languageVersionSettings, project)
         )
     }
 
@@ -73,7 +73,7 @@ abstract class KlibMetadataSerializer(
         with(serializerContext) {
             val previousSerializer = classSerializer
 
-            classSerializer = DescriptorSerializer.create(classDescriptor, serializerExtension, classSerializer, project)
+            classSerializer = DescriptorSerializer.create(classDescriptor, serializerExtension, classSerializer, languageVersionSettings, project)
             val classProto = classSerializer.classProto(classDescriptor).build() ?: error("Class not serialized: $classDescriptor")
             //builder.addClass(classProto)
 

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt

@@ -62,7 +62,6 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
 import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
 import org.jetbrains.kotlin.psi2ir.descriptors.IrBuiltInsOverDescriptors
-import org.jetbrains.kotlin.psi2ir.generators.DeclarationStubGeneratorImpl
 import org.jetbrains.kotlin.psi2ir.generators.GeneratorContext
 import org.jetbrains.kotlin.psi2ir.generators.TypeTranslatorImpl
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -622,6 +621,7 @@ fun serializeModuleIntoKlib(
             skipExpects = !configuration.expectActualLinker,
             normalizeAbsolutePaths = absolutePathNormalization,
             sourceBaseDirs = sourceBaseDirs,
+            configuration.languageVersionSettings,
             signatureClashChecks
         ).serializedIrModule(moduleFragment)
 

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrFileSerializer.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir
 import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IrFileSerializer
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrAnnotationContainer
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
@@ -21,6 +22,7 @@ class JsIrFileSerializer(
     expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>,
     compatibilityMode: CompatibilityMode,
     skipExpects: Boolean,
+    languageVersionSettings: LanguageVersionSettings,
     bodiesOnlyForInlines: Boolean = false,
     normalizeAbsolutePaths: Boolean,
     sourceBaseDirs: Collection<String>
@@ -29,6 +31,7 @@ class JsIrFileSerializer(
     declarationTable,
     expectDescriptorToSymbol,
     compatibilityMode,
+    languageVersionSettings,
     bodiesOnlyForInlines = bodiesOnlyForInlines,
     skipExpects = skipExpects,
     normalizeAbsolutePaths = normalizeAbsolutePaths,

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IdSignatureClashTracker
 import org.jetbrains.kotlin.backend.common.serialization.IrModuleSerializer
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrFile
@@ -23,6 +24,7 @@ class JsIrModuleSerializer(
     val skipExpects: Boolean,
     normalizeAbsolutePaths: Boolean,
     sourceBaseDirs: Collection<String>,
+    private val languageVersionSettings: LanguageVersionSettings,
     shouldCheckSignaturesOnUniqueness: Boolean = true
 ) : IrModuleSerializer<JsIrFileSerializer>(messageLogger, compatibilityMode, normalizeAbsolutePaths, sourceBaseDirs) {
 
@@ -39,6 +41,7 @@ class JsIrModuleSerializer(
             compatibilityMode = compatibilityMode,
             skipExpects = skipExpects,
             normalizeAbsolutePaths = normalizeAbsolutePaths,
-            sourceBaseDirs = sourceBaseDirs
+            sourceBaseDirs = sourceBaseDirs,
+            languageVersionSettings = languageVersionSettings,
         )
 }

compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIrSerializerSession.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IrFileSerializer
 import org.jetbrains.kotlin.backend.jvm.serialization.proto.JvmIr
 import org.jetbrains.kotlin.config.JvmSerializeIrMode
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
@@ -25,9 +26,10 @@ class JvmIrSerializerSession(
     expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>,
     private val mode: JvmSerializeIrMode,
     private val fileClassFqName: FqName,
+    languageVersionSettings: LanguageVersionSettings,
     skipExpects: Boolean = false,
 ) : IrFileSerializer(
-    messageLogger, declarationTable, expectDescriptorToSymbol, CompatibilityMode.CURRENT,
+    messageLogger, declarationTable, expectDescriptorToSymbol, CompatibilityMode.CURRENT, languageVersionSettings,
     bodiesOnlyForInlines = mode == JvmSerializeIrMode.INLINE,
     skipExpects, normalizeAbsolutePaths = false, sourceBaseDirs = emptyList()
 ) {

compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
 import org.jetbrains.kotlin.builtins.transformSuspendFunctionToRuntimeFunctionType
 import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
@@ -51,8 +52,9 @@ class DescriptorSerializer private constructor(
     val typeTable: MutableTypeTable,
     private val versionRequirementTable: MutableVersionRequirementTable?,
     private val serializeTypeTableToFunction: Boolean,
+    private val languageVersionSettings: LanguageVersionSettings,
     val plugins: List<DescriptorSerializerPlugin> = emptyList(),
-    val typeAttributeTranslators: TypeAttributeTranslators? = null
+    val typeAttributeTranslators: TypeAttributeTranslators? = null,
 ) {
     private val contractSerializer = ContractSerializer()
 
@@ -66,7 +68,8 @@ class DescriptorSerializer private constructor(
     private fun createChildSerializer(descriptor: DeclarationDescriptor): DescriptorSerializer =
         DescriptorSerializer(
             descriptor, Interner(typeParameters), extension, typeTable, versionRequirementTable,
-            serializeTypeTableToFunction = false, typeAttributeTranslators = typeAttributeTranslators
+            serializeTypeTableToFunction = false, typeAttributeTranslators = typeAttributeTranslators,
+            languageVersionSettings = languageVersionSettings,
         )
 
     val stringTable: DescriptorAwareStringTable
@@ -86,6 +89,8 @@ class DescriptorSerializer private constructor(
     fun classProto(classDescriptor: ClassDescriptor): ProtoBuf.Class.Builder = withNewMetDefinitelyNotNullType {
         val builder = ProtoBuf.Class.newBuilder()
 
+        val hasEnumEntries = classDescriptor.kind == ClassKind.ENUM_CLASS &&
+                languageVersionSettings.supportsFeature(LanguageFeature.EnumEntries)
         val flags = Flags.getClassFlags(
             // Since 1.4.30 isInline & isValue are the same flag. To distinguish them we generate @JvmInline annotation.
             // See ClassDescriptor.isInlineClass() function.
@@ -94,7 +99,7 @@ class DescriptorSerializer private constructor(
             ProtoEnumFlags.modality(classDescriptor.modality),
             ProtoEnumFlags.classKind(classDescriptor.kind, classDescriptor.isCompanionObject),
             classDescriptor.isInner, classDescriptor.isData, classDescriptor.isExternal, classDescriptor.isExpect,
-            classDescriptor.isValueClass(), classDescriptor.isFun
+            classDescriptor.isValueClass(), classDescriptor.isFun, hasEnumEntries,
         )
         if (flags != builder.flags) {
             builder.flags = flags
@@ -861,16 +866,21 @@ class DescriptorSerializer private constructor(
 
     companion object {
         @JvmStatic
-        fun createTopLevel(extension: SerializerExtension, project: Project? = null): DescriptorSerializer =
+        fun createTopLevel(
+            extension: SerializerExtension, languageVersionSettings: LanguageVersionSettings,
+            project: Project? = null
+        ): DescriptorSerializer =
             DescriptorSerializer(
                 null, Interner(), extension, MutableTypeTable(), MutableVersionRequirementTable(), serializeTypeTableToFunction = false,
-                typeAttributeTranslators = project?.let { TypeAttributeTranslatorExtension.createTranslators(it) }
+                typeAttributeTranslators = project?.let { TypeAttributeTranslatorExtension.createTranslators(it) },
+                languageVersionSettings = languageVersionSettings,
             )
 
         @JvmStatic
-        fun createForLambda(extension: SerializerExtension): DescriptorSerializer =
+        fun createForLambda(extension: SerializerExtension, languageVersionSettings: LanguageVersionSettings): DescriptorSerializer =
             DescriptorSerializer(
-                null, Interner(), extension, MutableTypeTable(), versionRequirementTable = null, serializeTypeTableToFunction = true
+                null, Interner(), extension, MutableTypeTable(), versionRequirementTable = null,
+                serializeTypeTableToFunction = true, languageVersionSettings = languageVersionSettings,
             )
 
         @JvmStatic
@@ -878,13 +888,14 @@ class DescriptorSerializer private constructor(
             descriptor: ClassDescriptor,
             extension: SerializerExtension,
             parentSerializer: DescriptorSerializer?,
+            languageVersionSettings: LanguageVersionSettings,
             project: Project? = null
         ): DescriptorSerializer {
             val container = descriptor.containingDeclaration
             val parent = if (container is ClassDescriptor)
-                parentSerializer ?: create(container, extension, null, project)
+                parentSerializer ?: create(container, extension, null, languageVersionSettings, project)
             else
-                createTopLevel(extension)
+                createTopLevel(extension, languageVersionSettings)
             val plugins = project?.let { DescriptorSerializerPlugin.getInstances(it) }.orEmpty()
             val typeAttributeTranslators = project?.let { TypeAttributeTranslatorExtension.createTranslators(it) }
 
@@ -899,6 +910,7 @@ class DescriptorSerializer private constructor(
                 if (container is ClassDescriptor && !isVersionRequirementTableWrittenCorrectly(extension.metadataVersion))
                     parent.versionRequirementTable else MutableVersionRequirementTable(),
                 serializeTypeTableToFunction = false,
+                languageVersionSettings,
                 plugins,
                 typeAttributeTranslators
             )

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt

@@ -96,7 +96,8 @@ class Fir2IrJsResultsConverter(
                 firFile,
                 components.session,
                 components.scopeSession,
-                FirKLibSerializerExtension(components.session, metadataVersion, FirElementAwareSerializableStringTable())
+                FirKLibSerializerExtension(components.session, metadataVersion, FirElementAwareSerializableStringTable()),
+                configuration.languageVersionSettings,
             )
         }
     }

compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibTextTestCase.kt

@@ -145,7 +145,8 @@ abstract class AbstractKlibTextTestCase : CodegenTestCase() {
                 CompatibilityMode.CURRENT,
                 skipExpect,
                 false,
-                emptyList()
+                emptyList(),
+                myEnvironment.configuration.languageVersionSettings,
             ).serializedIrModule(irModuleFragment)
 
         val moduleDescriptor = irModuleFragment.descriptor

core/metadata/src/org/jetbrains/kotlin/metadata/deserialization/Flags.java

@@ -32,6 +32,7 @@ public class Flags {
     public static final BooleanFlagField IS_EXPECT_CLASS = FlagField.booleanAfter(IS_EXTERNAL_CLASS);
     public static final BooleanFlagField IS_VALUE_CLASS = FlagField.booleanAfter(IS_EXPECT_CLASS);
     public static final BooleanFlagField IS_FUN_INTERFACE = FlagField.booleanAfter(IS_VALUE_CLASS);
+    private static final BooleanFlagField HAS_ENUM_ENTRIES = FlagField.booleanAfter(IS_FUN_INTERFACE);
 
     // Constructors
 
@@ -100,7 +101,8 @@ public class Flags {
             boolean isExternal,
             boolean isExpect,
             boolean isValue,
-            boolean isFun
+            boolean isFun,
+            boolean hasEnumEntries
     ) {
         return HAS_ANNOTATIONS.toFlags(hasAnnotations)
                | MODALITY.toFlags(modality)
@@ -112,6 +114,7 @@ public class Flags {
                | IS_EXPECT_CLASS.toFlags(isExpect)
                | IS_VALUE_CLASS.toFlags(isValue)
                | IS_FUN_INTERFACE.toFlags(isFun)
+               | HAS_ENUM_ENTRIES.toFlags(hasEnumEntries)
                 ;
     }
 

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt

@@ -185,14 +185,14 @@ object KotlinJavascriptSerializationUtil {
             for (descriptor in descriptors) {
                 if (descriptor !is ClassDescriptor || skip(descriptor)) continue
 
-                val serializer = DescriptorSerializer.create(descriptor, extension, parentSerializer, project)
+                val serializer = DescriptorSerializer.create(descriptor, extension, parentSerializer, languageVersionSettings, project)
                 serializeClasses(descriptor.unsubstitutedInnerClassesScope.getContributedDescriptors(), serializer)
                 val classProto = serializer.classProto(descriptor).build() ?: error("Class not serialized: $descriptor")
                 builder.addClass_(classProto)
             }
         }
 
-        val serializer = DescriptorSerializer.createTopLevel(extension)
+        val serializer = DescriptorSerializer.createTopLevel(extension, languageVersionSettings)
         serializeClasses(classDescriptors, serializer)
 
         val stringTable = extension.stringTable

js/js.tests/test/org/jetbrains/kotlin/benchmarks/GenerateIrRuntime.kt

@@ -535,7 +535,8 @@ class GenerateIrRuntime {
             CompatibilityMode.CURRENT,
             skipExpects = true,
             normalizeAbsolutePaths = false,
-            emptyList()
+            emptyList(),
+            configuration.languageVersionSettings,
         ).serializedIrModule(module)
         return serializedIr
     }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/FirSerializer.kt

@@ -53,7 +53,9 @@ internal fun PhaseContext.firSerializer(
                 firFile,
                 input.session,
                 input.scopeSession,
-                FirNativeKLibSerializerExtension(input.session, metadataVersion, FirElementAwareSerializableStringTable()))
+                FirNativeKLibSerializerExtension(input.session, metadataVersion, FirElementAwareSerializableStringTable()),
+                configuration.languageVersionSettings,
+        )
     }
 }
 
@@ -82,7 +84,8 @@ internal fun PhaseContext.serializeNativeModule(
                     skipExpects = !expectActualLinker,
                     CompatibilityMode.CURRENT,
                     normalizeAbsolutePaths = absolutePathNormalization,
-                    sourceBaseDirs = sourceBaseDirs
+                    sourceBaseDirs = sourceBaseDirs,
+                    languageVersionSettings = configuration.languageVersionSettings,
             ).serializedIrModule(moduleFragment)
 
     val moduleDescriptor = moduleFragment.descriptor

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/Serializer.kt

@@ -48,6 +48,7 @@ internal val SerializerPhase = createSimpleNamedCompilerPhase<PhaseContext, Seri
                 compatibilityMode = CompatibilityMode.CURRENT,
                 normalizeAbsolutePaths = normalizeAbsolutePaths,
                 sourceBaseDirs = relativePathBase,
+                languageVersionSettings = config.languageVersionSettings,
         ).serializedIrModule(ir)
     }
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrFileSerializer.kt

@@ -4,6 +4,7 @@ import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IrFileSerializer
 import org.jetbrains.kotlin.backend.konan.RuntimeNames
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrAnnotationContainer
 import org.jetbrains.kotlin.ir.declarations.IrClass
@@ -17,11 +18,13 @@ class KonanIrFileSerializer(
     declarationTable: DeclarationTable,
     expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>,
     skipExpects: Boolean,
+    languageVersionSettings: LanguageVersionSettings,
     bodiesOnlyForInlines: Boolean = false,
     compatibilityMode: CompatibilityMode,
     normalizeAbsolutePaths: Boolean,
     sourceBaseDirs: Collection<String>
-): IrFileSerializer(messageLogger, declarationTable, expectDescriptorToSymbol, compatibilityMode, bodiesOnlyForInlines, skipExpects, normalizeAbsolutePaths = normalizeAbsolutePaths, sourceBaseDirs = sourceBaseDirs) {
+): IrFileSerializer(messageLogger, declarationTable, expectDescriptorToSymbol, compatibilityMode, languageVersionSettings,
+        bodiesOnlyForInlines, skipExpects, normalizeAbsolutePaths = normalizeAbsolutePaths, sourceBaseDirs = sourceBaseDirs) {
 
     override fun backendSpecificExplicitRoot(node: IrAnnotationContainer): Boolean {
         val fqn = when (node) {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt

@@ -3,6 +3,7 @@ package org.jetbrains.kotlin.backend.konan.serialization
 import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.IrModuleSerializer
 import org.jetbrains.kotlin.backend.konan.ir.interop.IrProviderForCEnumAndCStructStubs
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrFile
@@ -16,7 +17,8 @@ class KonanIrModuleSerializer(
     val skipExpects: Boolean,
     compatibilityMode: CompatibilityMode,
     normalizeAbsolutePaths: Boolean,
-    sourceBaseDirs: Collection<String>
+    sourceBaseDirs: Collection<String>,
+    private val languageVersionSettings: LanguageVersionSettings,
 ) : IrModuleSerializer<KonanIrFileSerializer>(messageLogger, compatibilityMode, normalizeAbsolutePaths, sourceBaseDirs) {
 
     private val globalDeclarationTable = KonanGlobalDeclarationTable(irBuiltIns)
@@ -31,5 +33,10 @@ class KonanIrModuleSerializer(
             file.fileEntry.name != IrProviderForCEnumAndCStructStubs.cTypeDefinitionsFileName
 
     override fun createSerializerForFile(file: IrFile): KonanIrFileSerializer =
-            KonanIrFileSerializer(messageLogger, KonanDeclarationTable(globalDeclarationTable), expectDescriptorToSymbol, skipExpects = skipExpects, compatibilityMode = compatibilityMode, normalizeAbsolutePaths = normalizeAbsolutePaths, sourceBaseDirs = sourceBaseDirs)
+            KonanIrFileSerializer(messageLogger, KonanDeclarationTable(globalDeclarationTable), expectDescriptorToSymbol,
+                    skipExpects = skipExpects,
+                    compatibilityMode = compatibilityMode,
+                    normalizeAbsolutePaths = normalizeAbsolutePaths,
+                    sourceBaseDirs = sourceBaseDirs,
+                    languageVersionSettings = languageVersionSettings)
 }