Minor, rename Deserialization -> ProtoEnumFlags

Also fix warnings and remove unneeded JvmStatic

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

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.serialization.Flags
 import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.Deserialization
 import org.jetbrains.kotlin.serialization.deserialization.NameResolver
+import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 import java.util.*
 
@@ -50,7 +50,7 @@ fun ProtoMapValue.toProtoData(packageFqName: FqName): ProtoData =
     }
 
 internal val MessageLite.isPrivate: Boolean
-    get() = Visibilities.isPrivate(Deserialization.visibility(
+    get() = Visibilities.isPrivate(ProtoEnumFlags.visibility(
             when (this) {
                 is ProtoBuf.Constructor -> Flags.VISIBILITY.get(flags)
                 is ProtoBuf.Function -> Flags.VISIBILITY.get(flags)

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

@@ -38,11 +38,11 @@ class MemberDeserializer(private val c: DeserializationContext) {
         val property = DeserializedPropertyDescriptor(
             c.containingDeclaration, null,
             getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY),
-            Deserialization.modality(Flags.MODALITY.get(flags)),
-            Deserialization.visibility(Flags.VISIBILITY.get(flags)),
+            ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
+            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
             Flags.IS_VAR.get(flags),
             c.nameResolver.getName(proto.name),
-            Deserialization.memberKind(Flags.MEMBER_KIND.get(flags)),
+            ProtoEnumFlags.memberKind(Flags.MEMBER_KIND.get(flags)),
             Flags.IS_LATEINIT.get(flags),
             Flags.IS_CONST.get(flags),
             Flags.IS_EXTERNAL_PROPERTY.get(flags),
@@ -80,8 +80,8 @@ class MemberDeserializer(private val c: DeserializationContext) {
                 PropertyGetterDescriptorImpl(
                     property,
                     annotations,
-                    Deserialization.modality(Flags.MODALITY.get(getterFlags)),
-                    Deserialization.visibility(Flags.VISIBILITY.get(getterFlags)),
+                    ProtoEnumFlags.modality(Flags.MODALITY.get(getterFlags)),
+                    ProtoEnumFlags.visibility(Flags.VISIBILITY.get(getterFlags)),
                     /* isDefault = */ !isNotDefault,
                     /* isExternal = */ isExternal,
                     isInline,
@@ -106,8 +106,8 @@ class MemberDeserializer(private val c: DeserializationContext) {
                 val setter = PropertySetterDescriptorImpl(
                     property,
                     annotations,
-                    Deserialization.modality(Flags.MODALITY.get(setterFlags)),
-                    Deserialization.visibility(Flags.VISIBILITY.get(setterFlags)),
+                    ProtoEnumFlags.modality(Flags.MODALITY.get(setterFlags)),
+                    ProtoEnumFlags.visibility(Flags.VISIBILITY.get(setterFlags)),
                     /* isDefault = */ !isNotDefault,
                     /* isExternal = */ isExternal,
                     isInline,
@@ -154,7 +154,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
         else Annotations.EMPTY
         val function = DeserializedSimpleFunctionDescriptor(
             c.containingDeclaration, /* original = */ null, annotations, c.nameResolver.getName(proto.name),
-            Deserialization.memberKind(Flags.MEMBER_KIND.get(flags)), proto, c.nameResolver, c.typeTable, c.versionRequirementTable,
+            ProtoEnumFlags.memberKind(Flags.MEMBER_KIND.get(flags)), proto, c.nameResolver, c.typeTable, c.versionRequirementTable,
             c.containerSource
         )
         val local = c.childContext(function, proto.typeParameterList)
@@ -165,8 +165,8 @@ class MemberDeserializer(private val c: DeserializationContext) {
             local.typeDeserializer.ownTypeParameters,
             local.memberDeserializer.valueParameters(proto.valueParameterList, proto, AnnotatedCallableKind.FUNCTION),
             local.typeDeserializer.type(proto.returnType(c.typeTable)),
-            Deserialization.modality(Flags.MODALITY.get(flags)),
-            Deserialization.visibility(Flags.VISIBILITY.get(flags)),
+            ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
+            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
             emptyMap<FunctionDescriptor.UserDataKey<*>, Any?>()
         )
         function.isOperator = Flags.IS_OPERATOR.get(flags)
@@ -189,7 +189,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
     fun loadTypeAlias(proto: ProtoBuf.TypeAlias): TypeAliasDescriptor {
         val annotations = AnnotationsImpl(proto.annotationList.map { annotationDeserializer.deserializeAnnotation(it, c.nameResolver) })
 
-        val visibility = Deserialization.visibility(Flags.VISIBILITY.get(proto.flags))
+        val visibility = ProtoEnumFlags.visibility(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
@@ -219,7 +219,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
         val local = c.childContext(descriptor, listOf())
         descriptor.initialize(
             local.memberDeserializer.valueParameters(proto.valueParameterList, proto, AnnotatedCallableKind.FUNCTION),
-            Deserialization.visibility(Flags.VISIBILITY.get(proto.flags))
+            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(proto.flags))
         )
         descriptor.returnType = classDescriptor.defaultType
         return descriptor

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

@@ -24,8 +24,7 @@ import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.ProtoBuf.TypeParameter
 import org.jetbrains.kotlin.types.Variance
 
-object Deserialization {
-    @JvmStatic
+object ProtoEnumFlags {
     fun memberKind(memberKind: ProtoBuf.MemberKind?) = when (memberKind) {
         ProtoBuf.MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION
         ProtoBuf.MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE
@@ -34,7 +33,6 @@ object Deserialization {
         else -> CallableMemberDescriptor.Kind.DECLARATION
     }
 
-    @JvmStatic
     fun modality(modality: ProtoBuf.Modality?) = when (modality) {
         ProtoBuf.Modality.FINAL -> Modality.FINAL
         ProtoBuf.Modality.OPEN -> Modality.OPEN
@@ -43,7 +41,6 @@ object Deserialization {
         else -> Modality.FINAL
     }
 
-    @JvmStatic
     fun visibility(visibility: ProtoBuf.Visibility?) = when (visibility) {
         ProtoBuf.Visibility.INTERNAL -> Visibilities.INTERNAL
         ProtoBuf.Visibility.PRIVATE -> Visibilities.PRIVATE
@@ -54,7 +51,6 @@ object Deserialization {
         else -> Visibilities.PRIVATE
     }
 
-    @JvmStatic
     fun classKind(kind: ProtoBuf.Class.Kind?): ClassKind = when (kind) {
         ProtoBuf.Class.Kind.CLASS -> ClassKind.CLASS
         ProtoBuf.Class.Kind.INTERFACE -> ClassKind.INTERFACE
@@ -65,21 +61,17 @@ object Deserialization {
         else -> ClassKind.CLASS
     }
 
-    @JvmStatic
     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
-        else -> Variance.INVARIANT
     }
 
-    @JvmStatic
     fun variance(variance: ProtoBuf.Type.Argument.Projection) = when (variance) {
         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: $variance")
-        else -> Variance.INVARIANT
     }
 }

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

@@ -201,7 +201,7 @@ class TypeDeserializer(
                 StarProjectionImpl(parameter)
         }
 
-        val variance = Deserialization.variance(typeArgumentProto.projection)
+        val variance = ProtoEnumFlags.variance(typeArgumentProto.projection)
         val type = typeArgumentProto.type(c.typeTable) ?:
                 return TypeProjectionImpl(ErrorUtils.createErrorType("No type recorded"))
 

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

@@ -40,9 +40,9 @@ class DeserializedClassDescriptor(
 ) {
     private val classId = nameResolver.getClassId(classProto.fqName)
 
-    private val modality = Deserialization.modality(Flags.MODALITY.get(classProto.flags))
-    private val visibility = Deserialization.visibility(Flags.VISIBILITY.get(classProto.flags))
-    private val kind = Deserialization.classKind(Flags.CLASS_KIND.get(classProto.flags))
+    private val modality = ProtoEnumFlags.modality(Flags.MODALITY.get(classProto.flags))
+    private val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(classProto.flags))
+    private val kind = ProtoEnumFlags.classKind(Flags.CLASS_KIND.get(classProto.flags))
 
     val c = outerContext.childContext(this, classProto.typeParameterList, nameResolver, TypeTable(classProto.typeTable))
 

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

@@ -22,8 +22,8 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.AbstractLazyTypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.serialization.ProtoBuf
-import org.jetbrains.kotlin.serialization.deserialization.Deserialization
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationContext
+import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.serialization.deserialization.upperBounds
 import org.jetbrains.kotlin.types.KotlinType
 
@@ -32,8 +32,8 @@ class DeserializedTypeParameterDescriptor(
         private val proto: ProtoBuf.TypeParameter,
         index: Int
 ) : AbstractLazyTypeParameterDescriptor(
-        c.storageManager, c.containingDeclaration, c.nameResolver.getName(proto.name),
-        Deserialization.variance(proto.variance), proto.reified, index, SourceElement.NO_SOURCE, SupertypeLoopChecker.EMPTY
+    c.storageManager, c.containingDeclaration, c.nameResolver.getName(proto.name),
+    ProtoEnumFlags.variance(proto.variance), proto.reified, index, SourceElement.NO_SOURCE, SupertypeLoopChecker.EMPTY
 ) {
     override val annotations = DeserializedAnnotations(c.storageManager) {
         c.components.annotationAndConstantLoader.loadTypeParameterAnnotations(proto, c.nameResolver).toList()