From 3e2eb8c1a0a4374500e18d6eac8834774c233a04 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 10 Dec 2015 15:26:00 +0300 Subject: [PATCH] Serialize/deserialize annotations on enum entries #KT-10338 Fixed --- .../serialization/DescriptorSerializer.java | 11 +- .../serialization/SerializerExtension.java | 3 + .../serialization/SerializerExtensionBase.kt | 6 + .../builtinsSerializer/annotatedEnumEntry.kt | 14 + .../builtinsSerializer/annotatedEnumEntry.txt | 32 + .../kotlin/serialization/DebugProtoBuf.java | 1049 +++++++++++++++-- .../builtins/BuiltInsSerializerTest.kt | 4 + .../builtins/DebugBuiltInsProtoBuf.java | 44 +- .../serialization/js/DebugJsProtoBuf.java | 44 +- .../js/KotlinJavascriptSerializerTest.kt | 4 + .../jetbrains/kotlin/load/java/JvmAbi.java | 2 +- ...tBinaryClassAnnotationAndConstantLoader.kt | 13 +- .../builtins/BuiltInSerializerProtocol.kt | 4 +- core/deserialization/src/builtins.proto | 4 + core/deserialization/src/descriptors.proto | 10 +- .../kotlin/serialization/ProtoBuf.java | 691 ++++++++++- .../SerializerExtensionProtocol.kt | 1 + .../builtins/BuiltInsProtoBuf.java | 16 + .../AnnotationAndConstantLoader.java | 6 + .../AnnotationAndConstantLoaderImpl.kt | 8 + .../DeserializedClassDescriptor.kt | 59 +- .../AnnotationLoaderForStubBuilderImpl.kt | 5 + .../stubBuilder/ClassClsStubBuilder.kt | 2 +- .../jps/incremental/IncrementalCacheImpl.kt | 2 +- .../jps/incremental/ProtoCompareGenerated.kt | 42 +- .../jps/incremental/protoDifferenceUtils.kt | 4 +- js/js.serializer/src/js.proto | 4 + .../kotlin/serialization/js/JsProtoBuf.java | 16 + .../js/KotlinJavascriptSerializerExtension.kt | 5 +- 29 files changed, 1845 insertions(+), 260 deletions(-) create mode 100644 compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.kt create mode 100644 compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.txt diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java index 360d93c1781..61bf8a6af2f 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java @@ -174,7 +174,8 @@ public class DescriptorSerializer { for (DeclarationDescriptor descriptor : sort(DescriptorUtils.getAllDescriptors(classDescriptor.getUnsubstitutedInnerClassesScope()))) { int name = getSimpleNameIndex(descriptor.getName()); if (isEnumEntry(descriptor)) { - builder.addEnumEntry(name); + builder.addEnumEntryName(name); + builder.addEnumEntry(enumEntryProto((ClassDescriptor) descriptor)); } else { builder.addNestedClassName(name); @@ -357,6 +358,14 @@ public class DescriptorSerializer { return builder; } + @NotNull + public ProtoBuf.EnumEntry.Builder enumEntryProto(@NotNull ClassDescriptor descriptor) { + ProtoBuf.EnumEntry.Builder builder = ProtoBuf.EnumEntry.newBuilder(); + builder.setName(getSimpleNameIndex(descriptor.getName())); + extension.serializeEnumEntry(descriptor, builder); + return builder; + } + private static int getAccessorFlags(@NotNull PropertyAccessorDescriptor accessor) { return Flags.getAccessorFlags( hasAnnotations(accessor), diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java index 29f4743e46e..5e1ad776be7 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.java @@ -45,6 +45,9 @@ public abstract class SerializerExtension { public void serializeProperty(@NotNull PropertyDescriptor descriptor, @NotNull ProtoBuf.Property.Builder proto) { } + public void serializeEnumEntry(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.EnumEntry.Builder proto) { + } + public void serializeValueParameter(@NotNull ValueParameterDescriptor descriptor, @NotNull ProtoBuf.ValueParameter.Builder proto) { } diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt index 9767d051e64..197dd6acd17 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionBase.kt @@ -54,6 +54,12 @@ public open class KotlinSerializerExtensionBase(private val protocol: Serializer } } + override fun serializeEnumEntry(descriptor: ClassDescriptor, proto: ProtoBuf.EnumEntry.Builder) { + for (annotation in descriptor.annotations) { + proto.addExtension(protocol.enumEntryAnnotation, annotationSerializer.serializeAnnotation(annotation)) + } + } + override fun serializeValueParameter(descriptor: ValueParameterDescriptor, proto: ProtoBuf.ValueParameter.Builder) { for (annotation in descriptor.annotations) { proto.addExtension(protocol.parameterAnnotation, annotationSerializer.serializeAnnotation(annotation)) diff --git a/compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.kt b/compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.kt new file mode 100644 index 00000000000..68698caec13 --- /dev/null +++ b/compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.kt @@ -0,0 +1,14 @@ +package test + +annotation class Anno(val value: String = "0", val x: Int = 0) +annotation class Bnno + +enum class Eee { + @Anno() + Entry1, + Entry2, + @Anno("3") @Bnno + Entry3, + @Anno("4", 4) + Entry4, +} diff --git a/compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.txt b/compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.txt new file mode 100644 index 00000000000..6dc12c5bea5 --- /dev/null +++ b/compiler/testData/serialization/builtinsSerializer/annotatedEnumEntry.txt @@ -0,0 +1,32 @@ +package test + +public final annotation class Anno : kotlin.Annotation { + public constructor Anno(/*0*/ value: kotlin.String = ..., /*1*/ x: kotlin.Int = ...) + public final val value: kotlin.String + public final val x: kotlin.Int +} + +public final annotation class Bnno : kotlin.Annotation { + public constructor Bnno() +} + +public final enum class Eee : kotlin.Enum { + @test.Anno() enum entry Entry1 + + enum entry Entry2 + + @test.Anno(value = "3") @test.Bnno() enum entry Entry3 + + @test.Anno(value = "4", x = 4) enum entry Entry4 + + private constructor Eee() + public final override /*1*/ /*fake_override*/ val name: kotlin.String + public final override /*1*/ /*fake_override*/ val ordinal: kotlin.Int + protected final override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Eee): kotlin.Int + + // Static members + @kotlin.Deprecated(level = DeprecationLevel.ERROR, message = "Use 'values()' function instead", replaceWith = kotlin.ReplaceWith(expression = "this.values()", imports = {})) public final /*synthesized*/ val values: kotlin.Array + public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): test.Eee + public final /*synthesized*/ fun values(): kotlin.Array +} diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java b/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java index 048b6019aaf..a7c47973864 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java +++ b/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java @@ -9492,19 +9492,44 @@ public final class DebugProtoBuf { org.jetbrains.kotlin.serialization.DebugProtoBuf.PropertyOrBuilder getPropertyOrBuilder( int index); - // repeated int32 enum_entry = 12 [packed = true]; + // repeated int32 enum_entry_name = 12 [packed = true]; /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - java.util.List getEnumEntryList(); + java.util.List getEnumEntryNameList(); /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + int getEnumEntryNameCount(); + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + int getEnumEntryName(int index); + + // repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + java.util.List + getEnumEntryList(); + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry getEnumEntry(int index); + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ int getEnumEntryCount(); /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ - int getEnumEntry(int index); + java.util.List + getEnumEntryOrBuilderList(); + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntryOrBuilder getEnumEntryOrBuilder( + int index); // optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; /** @@ -9670,25 +9695,33 @@ public final class DebugProtoBuf { } case 96: { if (!((mutable_bitField0_ & 0x00000400) == 0x00000400)) { - enumEntry_ = new java.util.ArrayList(); + enumEntryName_ = new java.util.ArrayList(); mutable_bitField0_ |= 0x00000400; } - enumEntry_.add(input.readInt32()); + enumEntryName_.add(input.readInt32()); break; } case 98: { int length = input.readRawVarint32(); int limit = input.pushLimit(length); if (!((mutable_bitField0_ & 0x00000400) == 0x00000400) && input.getBytesUntilLimit() > 0) { - enumEntry_ = new java.util.ArrayList(); + enumEntryName_ = new java.util.ArrayList(); mutable_bitField0_ |= 0x00000400; } while (input.getBytesUntilLimit() > 0) { - enumEntry_.add(input.readInt32()); + enumEntryName_.add(input.readInt32()); } input.popLimit(limit); break; } + case 106: { + if (!((mutable_bitField0_ & 0x00000800) == 0x00000800)) { + enumEntry_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000800; + } + enumEntry_.add(input.readMessage(org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.PARSER, extensionRegistry)); + break; + } case 242: { org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable.Builder subBuilder = null; if (((bitField0_ & 0x00000008) == 0x00000008)) { @@ -9732,6 +9765,9 @@ public final class DebugProtoBuf { property_ = java.util.Collections.unmodifiableList(property_); } if (((mutable_bitField0_ & 0x00000400) == 0x00000400)) { + enumEntryName_ = java.util.Collections.unmodifiableList(enumEntryName_); + } + if (((mutable_bitField0_ & 0x00000800) == 0x00000800)) { enumEntry_ = java.util.Collections.unmodifiableList(enumEntry_); } this.unknownFields = unknownFields.build(); @@ -10197,29 +10233,65 @@ public final class DebugProtoBuf { return property_.get(index); } - // repeated int32 enum_entry = 12 [packed = true]; - public static final int ENUM_ENTRY_FIELD_NUMBER = 12; - private java.util.List enumEntry_; + // repeated int32 enum_entry_name = 12 [packed = true]; + public static final int ENUM_ENTRY_NAME_FIELD_NUMBER = 12; + private java.util.List enumEntryName_; /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ public java.util.List - getEnumEntryList() { + getEnumEntryNameList() { + return enumEntryName_; + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public int getEnumEntryNameCount() { + return enumEntryName_.size(); + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public int getEnumEntryName(int index) { + return enumEntryName_.get(index); + } + private int enumEntryNameMemoizedSerializedSize = -1; + + // repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + public static final int ENUM_ENTRY_FIELD_NUMBER = 13; + private java.util.List enumEntry_; + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List getEnumEntryList() { return enumEntry_; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List + getEnumEntryOrBuilderList() { + return enumEntry_; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ public int getEnumEntryCount() { return enumEntry_.size(); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ - public int getEnumEntry(int index) { + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry getEnumEntry(int index) { + return enumEntry_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntryOrBuilder getEnumEntryOrBuilder( + int index) { return enumEntry_.get(index); } - private int enumEntryMemoizedSerializedSize = -1; // optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; public static final int TYPE_TABLE_FIELD_NUMBER = 30; @@ -10254,6 +10326,7 @@ public final class DebugProtoBuf { constructor_ = java.util.Collections.emptyList(); function_ = java.util.Collections.emptyList(); property_ = java.util.Collections.emptyList(); + enumEntryName_ = java.util.Collections.emptyList(); enumEntry_ = java.util.Collections.emptyList(); typeTable_ = org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable.getDefaultInstance(); } @@ -10296,6 +10369,12 @@ public final class DebugProtoBuf { return false; } } + for (int i = 0; i < getEnumEntryCount(); i++) { + if (!getEnumEntry(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } if (hasTypeTable()) { if (!getTypeTable().isInitialized()) { memoizedIsInitialized = 0; @@ -10354,12 +10433,15 @@ public final class DebugProtoBuf { for (int i = 0; i < property_.size(); i++) { output.writeMessage(10, property_.get(i)); } - if (getEnumEntryList().size() > 0) { + if (getEnumEntryNameList().size() > 0) { output.writeRawVarint32(98); - output.writeRawVarint32(enumEntryMemoizedSerializedSize); + output.writeRawVarint32(enumEntryNameMemoizedSerializedSize); + } + for (int i = 0; i < enumEntryName_.size(); i++) { + output.writeInt32NoTag(enumEntryName_.get(i)); } for (int i = 0; i < enumEntry_.size(); i++) { - output.writeInt32NoTag(enumEntry_.get(i)); + output.writeMessage(13, enumEntry_.get(i)); } if (((bitField0_ & 0x00000008) == 0x00000008)) { output.writeMessage(30, typeTable_); @@ -10436,17 +10518,21 @@ public final class DebugProtoBuf { } { int dataSize = 0; - for (int i = 0; i < enumEntry_.size(); i++) { + for (int i = 0; i < enumEntryName_.size(); i++) { dataSize += com.google.protobuf.CodedOutputStream - .computeInt32SizeNoTag(enumEntry_.get(i)); + .computeInt32SizeNoTag(enumEntryName_.get(i)); } size += dataSize; - if (!getEnumEntryList().isEmpty()) { + if (!getEnumEntryNameList().isEmpty()) { size += 1; size += com.google.protobuf.CodedOutputStream .computeInt32SizeNoTag(dataSize); } - enumEntryMemoizedSerializedSize = dataSize; + enumEntryNameMemoizedSerializedSize = dataSize; + } + for (int i = 0; i < enumEntry_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(13, enumEntry_.get(i)); } if (((bitField0_ & 0x00000008) == 0x00000008)) { size += com.google.protobuf.CodedOutputStream @@ -10566,6 +10652,7 @@ public final class DebugProtoBuf { getConstructorFieldBuilder(); getFunctionFieldBuilder(); getPropertyFieldBuilder(); + getEnumEntryFieldBuilder(); getTypeTableFieldBuilder(); } } @@ -10615,14 +10702,20 @@ public final class DebugProtoBuf { } else { propertyBuilder_.clear(); } - enumEntry_ = java.util.Collections.emptyList(); + enumEntryName_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000400); + if (enumEntryBuilder_ == null) { + enumEntry_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000800); + } else { + enumEntryBuilder_.clear(); + } if (typeTableBuilder_ == null) { typeTable_ = org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable.getDefaultInstance(); } else { typeTableBuilder_.clear(); } - bitField0_ = (bitField0_ & ~0x00000800); + bitField0_ = (bitField0_ & ~0x00001000); return this; } @@ -10719,11 +10812,20 @@ public final class DebugProtoBuf { result.property_ = propertyBuilder_.build(); } if (((bitField0_ & 0x00000400) == 0x00000400)) { - enumEntry_ = java.util.Collections.unmodifiableList(enumEntry_); + enumEntryName_ = java.util.Collections.unmodifiableList(enumEntryName_); bitField0_ = (bitField0_ & ~0x00000400); } - result.enumEntry_ = enumEntry_; - if (((from_bitField0_ & 0x00000800) == 0x00000800)) { + result.enumEntryName_ = enumEntryName_; + if (enumEntryBuilder_ == null) { + if (((bitField0_ & 0x00000800) == 0x00000800)) { + enumEntry_ = java.util.Collections.unmodifiableList(enumEntry_); + bitField0_ = (bitField0_ & ~0x00000800); + } + result.enumEntry_ = enumEntry_; + } else { + result.enumEntry_ = enumEntryBuilder_.build(); + } + if (((from_bitField0_ & 0x00001000) == 0x00001000)) { to_bitField0_ |= 0x00000008; } if (typeTableBuilder_ == null) { @@ -10906,16 +11008,42 @@ public final class DebugProtoBuf { } } } - if (!other.enumEntry_.isEmpty()) { - if (enumEntry_.isEmpty()) { - enumEntry_ = other.enumEntry_; + if (!other.enumEntryName_.isEmpty()) { + if (enumEntryName_.isEmpty()) { + enumEntryName_ = other.enumEntryName_; bitField0_ = (bitField0_ & ~0x00000400); } else { - ensureEnumEntryIsMutable(); - enumEntry_.addAll(other.enumEntry_); + ensureEnumEntryNameIsMutable(); + enumEntryName_.addAll(other.enumEntryName_); } onChanged(); } + if (enumEntryBuilder_ == null) { + if (!other.enumEntry_.isEmpty()) { + if (enumEntry_.isEmpty()) { + enumEntry_ = other.enumEntry_; + bitField0_ = (bitField0_ & ~0x00000800); + } else { + ensureEnumEntryIsMutable(); + enumEntry_.addAll(other.enumEntry_); + } + onChanged(); + } + } else { + if (!other.enumEntry_.isEmpty()) { + if (enumEntryBuilder_.isEmpty()) { + enumEntryBuilder_.dispose(); + enumEntryBuilder_ = null; + enumEntry_ = other.enumEntry_; + bitField0_ = (bitField0_ & ~0x00000800); + enumEntryBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getEnumEntryFieldBuilder() : null; + } else { + enumEntryBuilder_.addAllMessages(other.enumEntry_); + } + } + } if (other.hasTypeTable()) { mergeTypeTable(other.getTypeTable()); } @@ -10959,6 +11087,12 @@ public final class DebugProtoBuf { return false; } } + for (int i = 0; i < getEnumEntryCount(); i++) { + if (!getEnumEntry(i).isInitialized()) { + + return false; + } + } if (hasTypeTable()) { if (!getTypeTable().isInitialized()) { @@ -12462,72 +12596,312 @@ public final class DebugProtoBuf { return propertyBuilder_; } - // repeated int32 enum_entry = 12 [packed = true]; - private java.util.List enumEntry_ = java.util.Collections.emptyList(); - private void ensureEnumEntryIsMutable() { + // repeated int32 enum_entry_name = 12 [packed = true]; + private java.util.List enumEntryName_ = java.util.Collections.emptyList(); + private void ensureEnumEntryNameIsMutable() { if (!((bitField0_ & 0x00000400) == 0x00000400)) { - enumEntry_ = new java.util.ArrayList(enumEntry_); + enumEntryName_ = new java.util.ArrayList(enumEntryName_); bitField0_ |= 0x00000400; } } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ public java.util.List - getEnumEntryList() { - return java.util.Collections.unmodifiableList(enumEntry_); + getEnumEntryNameList() { + return java.util.Collections.unmodifiableList(enumEntryName_); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - public int getEnumEntryCount() { - return enumEntry_.size(); + public int getEnumEntryNameCount() { + return enumEntryName_.size(); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - public int getEnumEntry(int index) { - return enumEntry_.get(index); + public int getEnumEntryName(int index) { + return enumEntryName_.get(index); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - public Builder setEnumEntry( + public Builder setEnumEntryName( int index, int value) { - ensureEnumEntryIsMutable(); - enumEntry_.set(index, value); + ensureEnumEntryNameIsMutable(); + enumEntryName_.set(index, value); onChanged(); return this; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - public Builder addEnumEntry(int value) { - ensureEnumEntryIsMutable(); - enumEntry_.add(value); + public Builder addEnumEntryName(int value) { + ensureEnumEntryNameIsMutable(); + enumEntryName_.add(value); onChanged(); return this; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - public Builder addAllEnumEntry( + public Builder addAllEnumEntryName( java.lang.Iterable values) { - ensureEnumEntryIsMutable(); - super.addAll(values, enumEntry_); + ensureEnumEntryNameIsMutable(); + super.addAll(values, enumEntryName_); onChanged(); return this; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - public Builder clearEnumEntry() { - enumEntry_ = java.util.Collections.emptyList(); + public Builder clearEnumEntryName() { + enumEntryName_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000400); onChanged(); return this; } + // repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + private java.util.List enumEntry_ = + java.util.Collections.emptyList(); + private void ensureEnumEntryIsMutable() { + if (!((bitField0_ & 0x00000800) == 0x00000800)) { + enumEntry_ = new java.util.ArrayList(enumEntry_); + bitField0_ |= 0x00000800; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntryOrBuilder> enumEntryBuilder_; + + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List getEnumEntryList() { + if (enumEntryBuilder_ == null) { + return java.util.Collections.unmodifiableList(enumEntry_); + } else { + return enumEntryBuilder_.getMessageList(); + } + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public int getEnumEntryCount() { + if (enumEntryBuilder_ == null) { + return enumEntry_.size(); + } else { + return enumEntryBuilder_.getCount(); + } + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry getEnumEntry(int index) { + if (enumEntryBuilder_ == null) { + return enumEntry_.get(index); + } else { + return enumEntryBuilder_.getMessage(index); + } + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder setEnumEntry( + int index, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry value) { + if (enumEntryBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureEnumEntryIsMutable(); + enumEntry_.set(index, value); + onChanged(); + } else { + enumEntryBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder setEnumEntry( + int index, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder builderForValue) { + if (enumEntryBuilder_ == null) { + ensureEnumEntryIsMutable(); + enumEntry_.set(index, builderForValue.build()); + onChanged(); + } else { + enumEntryBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry(org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry value) { + if (enumEntryBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureEnumEntryIsMutable(); + enumEntry_.add(value); + onChanged(); + } else { + enumEntryBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry( + int index, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry value) { + if (enumEntryBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureEnumEntryIsMutable(); + enumEntry_.add(index, value); + onChanged(); + } else { + enumEntryBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry( + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder builderForValue) { + if (enumEntryBuilder_ == null) { + ensureEnumEntryIsMutable(); + enumEntry_.add(builderForValue.build()); + onChanged(); + } else { + enumEntryBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry( + int index, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder builderForValue) { + if (enumEntryBuilder_ == null) { + ensureEnumEntryIsMutable(); + enumEntry_.add(index, builderForValue.build()); + onChanged(); + } else { + enumEntryBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addAllEnumEntry( + java.lang.Iterable values) { + if (enumEntryBuilder_ == null) { + ensureEnumEntryIsMutable(); + super.addAll(values, enumEntry_); + onChanged(); + } else { + enumEntryBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder clearEnumEntry() { + if (enumEntryBuilder_ == null) { + enumEntry_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000800); + onChanged(); + } else { + enumEntryBuilder_.clear(); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder removeEnumEntry(int index) { + if (enumEntryBuilder_ == null) { + ensureEnumEntryIsMutable(); + enumEntry_.remove(index); + onChanged(); + } else { + enumEntryBuilder_.remove(index); + } + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder getEnumEntryBuilder( + int index) { + return getEnumEntryFieldBuilder().getBuilder(index); + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntryOrBuilder getEnumEntryOrBuilder( + int index) { + if (enumEntryBuilder_ == null) { + return enumEntry_.get(index); } else { + return enumEntryBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List + getEnumEntryOrBuilderList() { + if (enumEntryBuilder_ != null) { + return enumEntryBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(enumEntry_); + } + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder addEnumEntryBuilder() { + return getEnumEntryFieldBuilder().addBuilder( + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.getDefaultInstance()); + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder addEnumEntryBuilder( + int index) { + return getEnumEntryFieldBuilder().addBuilder( + index, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.getDefaultInstance()); + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List + getEnumEntryBuilderList() { + return getEnumEntryFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntryOrBuilder> + getEnumEntryFieldBuilder() { + if (enumEntryBuilder_ == null) { + enumEntryBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntryOrBuilder>( + enumEntry_, + ((bitField0_ & 0x00000800) == 0x00000800), + getParentForChildren(), + isClean()); + enumEntry_ = null; + } + return enumEntryBuilder_; + } + // optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; private org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable typeTable_ = org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable.getDefaultInstance(); private com.google.protobuf.SingleFieldBuilder< @@ -12536,7 +12910,7 @@ public final class DebugProtoBuf { * optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; */ public boolean hasTypeTable() { - return ((bitField0_ & 0x00000800) == 0x00000800); + return ((bitField0_ & 0x00001000) == 0x00001000); } /** * optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; @@ -12561,7 +12935,7 @@ public final class DebugProtoBuf { } else { typeTableBuilder_.setMessage(value); } - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return this; } /** @@ -12575,7 +12949,7 @@ public final class DebugProtoBuf { } else { typeTableBuilder_.setMessage(builderForValue.build()); } - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return this; } /** @@ -12583,7 +12957,7 @@ public final class DebugProtoBuf { */ public Builder mergeTypeTable(org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable value) { if (typeTableBuilder_ == null) { - if (((bitField0_ & 0x00000800) == 0x00000800) && + if (((bitField0_ & 0x00001000) == 0x00001000) && typeTable_ != org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable.getDefaultInstance()) { typeTable_ = org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable.newBuilder(typeTable_).mergeFrom(value).buildPartial(); @@ -12594,7 +12968,7 @@ public final class DebugProtoBuf { } else { typeTableBuilder_.mergeFrom(value); } - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return this; } /** @@ -12607,14 +12981,14 @@ public final class DebugProtoBuf { } else { typeTableBuilder_.clear(); } - bitField0_ = (bitField0_ & ~0x00000800); + bitField0_ = (bitField0_ & ~0x00001000); return this; } /** * optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; */ public org.jetbrains.kotlin.serialization.DebugProtoBuf.TypeTable.Builder getTypeTableBuilder() { - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; onChanged(); return getTypeTableFieldBuilder().getBuilder(); } @@ -20843,6 +21217,417 @@ public final class DebugProtoBuf { // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.ValueParameter) } + public interface EnumEntryOrBuilder extends + com.google.protobuf.GeneratedMessage. + ExtendableMessageOrBuilder { + + // optional int32 name = 1; + /** + * optional int32 name = 1; + */ + boolean hasName(); + /** + * optional int32 name = 1; + */ + int getName(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.serialization.EnumEntry} + */ + public static final class EnumEntry extends + com.google.protobuf.GeneratedMessage.ExtendableMessage< + EnumEntry> implements EnumEntryOrBuilder { + // Use EnumEntry.newBuilder() to construct. + private EnumEntry(com.google.protobuf.GeneratedMessage.ExtendableBuilder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private EnumEntry(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final EnumEntry defaultInstance; + public static EnumEntry getDefaultInstance() { + return defaultInstance; + } + + public EnumEntry getDefaultInstanceForType() { + return defaultInstance; + } + + private final com.google.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private EnumEntry( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + name_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.jetbrains.kotlin.serialization.DebugProtoBuf.internal_static_org_jetbrains_kotlin_serialization_EnumEntry_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.jetbrains.kotlin.serialization.DebugProtoBuf.internal_static_org_jetbrains_kotlin_serialization_EnumEntry_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.class, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder.class); + } + + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public EnumEntry parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new EnumEntry(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // optional int32 name = 1; + public static final int NAME_FIELD_NUMBER = 1; + private int name_; + /** + * optional int32 name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional int32 name = 1; + */ + public int getName() { + return name_; + } + + private void initFields() { + name_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!extensionsAreInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + com.google.protobuf.GeneratedMessage + .ExtendableMessage.ExtensionWriter extensionWriter = + newExtensionWriter(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, name_); + } + extensionWriter.writeUntil(200, output); + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, name_); + } + size += extensionsSerializedSize(); + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code org.jetbrains.kotlin.serialization.EnumEntry} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessage.ExtendableBuilder< + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry, Builder> implements org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntryOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.jetbrains.kotlin.serialization.DebugProtoBuf.internal_static_org_jetbrains_kotlin_serialization_EnumEntry_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.jetbrains.kotlin.serialization.DebugProtoBuf.internal_static_org_jetbrains_kotlin_serialization_EnumEntry_fieldAccessorTable + .ensureFieldAccessorsInitialized( + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.class, org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.Builder.class); + } + + // Construct using org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.jetbrains.kotlin.serialization.DebugProtoBuf.internal_static_org_jetbrains_kotlin_serialization_EnumEntry_descriptor; + } + + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry getDefaultInstanceForType() { + return org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry build() { + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry buildPartial() { + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry result = new org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry) { + return mergeFrom((org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry other) { + if (other == org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry.getDefaultInstance()) return this; + if (other.hasName()) { + setName(other.getName()); + } + this.mergeExtensionFields(other); + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!extensionsAreInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional int32 name = 1; + private int name_ ; + /** + * optional int32 name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional int32 name = 1; + */ + public int getName() { + return name_; + } + /** + * optional int32 name = 1; + */ + public Builder setName(int value) { + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + /** + * optional int32 name = 1; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = 0; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.serialization.EnumEntry) + } + + static { + defaultInstance = new EnumEntry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.EnumEntry) + } + private static com.google.protobuf.Descriptors.Descriptor internal_static_org_jetbrains_kotlin_serialization_StringTable_descriptor; private static @@ -20923,6 +21708,11 @@ public final class DebugProtoBuf { private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_jetbrains_kotlin_serialization_ValueParameter_fieldAccessorTable; + private static com.google.protobuf.Descriptors.Descriptor + internal_static_org_jetbrains_kotlin_serialization_EnumEntry_descriptor; + private static + com.google.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_org_jetbrains_kotlin_serialization_EnumEntry_fieldAccessorTable; public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() { @@ -20987,7 +21777,7 @@ public final class DebugProtoBuf { "per_bound\030\005 \003(\0132(.org.jetbrains.kotlin.s" + "erialization.Type\022\026\n\016upper_bound_id\030\006 \003(" + "\005\"$\n\010Variance\022\006\n\002IN\020\000\022\007\n\003OUT\020\001\022\007\n\003INV\020\002*" + - "\005\010d\020\350\007\"\300\005\n\005Class\022\020\n\005flags\030\001 \001(\005:\0016\022\025\n\007fq" + + "\005\010d\020\350\007\"\210\006\n\005Class\022\020\n\005flags\030\001 \001(\005:\0016\022\025\n\007fq" + "_name\030\003 \002(\005B\004\220\265\030\001\022#\n\025companion_object_na" + "me\030\004 \001(\005B\004\210\265\030\001\022I\n\016type_parameter\030\005 \003(\01321" + ".org.jetbrains.kotlin.serialization.Type" + @@ -20999,58 +21789,61 @@ public final class DebugProtoBuf { "r\022>\n\010function\030\t \003(\0132,.org.jetbrains.kotl" + "in.serialization.Function\022>\n\010property\030\n " + "\003(\0132,.org.jetbrains.kotlin.serialization" + - ".Property\022\032\n\nenum_entry\030\014 \003(\005B\006\020\001\210\265\030\001\022A\n" + - "\ntype_table\030\036 \001(\0132-.org.jetbrains.kotlin" + - ".serialization.TypeTable\"x\n\004Kind\022\t\n\005CLAS", - "S\020\000\022\r\n\tINTERFACE\020\001\022\016\n\nENUM_CLASS\020\002\022\016\n\nEN" + - "UM_ENTRY\020\003\022\024\n\020ANNOTATION_CLASS\020\004\022\n\n\006OBJE" + - "CT\020\005\022\024\n\020COMPANION_OBJECT\020\006*\005\010d\020\310\001\"\323\001\n\007Pa" + - "ckage\022>\n\010function\030\003 \003(\0132,.org.jetbrains." + - "kotlin.serialization.Function\022>\n\010propert" + - "y\030\004 \003(\0132,.org.jetbrains.kotlin.serializa" + - "tion.Property\022A\n\ntype_table\030\036 \001(\0132-.org." + - "jetbrains.kotlin.serialization.TypeTable" + - "*\005\010d\020\310\001\"_\n\tTypeTable\0226\n\004type\030\001 \003(\0132(.org" + - ".jetbrains.kotlin.serialization.Type\022\032\n\016", - "first_nullable\030\002 \001(\005:\002-1\"s\n\013Constructor\022" + - "\020\n\005flags\030\001 \001(\005:\0016\022K\n\017value_parameter\030\002 \003" + - "(\01322.org.jetbrains.kotlin.serialization." + - "ValueParameter*\005\010d\020\310\001\"\304\003\n\010Function\022\020\n\005fl" + - "ags\030\001 \001(\005:\0016\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\022=\n\013retu" + - "rn_type\030\003 \001(\0132(.org.jetbrains.kotlin.ser" + - "ialization.Type\022\026\n\016return_type_id\030\007 \001(\005\022" + - "I\n\016type_parameter\030\004 \003(\01321.org.jetbrains." + - "kotlin.serialization.TypeParameter\022?\n\rre" + - "ceiver_type\030\005 \001(\0132(.org.jetbrains.kotlin", - ".serialization.Type\022\030\n\020receiver_type_id\030" + - "\010 \001(\005\022K\n\017value_parameter\030\006 \003(\01322.org.jet" + - "brains.kotlin.serialization.ValueParamet" + - "er\022A\n\ntype_table\030\036 \001(\0132-.org.jetbrains.k" + - "otlin.serialization.TypeTable*\005\010d\020\310\001\"\266\003\n" + - "\010Property\022\022\n\005flags\030\001 \001(\005:\003262\022\022\n\004name\030\002 " + - "\002(\005B\004\210\265\030\001\022=\n\013return_type\030\003 \001(\0132(.org.jet" + - "brains.kotlin.serialization.Type\022\026\n\016retu" + - "rn_type_id\030\t \001(\005\022I\n\016type_parameter\030\004 \003(\013" + - "21.org.jetbrains.kotlin.serialization.Ty", - "peParameter\022?\n\rreceiver_type\030\005 \001(\0132(.org" + - ".jetbrains.kotlin.serialization.Type\022\030\n\020" + - "receiver_type_id\030\n \001(\005\022R\n\026setter_value_p" + - "arameter\030\006 \001(\01322.org.jetbrains.kotlin.se" + - "rialization.ValueParameter\022\024\n\014getter_fla" + - "gs\030\007 \001(\005\022\024\n\014setter_flags\030\010 \001(\005*\005\010d\020\310\001\"\355\001" + - "\n\016ValueParameter\022\020\n\005flags\030\001 \001(\005:\0010\022\022\n\004na" + - "me\030\002 \002(\005B\004\210\265\030\001\0226\n\004type\030\003 \001(\0132(.org.jetbr" + - "ains.kotlin.serialization.Type\022\017\n\007type_i" + - "d\030\005 \001(\005\022E\n\023vararg_element_type\030\004 \001(\0132(.o", - "rg.jetbrains.kotlin.serialization.Type\022\036" + - "\n\026vararg_element_type_id\030\006 \001(\005*\005\010d\020\310\001*9\n" + - "\010Modality\022\t\n\005FINAL\020\000\022\010\n\004OPEN\020\001\022\014\n\010ABSTRA" + - "CT\020\002\022\n\n\006SEALED\020\003*b\n\nVisibility\022\014\n\010INTERN" + - "AL\020\000\022\013\n\007PRIVATE\020\001\022\r\n\tPROTECTED\020\002\022\n\n\006PUBL" + - "IC\020\003\022\023\n\017PRIVATE_TO_THIS\020\004\022\t\n\005LOCAL\020\005*Q\n\n" + - "MemberKind\022\017\n\013DECLARATION\020\000\022\021\n\rFAKE_OVER" + - "RIDE\020\001\022\016\n\nDELEGATION\020\002\022\017\n\013SYNTHESIZED\020\003B" + - "\022B\rDebugProtoBuf\210\001\000" + ".Property\022\037\n\017enum_entry_name\030\014 \003(\005B\006\020\001\210\265" + + "\030\001\022A\n\nenum_entry\030\r \003(\0132-.org.jetbrains.k" + + "otlin.serialization.EnumEntry\022A\n\ntype_ta", + "ble\030\036 \001(\0132-.org.jetbrains.kotlin.seriali" + + "zation.TypeTable\"x\n\004Kind\022\t\n\005CLASS\020\000\022\r\n\tI" + + "NTERFACE\020\001\022\016\n\nENUM_CLASS\020\002\022\016\n\nENUM_ENTRY" + + "\020\003\022\024\n\020ANNOTATION_CLASS\020\004\022\n\n\006OBJECT\020\005\022\024\n\020" + + "COMPANION_OBJECT\020\006*\005\010d\020\310\001\"\323\001\n\007Package\022>\n" + + "\010function\030\003 \003(\0132,.org.jetbrains.kotlin.s" + + "erialization.Function\022>\n\010property\030\004 \003(\0132" + + ",.org.jetbrains.kotlin.serialization.Pro" + + "perty\022A\n\ntype_table\030\036 \001(\0132-.org.jetbrain" + + "s.kotlin.serialization.TypeTable*\005\010d\020\310\001\"", + "_\n\tTypeTable\0226\n\004type\030\001 \003(\0132(.org.jetbrai" + + "ns.kotlin.serialization.Type\022\032\n\016first_nu" + + "llable\030\002 \001(\005:\002-1\"s\n\013Constructor\022\020\n\005flags" + + "\030\001 \001(\005:\0016\022K\n\017value_parameter\030\002 \003(\01322.org" + + ".jetbrains.kotlin.serialization.ValuePar" + + "ameter*\005\010d\020\310\001\"\304\003\n\010Function\022\020\n\005flags\030\001 \001(" + + "\005:\0016\022\022\n\004name\030\002 \002(\005B\004\210\265\030\001\022=\n\013return_type\030" + + "\003 \001(\0132(.org.jetbrains.kotlin.serializati" + + "on.Type\022\026\n\016return_type_id\030\007 \001(\005\022I\n\016type_" + + "parameter\030\004 \003(\01321.org.jetbrains.kotlin.s", + "erialization.TypeParameter\022?\n\rreceiver_t" + + "ype\030\005 \001(\0132(.org.jetbrains.kotlin.seriali" + + "zation.Type\022\030\n\020receiver_type_id\030\010 \001(\005\022K\n" + + "\017value_parameter\030\006 \003(\01322.org.jetbrains.k" + + "otlin.serialization.ValueParameter\022A\n\nty" + + "pe_table\030\036 \001(\0132-.org.jetbrains.kotlin.se" + + "rialization.TypeTable*\005\010d\020\310\001\"\266\003\n\010Propert" + + "y\022\022\n\005flags\030\001 \001(\005:\003262\022\022\n\004name\030\002 \002(\005B\004\210\265\030" + + "\001\022=\n\013return_type\030\003 \001(\0132(.org.jetbrains.k" + + "otlin.serialization.Type\022\026\n\016return_type_", + "id\030\t \001(\005\022I\n\016type_parameter\030\004 \003(\01321.org.j" + + "etbrains.kotlin.serialization.TypeParame" + + "ter\022?\n\rreceiver_type\030\005 \001(\0132(.org.jetbrai" + + "ns.kotlin.serialization.Type\022\030\n\020receiver" + + "_type_id\030\n \001(\005\022R\n\026setter_value_parameter" + + "\030\006 \001(\01322.org.jetbrains.kotlin.serializat" + + "ion.ValueParameter\022\024\n\014getter_flags\030\007 \001(\005" + + "\022\024\n\014setter_flags\030\010 \001(\005*\005\010d\020\310\001\"\355\001\n\016ValueP" + + "arameter\022\020\n\005flags\030\001 \001(\005:\0010\022\022\n\004name\030\002 \002(\005" + + "B\004\210\265\030\001\0226\n\004type\030\003 \001(\0132(.org.jetbrains.kot", + "lin.serialization.Type\022\017\n\007type_id\030\005 \001(\005\022" + + "E\n\023vararg_element_type\030\004 \001(\0132(.org.jetbr" + + "ains.kotlin.serialization.Type\022\036\n\026vararg" + + "_element_type_id\030\006 \001(\005*\005\010d\020\310\001\" \n\tEnumEnt" + + "ry\022\014\n\004name\030\001 \001(\005*\005\010d\020\310\001*9\n\010Modality\022\t\n\005F" + + "INAL\020\000\022\010\n\004OPEN\020\001\022\014\n\010ABSTRACT\020\002\022\n\n\006SEALED" + + "\020\003*b\n\nVisibility\022\014\n\010INTERNAL\020\000\022\013\n\007PRIVAT" + + "E\020\001\022\r\n\tPROTECTED\020\002\022\n\n\006PUBLIC\020\003\022\023\n\017PRIVAT" + + "E_TO_THIS\020\004\022\t\n\005LOCAL\020\005*Q\n\nMemberKind\022\017\n\013" + + "DECLARATION\020\000\022\021\n\rFAKE_OVERRIDE\020\001\022\016\n\nDELE", + "GATION\020\002\022\017\n\013SYNTHESIZED\020\003B\022B\rDebugProtoB" + + "uf\210\001\000" }; com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @@ -21116,7 +21909,7 @@ public final class DebugProtoBuf { internal_static_org_jetbrains_kotlin_serialization_Class_fieldAccessorTable = new com.google.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_org_jetbrains_kotlin_serialization_Class_descriptor, - new java.lang.String[] { "Flags", "FqName", "CompanionObjectName", "TypeParameter", "Supertype", "SupertypeId", "NestedClassName", "Constructor", "Function", "Property", "EnumEntry", "TypeTable", }); + new java.lang.String[] { "Flags", "FqName", "CompanionObjectName", "TypeParameter", "Supertype", "SupertypeId", "NestedClassName", "Constructor", "Function", "Property", "EnumEntryName", "EnumEntry", "TypeTable", }); internal_static_org_jetbrains_kotlin_serialization_Package_descriptor = getDescriptor().getMessageTypes().get(6); internal_static_org_jetbrains_kotlin_serialization_Package_fieldAccessorTable = new @@ -21153,6 +21946,12 @@ public final class DebugProtoBuf { com.google.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_org_jetbrains_kotlin_serialization_ValueParameter_descriptor, new java.lang.String[] { "Flags", "Name", "Type", "TypeId", "VarargElementType", "VarargElementTypeId", }); + internal_static_org_jetbrains_kotlin_serialization_EnumEntry_descriptor = + getDescriptor().getMessageTypes().get(12); + internal_static_org_jetbrains_kotlin_serialization_EnumEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_org_jetbrains_kotlin_serialization_EnumEntry_descriptor, + new java.lang.String[] { "Name", }); com.google.protobuf.ExtensionRegistry registry = com.google.protobuf.ExtensionRegistry.newInstance(); registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.fqNameIdInTable); diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt index 304632a5469..e2f067c5f39 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt @@ -74,6 +74,10 @@ public class BuiltInsSerializerTest : TestCaseWithTmpdir() { doTest("annotationTargets.kt") } + fun testAnnotatedEnumEntry() { + doTest("annotatedEnumEntry.kt") + } + fun testPrimitives() { doTest("annotationArguments/primitives.kt") } diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/DebugBuiltInsProtoBuf.java b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/DebugBuiltInsProtoBuf.java index 9c57c695dad..8ffdd6d8cf1 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/DebugBuiltInsProtoBuf.java +++ b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/DebugBuiltInsProtoBuf.java @@ -14,6 +14,7 @@ public final class DebugBuiltInsProtoBuf { registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.functionAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.propertyAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.compileTimeValue); + registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.enumEntryAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.parameterAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.typeAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.DebugBuiltInsProtoBuf.typeParameterAnnotation); @@ -95,6 +96,17 @@ public final class DebugBuiltInsProtoBuf { .newFileScopedGeneratedExtension( org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.Argument.Value.class, org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.Argument.Value.getDefaultInstance()); + public static final int ENUM_ENTRY_ANNOTATION_FIELD_NUMBER = 150; + /** + * extend .org.jetbrains.kotlin.serialization.EnumEntry { ... } + */ + public static final + com.google.protobuf.GeneratedMessage.GeneratedExtension< + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry, + java.util.List> enumEntryAnnotation = com.google.protobuf.GeneratedMessage + .newFileScopedGeneratedExtension( + org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class, + org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance()); public static final int PARAMETER_ANNOTATION_FIELD_NUMBER = 150; /** * extend .org.jetbrains.kotlin.serialization.ValueParameter { ... } @@ -160,17 +172,20 @@ public final class DebugBuiltInsProtoBuf { "lue\022,.org.jetbrains.kotlin.serialization" + ".Property\030\227\001 \001(\0132=.org.jetbrains.kotlin." + "serialization.Annotation.Argument.Value:" + - "\201\001\n\024parameter_annotation\0222.org.jetbrains" + - ".kotlin.serialization.ValueParameter\030\226\001 " + - "\003(\0132..org.jetbrains.kotlin.serialization" + - ".Annotation:r\n\017type_annotation\022(.org.jet" + - "brains.kotlin.serialization.Type\030\226\001 \003(\0132" + - "..org.jetbrains.kotlin.serialization.Ann" + - "otation:\205\001\n\031type_parameter_annotation\0221.", - "org.jetbrains.kotlin.serialization.TypeP" + - "arameter\030\226\001 \003(\0132..org.jetbrains.kotlin.s" + - "erialization.AnnotationB\027B\025DebugBuiltIns" + - "ProtoBuf" + "}\n\025enum_entry_annotation\022-.org.jetbrains" + + ".kotlin.serialization.EnumEntry\030\226\001 \003(\0132." + + ".org.jetbrains.kotlin.serialization.Anno" + + "tation:\201\001\n\024parameter_annotation\0222.org.je" + + "tbrains.kotlin.serialization.ValueParame" + + "ter\030\226\001 \003(\0132..org.jetbrains.kotlin.serial" + + "ization.Annotation:r\n\017type_annotation\022(.", + "org.jetbrains.kotlin.serialization.Type\030" + + "\226\001 \003(\0132..org.jetbrains.kotlin.serializat" + + "ion.Annotation:\205\001\n\031type_parameter_annota" + + "tion\0221.org.jetbrains.kotlin.serializatio" + + "n.TypeParameter\030\226\001 \003(\0132..org.jetbrains.k" + + "otlin.serialization.AnnotationB\027B\025DebugB" + + "uiltInsProtoBuf" }; com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @@ -184,9 +199,10 @@ public final class DebugBuiltInsProtoBuf { functionAnnotation.internalInit(descriptor.getExtensions().get(4)); propertyAnnotation.internalInit(descriptor.getExtensions().get(5)); compileTimeValue.internalInit(descriptor.getExtensions().get(6)); - parameterAnnotation.internalInit(descriptor.getExtensions().get(7)); - typeAnnotation.internalInit(descriptor.getExtensions().get(8)); - typeParameterAnnotation.internalInit(descriptor.getExtensions().get(9)); + enumEntryAnnotation.internalInit(descriptor.getExtensions().get(7)); + parameterAnnotation.internalInit(descriptor.getExtensions().get(8)); + typeAnnotation.internalInit(descriptor.getExtensions().get(9)); + typeParameterAnnotation.internalInit(descriptor.getExtensions().get(10)); return null; } }; diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/js/DebugJsProtoBuf.java b/compiler/tests/org/jetbrains/kotlin/serialization/js/DebugJsProtoBuf.java index d34c6540438..7f2da222f38 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/js/DebugJsProtoBuf.java +++ b/compiler/tests/org/jetbrains/kotlin/serialization/js/DebugJsProtoBuf.java @@ -12,6 +12,7 @@ public final class DebugJsProtoBuf { registry.add(org.jetbrains.kotlin.serialization.js.DebugJsProtoBuf.functionAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.DebugJsProtoBuf.propertyAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.DebugJsProtoBuf.compileTimeValue); + registry.add(org.jetbrains.kotlin.serialization.js.DebugJsProtoBuf.enumEntryAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.DebugJsProtoBuf.parameterAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.DebugJsProtoBuf.typeAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.DebugJsProtoBuf.typeParameterAnnotation); @@ -1859,6 +1860,17 @@ public final class DebugJsProtoBuf { .newFileScopedGeneratedExtension( org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.Argument.Value.class, org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.Argument.Value.getDefaultInstance()); + public static final int ENUM_ENTRY_ANNOTATION_FIELD_NUMBER = 130; + /** + * extend .org.jetbrains.kotlin.serialization.EnumEntry { ... } + */ + public static final + com.google.protobuf.GeneratedMessage.GeneratedExtension< + org.jetbrains.kotlin.serialization.DebugProtoBuf.EnumEntry, + java.util.List> enumEntryAnnotation = com.google.protobuf.GeneratedMessage + .newFileScopedGeneratedExtension( + org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class, + org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance()); public static final int PARAMETER_ANNOTATION_FIELD_NUMBER = 130; /** * extend .org.jetbrains.kotlin.serialization.ValueParameter { ... } @@ -1939,17 +1951,20 @@ public final class DebugJsProtoBuf { "ime_value\022,.org.jetbrains.kotlin.seriali" + "zation.Property\030\203\001 \001(\0132=.org.jetbrains.k" + "otlin.serialization.Annotation.Argument." + - "Value:\201\001\n\024parameter_annotation\0222.org.jet" + - "brains.kotlin.serialization.ValueParamet" + - "er\030\202\001 \003(\0132..org.jetbrains.kotlin.seriali" + - "zation.Annotation:r\n\017type_annotation\022(.o" + - "rg.jetbrains.kotlin.serialization.Type\030\202" + - "\001 \003(\0132..org.jetbrains.kotlin.serializati" + - "on.Annotation:\205\001\n\031type_parameter_annotat", - "ion\0221.org.jetbrains.kotlin.serialization" + - ".TypeParameter\030\202\001 \003(\0132..org.jetbrains.ko" + - "tlin.serialization.AnnotationB\021B\017DebugJs" + - "ProtoBuf" + "Value:}\n\025enum_entry_annotation\022-.org.jet" + + "brains.kotlin.serialization.EnumEntry\030\202\001" + + " \003(\0132..org.jetbrains.kotlin.serializatio" + + "n.Annotation:\201\001\n\024parameter_annotation\0222." + + "org.jetbrains.kotlin.serialization.Value" + + "Parameter\030\202\001 \003(\0132..org.jetbrains.kotlin." + + "serialization.Annotation:r\n\017type_annotat", + "ion\022(.org.jetbrains.kotlin.serialization" + + ".Type\030\202\001 \003(\0132..org.jetbrains.kotlin.seri" + + "alization.Annotation:\205\001\n\031type_parameter_" + + "annotation\0221.org.jetbrains.kotlin.serial" + + "ization.TypeParameter\030\202\001 \003(\0132..org.jetbr" + + "ains.kotlin.serialization.AnnotationB\021B\017" + + "DebugJsProtoBuf" }; com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @@ -1979,9 +1994,10 @@ public final class DebugJsProtoBuf { functionAnnotation.internalInit(descriptor.getExtensions().get(2)); propertyAnnotation.internalInit(descriptor.getExtensions().get(3)); compileTimeValue.internalInit(descriptor.getExtensions().get(4)); - parameterAnnotation.internalInit(descriptor.getExtensions().get(5)); - typeAnnotation.internalInit(descriptor.getExtensions().get(6)); - typeParameterAnnotation.internalInit(descriptor.getExtensions().get(7)); + enumEntryAnnotation.internalInit(descriptor.getExtensions().get(5)); + parameterAnnotation.internalInit(descriptor.getExtensions().get(6)); + typeAnnotation.internalInit(descriptor.getExtensions().get(7)); + typeParameterAnnotation.internalInit(descriptor.getExtensions().get(8)); return null; } }; diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt index ff9d49cdde0..13b313554c4 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt @@ -111,6 +111,10 @@ public class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() { doTest("builtinsSerializer/annotationTargets.kt") } + fun testAnnotatedEnumEntry() { + doTest("builtinsSerializer/annotatedEnumEntry.kt") + } + fun testPrimitives() { doTest("builtinsSerializer/annotationArguments/primitives.kt") } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java index ff6c01ee5f5..dccff8da7c7 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java @@ -35,7 +35,7 @@ public final class JvmAbi { * - Patch version can be increased freely and is only supposed to be used for debugging. Increase the patch version when you * make a change to the metadata format or the bytecode which is both forward- and backward compatible. */ - public static final BinaryVersion VERSION = BinaryVersion.create(1, 0, 0); + public static final BinaryVersion VERSION = BinaryVersion.create(1, 0, 1); public static final String DEFAULT_IMPLS_CLASS_NAME = "DefaultImpls"; public static final String DEFAULT_IMPLS_SUFFIX = "$" + DEFAULT_IMPLS_CLASS_NAME; diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt index 0eb1bc2b28d..e0d0200716b 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt @@ -26,10 +26,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.* import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf -import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.index -import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.methodImplClassName -import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertyImplClassName -import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertySignature +import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.* import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.KotlinType @@ -112,6 +109,14 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader { + // TODO + return listOf() + } + protected abstract fun loadPropertyAnnotations(propertyAnnotations: List, fieldAnnotations: List): List protected abstract fun transformAnnotations(annotations: List): List diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt index 147107d8d4c..c73f2ca4d59 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInSerializerProtocol.kt @@ -21,6 +21,6 @@ import org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf object BuiltInSerializerProtocol : SerializerExtensionProtocol( BuiltInsProtoBuf.constructorAnnotation, BuiltInsProtoBuf.classAnnotation, BuiltInsProtoBuf.functionAnnotation, - BuiltInsProtoBuf.propertyAnnotation, BuiltInsProtoBuf.compileTimeValue, BuiltInsProtoBuf.parameterAnnotation, - BuiltInsProtoBuf.typeAnnotation, BuiltInsProtoBuf.typeParameterAnnotation + BuiltInsProtoBuf.propertyAnnotation, BuiltInsProtoBuf.enumEntryAnnotation, BuiltInsProtoBuf.compileTimeValue, + BuiltInsProtoBuf.parameterAnnotation, BuiltInsProtoBuf.typeAnnotation, BuiltInsProtoBuf.typeParameterAnnotation ) diff --git a/core/deserialization/src/builtins.proto b/core/deserialization/src/builtins.proto index c22a77cf7a4..e4386a626ee 100644 --- a/core/deserialization/src/builtins.proto +++ b/core/deserialization/src/builtins.proto @@ -44,6 +44,10 @@ extend Property { optional Annotation.Argument.Value compile_time_value = 151; } +extend EnumEntry { + repeated Annotation enum_entry_annotation = 150; +} + extend ValueParameter { repeated Annotation parameter_annotation = 150; } diff --git a/core/deserialization/src/descriptors.proto b/core/deserialization/src/descriptors.proto index e65936bd71c..194e2225b5e 100644 --- a/core/deserialization/src/descriptors.proto +++ b/core/deserialization/src/descriptors.proto @@ -192,7 +192,9 @@ message Class { repeated Function function = 9; repeated Property property = 10; - repeated int32 enum_entry = 12 [packed = true, (name_id_in_table) = true]; + repeated int32 enum_entry_name = 12 [packed = true, (name_id_in_table) = true]; + + repeated EnumEntry enum_entry = 13; optional TypeTable type_table = 30; @@ -320,6 +322,12 @@ message ValueParameter { extensions 100 to 199; } +message EnumEntry { + optional int32 name = 1; + + extensions 100 to 199; +} + enum Modality { // 2 bits FINAL = 0; diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java index 3a15dd63a84..fc5d912c954 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java @@ -7538,19 +7538,34 @@ public final class ProtoBuf { */ int getPropertyCount(); - // repeated int32 enum_entry = 12 [packed = true]; + // repeated int32 enum_entry_name = 12 [packed = true]; /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ - java.util.List getEnumEntryList(); + java.util.List getEnumEntryNameList(); /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + int getEnumEntryNameCount(); + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + int getEnumEntryName(int index); + + // repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + java.util.List + getEnumEntryList(); + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry getEnumEntry(int index); + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ int getEnumEntryCount(); - /** - * repeated int32 enum_entry = 12 [packed = true]; - */ - int getEnumEntry(int index); // optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; /** @@ -7704,25 +7719,33 @@ public final class ProtoBuf { } case 96: { if (!((mutable_bitField0_ & 0x00000400) == 0x00000400)) { - enumEntry_ = new java.util.ArrayList(); + enumEntryName_ = new java.util.ArrayList(); mutable_bitField0_ |= 0x00000400; } - enumEntry_.add(input.readInt32()); + enumEntryName_.add(input.readInt32()); break; } case 98: { int length = input.readRawVarint32(); int limit = input.pushLimit(length); if (!((mutable_bitField0_ & 0x00000400) == 0x00000400) && input.getBytesUntilLimit() > 0) { - enumEntry_ = new java.util.ArrayList(); + enumEntryName_ = new java.util.ArrayList(); mutable_bitField0_ |= 0x00000400; } while (input.getBytesUntilLimit() > 0) { - enumEntry_.add(input.readInt32()); + enumEntryName_.add(input.readInt32()); } input.popLimit(limit); break; } + case 106: { + if (!((mutable_bitField0_ & 0x00000800) == 0x00000800)) { + enumEntry_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000800; + } + enumEntry_.add(input.readMessage(org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.PARSER, extensionRegistry)); + break; + } case 242: { org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.Builder subBuilder = null; if (((bitField0_ & 0x00000008) == 0x00000008)) { @@ -7766,6 +7789,9 @@ public final class ProtoBuf { property_ = java.util.Collections.unmodifiableList(property_); } if (((mutable_bitField0_ & 0x00000400) == 0x00000400)) { + enumEntryName_ = java.util.Collections.unmodifiableList(enumEntryName_); + } + if (((mutable_bitField0_ & 0x00000800) == 0x00000800)) { enumEntry_ = java.util.Collections.unmodifiableList(enumEntry_); } makeExtensionsImmutable(); @@ -8192,29 +8218,65 @@ public final class ProtoBuf { return property_.get(index); } - // repeated int32 enum_entry = 12 [packed = true]; - public static final int ENUM_ENTRY_FIELD_NUMBER = 12; - private java.util.List enumEntry_; + // repeated int32 enum_entry_name = 12 [packed = true]; + public static final int ENUM_ENTRY_NAME_FIELD_NUMBER = 12; + private java.util.List enumEntryName_; /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ public java.util.List - getEnumEntryList() { + getEnumEntryNameList() { + return enumEntryName_; + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public int getEnumEntryNameCount() { + return enumEntryName_.size(); + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public int getEnumEntryName(int index) { + return enumEntryName_.get(index); + } + private int enumEntryNameMemoizedSerializedSize = -1; + + // repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + public static final int ENUM_ENTRY_FIELD_NUMBER = 13; + private java.util.List enumEntry_; + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List getEnumEntryList() { return enumEntry_; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List + getEnumEntryOrBuilderList() { + return enumEntry_; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ public int getEnumEntryCount() { return enumEntry_.size(); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ - public int getEnumEntry(int index) { + public org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry getEnumEntry(int index) { + return enumEntry_.get(index); + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntryOrBuilder getEnumEntryOrBuilder( + int index) { return enumEntry_.get(index); } - private int enumEntryMemoizedSerializedSize = -1; // optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; public static final int TYPE_TABLE_FIELD_NUMBER = 30; @@ -8243,6 +8305,7 @@ public final class ProtoBuf { constructor_ = java.util.Collections.emptyList(); function_ = java.util.Collections.emptyList(); property_ = java.util.Collections.emptyList(); + enumEntryName_ = java.util.Collections.emptyList(); enumEntry_ = java.util.Collections.emptyList(); typeTable_ = org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.getDefaultInstance(); } @@ -8285,6 +8348,12 @@ public final class ProtoBuf { return false; } } + for (int i = 0; i < getEnumEntryCount(); i++) { + if (!getEnumEntry(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } if (hasTypeTable()) { if (!getTypeTable().isInitialized()) { memoizedIsInitialized = 0; @@ -8343,12 +8412,15 @@ public final class ProtoBuf { for (int i = 0; i < property_.size(); i++) { output.writeMessage(10, property_.get(i)); } - if (getEnumEntryList().size() > 0) { + if (getEnumEntryNameList().size() > 0) { output.writeRawVarint32(98); - output.writeRawVarint32(enumEntryMemoizedSerializedSize); + output.writeRawVarint32(enumEntryNameMemoizedSerializedSize); + } + for (int i = 0; i < enumEntryName_.size(); i++) { + output.writeInt32NoTag(enumEntryName_.get(i)); } for (int i = 0; i < enumEntry_.size(); i++) { - output.writeInt32NoTag(enumEntry_.get(i)); + output.writeMessage(13, enumEntry_.get(i)); } if (((bitField0_ & 0x00000008) == 0x00000008)) { output.writeMessage(30, typeTable_); @@ -8424,17 +8496,21 @@ public final class ProtoBuf { } { int dataSize = 0; - for (int i = 0; i < enumEntry_.size(); i++) { + for (int i = 0; i < enumEntryName_.size(); i++) { dataSize += com.google.protobuf.CodedOutputStream - .computeInt32SizeNoTag(enumEntry_.get(i)); + .computeInt32SizeNoTag(enumEntryName_.get(i)); } size += dataSize; - if (!getEnumEntryList().isEmpty()) { + if (!getEnumEntryNameList().isEmpty()) { size += 1; size += com.google.protobuf.CodedOutputStream .computeInt32SizeNoTag(dataSize); } - enumEntryMemoizedSerializedSize = dataSize; + enumEntryNameMemoizedSerializedSize = dataSize; + } + for (int i = 0; i < enumEntry_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(13, enumEntry_.get(i)); } if (((bitField0_ & 0x00000008) == 0x00000008)) { size += com.google.protobuf.CodedOutputStream @@ -8551,10 +8627,12 @@ public final class ProtoBuf { bitField0_ = (bitField0_ & ~0x00000100); property_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000200); - enumEntry_ = java.util.Collections.emptyList(); + enumEntryName_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000400); - typeTable_ = org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.getDefaultInstance(); + enumEntry_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000800); + typeTable_ = org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00001000); return this; } @@ -8626,11 +8704,16 @@ public final class ProtoBuf { } result.property_ = property_; if (((bitField0_ & 0x00000400) == 0x00000400)) { - enumEntry_ = java.util.Collections.unmodifiableList(enumEntry_); + enumEntryName_ = java.util.Collections.unmodifiableList(enumEntryName_); bitField0_ = (bitField0_ & ~0x00000400); } + result.enumEntryName_ = enumEntryName_; + if (((bitField0_ & 0x00000800) == 0x00000800)) { + enumEntry_ = java.util.Collections.unmodifiableList(enumEntry_); + bitField0_ = (bitField0_ & ~0x00000800); + } result.enumEntry_ = enumEntry_; - if (((from_bitField0_ & 0x00000800) == 0x00000800)) { + if (((from_bitField0_ & 0x00001000) == 0x00001000)) { to_bitField0_ |= 0x00000008; } result.typeTable_ = typeTable_; @@ -8718,11 +8801,21 @@ public final class ProtoBuf { property_.addAll(other.property_); } + } + if (!other.enumEntryName_.isEmpty()) { + if (enumEntryName_.isEmpty()) { + enumEntryName_ = other.enumEntryName_; + bitField0_ = (bitField0_ & ~0x00000400); + } else { + ensureEnumEntryNameIsMutable(); + enumEntryName_.addAll(other.enumEntryName_); + } + } if (!other.enumEntry_.isEmpty()) { if (enumEntry_.isEmpty()) { enumEntry_ = other.enumEntry_; - bitField0_ = (bitField0_ & ~0x00000400); + bitField0_ = (bitField0_ & ~0x00000800); } else { ensureEnumEntryIsMutable(); enumEntry_.addAll(other.enumEntry_); @@ -8771,6 +8864,12 @@ public final class ProtoBuf { return false; } } + for (int i = 0; i < getEnumEntryCount(); i++) { + if (!getEnumEntry(i).isInitialized()) { + + return false; + } + } if (hasTypeTable()) { if (!getTypeTable().isInitialized()) { @@ -9699,69 +9798,194 @@ public final class ProtoBuf { return this; } - // repeated int32 enum_entry = 12 [packed = true]; - private java.util.List enumEntry_ = java.util.Collections.emptyList(); - private void ensureEnumEntryIsMutable() { + // repeated int32 enum_entry_name = 12 [packed = true]; + private java.util.List enumEntryName_ = java.util.Collections.emptyList(); + private void ensureEnumEntryNameIsMutable() { if (!((bitField0_ & 0x00000400) == 0x00000400)) { - enumEntry_ = new java.util.ArrayList(enumEntry_); + enumEntryName_ = new java.util.ArrayList(enumEntryName_); bitField0_ |= 0x00000400; } } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated int32 enum_entry_name = 12 [packed = true]; */ public java.util.List - getEnumEntryList() { + getEnumEntryNameList() { + return java.util.Collections.unmodifiableList(enumEntryName_); + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public int getEnumEntryNameCount() { + return enumEntryName_.size(); + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public int getEnumEntryName(int index) { + return enumEntryName_.get(index); + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public Builder setEnumEntryName( + int index, int value) { + ensureEnumEntryNameIsMutable(); + enumEntryName_.set(index, value); + + return this; + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public Builder addEnumEntryName(int value) { + ensureEnumEntryNameIsMutable(); + enumEntryName_.add(value); + + return this; + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public Builder addAllEnumEntryName( + java.lang.Iterable values) { + ensureEnumEntryNameIsMutable(); + super.addAll(values, enumEntryName_); + + return this; + } + /** + * repeated int32 enum_entry_name = 12 [packed = true]; + */ + public Builder clearEnumEntryName() { + enumEntryName_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000400); + + return this; + } + + // repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + private java.util.List enumEntry_ = + java.util.Collections.emptyList(); + private void ensureEnumEntryIsMutable() { + if (!((bitField0_ & 0x00000800) == 0x00000800)) { + enumEntry_ = new java.util.ArrayList(enumEntry_); + bitField0_ |= 0x00000800; + } + } + + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public java.util.List getEnumEntryList() { return java.util.Collections.unmodifiableList(enumEntry_); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ public int getEnumEntryCount() { return enumEntry_.size(); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ - public int getEnumEntry(int index) { + public org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry getEnumEntry(int index) { return enumEntry_.get(index); } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ public Builder setEnumEntry( - int index, int value) { + int index, org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry value) { + if (value == null) { + throw new NullPointerException(); + } ensureEnumEntryIsMutable(); enumEntry_.set(index, value); - + return this; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ - public Builder addEnumEntry(int value) { + public Builder setEnumEntry( + int index, org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.Builder builderForValue) { + ensureEnumEntryIsMutable(); + enumEntry_.set(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry(org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry value) { + if (value == null) { + throw new NullPointerException(); + } ensureEnumEntryIsMutable(); enumEntry_.add(value); - + return this; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry( + int index, org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry value) { + if (value == null) { + throw new NullPointerException(); + } + ensureEnumEntryIsMutable(); + enumEntry_.add(index, value); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry( + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.Builder builderForValue) { + ensureEnumEntryIsMutable(); + enumEntry_.add(builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder addEnumEntry( + int index, org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.Builder builderForValue) { + ensureEnumEntryIsMutable(); + enumEntry_.add(index, builderForValue.build()); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ public Builder addAllEnumEntry( - java.lang.Iterable values) { + java.lang.Iterable values) { ensureEnumEntryIsMutable(); super.addAll(values, enumEntry_); - + return this; } /** - * repeated int32 enum_entry = 12 [packed = true]; + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; */ public Builder clearEnumEntry() { enumEntry_ = java.util.Collections.emptyList(); - bitField0_ = (bitField0_ & ~0x00000400); - + bitField0_ = (bitField0_ & ~0x00000800); + + return this; + } + /** + * repeated .org.jetbrains.kotlin.serialization.EnumEntry enum_entry = 13; + */ + public Builder removeEnumEntry(int index) { + ensureEnumEntryIsMutable(); + enumEntry_.remove(index); + return this; } @@ -9771,7 +9995,7 @@ public final class ProtoBuf { * optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; */ public boolean hasTypeTable() { - return ((bitField0_ & 0x00000800) == 0x00000800); + return ((bitField0_ & 0x00001000) == 0x00001000); } /** * optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; @@ -9788,7 +10012,7 @@ public final class ProtoBuf { } typeTable_ = value; - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return this; } /** @@ -9798,14 +10022,14 @@ public final class ProtoBuf { org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.Builder builderForValue) { typeTable_ = builderForValue.build(); - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return this; } /** * optional .org.jetbrains.kotlin.serialization.TypeTable type_table = 30; */ public Builder mergeTypeTable(org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable value) { - if (((bitField0_ & 0x00000800) == 0x00000800) && + if (((bitField0_ & 0x00001000) == 0x00001000) && typeTable_ != org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.getDefaultInstance()) { typeTable_ = org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.newBuilder(typeTable_).mergeFrom(value).buildPartial(); @@ -9813,7 +10037,7 @@ public final class ProtoBuf { typeTable_ = value; } - bitField0_ |= 0x00000800; + bitField0_ |= 0x00001000; return this; } /** @@ -9822,7 +10046,7 @@ public final class ProtoBuf { public Builder clearTypeTable() { typeTable_ = org.jetbrains.kotlin.serialization.ProtoBuf.TypeTable.getDefaultInstance(); - bitField0_ = (bitField0_ & ~0x00000800); + bitField0_ = (bitField0_ & ~0x00001000); return this; } @@ -15916,6 +16140,353 @@ public final class ProtoBuf { // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.ValueParameter) } + public interface EnumEntryOrBuilder extends + com.google.protobuf.GeneratedMessageLite. + ExtendableMessageOrBuilder { + + // optional int32 name = 1; + /** + * optional int32 name = 1; + */ + boolean hasName(); + /** + * optional int32 name = 1; + */ + int getName(); + } + /** + * Protobuf type {@code org.jetbrains.kotlin.serialization.EnumEntry} + */ + public static final class EnumEntry extends + com.google.protobuf.GeneratedMessageLite.ExtendableMessage< + EnumEntry> implements EnumEntryOrBuilder { + // Use EnumEntry.newBuilder() to construct. + private EnumEntry(com.google.protobuf.GeneratedMessageLite.ExtendableBuilder builder) { + super(builder); + + } + private EnumEntry(boolean noInit) {} + + private static final EnumEntry defaultInstance; + public static EnumEntry getDefaultInstance() { + return defaultInstance; + } + + public EnumEntry getDefaultInstanceForType() { + return defaultInstance; + } + + private EnumEntry( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + name_ = input.readInt32(); + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + makeExtensionsImmutable(); + } + } + public static com.google.protobuf.Parser PARSER = + new com.google.protobuf.AbstractParser() { + public EnumEntry parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new EnumEntry(input, extensionRegistry); + } + }; + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // optional int32 name = 1; + public static final int NAME_FIELD_NUMBER = 1; + private int name_; + /** + * optional int32 name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional int32 name = 1; + */ + public int getName() { + return name_; + } + + private void initFields() { + name_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!extensionsAreInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + com.google.protobuf.GeneratedMessageLite + .ExtendableMessage.ExtensionWriter extensionWriter = + newExtensionWriter(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, name_); + } + extensionWriter.writeUntil(200, output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, name_); + } + size += extensionsSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + /** + * Protobuf type {@code org.jetbrains.kotlin.serialization.EnumEntry} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageLite.ExtendableBuilder< + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry, Builder> implements org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntryOrBuilder { + // Construct using org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry getDefaultInstanceForType() { + return org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.getDefaultInstance(); + } + + public org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry build() { + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry buildPartial() { + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry result = new org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry other) { + if (other == org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.getDefaultInstance()) return this; + if (other.hasName()) { + setName(other.getName()); + } + this.mergeExtensionFields(other); + return this; + } + + public final boolean isInitialized() { + if (!extensionsAreInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // optional int32 name = 1; + private int name_ ; + /** + * optional int32 name = 1; + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * optional int32 name = 1; + */ + public int getName() { + return name_; + } + /** + * optional int32 name = 1; + */ + public Builder setName(int value) { + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + /** + * optional int32 name = 1; + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = 0; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.serialization.EnumEntry) + } + + static { + defaultInstance = new EnumEntry(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.EnumEntry) + } + static { } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt index 8b4e0b9b988..dfe9909c2a0 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/SerializerExtensionProtocol.kt @@ -23,6 +23,7 @@ open class SerializerExtensionProtocol( val classAnnotation: GeneratedExtension>, val functionAnnotation: GeneratedExtension>, val propertyAnnotation: GeneratedExtension>, + val enumEntryAnnotation: GeneratedExtension>, val compileTimeValue: GeneratedExtension, val parameterAnnotation: GeneratedExtension>, val typeAnnotation: GeneratedExtension>, diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsProtoBuf.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsProtoBuf.java index d82a3b5f0a1..20bef9e756c 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsProtoBuf.java +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsProtoBuf.java @@ -14,6 +14,7 @@ public final class BuiltInsProtoBuf { registry.add(org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf.functionAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf.propertyAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf.compileTimeValue); + registry.add(org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf.enumEntryAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf.parameterAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf.typeAnnotation); registry.add(org.jetbrains.kotlin.serialization.builtins.BuiltInsProtoBuf.typeParameterAnnotation); @@ -123,6 +124,21 @@ public final class BuiltInsProtoBuf { null, 151, com.google.protobuf.WireFormat.FieldType.MESSAGE); + public static final int ENUM_ENTRY_ANNOTATION_FIELD_NUMBER = 150; + /** + * extend .org.jetbrains.kotlin.serialization.EnumEntry { ... } + */ + public static final + com.google.protobuf.GeneratedMessageLite.GeneratedExtension< + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry, + java.util.List> enumEntryAnnotation = com.google.protobuf.GeneratedMessageLite + .newRepeatedGeneratedExtension( + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.getDefaultInstance(), + org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.getDefaultInstance(), + null, + 150, + com.google.protobuf.WireFormat.FieldType.MESSAGE, + false); public static final int PARAMETER_ANNOTATION_FIELD_NUMBER = 150; /** * extend .org.jetbrains.kotlin.serialization.ValueParameter { ... } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java index 91945666a3d..c8c1f8ca94a 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java @@ -40,6 +40,12 @@ public interface AnnotationAndConstantLoader { @NotNull AnnotatedCallableKind kind ); + @NotNull + List loadEnumEntryAnnotations( + @NotNull ProtoContainer container, + @NotNull ProtoBuf.EnumEntry proto + ); + @NotNull List loadValueParameterAnnotations( @NotNull ProtoContainer container, diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt index b203de15bc5..dbbc9dc9776 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoaderImpl.kt @@ -53,6 +53,14 @@ class AnnotationAndConstantLoaderImpl( return annotations.map { proto -> AnnotationWithTarget(deserializer.deserializeAnnotation(proto, container.nameResolver), null) } } + override fun loadEnumEntryAnnotations( + container: ProtoContainer, + proto: ProtoBuf.EnumEntry + ): List { + val annotations = proto.getExtension(protocol.enumEntryAnnotation).orEmpty() + return annotations.map { proto -> deserializer.deserializeAnnotation(proto, container.nameResolver) } + } + override fun loadValueParameterAnnotations( container: ProtoContainer, message: MessageLite, 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 0b150fff3c6..3b94f558e4f 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 @@ -65,7 +65,7 @@ public class DeserializedClassDescriptor( private val typeConstructor = DeserializedClassTypeConstructor() private val memberScope = DeserializedClassMemberScope() private val nestedClasses = NestedClassDescriptors() - private val enumEntries = EnumEntryClassDescriptors() + private val enumEntries = if (kind == ClassKind.ENUM_CLASS) EnumEntryClassDescriptors() else null private val containingDeclaration = outerContext.containingDeclaration private val primaryConstructor = c.storageManager.createNullableLazyValue { computePrimaryConstructor() } @@ -248,14 +248,14 @@ public class DeserializedClassDescriptor( } override fun getClassDescriptor(name: Name): ClassifierDescriptor? = - classDescriptor.enumEntries.findEnumEntry(name) ?: classDescriptor.nestedClasses.findNestedClass(name) + classDescriptor.enumEntries?.findEnumEntry(name) ?: classDescriptor.nestedClasses.findNestedClass(name) override fun addClassDescriptors(result: MutableCollection, nameFilter: (Name) -> Boolean) { result.addAll(classDescriptor.nestedClasses.all()) } override fun addEnumEntryDescriptors(result: MutableCollection, nameFilter: (Name) -> Boolean) { - result.addAll(classDescriptor.enumEntries.all()) + result.addAll(classDescriptor.enumEntries?.all().orEmpty()) } } @@ -287,54 +287,51 @@ public class DeserializedClassDescriptor( } private inner class EnumEntryClassDescriptors { - private val enumEntryNames = enumEntryNames() + private val oldEnumEntryNames = classProto.enumEntryNameList.mapTo(LinkedHashSet()) { c.nameResolver.getName(it) } + private val enumEntryProtos = classProto.enumEntryList.toMapBy { c.nameResolver.getName(it.name) } - private fun enumEntryNames(): Set { - if (getKind() != ClassKind.ENUM_CLASS) return setOf() - - val result = LinkedHashSet() - val nameResolver = c.nameResolver - for (index in classProto.getEnumEntryList()) { - result.add(nameResolver.getName(index!!)) - } - return result - } - - val findEnumEntry = c.storageManager.createMemoizedFunctionWithNullableValues { + val enumEntryByName = c.storageManager.createMemoizedFunctionWithNullableValues { name -> - if (name in enumEntryNames) { + + val annotations = enumEntryProtos[name]?.let { proto -> + DeserializedAnnotations(c.storageManager) { + c.components.annotationAndConstantLoader.loadEnumEntryAnnotations( + ProtoContainer(classProto, null, c.nameResolver, c.typeTable), proto + ) + } + } ?: if (name in oldEnumEntryNames) Annotations.EMPTY + else null + + annotations?.let { annotations -> EnumEntrySyntheticClassDescriptor.create( - //TODO: load annotations from class file - c.storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, Annotations.EMPTY, SourceElement.NO_SOURCE + c.storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, annotations, SourceElement.NO_SOURCE ) } - else null } private val enumMemberNames = c.storageManager.createLazyValue { computeEnumMemberNames() } + fun findEnumEntry(name: Name): ClassDescriptor? = enumEntryByName(name) + private fun computeEnumMemberNames(): Collection { // NOTE: order of enum entry members should be irrelevant // because enum entries are effectively invisible to user (as classes) val result = HashSet() - for (supertype in getTypeConstructor().getSupertypes()) { - for (descriptor in supertype.getMemberScope().getContributedDescriptors()) { + for (supertype in getTypeConstructor().supertypes) { + for (descriptor in supertype.memberScope.getContributedDescriptors()) { if (descriptor is SimpleFunctionDescriptor || descriptor is PropertyDescriptor) { - result.add(descriptor.getName()) + result.add(descriptor.name) } } } - val nameResolver = c.nameResolver - return classProto.functionList.mapTo(result) { nameResolver.getName(it.name) } + - classProto.propertyList.mapTo(result) { nameResolver.getName(it.name) } + return classProto.functionList.mapTo(result) { c.nameResolver.getName(it.name) } + + classProto.propertyList.mapTo(result) { c.nameResolver.getName(it.name) } } - fun all(): Collection { - val result = ArrayList(enumEntryNames.size()) - enumEntryNames.forEach { name -> result.addIfNotNull(findEnumEntry(name)) } - return result - } + fun all(): Collection = + (if (oldEnumEntryNames.isEmpty()) enumEntryProtos.keys else oldEnumEntryNames) + .mapNotNull { name -> findEnumEntry(name) } } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/common/AnnotationLoaderForStubBuilderImpl.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/common/AnnotationLoaderForStubBuilderImpl.kt index a7d701515ca..65cba34a914 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/common/AnnotationLoaderForStubBuilderImpl.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/common/AnnotationLoaderForStubBuilderImpl.kt @@ -52,6 +52,11 @@ public class AnnotationLoaderForStubBuilderImpl( } } + override fun loadEnumEntryAnnotations(container: ProtoContainer, proto: ProtoBuf.EnumEntry): List { + // TODO + return listOf() + } + override fun loadValueParameterAnnotations( container: ProtoContainer, message: MessageLite, diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt index 5388909acde..7de29d48fc0 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt @@ -172,7 +172,7 @@ private class ClassClsStubBuilder( } private fun createEnumEntryStubs(classBody: KotlinPlaceHolderStubImpl) { - classProto.getEnumEntryList().forEach { id -> + classProto.getEnumEntryNameList().forEach { id -> val name = c.nameResolver.getName(id) KotlinClassStubImpl( KtStubElementTypes.ENUM_ENTRY, diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt index 7f7493ff775..bbbaf1514c6 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt @@ -249,7 +249,7 @@ public class IncrementalCacheImpl( ProtoBuf.Class::getFunctionList, ProtoBuf.Class::getPropertyList ) + - classData.classProto.enumEntryList.map { classData.nameResolver.getString(it) }.toSet() + classData.classProto.enumEntryNameList.map { classData.nameResolver.getString(it) }.toSet() ChangeInfo.Removed(className.fqNameForClassNameWithoutDollars, memberNames) } diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt index a4f9787fddf..1ab985461c7 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt @@ -94,6 +94,8 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi if (!checkEqualsClassProperty(old, new)) return false + if (!checkEqualsClassEnumEntryName(old, new)) return false + if (!checkEqualsClassEnumEntry(old, new)) return false if (old.hasTypeTable() != new.hasTypeTable()) return false @@ -120,6 +122,7 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi CONSTRUCTOR_LIST, FUNCTION_LIST, PROPERTY_LIST, + ENUM_ENTRY_NAME_LIST, ENUM_ENTRY_LIST, TYPE_TABLE, CLASS_ANNOTATION_LIST @@ -154,6 +157,8 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi if (!checkEqualsClassProperty(old, new)) result.add(ProtoBufClassKind.PROPERTY_LIST) + if (!checkEqualsClassEnumEntryName(old, new)) result.add(ProtoBufClassKind.ENUM_ENTRY_NAME_LIST) + if (!checkEqualsClassEnumEntry(old, new)) result.add(ProtoBufClassKind.ENUM_ENTRY_LIST) if (old.hasTypeTable() != new.hasTypeTable()) result.add(ProtoBufClassKind.TYPE_TABLE) @@ -395,6 +400,15 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi return true } + open fun checkEquals(old: ProtoBuf.EnumEntry, new: ProtoBuf.EnumEntry): Boolean { + if (old.hasName() != new.hasName()) return false + if (old.hasName()) { + if (old.name != new.name) return false + } + + return true + } + open fun checkEquals(old: ProtoBuf.Annotation, new: ProtoBuf.Annotation): Boolean { if (!checkClassIdEquals(old.id, new.id)) return false @@ -659,11 +673,21 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi return true } + open fun checkEqualsClassEnumEntryName(old: ProtoBuf.Class, new: ProtoBuf.Class): Boolean { + if (old.enumEntryNameCount != new.enumEntryNameCount) return false + + for(i in 0..old.enumEntryNameCount - 1) { + if (!checkStringEquals(old.getEnumEntryName(i), new.getEnumEntryName(i))) return false + } + + return true + } + open fun checkEqualsClassEnumEntry(old: ProtoBuf.Class, new: ProtoBuf.Class): Boolean { if (old.enumEntryCount != new.enumEntryCount) return false for(i in 0..old.enumEntryCount - 1) { - if (!checkStringEquals(old.getEnumEntry(i), new.getEnumEntry(i))) return false + if (!checkEquals(old.getEnumEntry(i), new.getEnumEntry(i))) return false } return true @@ -859,8 +883,12 @@ public fun ProtoBuf.Class.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: ( hashCode = 31 * hashCode + getProperty(i).hashCode(stringIndexes, fqNameIndexes) } + for(i in 0..enumEntryNameCount - 1) { + hashCode = 31 * hashCode + stringIndexes(getEnumEntryName(i)) + } + for(i in 0..enumEntryCount - 1) { - hashCode = 31 * hashCode + stringIndexes(getEnumEntry(i)) + hashCode = 31 * hashCode + getEnumEntry(i).hashCode(stringIndexes, fqNameIndexes) } if (hasTypeTable()) { @@ -1090,6 +1118,16 @@ public fun ProtoBuf.Constructor.hashCode(stringIndexes: (Int) -> Int, fqNameInde return hashCode } +public fun ProtoBuf.EnumEntry.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int { + var hashCode = 1 + + if (hasName()) { + hashCode = 31 * hashCode + name + } + + return hashCode +} + public fun ProtoBuf.Annotation.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int) -> Int): Int { var hashCode = 1 diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt index 5124aa85eda..6581f60fadb 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt @@ -206,8 +206,10 @@ private class DifferenceCalculatorForClass(oldData: ProtoMapValue, newData: Prot names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getFunctionList)) ProtoBufClassKind.PROPERTY_LIST -> names.addAll(calcDifferenceForNonPrivateMembers(ProtoBuf.Class::getPropertyList)) + ProtoBufClassKind.ENUM_ENTRY_NAME_LIST -> + names.addAll(calcDifferenceForNames(oldProto.enumEntryNameList, newProto.enumEntryNameList)) ProtoBufClassKind.ENUM_ENTRY_LIST -> - names.addAll(calcDifferenceForNames(oldProto.enumEntryList, newProto.enumEntryList)) + names.addAll(calcDifferenceForNames(oldProto.enumEntryList.map { it.name }, newProto.enumEntryList.map { it.name })) ProtoBufClassKind.TYPE_TABLE -> { // TODO } diff --git a/js/js.serializer/src/js.proto b/js/js.serializer/src/js.proto index 43074d5ce5f..8d42dc3093e 100644 --- a/js/js.serializer/src/js.proto +++ b/js/js.serializer/src/js.proto @@ -38,6 +38,10 @@ extend Property { optional Annotation.Argument.Value compile_time_value = 131; } +extend EnumEntry { + repeated Annotation enum_entry_annotation = 130; +} + extend ValueParameter { repeated Annotation parameter_annotation = 130; } diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/JsProtoBuf.java b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/JsProtoBuf.java index c19a199697c..bcdb15ab97e 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/JsProtoBuf.java +++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/JsProtoBuf.java @@ -12,6 +12,7 @@ public final class JsProtoBuf { registry.add(org.jetbrains.kotlin.serialization.js.JsProtoBuf.functionAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.JsProtoBuf.propertyAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.JsProtoBuf.compileTimeValue); + registry.add(org.jetbrains.kotlin.serialization.js.JsProtoBuf.enumEntryAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.JsProtoBuf.parameterAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.JsProtoBuf.typeAnnotation); registry.add(org.jetbrains.kotlin.serialization.js.JsProtoBuf.typeParameterAnnotation); @@ -1540,6 +1541,21 @@ public final class JsProtoBuf { null, 131, com.google.protobuf.WireFormat.FieldType.MESSAGE); + public static final int ENUM_ENTRY_ANNOTATION_FIELD_NUMBER = 130; + /** + * extend .org.jetbrains.kotlin.serialization.EnumEntry { ... } + */ + public static final + com.google.protobuf.GeneratedMessageLite.GeneratedExtension< + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry, + java.util.List> enumEntryAnnotation = com.google.protobuf.GeneratedMessageLite + .newRepeatedGeneratedExtension( + org.jetbrains.kotlin.serialization.ProtoBuf.EnumEntry.getDefaultInstance(), + org.jetbrains.kotlin.serialization.ProtoBuf.Annotation.getDefaultInstance(), + null, + 130, + com.google.protobuf.WireFormat.FieldType.MESSAGE, + false); public static final int PARAMETER_ANNOTATION_FIELD_NUMBER = 130; /** * extend .org.jetbrains.kotlin.serialization.ValueParameter { ... } diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt index 0d639fbe576..9ea407b7dff 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt +++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt @@ -23,5 +23,6 @@ public class KotlinJavascriptSerializerExtension : KotlinSerializerExtensionBase object JsSerializerProtocol : SerializerExtensionProtocol( JsProtoBuf.constructorAnnotation, JsProtoBuf.classAnnotation, JsProtoBuf.functionAnnotation, JsProtoBuf.propertyAnnotation, - JsProtoBuf.compileTimeValue, JsProtoBuf.parameterAnnotation, JsProtoBuf.typeAnnotation, JsProtoBuf.typeParameterAnnotation -) \ No newline at end of file + JsProtoBuf.enumEntryAnnotation, JsProtoBuf.compileTimeValue, JsProtoBuf.parameterAnnotation, JsProtoBuf.typeAnnotation, + JsProtoBuf.typeParameterAnnotation +)