diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index 0d6bc20c253..838732ed865 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt @@ -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 diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java index 14e730250a1..5280bad560e 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java @@ -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) ; } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt index e5052bf00d4..ce3107d8a58 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt @@ -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") } } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt index 0d8ff26b3cc..f11565e58e6 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/TypeDeserializer.kt @@ -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}")