Move descriptor-related utilities from Flags to ProtoEnumFlags

2018-02-28 17:30:52 +01:00
parent ec67a878a0
commit 99964cd030
4 changed files with 108 additions and 138 deletions
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.resolve.constants.EnumValue
 import org.jetbrains.kotlin.resolve.constants.IntValue
 import org.jetbrains.kotlin.resolve.constants.NullValue
 import org.jetbrains.kotlin.resolve.constants.StringValue
+import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.VersionRequirement
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.contains
@@ -54,9 +55,11 @@ class DescriptorSerializer private constructor(
        val builder = ProtoBuf.Class.newBuilder()

        val flags = Flags.getClassFlags(
-                hasAnnotations(classDescriptor), normalizeVisibility(classDescriptor), classDescriptor.modality, classDescriptor.kind,
-                classDescriptor.isInner, classDescriptor.isCompanionObject, classDescriptor.isData, classDescriptor.isExternal,
-                classDescriptor.isExpect, classDescriptor.isInline
+            hasAnnotations(classDescriptor),
+            ProtoEnumFlags.visibility(normalizeVisibility(classDescriptor)),
+            ProtoEnumFlags.modality(classDescriptor.modality),
+            ProtoEnumFlags.classKind(classDescriptor.kind, classDescriptor.isCompanionObject),
+            classDescriptor.isInner, classDescriptor.isData, classDescriptor.isExternal, classDescriptor.isExpect, classDescriptor.isInline
        )
        if (flags != builder.flags) {
            builder.flags = flags
@@ -157,7 +160,12 @@ class DescriptorSerializer private constructor(

        val hasAnnotations = descriptor.annotations.getAllAnnotations().isNotEmpty()

-        val propertyFlags = Flags.getAccessorFlags(hasAnnotations, normalizeVisibility(descriptor), descriptor.modality, false, false, false)
+        val propertyFlags = Flags.getAccessorFlags(
+            hasAnnotations,
+            ProtoEnumFlags.visibility(normalizeVisibility(descriptor)),
+            ProtoEnumFlags.modality(descriptor.modality),
+            false, false, false
+        )

        val getter = descriptor.getter
        if (getter != null) {
@@ -185,9 +193,12 @@ class DescriptorSerializer private constructor(
        }

        val flags = Flags.getPropertyFlags(
-                hasAnnotations, normalizeVisibility(descriptor), descriptor.modality, descriptor.kind, descriptor.isVar,
-                hasGetter, hasSetter, hasConstant, descriptor.isConst, descriptor.isLateInit, descriptor.isExternal,
-                @Suppress("DEPRECATION") descriptor.isDelegated, descriptor.isExpect
+            hasAnnotations,
+            ProtoEnumFlags.visibility(normalizeVisibility(descriptor)),
+            ProtoEnumFlags.modality(descriptor.modality),
+            ProtoEnumFlags.memberKind(descriptor.kind),
+            descriptor.isVar, hasGetter, hasSetter, hasConstant, descriptor.isConst, descriptor.isLateInit, descriptor.isExternal,
+            @Suppress("DEPRECATION") descriptor.isDelegated, descriptor.isExpect
        )
        if (flags != builder.flags) {
            builder.flags = flags
@@ -242,9 +253,12 @@ class DescriptorSerializer private constructor(
        val local = createChildSerializer(descriptor)

        val flags = Flags.getFunctionFlags(
-                hasAnnotations(descriptor), normalizeVisibility(descriptor), descriptor.modality, descriptor.kind, descriptor.isOperator,
-                descriptor.isInfix, descriptor.isInline, descriptor.isTailrec, descriptor.isExternal, descriptor.isSuspend,
-                descriptor.isExpect
+            hasAnnotations(descriptor),
+            ProtoEnumFlags.visibility(normalizeVisibility(descriptor)),
+            ProtoEnumFlags.modality(descriptor.modality),
+            ProtoEnumFlags.memberKind(descriptor.kind),
+            descriptor.isOperator, descriptor.isInfix, descriptor.isInline, descriptor.isTailrec, descriptor.isExternal,
+            descriptor.isSuspend, descriptor.isExpect
        )
        if (flags != builder.flags) {
            builder.flags = flags
@@ -304,7 +318,9 @@ class DescriptorSerializer private constructor(

        val local = createChildSerializer(descriptor)

-        val flags = Flags.getConstructorFlags(hasAnnotations(descriptor), normalizeVisibility(descriptor), !descriptor.isPrimary)
+        val flags = Flags.getConstructorFlags(
+            hasAnnotations(descriptor), ProtoEnumFlags.visibility(normalizeVisibility(descriptor)), !descriptor.isPrimary
+        )
        if (flags != builder.flags) {
            builder.flags = flags
        }
@@ -340,7 +356,7 @@ class DescriptorSerializer private constructor(
        val builder = ProtoBuf.TypeAlias.newBuilder()
        val local = createChildSerializer(descriptor)

-        val flags = Flags.getTypeAliasFlags(hasAnnotations(descriptor), normalizeVisibility(descriptor))
+        val flags = Flags.getTypeAliasFlags(hasAnnotations(descriptor), ProtoEnumFlags.visibility(normalizeVisibility(descriptor)))
        if (flags != builder.flags) {
            builder.flags = flags
        }
@@ -661,16 +677,14 @@ class DescriptorSerializer private constructor(
    private fun getTypeParameterId(descriptor: TypeParameterDescriptor): Int =
            typeParameters.intern(descriptor)

-    private fun getAccessorFlags(accessor: PropertyAccessorDescriptor): Int {
-        return Flags.getAccessorFlags(
-                hasAnnotations(accessor),
-                normalizeVisibility(accessor),
-                accessor.modality,
-                !accessor.isDefault,
-                accessor.isExternal,
-                accessor.isInline
-        )
-    }
+    private fun getAccessorFlags(accessor: PropertyAccessorDescriptor): Int = Flags.getAccessorFlags(
+        hasAnnotations(accessor),
+        ProtoEnumFlags.visibility(normalizeVisibility(accessor)),
+        ProtoEnumFlags.modality(accessor.modality),
+        !accessor.isDefault,
+        accessor.isExternal,
+        accessor.isInline
+    )

    companion object {
        @JvmStatic
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.serialization;

 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.protobuf.Internal;

 public class Flags {
@@ -86,64 +85,43 @@ public class Flags {

    public static int getClassFlags(
            boolean hasAnnotations,
-            Visibility visibility,
-            Modality modality,
-            ClassKind kind,
+            @NotNull ProtoBuf.Visibility visibility,
+            @NotNull ProtoBuf.Modality modality,
+            @NotNull ProtoBuf.Class.Kind kind,
            boolean inner,
-            boolean isCompanionObject,
            boolean isData,
            boolean isExternal,
            boolean isExpect,
            boolean isInline
    ) {
        return HAS_ANNOTATIONS.toFlags(hasAnnotations)
-               | MODALITY.toFlags(modality(modality))
-               | VISIBILITY.toFlags(visibility(visibility))
-               | CLASS_KIND.toFlags(classKind(kind, isCompanionObject))
+               | MODALITY.toFlags(modality)
+               | VISIBILITY.toFlags(visibility)
+               | CLASS_KIND.toFlags(kind)
               | IS_INNER.toFlags(inner)
               | IS_DATA.toFlags(isData)
               | IS_EXTERNAL_CLASS.toFlags(isExternal)
               | IS_EXPECT_CLASS.toFlags(isExpect)
               | IS_INLINE_CLASS.toFlags(isInline)
-               ;
-    }
-
-    private static ProtoBuf.Class.Kind classKind(ClassKind kind, boolean isCompanionObject) {
-        if (isCompanionObject) return ProtoBuf.Class.Kind.COMPANION_OBJECT;
-
-        switch (kind) {
-            case CLASS:
-                return ProtoBuf.Class.Kind.CLASS;
-            case INTERFACE:
-                return ProtoBuf.Class.Kind.INTERFACE;
-            case ENUM_CLASS:
-                return ProtoBuf.Class.Kind.ENUM_CLASS;
-            case ENUM_ENTRY:
-                return ProtoBuf.Class.Kind.ENUM_ENTRY;
-            case ANNOTATION_CLASS:
-                return ProtoBuf.Class.Kind.ANNOTATION_CLASS;
-            case OBJECT:
-                return ProtoBuf.Class.Kind.OBJECT;
-        }
-        throw new IllegalArgumentException("Unknown class kind: " + kind);
+                ;
    }

    public static int getConstructorFlags(
            boolean hasAnnotations,
-            @NotNull Visibility visibility,
+            @NotNull ProtoBuf.Visibility visibility,
            boolean isSecondary
    ) {
        return HAS_ANNOTATIONS.toFlags(hasAnnotations)
-               | VISIBILITY.toFlags(visibility(visibility))
+               | VISIBILITY.toFlags(visibility)
               | IS_SECONDARY.toFlags(isSecondary)
                ;
    }

    public static int getFunctionFlags(
            boolean hasAnnotations,
-            @NotNull Visibility visibility,
-            @NotNull Modality modality,
-            @NotNull CallableMemberDescriptor.Kind memberKind,
+            @NotNull ProtoBuf.Visibility visibility,
+            @NotNull ProtoBuf.Modality modality,
+            @NotNull ProtoBuf.MemberKind memberKind,
            boolean isOperator,
            boolean isInfix,
            boolean isInline,
@@ -153,9 +131,9 @@ public class Flags {
            boolean isExpect
    ) {
        return HAS_ANNOTATIONS.toFlags(hasAnnotations)
-               | VISIBILITY.toFlags(visibility(visibility))
-               | MODALITY.toFlags(modality(modality))
-               | MEMBER_KIND.toFlags(memberKind(memberKind))
+               | VISIBILITY.toFlags(visibility)
+               | MODALITY.toFlags(modality)
+               | MEMBER_KIND.toFlags(memberKind)
               | IS_OPERATOR.toFlags(isOperator)
               | IS_INFIX.toFlags(isInfix)
               | IS_INLINE.toFlags(isInline)
@@ -168,9 +146,9 @@ public class Flags {

    public static int getPropertyFlags(
            boolean hasAnnotations,
-            @NotNull Visibility visibility,
-            @NotNull Modality modality,
-            @NotNull CallableMemberDescriptor.Kind memberKind,
+            @NotNull ProtoBuf.Visibility visibility,
+            @NotNull ProtoBuf.Modality modality,
+            @NotNull ProtoBuf.MemberKind memberKind,
            boolean isVar,
            boolean hasGetter,
            boolean hasSetter,
@@ -182,9 +160,9 @@ public class Flags {
            boolean isExpect
    ) {
        return HAS_ANNOTATIONS.toFlags(hasAnnotations)
-               | VISIBILITY.toFlags(visibility(visibility))
-               | MODALITY.toFlags(modality(modality))
-               | MEMBER_KIND.toFlags(memberKind(memberKind))
+               | VISIBILITY.toFlags(visibility)
+               | MODALITY.toFlags(modality)
+               | MEMBER_KIND.toFlags(memberKind)
               | IS_VAR.toFlags(isVar)
               | HAS_GETTER.toFlags(hasGetter)
               | HAS_SETTER.toFlags(hasSetter)
@@ -199,82 +177,26 @@ public class Flags {

    public static int getAccessorFlags(
            boolean hasAnnotations,
-            @NotNull Visibility visibility,
-            @NotNull Modality modality,
+            @NotNull ProtoBuf.Visibility visibility,
+            @NotNull ProtoBuf.Modality modality,
            boolean isNotDefault,
            boolean isExternal,
            boolean isInlineAccessor
    ) {
        return HAS_ANNOTATIONS.toFlags(hasAnnotations)
-               | MODALITY.toFlags(modality(modality))
-               | VISIBILITY.toFlags(visibility(visibility))
+               | MODALITY.toFlags(modality)
+               | VISIBILITY.toFlags(visibility)
               | IS_NOT_DEFAULT.toFlags(isNotDefault)
               | IS_EXTERNAL_ACCESSOR.toFlags(isExternal)
               | IS_INLINE_ACCESSOR.toFlags(isInlineAccessor)
-               ;
+                ;
    }

-    public static int getContractExpressionFlags(
-            @NotNull boolean isNegated,
-            @NotNull boolean isNullCheckPredicate
-    ) {
+    public static int getContractExpressionFlags(boolean isNegated, boolean isNullCheckPredicate) {
        return IS_NEGATED.toFlags(isNegated)
                | IS_NULL_CHECK_PREDICATE.toFlags(isNullCheckPredicate);
    }

-    @NotNull
-    private static ProtoBuf.Visibility visibility(@NotNull Visibility visibility) {
-        if (visibility == Visibilities.INTERNAL) {
-            return ProtoBuf.Visibility.INTERNAL;
-        }
-        else if (visibility == Visibilities.PUBLIC) {
-            return ProtoBuf.Visibility.PUBLIC;
-        }
-        else if (visibility == Visibilities.PRIVATE) {
-            return ProtoBuf.Visibility.PRIVATE;
-        }
-        else if (visibility == Visibilities.PRIVATE_TO_THIS) {
-            return ProtoBuf.Visibility.PRIVATE_TO_THIS;
-        }
-        else if (visibility == Visibilities.PROTECTED) {
-            return ProtoBuf.Visibility.PROTECTED;
-        }
-        else if (visibility == Visibilities.LOCAL) {
-            return ProtoBuf.Visibility.LOCAL;
-        }
-        throw new IllegalArgumentException("Unknown visibility: " + visibility);
-    }
-
-    @NotNull
-    private static ProtoBuf.Modality modality(@NotNull Modality modality) {
-        switch (modality) {
-            case FINAL:
-                return ProtoBuf.Modality.FINAL;
-            case OPEN:
-                return ProtoBuf.Modality.OPEN;
-            case ABSTRACT:
-                return ProtoBuf.Modality.ABSTRACT;
-            case SEALED:
-                return ProtoBuf.Modality.SEALED;
-        }
-        throw new IllegalArgumentException("Unknown modality: " + modality);
-    }
-
-    @NotNull
-    private static ProtoBuf.MemberKind memberKind(@NotNull CallableMemberDescriptor.Kind kind) {
-        switch (kind) {
-            case DECLARATION:
-                return ProtoBuf.MemberKind.DECLARATION;
-            case FAKE_OVERRIDE:
-                return ProtoBuf.MemberKind.FAKE_OVERRIDE;
-            case DELEGATION:
-                return ProtoBuf.MemberKind.DELEGATION;
-            case SYNTHESIZED:
-                return ProtoBuf.MemberKind.SYNTHESIZED;
-        }
-        throw new IllegalArgumentException("Unknown member kind: " + kind);
-    }
-
    public static int getValueParameterFlags(
            boolean hasAnnotations,
            boolean declaresDefaultValue,
@@ -285,12 +207,12 @@ public class Flags {
               | DECLARES_DEFAULT_VALUE.toFlags(declaresDefaultValue)
               | IS_CROSSINLINE.toFlags(isCrossinline)
               | IS_NOINLINE.toFlags(isNoinline)
-               ;
+                ;
    }

-    public static int getTypeAliasFlags(boolean hasAnnotations, Visibility visibility) {
+    public static int getTypeAliasFlags(boolean hasAnnotations, ProtoBuf.Visibility visibility) {
        return HAS_ANNOTATIONS.toFlags(hasAnnotations)
-                | VISIBILITY.toFlags(visibility(visibility))
+               | VISIBILITY.toFlags(visibility)
                ;
    }

@@ -16,10 +16,7 @@

 package org.jetbrains.kotlin.serialization.deserialization

-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.ProtoBuf.TypeParameter
 import org.jetbrains.kotlin.types.Variance
@@ -33,6 +30,13 @@ object ProtoEnumFlags {
        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
@@ -41,6 +45,13 @@ object ProtoEnumFlags {
        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 -> Visibilities.INTERNAL
        ProtoBuf.Visibility.PRIVATE -> Visibilities.PRIVATE
@@ -51,6 +62,16 @@ object ProtoEnumFlags {
        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.PRIVATE_TO_THIS -> 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
@@ -61,17 +82,30 @@ object ProtoEnumFlags {
        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(variance: ProtoBuf.Type.Argument.Projection) = when (variance) {
+    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: $variance")
+            throw IllegalArgumentException("Only IN, OUT and INV are supported. Actual argument: $projection")
    }
 }
@@ -201,11 +201,11 @@ class TypeDeserializer(
                StarProjectionImpl(parameter)
        }

-        val variance = ProtoEnumFlags.variance(typeArgumentProto.projection)
+        val projection = ProtoEnumFlags.variance(typeArgumentProto.projection)
        val type = typeArgumentProto.type(c.typeTable) ?:
                return TypeProjectionImpl(ErrorUtils.createErrorType("No type recorded"))

-        return TypeProjectionImpl(variance, type(type))
+        return TypeProjectionImpl(projection, type(type))
    }

    override fun toString() = debugName + (if (parent == null) "" else ". Child of ${parent.debugName}")