Deprecate old kotlinx-metadata flags API:

Flag, Flag constants, Flags typealias, flagsOf() function, and
Flag accessors in nodes (such as KmClass.flags, KmClass.jvmFlags, KmProperty.setterFlags, etc)

#KT-59440

native/commonizer/src/org/jetbrains/kotlin/commonizer/metadata/CirDeserializers.kt

@@ -20,8 +20,12 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.types.Variance
 
 object CirDeserializers {
-    private fun annotations(flags: Flags, typeResolver: CirTypeResolver, annotations: () -> List<KmAnnotation>): List<CirAnnotation> {
-        return if (!Flag.Common.HAS_ANNOTATIONS(flags))
+    private fun annotations(
+        hasAnnotations: Boolean,
+        typeResolver: CirTypeResolver,
+        annotations: () -> List<KmAnnotation>,
+    ): List<CirAnnotation> {
+        return if (!hasAnnotations)
             emptyList()
         else
             annotations().compactMap { annotation(it, typeResolver) }
@@ -72,12 +76,10 @@ object CirDeserializers {
         )
     }
 
-    private val ALWAYS_HAS_ANNOTATIONS: Flags = flagsOf(Flag.Common.HAS_ANNOTATIONS)
-
     private fun typeParameter(source: KmTypeParameter, typeResolver: CirTypeResolver): CirTypeParameter = CirTypeParameter(
-        annotations = annotations(ALWAYS_HAS_ANNOTATIONS, typeResolver, source::annotations),
+        annotations = annotations(true, typeResolver, source::annotations),
         name = CirName.create(source.name),
-        isReified = Flag.TypeParameter.IS_REIFIED(source.flags),
+        isReified = source.isReified,
         variance = variance(source.variance),
         upperBounds = source.filteredUpperBounds.compactMap { type(it, typeResolver) }
     )
@@ -91,7 +93,7 @@ object CirDeserializers {
     )
 
     fun property(name: CirName, source: KmProperty, containingClass: CirContainingClass?, typeResolver: CirTypeResolver): CirProperty {
-        val compileTimeInitializer = if (Flag.Property.HAS_CONSTANT(source.flags)) {
+        val compileTimeInitializer = if (source.hasConstant) {
             constantValue(
                 constantValue = source.compileTimeValue,
                 owner = source,
@@ -99,19 +101,19 @@ object CirDeserializers {
         } else CirConstantValue.NullValue
 
         return CirProperty(
-            annotations = annotations(source.flags, typeResolver, source::annotations),
+            annotations = annotations(source.hasAnnotations, typeResolver, source::annotations),
             name = name,
             typeParameters = source.typeParameters.compactMap { typeParameter(it, typeResolver) },
-            visibility = visibility(source.flags),
-            modality = modality(source.flags),
+            visibility = visibility(source.visibility),
+            modality = modality(source.modality),
             containingClass = containingClass,
             extensionReceiver = source.receiverParameterType?.let { extensionReceiver(it, typeResolver) },
             returnType = type(source.returnType, typeResolver),
-            kind = callableKind(source.flags),
-            isVar = Flag.Property.IS_VAR(source.flags),
-            isLateInit = Flag.Property.IS_LATEINIT(source.flags),
-            isConst = Flag.Property.IS_CONST(source.flags),
-            isDelegate = Flag.Property.IS_DELEGATED(source.flags),
+            kind = callableKind(source.kind),
+            isVar = source.isVar,
+            isLateInit = source.isLateinit,
+            isConst = source.isConst,
+            isDelegate = source.isDelegated,
             getter = propertyGetter(source, typeResolver),
             setter = propertySetter(source, typeResolver),
             backingFieldAnnotations = emptyList(), // TODO unclear where to read backing/delegate field annotations from, see KT-44625
@@ -121,13 +123,11 @@ object CirDeserializers {
     }
 
     private fun propertyGetter(source: KmProperty, typeResolver: CirTypeResolver): CirPropertyGetter? {
-        if (!Flag.Property.HAS_GETTER(source.flags))
+        if (!source.hasGetter)
             return null
 
-        val getterFlags = source.getterFlags
-
-        val isDefault = !Flag.PropertyAccessor.IS_NOT_DEFAULT(getterFlags)
-        val annotations = annotations(getterFlags, typeResolver, source::getterAnnotations)
+        val isDefault = !source.getter.isNotDefault
+        val annotations = annotations(source.getter.hasAnnotations, typeResolver, source::getterAnnotations)
 
         if (isDefault && annotations.isEmpty())
             return CirPropertyGetter.DEFAULT_NO_ANNOTATIONS
@@ -135,69 +135,68 @@ object CirDeserializers {
         return CirPropertyGetter.createInterned(
             annotations = annotations,
             isDefault = isDefault,
-            isInline = Flag.PropertyAccessor.IS_INLINE(getterFlags)
+            isInline = source.getter.isInline
         )
     }
 
     private fun propertySetter(source: KmProperty, typeResolver: CirTypeResolver): CirPropertySetter? {
-        if (!Flag.Property.HAS_SETTER(source.flags))
+        if (!source.hasSetter)
             return null
 
-        val setterFlags = source.setterFlags
+        val setter = source.setter ?: return null
 
         return CirPropertySetter.createInterned(
-            annotations = annotations(setterFlags, typeResolver, source::setterAnnotations),
+            annotations = annotations(source.setter?.hasAnnotations == true, typeResolver, source::setterAnnotations),
             parameterAnnotations = source.setterParameter?.let { setterParameter ->
-                annotations(setterParameter.flags, typeResolver, setterParameter::annotations)
+                annotations(setterParameter.hasAnnotations, typeResolver, setterParameter::annotations)
             }.orEmpty(),
-            visibility = visibility(setterFlags),
-            isDefault = !Flag.PropertyAccessor.IS_NOT_DEFAULT(setterFlags),
-            isInline = Flag.PropertyAccessor.IS_INLINE(setterFlags)
+            visibility = visibility(setter.visibility),
+            isDefault = !setter.isNotDefault,
+            isInline = setter.isInline
         )
     }
 
     @Suppress("NOTHING_TO_INLINE")
-    private inline fun callableKind(flags: Flags): CallableMemberDescriptor.Kind =
-        when {
-            Flag.Property.IS_DECLARATION(flags) /*|| Flag.Function.IS_DECLARATION(flags)*/ -> CallableMemberDescriptor.Kind.DECLARATION
-            Flag.Property.IS_FAKE_OVERRIDE(flags) /*|| Flag.Function.IS_FAKE_OVERRIDE(flags)*/ -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE
-            Flag.Property.IS_DELEGATION(flags) /*|| Flag.Function.IS_DELEGATION(flags)*/ -> CallableMemberDescriptor.Kind.DELEGATION
-            Flag.Property.IS_SYNTHESIZED(flags) /*|| Flag.Function.IS_SYNTHESIZED(flags)*/ -> CallableMemberDescriptor.Kind.SYNTHESIZED
-            else -> error("Can't decode callable kind from flags: $flags")
+    private inline fun callableKind(memberKind: MemberKind): CallableMemberDescriptor.Kind =
+        when (memberKind) {
+            MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION
+            MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE
+            MemberKind.DELEGATION -> CallableMemberDescriptor.Kind.DELEGATION
+            MemberKind.SYNTHESIZED -> CallableMemberDescriptor.Kind.SYNTHESIZED
         }
 
     fun function(name: CirName, source: KmFunction, containingClass: CirContainingClass?, typeResolver: CirTypeResolver): CirFunction =
         CirFunction(
-            annotations = annotations(source.flags, typeResolver, source::annotations),
+            annotations = annotations(source.hasAnnotations, typeResolver, source::annotations),
             name = name,
             typeParameters = source.typeParameters.compactMap { typeParameter(it, typeResolver) },
-            visibility = visibility(source.flags),
-            modality = modality(source.flags),
+            visibility = visibility(source.visibility),
+            modality = modality(source.modality),
             containingClass = containingClass,
             valueParameters = source.valueParameters.compactMap { valueParameter(it, typeResolver) },
-            hasStableParameterNames = !Flag.Function.HAS_NON_STABLE_PARAMETER_NAMES(source.flags),
+            hasStableParameterNames = !source.hasNonStableParameterNames,
             extensionReceiver = source.receiverParameterType?.let { extensionReceiver(it, typeResolver) },
             returnType = type(source.returnType, typeResolver),
-            kind = callableKind(source.flags),
+            kind = callableKind(source.kind),
             modifiers = functionModifiers(source),
         )
 
     private fun functionModifiers(source: KmFunction): CirFunctionModifiers = CirFunctionModifiers.createInterned(
-        isOperator = Flag.Function.IS_OPERATOR(source.flags),
-        isInfix = Flag.Function.IS_INFIX(source.flags),
-        isInline = Flag.Function.IS_INLINE(source.flags),
-        isSuspend = Flag.Function.IS_SUSPEND(source.flags),
+        isOperator = source.isOperator,
+        isInfix = source.isInfix,
+        isInline = source.isInline,
+        isSuspend = source.isSuspend,
     )
 
     private fun valueParameter(source: KmValueParameter, typeResolver: CirTypeResolver): CirValueParameter =
         CirValueParameter.createInterned(
-            annotations = annotations(source.flags, typeResolver, source::annotations),
+            annotations = annotations(source.hasAnnotations, typeResolver, source::annotations),
             name = CirName.create(source.name),
             returnType = type(source.type, typeResolver),
             varargElementType = source.varargElementType?.let { type(it, typeResolver) },
-            declaresDefaultValue = Flag.ValueParameter.DECLARES_DEFAULT_VALUE(source.flags),
-            isCrossinline = Flag.ValueParameter.IS_CROSSINLINE(source.flags),
-            isNoinline = Flag.ValueParameter.IS_NOINLINE(source.flags)
+            declaresDefaultValue = source.declaresDefaultValue,
+            isCrossinline = source.isCrossinline,
+            isNoinline = source.isNoinline
         )
 
     private fun constantValue(
@@ -251,19 +250,19 @@ object CirDeserializers {
     }
 
     fun clazz(name: CirName, source: KmClass, typeResolver: CirTypeResolver): CirClass = CirClass.create(
-        annotations = annotations(source.flags, typeResolver, source::annotations),
+        annotations = annotations(source.hasAnnotations, typeResolver, source::annotations),
         name = name,
         typeParameters = source.typeParameters.compactMap { typeParameter(it, typeResolver) },
         supertypes = source.filteredSupertypes.compactMap { type(it, typeResolver) },
-        visibility = visibility(source.flags),
-        modality = modality(source.flags),
-        kind = classKind(source.flags),
+        visibility = visibility(source.visibility),
+        modality = modality(source.modality),
+        kind = classKind(source.kind),
         companion = source.companionObject?.let(CirName::create),
-        isCompanion = Flag.Class.IS_COMPANION_OBJECT(source.flags),
-        isData = Flag.Class.IS_DATA(source.flags),
-        isValue = Flag.Class.IS_VALUE(source.flags),
-        isInner = Flag.Class.IS_INNER(source.flags),
-        hasEnumEntries = Flag.Class.HAS_ENUM_ENTRIES(source.flags)
+        isCompanion = source.kind == KmClassKind.COMPANION_OBJECT,
+        isData = source.isData,
+        isValue = source.isValue,
+        isInner = source.isInner,
+        hasEnumEntries = source.hasEnumEntries
     )
 
     fun defaultEnumEntry(
@@ -296,26 +295,25 @@ object CirDeserializers {
     )
 
     @Suppress("NOTHING_TO_INLINE")
-    private inline fun classKind(flags: Flags): ClassKind =
-        when {
-            Flag.Class.IS_CLASS(flags) -> ClassKind.CLASS
-            Flag.Class.IS_INTERFACE(flags) -> ClassKind.INTERFACE
-            Flag.Class.IS_ENUM_CLASS(flags) -> ClassKind.ENUM_CLASS
-            Flag.Class.IS_ENUM_ENTRY(flags) -> ClassKind.ENUM_ENTRY
-            Flag.Class.IS_ANNOTATION_CLASS(flags) -> ClassKind.ANNOTATION_CLASS
-            Flag.Class.IS_OBJECT(flags) || Flag.Class.IS_COMPANION_OBJECT(flags) -> ClassKind.OBJECT
-            else -> error("Can't decode class kind from flags: $flags")
+    private inline fun classKind(kmClassKind: KmClassKind): ClassKind =
+        when (kmClassKind) {
+            KmClassKind.CLASS -> ClassKind.CLASS
+            KmClassKind.INTERFACE -> ClassKind.INTERFACE
+            KmClassKind.ENUM_CLASS -> ClassKind.ENUM_CLASS
+            KmClassKind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY
+            KmClassKind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS
+            KmClassKind.OBJECT, KmClassKind.COMPANION_OBJECT -> ClassKind.OBJECT
         }
 
     fun constructor(source: KmConstructor, containingClass: CirContainingClass, typeResolver: CirTypeResolver): CirClassConstructor =
         CirClassConstructor.create(
-            annotations = annotations(source.flags, typeResolver, source::annotations),
+            annotations = annotations(source.hasAnnotations, typeResolver, source::annotations),
             typeParameters = emptyList(), // TODO: nowhere to read constructor type parameters from
-            visibility = visibility(source.flags),
+            visibility = visibility(source.visibility),
             containingClass = containingClass,
             valueParameters = source.valueParameters.compactMap { valueParameter(it, typeResolver) },
-            hasStableParameterNames = !Flag.Constructor.HAS_NON_STABLE_PARAMETER_NAMES(source.flags),
-            isPrimary = !Flag.Constructor.IS_SECONDARY(source.flags)
+            hasStableParameterNames = !source.hasNonStableParameterNames,
+            isPrimary = !source.isSecondary
         )
 
     fun typeAlias(name: CirName, source: KmTypeAlias, typeResolver: CirTypeResolver): CirTypeAlias {
@@ -323,10 +321,10 @@ object CirDeserializers {
         val expandedType = underlyingType.unabbreviate()
 
         return CirTypeAlias.create(
-            annotations = annotations(source.flags, typeResolver, source::annotations),
+            annotations = annotations(source.hasAnnotations, typeResolver, source::annotations),
             name = name,
             typeParameters = source.typeParameters.compactMap { typeParameter(it, typeResolver) },
-            visibility = visibility(source.flags),
+            visibility = visibility(source.visibility),
             underlyingType = underlyingType,
             expandedType = expandedType
         )
@@ -335,7 +333,7 @@ object CirDeserializers {
     private fun type(source: KmType, typeResolver: CirTypeResolver): CirType {
         @Suppress("NAME_SHADOWING")
         val source = source.abbreviatedType ?: source
-        val isMarkedNullable = Flag.Type.IS_NULLABLE(source.flags)
+        val isMarkedNullable = source.isNullable
 
         return when (val classifier = source.classifier) {
             is KmClassifier.Class -> {
@@ -403,23 +401,22 @@ object CirDeserializers {
     }
 
     @Suppress("NOTHING_TO_INLINE")
-    private inline fun modality(flags: Flags): Modality =
-        when {
-            Flag.Common.IS_FINAL(flags) -> Modality.FINAL
-            Flag.Common.IS_ABSTRACT(flags) -> Modality.ABSTRACT
-            Flag.Common.IS_OPEN(flags) -> Modality.OPEN
-            Flag.Common.IS_SEALED(flags) -> Modality.SEALED
-            else -> error("Can't decode modality from flags: $flags")
+    private inline fun modality(kmModality: KmModality): Modality =
+        when (kmModality) {
+            KmModality.FINAL -> Modality.FINAL
+            KmModality.ABSTRACT -> Modality.ABSTRACT
+            KmModality.OPEN -> Modality.OPEN
+            KmModality.SEALED -> Modality.SEALED
         }
 
     @Suppress("NOTHING_TO_INLINE")
-    private inline fun visibility(flags: Flags): Visibility =
-        when {
-            Flag.Common.IS_PUBLIC(flags) -> Visibilities.Public
-            Flag.Common.IS_PROTECTED(flags) -> Visibilities.Protected
-            Flag.Common.IS_INTERNAL(flags) -> Visibilities.Internal
-            Flag.Common.IS_PRIVATE(flags) -> Visibilities.Private
-            else -> error("Can't decode visibility from flags: $flags")
+    private inline fun visibility(kmVisibility: KmVisibility): Visibility =
+        when (kmVisibility) {
+            KmVisibility.PUBLIC -> Visibilities.Public
+            KmVisibility.PROTECTED -> Visibilities.Protected
+            KmVisibility.INTERNAL -> Visibilities.Internal
+            KmVisibility.PRIVATE -> Visibilities.Private
+            else -> error("Can't decode visibility $kmVisibility")
         }
 }
 

native/commonizer/src/org/jetbrains/kotlin/commonizer/metadata/CirSerializers.kt

@@ -77,7 +77,7 @@ internal fun CirClass.serializeClass(
     nestedFunctions: Collection<KmFunction>,
     nestedProperties: Collection<KmProperty>
 ): KmClass = KmClass().also { clazz ->
-    clazz.flags = classFlags(isExpect = context.isCommon)
+    clazz.modifiersFrom(this, context.isCommon)
     annotations.mapTo(clazz.annotations) { it.serializeAnnotation() }
     typeParameters.serializeTypeParameters(context, output = clazz.typeParameters)
     clazz.name = className
@@ -89,7 +89,7 @@ internal fun CirClass.serializeClass(
     directNestedClasses.forEach { directNestedClass ->
         val shortClassName = directNestedClass.name.substringAfterLast('.')
 
-        if (Flag.Class.IS_ENUM_ENTRY(directNestedClass.flags)) {
+        if (directNestedClass.kind == ClassKind.ENUM_ENTRY) {
             clazz.enumEntries += shortClassName
             clazz.klibEnumEntries += KlibEnumEntry(name = shortClassName, annotations = directNestedClass.annotations)
         } else {
@@ -127,7 +127,7 @@ internal fun linkSealedClassesWithSubclasses(packageName: CirPackageName, classC
 internal fun CirClassConstructor.serializeConstructor(
     context: CirTreeSerializationContext
 ): KmConstructor = KmConstructor().also { constructor ->
-    constructor.flags = classConstructorFlags()
+    constructor.modifiersFrom(this)
     annotations.mapTo(constructor.annotations) { it.serializeAnnotation() }
     // TODO: nowhere to write constructor type parameters
     valueParameters.mapTo(constructor.valueParameters) { it.serializeValueParameter(context) }
@@ -138,7 +138,7 @@ internal fun CirTypeAlias.serializeTypeAlias(
 ): KmTypeAlias = KmTypeAlias(
     name = name.name
 ).also { typeAlias ->
-    typeAlias.flags = typeAliasFlags()
+    typeAlias.modifiersFrom(this)
     annotations.mapTo(typeAlias.annotations) { it.serializeAnnotation() }
     typeParameters.serializeTypeParameters(context, output = typeAlias.typeParameters)
     typeAlias.underlyingType = underlyingType.serializeType(context, expansion = ONLY_ABBREVIATIONS)
@@ -148,9 +148,9 @@ internal fun CirTypeAlias.serializeTypeAlias(
 internal fun CirProperty.serializeProperty(
     context: CirTreeSerializationContext,
 ): KmProperty = KmProperty(name = name.name).also { property ->
-    property.flags = propertyFlags(isExpect = context.isCommon && !isLiftedUp)
-    property.getterFlags = getter?.propertyAccessorFlags(this, this) ?: NO_FLAGS
-    property.setterFlags = setter?.let { setter -> setter.propertyAccessorFlags(setter, this) } ?: NO_FLAGS
+    property.modifiersFrom(this, isExpect = context.isCommon && !isLiftedUp)
+    this.getter?.let { property.getter.modifiersFrom(it, this, this) }
+    property.setter = this.setter?.let { KmPropertyAccessorAttributes().apply { modifiersFrom(it, it, this@serializeProperty) } }
     annotations.mapTo(property.annotations) { it.serializeAnnotation() }
     getter?.annotations?.mapTo(property.getterAnnotations) { it.serializeAnnotation() }
     setter?.annotations?.mapTo(property.setterAnnotations) { it.serializeAnnotation() }
@@ -180,7 +180,7 @@ internal fun CirFunction.serializeFunction(
 ): KmFunction = KmFunction(
     name = name.name
 ).also { function ->
-    function.flags = functionFlags(isExpect = context.isCommon && kind != CallableMemberDescriptor.Kind.SYNTHESIZED)
+    function.modifiersFrom(this, isExpect = context.isCommon && kind != CallableMemberDescriptor.Kind.SYNTHESIZED)
     annotations.mapTo(function.annotations) { it.serializeAnnotation() }
     typeParameters.serializeTypeParameters(context, output = function.typeParameters)
     valueParameters.mapTo(function.valueParameters) { it.serializeValueParameter(context) }
@@ -241,7 +241,7 @@ private fun CirValueParameter.serializeValueParameter(
 ): KmValueParameter = KmValueParameter(
     name = name.name
 ).also { parameter ->
-    parameter.flags = valueParameterFlags()
+    parameter.modifiersFrom(this)
     annotations.mapTo(parameter.annotations) { it.serializeAnnotation() }
     parameter.type = returnType.serializeType(context)
     varargElementType?.let { varargElementType ->
@@ -259,7 +259,7 @@ private fun List<CirTypeParameter>.serializeTypeParameters(
             id = context.typeParameterIndexOffset + index,
             variance = cirTypeParameter.variance.serializeVariance()
         ).also { parameter ->
-            parameter.flags = cirTypeParameter.typeParameterFlags()
+            parameter.isReified = cirTypeParameter.isReified
             cirTypeParameter.upperBounds.mapTo(parameter.upperBounds) { it.serializeType(context) }
             cirTypeParameter.annotations.mapTo(parameter.annotations) { it.serializeAnnotation() }
         }

native/commonizer/src/org/jetbrains/kotlin/commonizer/metadata/CirTreeSerializer.kt

@@ -220,15 +220,15 @@ private class CirTreeSerializationVisitor(
             clazz: KmClass,
             classContext: CirTreeSerializationContext
         ) = logDeclaration(classContext.targetIndex) {
-            val declarationType = when {
-                Flag.Class.IS_ENUM_CLASS(clazz.flags) -> DeclarationType.ENUM_CLASS
-                Flag.Class.IS_ENUM_ENTRY(clazz.flags) -> DeclarationType.ENUM_ENTRY
-                Flag.Class.IS_INTERFACE(clazz.flags) -> when {
+            val declarationType = when (clazz.kind) {
+                ClassKind.ENUM_CLASS -> DeclarationType.ENUM_CLASS
+                ClassKind.ENUM_ENTRY -> DeclarationType.ENUM_ENTRY
+                ClassKind.INTERFACE -> when {
                     (classContext.currentPath as Path.Classifier).classifierId.isNestedEntity -> DeclarationType.NESTED_INTERFACE
                     else -> DeclarationType.TOP_LEVEL_INTERFACE
                 }
                 else -> when {
-                    Flag.Class.IS_COMPANION_OBJECT(clazz.flags) -> DeclarationType.COMPANION_OBJECT
+                    clazz.kind == ClassKind.COMPANION_OBJECT -> DeclarationType.COMPANION_OBJECT
                     (classContext.currentPath as Path.Classifier).classifierId.isNestedEntity -> DeclarationType.NESTED_CLASS
                     else -> DeclarationType.TOP_LEVEL_CLASS
                 }
@@ -435,7 +435,7 @@ internal class ClassConsumer {
 
     fun consume(clazz: KmClass) {
         _allClasses += clazz
-        if (Flag.Common.IS_SEALED(clazz.flags)) _sealedClasses += clazz
+        if (clazz.modality == Modality.SEALED) _sealedClasses += clazz
     }
 
     fun reset() {

native/commonizer/src/org/jetbrains/kotlin/commonizer/metadata/flags.kt

@@ -6,56 +6,59 @@
 package org.jetbrains.kotlin.commonizer.metadata
 
 import kotlinx.metadata.*
+import kotlinx.metadata.Modality as KmModality
+import kotlinx.metadata.ClassKind as KmClassKind
 import org.jetbrains.kotlin.commonizer.cir.*
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 
-internal const val NO_FLAGS: Flags = 0
-
-internal fun CirFunction.functionFlags(isExpect: Boolean): Flags =
-    flagsOfNotNull(
-        hasAnnotationsFlag,
-        visibilityFlag,
-        modalityFlag,
-        memberKindFlag,
-        Flag.Function.HAS_NON_STABLE_PARAMETER_NAMES.takeIf { !hasStableParameterNames },
-        Flag.Function.IS_EXPECT.takeIf { isExpect }
-    ) or modifiers.modifiersFlags
-
-internal fun CirProperty.propertyFlags(isExpect: Boolean): Flags =
-    flagsOfNotNull(
-        hasAnnotationsFlag,
-        visibilityFlag,
-        modalityFlag,
-        memberKindFlag,
-        Flag.Property.HAS_GETTER.takeIf { getter != null },
-        Flag.Property.HAS_SETTER.takeIf { setter != null },
-        Flag.Property.IS_DELEGATED.takeIf { isDelegate },
-        Flag.Property.IS_EXPECT.takeIf { isExpect }
-    ) or modifiersFlags
-
-internal fun CirPropertyAccessor.propertyAccessorFlags(
-    visibilityHolder: CirHasVisibility,
-    modalityHolder: CirHasModality
-): Flags {
-    return flagsOfNotNull(
-        hasAnnotationsFlag,
-        visibilityHolder.visibilityFlag,
-        modalityHolder.modalityFlag,
-        Flag.PropertyAccessor.IS_NOT_DEFAULT.takeIf { !isDefault },
-        Flag.PropertyAccessor.IS_INLINE.takeIf { isInline }
-    )
+internal fun KmFunction.modifiersFrom(cf: CirFunction, isExpect: Boolean) {
+    hasAnnotations = cf.hasAnnotations
+    visibility = cf.kmVisibility
+    modality = cf.kmModality
+    kind = cf.kind.kmMemberKind
+    hasNonStableParameterNames = !cf.hasStableParameterNames
+    this.isExpect = isExpect
+    isOperator = cf.modifiers.isOperator
+    isInfix = cf.modifiers.isInfix
+    isInline = cf.modifiers.isInline
+    isSuspend = cf.modifiers.isSuspend
 }
 
-internal fun CirClassConstructor.classConstructorFlags(): Flags =
-    flagsOfNotNull(
-        hasAnnotationsFlag,
-        visibilityFlag,
-        Flag.Constructor.IS_SECONDARY.takeIf { !isPrimary },
-        Flag.Constructor.HAS_NON_STABLE_PARAMETER_NAMES.takeIf { !hasStableParameterNames }
-    )
+internal fun KmProperty.modifiersFrom(cp: CirProperty, isExpect: Boolean) {
+    hasAnnotations = cp.hasAnnotations
+    visibility = cp.kmVisibility
+    modality = cp.kmModality
+    kind = cp.kind.kmMemberKind
+    hasGetter = cp.getter != null
+    hasSetter = cp.setter != null
+    isDelegated = cp.isDelegate
+    this.isExpect = isExpect
+    isVar = cp.isVar
+    isConst = cp.isConst
+    hasConstant = cp.compileTimeInitializer.takeIf { it !is CirConstantValue.NullValue } != null
+    isLateinit = cp.isLateInit
+}
+
+internal fun KmPropertyAccessorAttributes.modifiersFrom(
+    cp: CirPropertyAccessor, visibilityHolder: CirHasVisibility,
+    modalityHolder: CirHasModality,
+) {
+    hasAnnotations = cp.hasAnnotations
+    visibility = visibilityHolder.kmVisibility
+    modality = modalityHolder.kmModality
+    isNotDefault = !cp.isDefault
+    isInline = cp.isInline
+}
+
+internal fun KmConstructor.modifiersFrom(cc: CirClassConstructor) {
+    hasAnnotations = cc.hasAnnotations
+    visibility = cc.kmVisibility
+    isSecondary = !cc.isPrimary
+    hasNonStableParameterNames = !cc.hasStableParameterNames
+}
 
 internal fun CirType.applyTypeFlagsTo(type: KmType) {
     type.isNullable = when (this) {
@@ -65,111 +68,79 @@ internal fun CirType.applyTypeFlagsTo(type: KmType) {
     //Flag.Type.IS_SUSPEND.takeIf { false }
 }
 
-internal fun CirTypeParameter.typeParameterFlags(): Flags =
-    flagsOfNotNull(
-        Flag.TypeParameter.IS_REIFIED.takeIf { isReified }
-    )
+internal fun KmValueParameter.modifiersFrom(cv: CirValueParameter) {
+    hasAnnotations = cv.hasAnnotations
+    declaresDefaultValue = cv.declaresDefaultValue
+    isCrossinline = cv.isCrossinline
+    isNoinline = cv.isNoinline
+}
 
-internal fun CirValueParameter.valueParameterFlags(): Flags =
-    flagsOfNotNull(
-        hasAnnotationsFlag,
-        Flag.ValueParameter.DECLARES_DEFAULT_VALUE.takeIf { declaresDefaultValue },
-        Flag.ValueParameter.IS_CROSSINLINE.takeIf { isCrossinline },
-        Flag.ValueParameter.IS_NOINLINE.takeIf { isNoinline }
-    )
+internal fun KmClass.modifiersFrom(cc: CirClass, isExpect: Boolean) {
+    hasAnnotations = cc.hasAnnotations
+    visibility = cc.kmVisibility
+    modality = cc.kmModality
+    kind = cc.kmClassKind
+    isInner = cc.isInner
+    isData = cc.isData
+    this.isExpect = isExpect
+    isValue = cc.isValue
+    hasEnumEntries = cc.hasEnumEntries
+    //Flag.Class.IS_FUN.takeIf { false }
+}
 
-internal fun CirClass.classFlags(isExpect: Boolean): Flags =
-    flagsOfNotNull(
-        hasAnnotationsFlag,
-        visibilityFlag,
-        modalityFlag,
-        classKindFlag,
-        Flag.Class.IS_COMPANION_OBJECT.takeIf { isCompanion },
-        Flag.Class.IS_INNER.takeIf { isInner },
-        Flag.Class.IS_DATA.takeIf { isData },
-        Flag.Class.IS_EXPECT.takeIf { isExpect },
-        Flag.Class.IS_VALUE.takeIf { isValue },
-        Flag.Class.HAS_ENUM_ENTRIES.takeIf { hasEnumEntries }
-        //Flag.Class.IS_FUN.takeIf { false }
-    )
+internal fun KmTypeAlias.modifiersFrom(ct: CirTypeAlias) {
+    hasAnnotations = ct.hasAnnotations
+    visibility = ct.kmVisibility
+}
 
-internal fun CirTypeAlias.typeAliasFlags(): Flags =
-    flagsOfNotNull(
-        hasAnnotationsFlag,
-        visibilityFlag
-    )
-
-private inline val CirHasAnnotations.hasAnnotationsFlag: Flag?
-    get() = if (annotations.isNotEmpty()) Flag.Common.HAS_ANNOTATIONS else null
+private inline val CirHasAnnotations.hasAnnotations: Boolean
+    get() = annotations.isNotEmpty()
 
 // Since 1.4.30 a special @JvmInline annotation is generated to distinguish JVM-inline from value classes.
 // This has an effect on class serialization: Every class with isValue == true automatically gets HAS_ANNOTATIONS flag.
-private inline val CirClass.hasAnnotationsFlag: Flag?
-    get() = if (annotations.isNotEmpty() || isValue) Flag.Common.HAS_ANNOTATIONS else null
+private inline val CirClass.hasAnnotations: Boolean
+    get() = annotations.isNotEmpty() || isValue
 
-private inline val CirProperty.hasAnnotationsFlag: Flag?
-    get() = if (annotations.isNotEmpty() || !backingFieldAnnotations.isNullOrEmpty() || !delegateFieldAnnotations.isNullOrEmpty())
-        Flag.Common.HAS_ANNOTATIONS
-    else
-        null
+private inline val CirProperty.hasAnnotations: Boolean
+    get() = annotations.isNotEmpty() || backingFieldAnnotations.isNotEmpty() || delegateFieldAnnotations.isNotEmpty()
 
-private inline val CirHasVisibility.visibilityFlag: Flag
+private inline val CirHasVisibility.kmVisibility: Visibility
     get() = when (visibility) {
-        Visibilities.Public -> Flag.Common.IS_PUBLIC
-        Visibilities.Protected -> Flag.Common.IS_PROTECTED
-        Visibilities.Internal -> Flag.Common.IS_INTERNAL
-        Visibilities.Private -> Flag.Common.IS_PRIVATE
+        Visibilities.Public -> Visibility.PUBLIC
+        Visibilities.Protected -> Visibility.PROTECTED
+        Visibilities.Internal -> Visibility.INTERNAL
+        Visibilities.Private -> Visibility.PRIVATE
         else -> error("Unexpected visibility: $this")
     }
 
-private inline val CirHasModality.modalityFlag: Flag
+private inline val CirHasModality.kmModality: KmModality
     get() = when (modality) {
-        Modality.FINAL -> Flag.Common.IS_FINAL
-        Modality.ABSTRACT -> Flag.Common.IS_ABSTRACT
-        Modality.OPEN -> Flag.Common.IS_OPEN
-        Modality.SEALED -> Flag.Common.IS_SEALED
+        Modality.FINAL -> KmModality.FINAL
+        Modality.ABSTRACT -> KmModality.ABSTRACT
+        Modality.OPEN -> KmModality.OPEN
+        Modality.SEALED -> KmModality.SEALED
     }
 
-private inline val CirFunction.memberKindFlag: Flag
-    get() = when (kind) {
-        CallableMemberDescriptor.Kind.DECLARATION -> Flag.Function.IS_DECLARATION
-        CallableMemberDescriptor.Kind.FAKE_OVERRIDE -> Flag.Function.IS_FAKE_OVERRIDE
-        CallableMemberDescriptor.Kind.DELEGATION -> Flag.Function.IS_DELEGATION
-        CallableMemberDescriptor.Kind.SYNTHESIZED -> Flag.Function.IS_SYNTHESIZED
+private inline val CallableMemberDescriptor.Kind.kmMemberKind: MemberKind
+    get() = when (this) {
+        CallableMemberDescriptor.Kind.DECLARATION -> MemberKind.DECLARATION
+        CallableMemberDescriptor.Kind.FAKE_OVERRIDE -> MemberKind.FAKE_OVERRIDE
+        CallableMemberDescriptor.Kind.DELEGATION -> MemberKind.DELEGATION
+        CallableMemberDescriptor.Kind.SYNTHESIZED -> MemberKind.SYNTHESIZED
     }
 
-private inline val CirProperty.memberKindFlag: Flag
-    get() = when (kind) {
-        CallableMemberDescriptor.Kind.DECLARATION -> Flag.Property.IS_DECLARATION
-        CallableMemberDescriptor.Kind.FAKE_OVERRIDE -> Flag.Property.IS_FAKE_OVERRIDE
-        CallableMemberDescriptor.Kind.DELEGATION -> Flag.Property.IS_DELEGATION
-        CallableMemberDescriptor.Kind.SYNTHESIZED -> Flag.Property.IS_SYNTHESIZED
+private inline val CirClass.kmClassKind: KmClassKind
+    get() {
+        if (isCompanion) return KmClassKind.COMPANION_OBJECT
+        return when (kind) {
+            ClassKind.CLASS -> KmClassKind.CLASS
+            ClassKind.INTERFACE -> KmClassKind.INTERFACE
+            ClassKind.ENUM_CLASS -> KmClassKind.ENUM_CLASS
+            ClassKind.ENUM_ENTRY -> KmClassKind.ENUM_ENTRY
+            ClassKind.ANNOTATION_CLASS -> KmClassKind.ANNOTATION_CLASS
+            ClassKind.OBJECT -> KmClassKind.OBJECT
+        }
     }
 
-private inline val CirClass.classKindFlag: Flag
-    get() = when (kind) {
-        ClassKind.CLASS -> Flag.Class.IS_CLASS
-        ClassKind.INTERFACE -> Flag.Class.IS_INTERFACE
-        ClassKind.ENUM_CLASS -> Flag.Class.IS_ENUM_CLASS
-        ClassKind.ENUM_ENTRY -> Flag.Class.IS_ENUM_ENTRY
-        ClassKind.ANNOTATION_CLASS -> Flag.Class.IS_ANNOTATION_CLASS
-        ClassKind.OBJECT -> Flag.Class.IS_OBJECT
-    }
 
-private inline val CirFunctionModifiers.modifiersFlags: Flags
-    get() = flagsOfNotNull(
-        Flag.Function.IS_OPERATOR.takeIf { isOperator },
-        Flag.Function.IS_INFIX.takeIf { isInfix },
-        Flag.Function.IS_INLINE.takeIf { isInline },
-        Flag.Function.IS_SUSPEND.takeIf { isSuspend },
-    )
 
-private inline val CirProperty.modifiersFlags: Flags
-    get() = flagsOfNotNull(
-        Flag.Property.IS_VAR.takeIf { isVar },
-        Flag.Property.IS_CONST.takeIf { isConst },
-        Flag.Property.HAS_CONSTANT.takeIf { compileTimeInitializer.takeIf { it !is CirConstantValue.NullValue } != null },
-        Flag.Property.IS_LATEINIT.takeIf { isLateInit },
-    )
-
-private fun flagsOfNotNull(vararg flags: Flag?): Flags = flagsOf(*listOfNotNull(*flags).toTypedArray())

native/commonizer/src/org/jetbrains/kotlin/commonizer/metadata/utils/MetadataDeclarationsComparator.kt

@@ -3,6 +3,8 @@
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
+@file:Suppress("DEPRECATION") // TODO: kotlinx.metadata Flags API. Usage here is too big.
+
 package org.jetbrains.kotlin.commonizer.metadata.utils
 
 import com.intellij.util.containers.FactoryMap
@@ -972,8 +974,8 @@ class MetadataDeclarationsComparator private constructor(private val config: Con
 
     private fun compareFlags(
         containerContext: Context,
-        flagsA: Flags,
-        flagsB: Flags,
+        flagsA: Int,
+        flagsB: Int,
         flagsToCompare: Array<KProperty0<Flag>>,
         flagKind: FlagKind = FlagKind.REGULAR
     ) {

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/CirTreeClassDeserializer.kt

@@ -5,8 +5,7 @@
 
 package org.jetbrains.kotlin.commonizer.tree.deserializer
 
-import kotlinx.metadata.Flag
-import kotlinx.metadata.KmClass
+import kotlinx.metadata.*
 import org.jetbrains.kotlin.commonizer.metadata.CirDeserializers
 import org.jetbrains.kotlin.commonizer.metadata.CirTypeResolver
 import org.jetbrains.kotlin.commonizer.tree.CirTreeClass
@@ -29,7 +28,7 @@ internal class CirTreeClassDeserializer(
         val cirClass = when (classEntry) {
             is ClassesToProcess.ClassEntry.RegularClassEntry -> {
                 clazz = classEntry.clazz
-                isEnumEntry = Flag.Class.IS_ENUM_ENTRY(clazz.flags)
+                isEnumEntry = clazz.kind == ClassKind.ENUM_ENTRY
                 CirDeserializers.clazz(className, clazz, classTypeResolver)
             }
             is ClassesToProcess.ClassEntry.EnumEntry -> {
@@ -40,7 +39,7 @@ internal class CirTreeClassDeserializer(
                     name = className,
                     annotations = classEntry.annotations,
                     enumClassId = classEntry.enumClassId,
-                    hasEnumEntries = Flag.Class.HAS_ENUM_ENTRIES(classEntry.enumClass.flags),
+                    hasEnumEntries = classEntry.enumClass.hasEnumEntries,
                     typeResolver = classTypeResolver
                 )
             }

native/commonizer/src/org/jetbrains/kotlin/commonizer/tree/deserializer/ClassesToProcess.kt

@@ -6,9 +6,7 @@
 package org.jetbrains.kotlin.commonizer.tree.deserializer
 
 import com.intellij.util.containers.FactoryMap
-import kotlinx.metadata.Flag
-import kotlinx.metadata.KmAnnotation
-import kotlinx.metadata.KmClass
+import kotlinx.metadata.*
 import kotlinx.metadata.internal.common.KmModuleFragment
 import kotlinx.metadata.klib.klibEnumEntries
 import org.jetbrains.kotlin.commonizer.cir.CirEntityId
@@ -44,7 +42,7 @@ internal class ClassesToProcess {
             val classId: CirEntityId = CirEntityId.create(clazz.name)
             val parentClassId: CirEntityId = classId.getParentEntityId() ?: NON_EXISTING_CLASSIFIER_ID
 
-            if (Flag.Class.IS_ENUM_CLASS(clazz.flags)) {
+            if (clazz.kind == ClassKind.ENUM_CLASS) {
                 clazz.klibEnumEntries.forEach { entry ->
                     val enumEntryId = classId.createNestedEntityId(CirName.create(entry.name))
                     klibEnumEntries[enumEntryId] = ClassEntry.EnumEntry(enumEntryId, entry.annotations, classId, clazz)

native/commonizer/src/org/jetbrains/kotlin/commonizer/utils/excludes.kt

@@ -5,9 +5,7 @@
 
 package org.jetbrains.kotlin.commonizer.utils
 
-import kotlinx.metadata.Flag
-import kotlinx.metadata.KmFunction
-import kotlinx.metadata.KmProperty
+import kotlinx.metadata.*
 import kotlinx.metadata.klib.annotations
 
 internal const val KNI_BRIDGE_FUNCTION_PREFIX = "kniBridge"
@@ -21,9 +19,7 @@ internal inline fun KmFunction.isTopLevelDeprecatedFunction(isTopLevel: Boolean)
     isTopLevel && annotations.any { it.className == DEPRECATED_ANNOTATION_FULL_NAME }
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun KmProperty.isFakeOverride() =
-    Flag.Property.IS_FAKE_OVERRIDE(flags)
+internal inline fun KmProperty.isFakeOverride() = this.kind == MemberKind.FAKE_OVERRIDE
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun KmFunction.isFakeOverride() =
-    Flag.Function.IS_FAKE_OVERRIDE(flags)
+internal inline fun KmFunction.isFakeOverride() = this.kind == MemberKind.FAKE_OVERRIDE

native/commonizer/src/org/jetbrains/kotlin/commonizer/utils/type.kt

@@ -14,10 +14,10 @@ internal inline val KmClass.filteredSupertypes: List<KmType>
     get() = supertypes.takeUnless { it.singleOrNull()?.isAny == true } ?: emptyList()
 
 private inline val KmType.isNullableAny: Boolean
-    get() = (classifier as? KmClassifier.Class)?.name == ANY_CLASS_FULL_NAME && Flag.Type.IS_NULLABLE(flags)
+    get() = (classifier as? KmClassifier.Class)?.name == ANY_CLASS_FULL_NAME && this.isNullable
 
 private inline val KmType.isAny: Boolean
-    get() = (classifier as? KmClassifier.Class)?.name == ANY_CLASS_FULL_NAME && !Flag.Type.IS_NULLABLE(flags)
+    get() = (classifier as? KmClassifier.Class)?.name == ANY_CLASS_FULL_NAME && !this.isNullable