Move ProtoEnumFlags to :core:metadata

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

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
+import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
 import java.util.*
 
 data class Difference(
@@ -50,7 +51,7 @@ fun ProtoMapValue.toProtoData(packageFqName: FqName): ProtoData =
 
 internal val MessageLite.isPrivate: Boolean
     get() = DescriptorVisibilities.isPrivate(
-        ProtoEnumFlags.visibility(
+        ProtoEnumFlags.descriptorVisibility(
             when (this) {
                 is ProtoBuf.Constructor -> Flags.VISIBILITY.get(flags)
                 is ProtoBuf.Function -> Flags.VISIBILITY.get(flags)

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt

@@ -58,7 +58,7 @@ fun deserializeClassToSymbol(
     val kind = Flags.CLASS_KIND.get(flags)
     val modality = ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
     val status = FirResolvedDeclarationStatusImpl(
-        FirProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+        ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
         modality
     ).apply {
         isExpect = Flags.IS_EXPECT_CLASS.get(flags)

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt

@@ -166,7 +166,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             origin = FirDeclarationOrigin.Library
             this.name = name
             status = FirResolvedDeclarationStatusImpl(
-                FirProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
                 Modality.FINAL
             ).apply {
                 isExpect = Flags.IS_EXPECT_CLASS.get(flags)
@@ -213,7 +213,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
 
         val getter = if (hasGetter) {
             val getterFlags = if (proto.hasGetterFlags()) proto.getterFlags else defaultAccessorFlags
-            val visibility = FirProtoEnumFlags.visibility(Flags.VISIBILITY.get(getterFlags))
+            val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(getterFlags))
             val modality = ProtoEnumFlags.modality(Flags.MODALITY.get(getterFlags))
             if (Flags.IS_NOT_DEFAULT.get(getterFlags)) {
                 buildPropertyAccessor {
@@ -238,7 +238,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
 
         val setter = if (Flags.HAS_SETTER.get(flags)) {
             val setterFlags = if (proto.hasSetterFlags()) proto.setterFlags else defaultAccessorFlags
-            val visibility = FirProtoEnumFlags.visibility(Flags.VISIBILITY.get(setterFlags))
+            val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(setterFlags))
             val modality = ProtoEnumFlags.modality(Flags.MODALITY.get(setterFlags))
             if (Flags.IS_NOT_DEFAULT.get(setterFlags)) {
                 buildPropertyAccessor {
@@ -280,7 +280,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             this.symbol = symbol
             isLocal = false
             status = FirResolvedDeclarationStatusImpl(
-                FirProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
                 ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
             ).apply {
                 isExpect = Flags.IS_EXPECT_PROPERTY.get(flags)
@@ -342,7 +342,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             }
             name = callableName
             status = FirResolvedDeclarationStatusImpl(
-                FirProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
                 ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
             ).apply {
                 isExpect = Flags.IS_EXPECT_FUNCTION.get(flags)
@@ -407,7 +407,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             session = c.session
             origin = FirDeclarationOrigin.Library
             returnTypeRef = delegatedSelfType
-            val visibility = FirProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags))
+            val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags))
             status = FirResolvedDeclarationStatusImpl(
                 visibility,
                 Modality.FINAL

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirProtoEnumFlags.kt

@@ -1,32 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir.deserialization
-
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.metadata.ProtoBuf
-
-object FirProtoEnumFlags {
-    fun visibility(visibility: ProtoBuf.Visibility?): Visibility = when (visibility) {
-        ProtoBuf.Visibility.INTERNAL -> Visibilities.Internal
-        ProtoBuf.Visibility.PRIVATE -> Visibilities.Private
-        ProtoBuf.Visibility.PRIVATE_TO_THIS -> Visibilities.PrivateToThis
-        ProtoBuf.Visibility.PROTECTED -> Visibilities.Protected
-        ProtoBuf.Visibility.PUBLIC -> Visibilities.Public
-        ProtoBuf.Visibility.LOCAL -> Visibilities.Local
-        else -> Visibilities.Private
-    }
-
-    fun visibility(visibility: Visibility): ProtoBuf.Visibility = when (visibility) {
-        Visibilities.Internal -> ProtoBuf.Visibility.INTERNAL
-        Visibilities.Public -> ProtoBuf.Visibility.PUBLIC
-        Visibilities.Private -> ProtoBuf.Visibility.PRIVATE
-        Visibilities.PrivateToThis -> ProtoBuf.Visibility.PRIVATE_TO_THIS
-        Visibilities.Protected -> ProtoBuf.Visibility.PROTECTED
-        Visibilities.Local -> ProtoBuf.Visibility.LOCAL
-        else -> throw IllegalArgumentException("Unknown visibility: $visibility")
-    }
-}

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ProtoEnumFlagsUtils.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.deserialization
+
+import org.jetbrains.kotlin.fir.types.ProjectionKind
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
+
+@Suppress("unused")
+fun ProtoEnumFlags.projection(projectionKind: ProjectionKind): ProtoBuf.Type.Argument.Projection = when (projectionKind) {
+    ProjectionKind.INVARIANT -> ProtoBuf.Type.Argument.Projection.INV
+    ProjectionKind.IN -> ProtoBuf.Type.Argument.Projection.IN
+    ProjectionKind.OUT -> ProtoBuf.Type.Argument.Projection.OUT
+    ProjectionKind.STAR -> throw AssertionError("Should not be here")
+}
+

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.deserialization.CONTINUATION_INTERFACE_CLASS_ID
-import org.jetbrains.kotlin.fir.deserialization.FirProtoEnumFlags
+import org.jetbrains.kotlin.fir.deserialization.projection
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirConstExpression
@@ -46,7 +46,6 @@ import org.jetbrains.kotlin.resolve.constants.EnumValue
 import org.jetbrains.kotlin.resolve.constants.IntValue
 import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
-import org.jetbrains.kotlin.types.Variance
 
 class FirElementSerializer private constructor(
     private val session: FirSession,
@@ -92,7 +91,7 @@ class FirElementSerializer private constructor(
         val modality = regularClass?.modality ?: Modality.FINAL
         val flags = Flags.getClassFlags(
             klass.nonSourceAnnotations(session).isNotEmpty(),
-            FirProtoEnumFlags.visibility(regularClass?.let { normalizeVisibility(it) } ?: Visibilities.Local),
+            ProtoEnumFlags.visibility(regularClass?.let { normalizeVisibility(it) } ?: Visibilities.Local),
             ProtoEnumFlags.modality(modality),
             ProtoEnumFlags.classKind(klass.classKind, regularClass?.isCompanion == true),
             regularClass?.isInner == true,
@@ -210,7 +209,7 @@ class FirElementSerializer private constructor(
         val modality = property.modality!!
         val defaultAccessorFlags = Flags.getAccessorFlags(
             hasAnnotations,
-            FirProtoEnumFlags.visibility(normalizeVisibility(property)),
+            ProtoEnumFlags.visibility(normalizeVisibility(property)),
             ProtoEnumFlags.modality(modality),
             false, false, false
         )
@@ -245,7 +244,7 @@ class FirElementSerializer private constructor(
 
         val flags = Flags.getPropertyFlags(
             hasAnnotations,
-            FirProtoEnumFlags.visibility(normalizeVisibility(property)),
+            ProtoEnumFlags.visibility(normalizeVisibility(property)),
             ProtoEnumFlags.modality(modality),
             ProtoBuf.MemberKind.DECLARATION,
             property.isVar, hasGetter, hasSetter, hasConstant, property.isConst, property.isLateInit,
@@ -303,7 +302,7 @@ class FirElementSerializer private constructor(
 
         val flags = Flags.getFunctionFlags(
             function.nonSourceAnnotations(session).isNotEmpty(),
-            FirProtoEnumFlags.visibility(simpleFunction?.let { normalizeVisibility(it) } ?: Visibilities.Local),
+            ProtoEnumFlags.visibility(simpleFunction?.let { normalizeVisibility(it) } ?: Visibilities.Local),
             ProtoEnumFlags.modality(simpleFunction?.modality ?: Modality.FINAL),
             ProtoBuf.MemberKind.DECLARATION,
             simpleFunction?.isOperator == true,
@@ -388,7 +387,7 @@ class FirElementSerializer private constructor(
 
         val flags = Flags.getTypeAliasFlags(
             typeAlias.nonSourceAnnotations(session).isNotEmpty(),
-            FirProtoEnumFlags.visibility(normalizeVisibility(typeAlias))
+            ProtoEnumFlags.visibility(normalizeVisibility(typeAlias))
         )
         if (flags != builder.flags) {
             builder.flags = flags
@@ -441,7 +440,7 @@ class FirElementSerializer private constructor(
 
         val flags = Flags.getConstructorFlags(
             constructor.nonSourceAnnotations(session).isNotEmpty(),
-            FirProtoEnumFlags.visibility(normalizeVisibility(constructor)),
+            ProtoEnumFlags.visibility(normalizeVisibility(constructor)),
             !constructor.isPrimary,
             true // TODO: supply 'hasStableParameterNames' flag for metadata
         )
@@ -516,7 +515,7 @@ class FirElementSerializer private constructor(
             builder.reified = typeParameter.isReified
         }
 
-        val variance = variance(typeParameter.variance)
+        val variance = ProtoEnumFlags.variance(typeParameter.variance)
         if (variance != builder.variance) {
             builder.variance = variance
         }
@@ -654,7 +653,7 @@ class FirElementSerializer private constructor(
         if (typeProjection is ConeStarProjection) {
             builder.projection = ProtoBuf.Type.Argument.Projection.STAR
         } else if (typeProjection is ConeKotlinTypeProjection) {
-            val projection = projection(typeProjection.kind)
+            val projection = ProtoEnumFlags.projection(typeProjection.kind)
 
             if (projection != builder.projection) {
                 builder.projection = projection
@@ -678,7 +677,7 @@ class FirElementSerializer private constructor(
                 !accessor.isExternal && !accessor.isInline
         return Flags.getAccessorFlags(
             accessor.nonSourceAnnotations(session).isNotEmpty(),
-            FirProtoEnumFlags.visibility(normalizeVisibility(accessor)),
+            ProtoEnumFlags.visibility(normalizeVisibility(accessor)),
             ProtoEnumFlags.modality(accessor.modality!!),
             !isDefault,
             accessor.isExternal,
@@ -901,18 +900,5 @@ class FirElementSerializer private constructor(
             }
             return versionRequirementTable[requirement]
         }
-
-        private fun variance(variance: Variance): ProtoBuf.TypeParameter.Variance = when (variance) {
-            Variance.INVARIANT -> ProtoBuf.TypeParameter.Variance.INV
-            Variance.IN_VARIANCE -> ProtoBuf.TypeParameter.Variance.IN
-            Variance.OUT_VARIANCE -> ProtoBuf.TypeParameter.Variance.OUT
-        }
-
-        private fun projection(projectionKind: ProjectionKind): ProtoBuf.Type.Argument.Projection = when (projectionKind) {
-            ProjectionKind.INVARIANT -> ProtoBuf.Type.Argument.Projection.INV
-            ProjectionKind.IN -> ProtoBuf.Type.Argument.Projection.IN
-            ProjectionKind.OUT -> ProtoBuf.Type.Argument.Projection.OUT
-            ProjectionKind.STAR -> throw AssertionError("Should not be here")
-        }
     }
 }

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

@@ -13,12 +13,14 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
+import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
+import org.jetbrains.kotlin.serialization.deserialization.memberKind
 import org.jetbrains.kotlin.types.Variance
 
 inline class ClassFlags(val flags: Long) {
 
     val modality: Modality get() = ProtoEnumFlags.modality(IrFlags.MODALITY.get(flags.toInt()))
-    val visibility: DescriptorVisibility get() = ProtoEnumFlags.visibility(IrFlags.VISIBILITY.get(flags.toInt()))
+    val visibility: DescriptorVisibility get() = ProtoEnumFlags.descriptorVisibility(IrFlags.VISIBILITY.get(flags.toInt()))
     val kind: ClassKind get() = ProtoEnumFlags.classKind(IrFlags.CLASS_KIND.get(flags.toInt()))
 
     val isCompanion: Boolean get() = IrFlags.CLASS_KIND.get(flags.toInt()) == ProtoBuf.Class.Kind.COMPANION_OBJECT
@@ -33,7 +35,7 @@ inline class ClassFlags(val flags: Long) {
         fun encode(clazz: IrClass): Long {
             return clazz.run {
                 val hasAnnotation = annotations.isNotEmpty()
-                val visibility = ProtoEnumFlags.visibility(visibility)
+                val visibility = ProtoEnumFlags.descriptorVisibility(visibility)
                 val modality = ProtoEnumFlags.modality(modality)
                 val kind = ProtoEnumFlags.classKind(kind, isCompanion)
 
@@ -51,7 +53,7 @@ inline class ClassFlags(val flags: Long) {
 inline class FunctionFlags(val flags: Long) {
 
     val modality: Modality get() = ProtoEnumFlags.modality(IrFlags.MODALITY.get(flags.toInt()))
-    val visibility: DescriptorVisibility get() = ProtoEnumFlags.visibility(IrFlags.VISIBILITY.get(flags.toInt()))
+    val visibility: DescriptorVisibility get() = ProtoEnumFlags.descriptorVisibility(IrFlags.VISIBILITY.get(flags.toInt()))
 
     val isOperator: Boolean get() = IrFlags.IS_OPERATOR.get(flags.toInt())
     val isInfix: Boolean get() = IrFlags.IS_INFIX.get(flags.toInt())
@@ -70,7 +72,7 @@ inline class FunctionFlags(val flags: Long) {
         fun encode(function: IrSimpleFunction): Long {
             function.run {
                 val hasAnnotation = annotations.isNotEmpty()
-                val visibility = ProtoEnumFlags.visibility(visibility)
+                val visibility = ProtoEnumFlags.descriptorVisibility(visibility)
                 val modality = ProtoEnumFlags.modality(modality)
                 val kind = if (isFakeOverride) ProtoBuf.MemberKind.FAKE_OVERRIDE else ProtoBuf.MemberKind.DECLARATION
 
@@ -87,7 +89,7 @@ inline class FunctionFlags(val flags: Long) {
         fun encode(constructor: IrConstructor): Long {
             constructor.run {
                 val hasAnnotation = annotations.isNotEmpty()
-                val visibility = ProtoEnumFlags.visibility(visibility)
+                val visibility = ProtoEnumFlags.descriptorVisibility(visibility)
                 val flags = IrFlags.getConstructorFlags(hasAnnotation, visibility, isInline, isExternal, isExpect, isPrimary)
 
                 return flags.toLong()
@@ -101,7 +103,7 @@ inline class FunctionFlags(val flags: Long) {
 inline class PropertyFlags(val flags: Long) {
 
     val modality: Modality get() = ProtoEnumFlags.modality(IrFlags.MODALITY.get(flags.toInt()))
-    val visibility: DescriptorVisibility get() = ProtoEnumFlags.visibility(IrFlags.VISIBILITY.get(flags.toInt()))
+    val visibility: DescriptorVisibility get() = ProtoEnumFlags.descriptorVisibility(IrFlags.VISIBILITY.get(flags.toInt()))
 
     val isVar: Boolean get() = IrFlags.IS_VAR.get(flags.toInt())
     val isConst: Boolean get() = IrFlags.IS_CONST.get(flags.toInt())
@@ -117,7 +119,7 @@ inline class PropertyFlags(val flags: Long) {
         fun encode(property: IrProperty): Long {
             return property.run {
                 val hasAnnotation = annotations.isNotEmpty()
-                val visibility = ProtoEnumFlags.visibility(visibility)
+                val visibility = ProtoEnumFlags.descriptorVisibility(visibility)
                 val modality = ProtoEnumFlags.modality(modality)
                 val kind = if (isFakeOverride) ProtoBuf.MemberKind.FAKE_OVERRIDE else ProtoBuf.MemberKind.DECLARATION
                 val hasGetter = getter != null
@@ -154,13 +156,13 @@ inline class ValueParameterFlags(val flags: Long) {
 
 inline class TypeAliasFlags(val flags: Long) {
 
-    val visibility: DescriptorVisibility get() = ProtoEnumFlags.visibility(IrFlags.VISIBILITY.get(flags.toInt()))
+    val visibility: DescriptorVisibility get() = ProtoEnumFlags.descriptorVisibility(IrFlags.VISIBILITY.get(flags.toInt()))
     val isActual: Boolean get() = IrFlags.IS_ACTUAL.get(flags.toInt())
 
     companion object {
         fun encode(typeAlias: IrTypeAlias): Long {
             return typeAlias.run {
-                val visibility = ProtoEnumFlags.visibility(visibility)
+                val visibility = ProtoEnumFlags.descriptorVisibility(visibility)
                 IrFlags.getTypeAliasFlags(annotations.isNotEmpty(), visibility, isActual).toLong()
             }
         }
@@ -188,7 +190,7 @@ inline class TypeParameterFlags(val flags: Long) {
 
 inline class FieldFlags(val flags: Long) {
 
-    val visibility: DescriptorVisibility get() = ProtoEnumFlags.visibility(IrFlags.VISIBILITY.get(flags.toInt()))
+    val visibility: DescriptorVisibility get() = ProtoEnumFlags.descriptorVisibility(IrFlags.VISIBILITY.get(flags.toInt()))
     val isFinal: Boolean get() = IrFlags.IS_FINAL.get(flags.toInt())
     val isExternal: Boolean get() = IrFlags.IS_EXTERNAL_FIELD.get(flags.toInt())
     val isStatic: Boolean get() = IrFlags.IS_STATIC.get(flags.toInt())
@@ -196,7 +198,7 @@ inline class FieldFlags(val flags: Long) {
     companion object {
         fun encode(field: IrField): Long {
             return field.run {
-                val visibility = ProtoEnumFlags.visibility(visibility)
+                val visibility = ProtoEnumFlags.descriptorVisibility(visibility)
                 IrFlags.getFieldFlags(annotations.isNotEmpty(), visibility, isFinal, isExternal, isStatic).toLong()
             }
         }

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

@@ -34,6 +34,8 @@ import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.nonSourceAnnotations
 import org.jetbrains.kotlin.resolve.isInlineClassType
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
+import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility
+import org.jetbrains.kotlin.serialization.deserialization.memberKind
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.contains
 import org.jetbrains.kotlin.types.typeUtil.immediateSupertypes
@@ -66,7 +68,7 @@ class DescriptorSerializer private constructor(
 
         val flags = Flags.getClassFlags(
             hasAnnotations(classDescriptor),
-            ProtoEnumFlags.visibility(normalizeVisibility(classDescriptor)),
+            ProtoEnumFlags.descriptorVisibility(normalizeVisibility(classDescriptor)),
             ProtoEnumFlags.modality(classDescriptor.modality),
             ProtoEnumFlags.classKind(classDescriptor.kind, classDescriptor.isCompanionObject),
             classDescriptor.isInner, classDescriptor.isData, classDescriptor.isExternal, classDescriptor.isExpect,
@@ -204,7 +206,7 @@ class DescriptorSerializer private constructor(
 
         val defaultAccessorFlags = Flags.getAccessorFlags(
             hasAnnotations,
-            ProtoEnumFlags.visibility(normalizeVisibility(descriptor)),
+            ProtoEnumFlags.descriptorVisibility(normalizeVisibility(descriptor)),
             ProtoEnumFlags.modality(descriptor.modality),
             false, false, false
         )
@@ -236,7 +238,7 @@ class DescriptorSerializer private constructor(
 
         val flags = Flags.getPropertyFlags(
             hasAnnotations,
-            ProtoEnumFlags.visibility(normalizeVisibility(descriptor)),
+            ProtoEnumFlags.descriptorVisibility(normalizeVisibility(descriptor)),
             ProtoEnumFlags.modality(descriptor.modality),
             ProtoEnumFlags.memberKind(descriptor.kind),
             descriptor.isVar, hasGetter, hasSetter, hasConstant, descriptor.isConst, descriptor.isLateInit, descriptor.isExternal,
@@ -308,7 +310,7 @@ class DescriptorSerializer private constructor(
 
         val flags = Flags.getFunctionFlags(
             hasAnnotations(descriptor),
-            ProtoEnumFlags.visibility(normalizeVisibility(descriptor)),
+            ProtoEnumFlags.descriptorVisibility(normalizeVisibility(descriptor)),
             ProtoEnumFlags.modality(descriptor.modality),
             ProtoEnumFlags.memberKind(descriptor.kind),
             descriptor.isOperator, descriptor.isInfix, descriptor.isInline, descriptor.isTailrec, descriptor.isExternal,
@@ -375,7 +377,7 @@ class DescriptorSerializer private constructor(
         val local = createChildSerializer(descriptor)
 
         val flags = Flags.getConstructorFlags(
-            hasAnnotations(descriptor), ProtoEnumFlags.visibility(normalizeVisibility(descriptor)), !descriptor.isPrimary,
+            hasAnnotations(descriptor), ProtoEnumFlags.descriptorVisibility(normalizeVisibility(descriptor)), !descriptor.isPrimary,
             shouldSerializeHasStableParameterNames(descriptor)
         )
         if (flags != builder.flags) {
@@ -431,7 +433,7 @@ class DescriptorSerializer private constructor(
         val builder = ProtoBuf.TypeAlias.newBuilder()
         val local = createChildSerializer(descriptor)
 
-        val flags = Flags.getTypeAliasFlags(hasAnnotations(descriptor), ProtoEnumFlags.visibility(normalizeVisibility(descriptor)))
+        val flags = Flags.getTypeAliasFlags(hasAnnotations(descriptor), ProtoEnumFlags.descriptorVisibility(normalizeVisibility(descriptor)))
         if (flags != builder.flags) {
             builder.flags = flags
         }
@@ -745,7 +747,7 @@ class DescriptorSerializer private constructor(
 
     private fun getAccessorFlags(accessor: PropertyAccessorDescriptor): Int = Flags.getAccessorFlags(
         hasAnnotations(accessor),
-        ProtoEnumFlags.visibility(normalizeVisibility(accessor)),
+        ProtoEnumFlags.descriptorVisibility(normalizeVisibility(accessor)),
         ProtoEnumFlags.modality(accessor.modality),
         !accessor.isDefault,
         accessor.isExternal,

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt

@@ -34,7 +34,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
             c.containingDeclaration, null,
             getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY),
             ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
-            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+            ProtoEnumFlags.descriptorVisibility(Flags.VISIBILITY.get(flags)),
             Flags.IS_VAR.get(flags),
             c.nameResolver.getName(proto.name),
             ProtoEnumFlags.memberKind(Flags.MEMBER_KIND.get(flags)),
@@ -87,7 +87,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
                     property,
                     annotations,
                     ProtoEnumFlags.modality(Flags.MODALITY.get(getterFlags)),
-                    ProtoEnumFlags.visibility(Flags.VISIBILITY.get(getterFlags)),
+                    ProtoEnumFlags.descriptorVisibility(Flags.VISIBILITY.get(getterFlags)),
                     /* isDefault = */ !isNotDefault,
                     /* isExternal = */ isExternal,
                     isInline,
@@ -113,7 +113,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
                     property,
                     annotations,
                     ProtoEnumFlags.modality(Flags.MODALITY.get(setterFlags)),
-                    ProtoEnumFlags.visibility(Flags.VISIBILITY.get(setterFlags)),
+                    ProtoEnumFlags.descriptorVisibility(Flags.VISIBILITY.get(setterFlags)),
                     /* isDefault = */ !isNotDefault,
                     /* isExternal = */ isExternal,
                     isInline,
@@ -284,7 +284,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
             local.memberDeserializer.valueParameters(proto.valueParameterList, proto, AnnotatedCallableKind.FUNCTION),
             local.typeDeserializer.type(proto.returnType(c.typeTable)),
             ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
-            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+            ProtoEnumFlags.descriptorVisibility(Flags.VISIBILITY.get(flags)),
             emptyMap<CallableDescriptor.UserDataKey<*>, Any?>(),
             Flags.IS_SUSPEND.get(flags)
         )
@@ -311,7 +311,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
             proto.annotationList.map { annotationDeserializer.deserializeAnnotation(it, c.nameResolver) }
         )
 
-        val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(proto.flags))
+        val visibility = ProtoEnumFlags.descriptorVisibility(Flags.VISIBILITY.get(proto.flags))
         val typeAlias = DeserializedTypeAliasDescriptor(
             c.storageManager, c.containingDeclaration, annotations, c.nameResolver.getName(proto.name),
             visibility, proto, c.nameResolver, c.typeTable, c.versionRequirementTable, c.containerSource
@@ -343,7 +343,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
         val local = c.childContext(descriptor, listOf())
         descriptor.initialize(
             local.memberDeserializer.valueParameters(proto.valueParameterList, proto, AnnotatedCallableKind.FUNCTION),
-            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(proto.flags))
+            ProtoEnumFlags.descriptorVisibility(Flags.VISIBILITY.get(proto.flags))
         )
         descriptor.returnType = classDescriptor.defaultType
 

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt

@@ -1,117 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.serialization.deserialization
-
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.metadata.ProtoBuf
-import org.jetbrains.kotlin.metadata.ProtoBuf.TypeParameter
-import org.jetbrains.kotlin.types.Variance
-
-object ProtoEnumFlags {
-    fun memberKind(memberKind: ProtoBuf.MemberKind?) = when (memberKind) {
-        ProtoBuf.MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION
-        ProtoBuf.MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE
-        ProtoBuf.MemberKind.DELEGATION -> CallableMemberDescriptor.Kind.DELEGATION
-        ProtoBuf.MemberKind.SYNTHESIZED -> CallableMemberDescriptor.Kind.SYNTHESIZED
-        else -> CallableMemberDescriptor.Kind.DECLARATION
-    }
-
-    fun memberKind(kind: CallableMemberDescriptor.Kind): ProtoBuf.MemberKind = when (kind) {
-        CallableMemberDescriptor.Kind.DECLARATION -> ProtoBuf.MemberKind.DECLARATION
-        CallableMemberDescriptor.Kind.FAKE_OVERRIDE -> ProtoBuf.MemberKind.FAKE_OVERRIDE
-        CallableMemberDescriptor.Kind.DELEGATION -> ProtoBuf.MemberKind.DELEGATION
-        CallableMemberDescriptor.Kind.SYNTHESIZED -> ProtoBuf.MemberKind.SYNTHESIZED
-    }
-
-    fun modality(modality: ProtoBuf.Modality?) = when (modality) {
-        ProtoBuf.Modality.FINAL -> Modality.FINAL
-        ProtoBuf.Modality.OPEN -> Modality.OPEN
-        ProtoBuf.Modality.ABSTRACT -> Modality.ABSTRACT
-        ProtoBuf.Modality.SEALED -> Modality.SEALED
-        else -> Modality.FINAL
-    }
-
-    fun modality(modality: Modality): ProtoBuf.Modality = when (modality) {
-        Modality.FINAL -> ProtoBuf.Modality.FINAL
-        Modality.OPEN -> ProtoBuf.Modality.OPEN
-        Modality.ABSTRACT -> ProtoBuf.Modality.ABSTRACT
-        Modality.SEALED -> ProtoBuf.Modality.SEALED
-    }
-
-    fun visibility(visibility: ProtoBuf.Visibility?) = when (visibility) {
-        ProtoBuf.Visibility.INTERNAL -> DescriptorVisibilities.INTERNAL
-        ProtoBuf.Visibility.PRIVATE -> DescriptorVisibilities.PRIVATE
-        ProtoBuf.Visibility.PRIVATE_TO_THIS -> DescriptorVisibilities.PRIVATE_TO_THIS
-        ProtoBuf.Visibility.PROTECTED -> DescriptorVisibilities.PROTECTED
-        ProtoBuf.Visibility.PUBLIC -> DescriptorVisibilities.PUBLIC
-        ProtoBuf.Visibility.LOCAL -> DescriptorVisibilities.LOCAL
-        else -> DescriptorVisibilities.PRIVATE
-    }
-
-    fun visibility(visibility: DescriptorVisibility): ProtoBuf.Visibility = when (visibility) {
-        DescriptorVisibilities.INTERNAL -> ProtoBuf.Visibility.INTERNAL
-        DescriptorVisibilities.PUBLIC -> ProtoBuf.Visibility.PUBLIC
-        DescriptorVisibilities.PRIVATE -> ProtoBuf.Visibility.PRIVATE
-        DescriptorVisibilities.PRIVATE_TO_THIS -> ProtoBuf.Visibility.PRIVATE_TO_THIS
-        DescriptorVisibilities.PROTECTED -> ProtoBuf.Visibility.PROTECTED
-        DescriptorVisibilities.LOCAL -> ProtoBuf.Visibility.LOCAL
-        else -> throw IllegalArgumentException("Unknown visibility: $visibility")
-    }
-
-    fun classKind(kind: ProtoBuf.Class.Kind?): ClassKind = when (kind) {
-        ProtoBuf.Class.Kind.CLASS -> ClassKind.CLASS
-        ProtoBuf.Class.Kind.INTERFACE -> ClassKind.INTERFACE
-        ProtoBuf.Class.Kind.ENUM_CLASS -> ClassKind.ENUM_CLASS
-        ProtoBuf.Class.Kind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY
-        ProtoBuf.Class.Kind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS
-        ProtoBuf.Class.Kind.OBJECT, ProtoBuf.Class.Kind.COMPANION_OBJECT -> ClassKind.OBJECT
-        else -> ClassKind.CLASS
-    }
-
-    fun classKind(kind: ClassKind, isCompanionObject: Boolean): ProtoBuf.Class.Kind {
-        if (isCompanionObject) return ProtoBuf.Class.Kind.COMPANION_OBJECT
-
-        return when (kind) {
-            ClassKind.CLASS -> ProtoBuf.Class.Kind.CLASS
-            ClassKind.INTERFACE -> ProtoBuf.Class.Kind.INTERFACE
-            ClassKind.ENUM_CLASS -> ProtoBuf.Class.Kind.ENUM_CLASS
-            ClassKind.ENUM_ENTRY -> ProtoBuf.Class.Kind.ENUM_ENTRY
-            ClassKind.ANNOTATION_CLASS -> ProtoBuf.Class.Kind.ANNOTATION_CLASS
-            ClassKind.OBJECT -> ProtoBuf.Class.Kind.OBJECT
-        }
-    }
-
-    fun variance(variance: TypeParameter.Variance) = when (variance) {
-        ProtoBuf.TypeParameter.Variance.IN -> Variance.IN_VARIANCE
-        ProtoBuf.TypeParameter.Variance.OUT -> Variance.OUT_VARIANCE
-        ProtoBuf.TypeParameter.Variance.INV -> Variance.INVARIANT
-    }
-
-    fun variance(projection: ProtoBuf.Type.Argument.Projection) = when (projection) {
-        ProtoBuf.Type.Argument.Projection.IN -> Variance.IN_VARIANCE
-        ProtoBuf.Type.Argument.Projection.OUT -> Variance.OUT_VARIANCE
-        ProtoBuf.Type.Argument.Projection.INV -> Variance.INVARIANT
-        ProtoBuf.Type.Argument.Projection.STAR ->
-            throw IllegalArgumentException("Only IN, OUT and INV are supported. Actual argument: $projection")
-    }
-
-    fun variance(variance: Variance) = when (variance) {
-        Variance.IN_VARIANCE -> TypeParameter.Variance.IN
-        Variance.OUT_VARIANCE -> TypeParameter.Variance.OUT
-        Variance.INVARIANT -> TypeParameter.Variance.INV
-    }
-}

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlagsUtils.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.serialization.deserialization
+
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.descriptors.DescriptorVisibility
+import org.jetbrains.kotlin.metadata.ProtoBuf
+
+@Suppress("unused")
+fun ProtoEnumFlags.memberKind(memberKind: ProtoBuf.MemberKind?): CallableMemberDescriptor.Kind = when (memberKind) {
+    ProtoBuf.MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION
+    ProtoBuf.MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE
+    ProtoBuf.MemberKind.DELEGATION -> CallableMemberDescriptor.Kind.DELEGATION
+    ProtoBuf.MemberKind.SYNTHESIZED -> CallableMemberDescriptor.Kind.SYNTHESIZED
+    else -> CallableMemberDescriptor.Kind.DECLARATION
+}
+
+@Suppress("unused")
+fun ProtoEnumFlags.memberKind(kind: CallableMemberDescriptor.Kind): ProtoBuf.MemberKind = when (kind) {
+    CallableMemberDescriptor.Kind.DECLARATION -> ProtoBuf.MemberKind.DECLARATION
+    CallableMemberDescriptor.Kind.FAKE_OVERRIDE -> ProtoBuf.MemberKind.FAKE_OVERRIDE
+    CallableMemberDescriptor.Kind.DELEGATION -> ProtoBuf.MemberKind.DELEGATION
+    CallableMemberDescriptor.Kind.SYNTHESIZED -> ProtoBuf.MemberKind.SYNTHESIZED
+}
+
+@Suppress("unused")
+fun ProtoEnumFlags.descriptorVisibility(visibility: ProtoBuf.Visibility?): DescriptorVisibility = when (visibility) {
+    ProtoBuf.Visibility.INTERNAL -> DescriptorVisibilities.INTERNAL
+    ProtoBuf.Visibility.PRIVATE -> DescriptorVisibilities.PRIVATE
+    ProtoBuf.Visibility.PRIVATE_TO_THIS -> DescriptorVisibilities.PRIVATE_TO_THIS
+    ProtoBuf.Visibility.PROTECTED -> DescriptorVisibilities.PROTECTED
+    ProtoBuf.Visibility.PUBLIC -> DescriptorVisibilities.PUBLIC
+    ProtoBuf.Visibility.LOCAL -> DescriptorVisibilities.LOCAL
+    else -> DescriptorVisibilities.PRIVATE
+}
+
+@Suppress("unused")
+fun ProtoEnumFlags.descriptorVisibility(visibility: DescriptorVisibility): ProtoBuf.Visibility = when (visibility) {
+    DescriptorVisibilities.INTERNAL -> ProtoBuf.Visibility.INTERNAL
+    DescriptorVisibilities.PUBLIC -> ProtoBuf.Visibility.PUBLIC
+    DescriptorVisibilities.PRIVATE -> ProtoBuf.Visibility.PRIVATE
+    DescriptorVisibilities.PRIVATE_TO_THIS -> ProtoBuf.Visibility.PRIVATE_TO_THIS
+    DescriptorVisibilities.PROTECTED -> ProtoBuf.Visibility.PROTECTED
+    DescriptorVisibilities.LOCAL -> ProtoBuf.Visibility.LOCAL
+    else -> throw IllegalArgumentException("Unknown visibility: $visibility")
+}

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt

@@ -46,7 +46,7 @@ class DeserializedClassDescriptor(
     private val classId = nameResolver.getClassId(classProto.fqName)
 
     private val modality = ProtoEnumFlags.modality(Flags.MODALITY.get(classProto.flags))
-    private val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(classProto.flags))
+    private val visibility = ProtoEnumFlags.descriptorVisibility(Flags.VISIBILITY.get(classProto.flags))
     private val kind = ProtoEnumFlags.classKind(Flags.CLASS_KIND.get(classProto.flags))
 
     val c = outerContext.childContext(

core/metadata/build.gradle.kts

@@ -1,5 +1,3 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
 plugins {
     kotlin("jvm")
     id("jps-compatible")
@@ -11,6 +9,7 @@ javaHome = rootProject.extra["JDK_16"] as String
 dependencies {
     compile(protobufLite())
     compile(kotlinStdlib())
+    api(project(":core:compiler.common"))
 }
 
 sourceSets {

core/metadata/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.serialization.deserialization
+
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.ProtoBuf.TypeParameter
+import org.jetbrains.kotlin.types.Variance
+
+object ProtoEnumFlags {
+    fun modality(modality: ProtoBuf.Modality?): Modality = when (modality) {
+        ProtoBuf.Modality.FINAL -> Modality.FINAL
+        ProtoBuf.Modality.OPEN -> Modality.OPEN
+        ProtoBuf.Modality.ABSTRACT -> Modality.ABSTRACT
+        ProtoBuf.Modality.SEALED -> Modality.SEALED
+        else -> Modality.FINAL
+    }
+
+    fun modality(modality: Modality): ProtoBuf.Modality = when (modality) {
+        Modality.FINAL -> ProtoBuf.Modality.FINAL
+        Modality.OPEN -> ProtoBuf.Modality.OPEN
+        Modality.ABSTRACT -> ProtoBuf.Modality.ABSTRACT
+        Modality.SEALED -> ProtoBuf.Modality.SEALED
+    }
+
+    fun visibility(visibility: ProtoBuf.Visibility?): Visibility = when (visibility) {
+        ProtoBuf.Visibility.INTERNAL -> Visibilities.Internal
+        ProtoBuf.Visibility.PRIVATE -> Visibilities.Private
+        ProtoBuf.Visibility.PRIVATE_TO_THIS -> Visibilities.PrivateToThis
+        ProtoBuf.Visibility.PROTECTED -> Visibilities.Protected
+        ProtoBuf.Visibility.PUBLIC -> Visibilities.Public
+        ProtoBuf.Visibility.LOCAL -> Visibilities.Local
+        else -> Visibilities.Private
+    }
+
+    fun visibility(visibility: Visibility): ProtoBuf.Visibility = when (visibility) {
+        Visibilities.Internal -> ProtoBuf.Visibility.INTERNAL
+        Visibilities.Public -> ProtoBuf.Visibility.PUBLIC
+        Visibilities.Private -> ProtoBuf.Visibility.PRIVATE
+        Visibilities.PrivateToThis -> ProtoBuf.Visibility.PRIVATE_TO_THIS
+        Visibilities.Protected -> ProtoBuf.Visibility.PROTECTED
+        Visibilities.Local -> ProtoBuf.Visibility.LOCAL
+        else -> throw IllegalArgumentException("Unknown visibility: $visibility")
+    }
+
+    fun classKind(kind: ProtoBuf.Class.Kind?): ClassKind = when (kind) {
+        ProtoBuf.Class.Kind.CLASS -> ClassKind.CLASS
+        ProtoBuf.Class.Kind.INTERFACE -> ClassKind.INTERFACE
+        ProtoBuf.Class.Kind.ENUM_CLASS -> ClassKind.ENUM_CLASS
+        ProtoBuf.Class.Kind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY
+        ProtoBuf.Class.Kind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS
+        ProtoBuf.Class.Kind.OBJECT, ProtoBuf.Class.Kind.COMPANION_OBJECT -> ClassKind.OBJECT
+        else -> ClassKind.CLASS
+    }
+
+    fun classKind(kind: ClassKind, isCompanionObject: Boolean): ProtoBuf.Class.Kind {
+        if (isCompanionObject) return ProtoBuf.Class.Kind.COMPANION_OBJECT
+
+        return when (kind) {
+            ClassKind.CLASS -> ProtoBuf.Class.Kind.CLASS
+            ClassKind.INTERFACE -> ProtoBuf.Class.Kind.INTERFACE
+            ClassKind.ENUM_CLASS -> ProtoBuf.Class.Kind.ENUM_CLASS
+            ClassKind.ENUM_ENTRY -> ProtoBuf.Class.Kind.ENUM_ENTRY
+            ClassKind.ANNOTATION_CLASS -> ProtoBuf.Class.Kind.ANNOTATION_CLASS
+            ClassKind.OBJECT -> ProtoBuf.Class.Kind.OBJECT
+        }
+    }
+
+    fun variance(variance: TypeParameter.Variance): Variance = when (variance) {
+        ProtoBuf.TypeParameter.Variance.IN -> Variance.IN_VARIANCE
+        ProtoBuf.TypeParameter.Variance.OUT -> Variance.OUT_VARIANCE
+        ProtoBuf.TypeParameter.Variance.INV -> Variance.INVARIANT
+    }
+
+    fun variance(projection: ProtoBuf.Type.Argument.Projection): Variance = when (projection) {
+        ProtoBuf.Type.Argument.Projection.IN -> Variance.IN_VARIANCE
+        ProtoBuf.Type.Argument.Projection.OUT -> Variance.OUT_VARIANCE
+        ProtoBuf.Type.Argument.Projection.INV -> Variance.INVARIANT
+        ProtoBuf.Type.Argument.Projection.STAR ->
+            throw IllegalArgumentException("Only IN, OUT and INV are supported. Actual argument: $projection")
+    }
+
+    fun variance(variance: Variance): TypeParameter.Variance = when (variance) {
+        Variance.IN_VARIANCE -> TypeParameter.Variance.IN
+        Variance.OUT_VARIANCE -> TypeParameter.Variance.OUT
+        Variance.INVARIANT -> TypeParameter.Variance.INV
+    }
+}