From 8d2e89a9eab911f05f16fd926e36deabbed4a04c Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Sep 2020 11:59:24 +0300 Subject: [PATCH] Move ProtoEnumFlags to :core:metadata --- .../incremental/protoDifferenceUtils.kt | 3 +- .../deserialization/ClassDeserialization.kt | 2 +- .../deserialization/FirMemberDeserializer.kt | 12 +- .../fir/deserialization/FirProtoEnumFlags.kt | 32 ----- .../deserialization/ProtoEnumFlagsUtils.kt | 19 +++ .../fir/serialization/FirElementSerializer.kt | 34 ++--- .../serialization/encodings/BinaryFlags.kt | 24 ++-- .../serialization/DescriptorSerializer.kt | 16 +-- .../deserialization/MemberDeserializer.kt | 12 +- .../deserialization/ProtoEnumFlags.kt | 117 ------------------ .../deserialization/ProtoEnumFlagsUtils.kt | 50 ++++++++ .../DeserializedClassDescriptor.kt | 2 +- core/metadata/build.gradle.kts | 3 +- .../deserialization/ProtoEnumFlags.kt | 91 ++++++++++++++ 14 files changed, 209 insertions(+), 208 deletions(-) delete mode 100644 compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirProtoEnumFlags.kt create mode 100644 compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ProtoEnumFlagsUtils.kt delete mode 100644 core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt create mode 100644 core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlagsUtils.kt create mode 100644 core/metadata/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt diff --git a/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt b/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt index cff64826e5d..9b84e4857fb 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt +++ b/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) diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt index 1bcdd370fd5..91fd1fd3e0a 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt +++ b/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) diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt index 3f0550f7fd2..ba49fc9df28 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt +++ b/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 diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirProtoEnumFlags.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirProtoEnumFlags.kt deleted file mode 100644 index fe884f98a30..00000000000 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirProtoEnumFlags.kt +++ /dev/null @@ -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") - } -} diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ProtoEnumFlagsUtils.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ProtoEnumFlagsUtils.kt new file mode 100644 index 00000000000..0c1f59e6a4e --- /dev/null +++ b/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") +} + diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt index f938acc93e6..c0c14cd706d 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt +++ b/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") - } } } diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/encodings/BinaryFlags.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/encodings/BinaryFlags.kt index 7d1497b2bfc..827109d4da2 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/encodings/BinaryFlags.kt +++ b/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() } } diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index 5a886cccaf2..ac7b522f635 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/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, diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt index bdb5a746c01..b21b64cc72e 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt +++ b/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, 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 diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt deleted file mode 100644 index e0b1af23f24..00000000000 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt +++ /dev/null @@ -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 - } -} diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlagsUtils.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlagsUtils.kt new file mode 100644 index 00000000000..048fa668486 --- /dev/null +++ b/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") +} diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index 367c64998ef..647f996059e 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/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( diff --git a/core/metadata/build.gradle.kts b/core/metadata/build.gradle.kts index adc8d805c07..c1f1f6245b6 100644 --- a/core/metadata/build.gradle.kts +++ b/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 { diff --git a/core/metadata/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt b/core/metadata/src/org/jetbrains/kotlin/serialization/deserialization/ProtoEnumFlags.kt new file mode 100644 index 00000000000..28cbd446ff2 --- /dev/null +++ b/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 + } +}