From 14b4cdc7c434cf1bbf08b4c4f63f626c68751b6b Mon Sep 17 00:00:00 2001 From: Roman Efremov Date: Mon, 2 Jan 2023 11:47:10 +0100 Subject: [PATCH] Write "hasEnumEntries" flag into metadata when feature enabled ^KT-53929 Fixed --- .../incremental/JavaClassesTrackerImpl.kt | 12 +++++--- .../kotlin/codegen/ClosureCodegen.java | 5 +++- .../codegen/ImplementationBodyCodegen.java | 3 +- .../kotlin/codegen/PackagePartCodegen.java | 3 +- .../jetbrains/kotlin/codegen/ScriptCodegen.kt | 6 +++- .../kotlin/codegen/classFileUtils.kt | 5 +++- .../codegen/coroutines/CoroutineCodegen.kt | 4 ++- .../serialization/JvmSerializerExtension.kt | 2 +- .../builtins/BuiltInsSerializer.kt | 7 +++-- .../jetbrains/kotlin/cli/js/K2JsIrCompiler.kt | 3 +- .../kotlin/cli/metadata/MetadataSerializer.kt | 22 ++++++++++---- .../fir/serialization/FirElementSerializer.kt | 28 ++++++++++++----- .../fir/serialization/firKlibSerialization.kt | 13 ++++++-- .../backend/jvm/FirJvmSerializerExtension.kt | 5 +++- .../fir/backend/jvm/FirMetadataSerializer.kt | 22 ++++++++++---- .../IncrementalJvmCompilerRunner.kt | 26 ++++++++++------ .../kotlin/backend/jvm/JvmIrSerializerImpl.kt | 4 ++- .../metadata/DescriptorMetadataSerializer.kt | 18 +++++++---- .../common/serialization/IrFileSerializer.kt | 4 ++- .../serialization/encodings/BinaryFlags.kt | 8 +++-- .../metadata/KlibMetadataSerializer.kt | 4 +-- .../jetbrains/kotlin/ir/backend/js/klib.kt | 2 +- .../serialization/ir/JsIrFileSerializer.kt | 3 ++ .../serialization/ir/JsIrModuleSerializer.kt | 5 +++- .../serialization/JvmIrSerializerSession.kt | 4 ++- .../serialization/DescriptorSerializer.kt | 30 +++++++++++++------ .../frontend/fir/Fir2IrJsResultsConverter.kt | 3 +- .../kotlin/klib/AbstractKlibTextTestCase.kt | 3 +- .../metadata/deserialization/Flags.java | 5 +++- .../js/KotlinJavascriptSerializationUtil.kt | 4 +-- .../kotlin/benchmarks/GenerateIrRuntime.kt | 3 +- .../kotlin/backend/konan/FirSerializer.kt | 7 +++-- .../backend/konan/driver/phases/Serializer.kt | 1 + .../serialization/KonanIrFileSerializer.kt | 5 +++- .../serialization/KonanIrModuleSerializer.kt | 11 +++++-- 35 files changed, 210 insertions(+), 80 deletions(-) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt b/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt index 11c7b0434e8..8e76254d9b0 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/JavaClassesTrackerImpl.kt +++ b/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 + private val untrackedJavaClasses: Set, + private val languageVersionSettings: LanguageVersionSettings, ) : JavaClassesTracker { private val classToSourceSerialized: MutableMap = 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" + diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java index fe87c8a4a34..39a93993f86 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java @@ -284,7 +284,10 @@ public class ClosureCodegen extends MemberCodegen { 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; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index fae2ea25b9e..23404e326fd 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/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() ); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java index 6c8581d8f35..d430a0dd6c0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackagePartCodegen.java @@ -127,7 +127,8 @@ public class PackagePartCodegen extends MemberCodegen { List 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); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt index 27c1abf6c79..44d88392e4b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt +++ b/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) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt index 1e46b822f9a..a6035bcbbce 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt +++ b/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)) } 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 3d07c58e086..ae1847d55e3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt +++ b/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) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt index 42849faede6..8a9c75c391b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt +++ b/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) } } diff --git a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt b/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt index 62bd1634341..5a318091483 100644 --- a/compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt +++ b/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() } } diff --git a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt index 932a6b5fb96..d14b90949ba 100644 --- a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt +++ b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt @@ -637,7 +637,8 @@ class K2JsIrCompiler : CLICompiler() { firFile, session, scopeSession, - FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()) + FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()), + configuration.languageVersionSettings, ) } } diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializer.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializer.kt index abbf685ff3c..9540cf36a62 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializer.kt +++ b/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, bindingContext: BindingContext, module: ModuleDescriptor, destDir: File, project: Project? + files: Collection, bindingContext: BindingContext, module: ModuleDescriptor, destDir: File, project: Project?, + languageVersionSettings: LanguageVersionSettings, ) { val packageTable = hashMapOf() @@ -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, 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, diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt index f7c962477ad..5a81729f429 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt +++ b/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 diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/firKlibSerialization.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/firKlibSerialization.kt index e3f223273ca..55847a4d144 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/firKlibSerialization.kt +++ b/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.makeClassesProtoWithNested(): List> = // TODO: filter out expects filterIsInstance().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() } diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt index b7594d53dce..41941b19c98 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt +++ b/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> ) { + 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) } } 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 205ad2888b5..84cb232f470 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 @@ -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 } diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt index 59173736e46..40e6937ba24 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt +++ b/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 = emptySet() - private val psiFileProvider = object { - val messageCollector = BufferingMessageCollector() + private 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 filterMessageCollector = FilteringMessageCollector(messageCollector, { !it.isError }) - configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, filterMessageCollector) - configuration.configureJdkClasspathRoots() + val configuration = compilerConfiguration 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) - psiFileProvider.messageCollector.clear() + this.messageCollector.flush(messageCollector) + 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) } diff --git a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrSerializerImpl.kt b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrSerializerImpl.kt index cfdc3c3dc31..61c831ec8b2 100644 --- a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrSerializerImpl.kt +++ b/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, ) } \ No newline at end of file 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 1053a784d80..f321ea572e7 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 @@ -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.Function -> DescriptorSerializer.createForLambda(serializerExtension) + is DescriptorMetadataSource.File -> DescriptorSerializer.createTopLevel( + serializerExtension, languageVersionSettings, + context.state.project + ) + is DescriptorMetadataSource.Function -> DescriptorSerializer.createForLambda(serializerExtension, languageVersionSettings) else -> null } + } override fun serialize(metadata: MetadataSource): Pair? { val localDelegatedProperties = context.localDelegatedProperties[irClass.attributeOwnerId] diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt index 2c71c89ea65..d73d4800b92 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileSerializer.kt +++ b/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, 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)) diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/encodings/BinaryFlags.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/encodings/BinaryFlags.kt index c95f2748687..4c5265e66f5 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/encodings/BinaryFlags.kt +++ b/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() diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/metadata/KlibMetadataSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/metadata/KlibMetadataSerializer.kt index 1f04bd0cdff..a695e7951ee 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/metadata/KlibMetadataSerializer.kt +++ b/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) diff --git a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt index 7f190165202..b3ef6194adb 100644 --- a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt +++ b/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) diff --git a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrFileSerializer.kt b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrFileSerializer.kt index c17d169ede0..c8f7a7b717e 100644 --- a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrFileSerializer.kt +++ b/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, compatibilityMode: CompatibilityMode, skipExpects: Boolean, + languageVersionSettings: LanguageVersionSettings, bodiesOnlyForInlines: Boolean = false, normalizeAbsolutePaths: Boolean, sourceBaseDirs: Collection @@ -29,6 +31,7 @@ class JsIrFileSerializer( declarationTable, expectDescriptorToSymbol, compatibilityMode, + languageVersionSettings, bodiesOnlyForInlines = bodiesOnlyForInlines, skipExpects = skipExpects, normalizeAbsolutePaths = normalizeAbsolutePaths, diff --git a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt index 64b208869b4..fe948be4cc3 100644 --- a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt +++ b/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, + private val languageVersionSettings: LanguageVersionSettings, shouldCheckSignaturesOnUniqueness: Boolean = true ) : IrModuleSerializer(messageLogger, compatibilityMode, normalizeAbsolutePaths, sourceBaseDirs) { @@ -39,6 +41,7 @@ class JsIrModuleSerializer( compatibilityMode = compatibilityMode, skipExpects = skipExpects, normalizeAbsolutePaths = normalizeAbsolutePaths, - sourceBaseDirs = sourceBaseDirs + sourceBaseDirs = sourceBaseDirs, + languageVersionSettings = languageVersionSettings, ) } \ No newline at end of file diff --git a/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIrSerializerSession.kt b/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIrSerializerSession.kt index 0df40f8c33a..bcfbc7106ad 100644 --- a/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIrSerializerSession.kt +++ b/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, 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() ) { diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index ace996592a7..6984cb377e4 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/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 = 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 ) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt index c26845a29d1..eb6e9d83e83 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt +++ b/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, ) } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibTextTestCase.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibTextTestCase.kt index d0e226ddc10..aa0a44afa00 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibTextTestCase.kt +++ b/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 diff --git a/core/metadata/src/org/jetbrains/kotlin/metadata/deserialization/Flags.java b/core/metadata/src/org/jetbrains/kotlin/metadata/deserialization/Flags.java index 6cc11aba6a6..4cf2642ce92 100644 --- a/core/metadata/src/org/jetbrains/kotlin/metadata/deserialization/Flags.java +++ b/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) ; } diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt index 55a8a3a8e4b..891b7d96a96 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt +++ b/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 diff --git a/js/js.tests/test/org/jetbrains/kotlin/benchmarks/GenerateIrRuntime.kt b/js/js.tests/test/org/jetbrains/kotlin/benchmarks/GenerateIrRuntime.kt index e0235031eb5..6164846bf15 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/benchmarks/GenerateIrRuntime.kt +++ b/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 } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/FirSerializer.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/FirSerializer.kt index dda73104a0b..6e200cf5937 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/FirSerializer.kt +++ b/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 diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/Serializer.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/Serializer.kt index aa3cd4322b4..b36c84b332f 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/Serializer.kt +++ b/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, skipExpects: Boolean, + languageVersionSettings: LanguageVersionSettings, bodiesOnlyForInlines: Boolean = false, compatibilityMode: CompatibilityMode, normalizeAbsolutePaths: Boolean, sourceBaseDirs: Collection -): 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) { diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt index ef416ce5a4a..d3c09af1103 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanIrModuleSerializer.kt +++ b/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 + sourceBaseDirs: Collection, + private val languageVersionSettings: LanguageVersionSettings, ) : IrModuleSerializer(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) }