From 453b0e8f106ce1cd76f043ffedec8792c7a719ba Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 11 Jul 2013 17:12:01 +0400 Subject: [PATCH] Write java signature of serialized descriptors efficiently Instead of storing a string with the signature, write the name, return type and parameter types separately, reusing the name table. Refactor the name table to allow it to store not only names of Kotlin entities, but also arbitrary names and fq-names --- .../jet/codegen/JavaSerializerExtension.java | 29 +- .../serialization.java/serialization.java.iml | 2 + .../src/java_descriptors.proto | 40 +- .../serialization/JavaProtoBuf.java | 1584 ++++++++++++++++- .../serialization/JavaProtoBufUtil.java | 126 +- .../AnnotationDescriptorDeserializer.java | 26 +- .../serialization/DescriptorDeserializer.java | 16 +- .../serialization/DescriptorSerializer.java | 2 +- .../serialization/NameResolver.java | 16 +- .../descriptors/serialization/NameTable.java | 48 +- .../serialization/SerializerExtension.java | 6 +- .../descriptors/AnnotationDeserializer.java | 17 +- .../AbstractDescriptorSerializationTest.java | 5 +- 13 files changed, 1841 insertions(+), 76 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java b/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java index ec9617a7c14..59a37bd8ed9 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JavaSerializerExtension.java @@ -17,14 +17,15 @@ package org.jetbrains.jet.codegen; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.codegen.signature.JvmMethodSignature; +import org.jetbrains.asm4.commons.Method; import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil; +import org.jetbrains.jet.descriptors.serialization.NameTable; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; import org.jetbrains.jet.descriptors.serialization.SerializerExtension; import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; public class JavaSerializerExtension extends SerializerExtension { private final JetTypeMapper typeMapper; @@ -33,20 +34,20 @@ public class JavaSerializerExtension extends SerializerExtension { this.typeMapper = typeMapper; } + // TODO: mapSignature should be done upon generation of the member instead, because we don't know enough at this point to map correctly @Override - public void serializeCallable(@NotNull CallableMemberDescriptor callable, @NotNull ProtoBuf.Callable.Builder proto) { - JvmMethodSignature signature = mapSignature(callable); - if (signature != null) { - JavaProtoBufUtil.saveJavaSignature(proto, signature.getAsmMethod().toString()); + public void serializeCallable( + @NotNull CallableMemberDescriptor callable, + @NotNull ProtoBuf.Callable.Builder proto, + @NotNull NameTable nameTable + ) { + if (callable instanceof FunctionDescriptor) { + Method method = typeMapper.mapSignature((FunctionDescriptor) callable).getAsmMethod(); + JavaProtoBufUtil.saveMethodSignature(proto, method, nameTable); } - } - - // TODO: this should be done upon generation of the member instead, because we don't know enough at this point to map correctly - @Nullable - private JvmMethodSignature mapSignature(@NotNull CallableMemberDescriptor descriptor) { - if (descriptor instanceof FunctionDescriptor) { - return typeMapper.mapSignature((FunctionDescriptor) descriptor); + else if (callable instanceof PropertyDescriptor) { + PropertyDescriptor property = (PropertyDescriptor) callable; + // TODO } - return null; } } diff --git a/compiler/frontend.java/serialization.java/serialization.java.iml b/compiler/frontend.java/serialization.java/serialization.java.iml index 0a493903138..3af933ee3e9 100644 --- a/compiler/frontend.java/serialization.java/serialization.java.iml +++ b/compiler/frontend.java/serialization.java/serialization.java.iml @@ -10,6 +10,8 @@ + + diff --git a/compiler/frontend.java/serialization.java/src/java_descriptors.proto b/compiler/frontend.java/serialization.java/src/java_descriptors.proto index 1248d0edd8e..39115e7ffcb 100644 --- a/compiler/frontend.java/serialization.java/src/java_descriptors.proto +++ b/compiler/frontend.java/serialization.java/src/java_descriptors.proto @@ -21,6 +21,42 @@ import "compiler/frontend/serialization/src/descriptors.proto"; option java_outer_classname = "JavaProtoBuf"; option optimize_for = LITE_RUNTIME; -extend Callable { - optional string java_signature = 100; +message JavaType { + enum PrimitiveType { + // These values correspond to ASM Type sorts + VOID = 0; + BOOLEAN = 1; + CHAR = 2; + BYTE = 3; + SHORT = 4; + INT = 5; + FLOAT = 6; + LONG = 7; + DOUBLE = 8; + } + + // One of these should be present + optional PrimitiveType primitive_type = 1; + optional int32 class_fq_name = 2; + + optional int32 array_dimension = 3 [default = 0]; +} + +message JavaMethodSignature { + required int32 name = 1; + required JavaType return_type = 2; + repeated JavaType parameter_type = 3; +} + +message JavaPropertySignature { + required JavaType type = 1; + optional int32 field_name = 2; + optional JavaMethodSignature getter = 3; + optional JavaMethodSignature setter = 4; +} + +extend Callable { + optional JavaMethodSignature method_signature = 100; + + optional JavaPropertySignature property_signature = 101; } diff --git a/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBuf.java b/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBuf.java index 9e7df4210cc..eccb8ddaea6 100644 --- a/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBuf.java +++ b/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBuf.java @@ -7,20 +7,1592 @@ public final class JavaProtoBuf { private JavaProtoBuf() {} public static void registerAllExtensions( com.google.protobuf.ExtensionRegistryLite registry) { - registry.add(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.javaSignature); + registry.add(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.methodSignature); + registry.add(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.propertySignature); } - public static final int JAVA_SIGNATURE_FIELD_NUMBER = 100; + public interface JavaTypeOrBuilder + extends com.google.protobuf.MessageLiteOrBuilder { + + // optional .org.jetbrains.jet.descriptors.serialization.JavaType.PrimitiveType primitive_type = 1; + boolean hasPrimitiveType(); + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType getPrimitiveType(); + + // optional int32 class_fq_name = 2; + boolean hasClassFqName(); + int getClassFqName(); + + // optional int32 array_dimension = 3 [default = 0]; + boolean hasArrayDimension(); + int getArrayDimension(); + } + public static final class JavaType extends + com.google.protobuf.GeneratedMessageLite + implements JavaTypeOrBuilder { + // Use JavaType.newBuilder() to construct. + private JavaType(Builder builder) { + super(builder); + } + private JavaType(boolean noInit) {} + + private static final JavaType defaultInstance; + public static JavaType getDefaultInstance() { + return defaultInstance; + } + + public JavaType getDefaultInstanceForType() { + return defaultInstance; + } + + public enum PrimitiveType + implements com.google.protobuf.Internal.EnumLite { + VOID(0, 0), + BOOLEAN(1, 1), + CHAR(2, 2), + BYTE(3, 3), + SHORT(4, 4), + INT(5, 5), + FLOAT(6, 6), + LONG(7, 7), + DOUBLE(8, 8), + ; + + public static final int VOID_VALUE = 0; + public static final int BOOLEAN_VALUE = 1; + public static final int CHAR_VALUE = 2; + public static final int BYTE_VALUE = 3; + public static final int SHORT_VALUE = 4; + public static final int INT_VALUE = 5; + public static final int FLOAT_VALUE = 6; + public static final int LONG_VALUE = 7; + public static final int DOUBLE_VALUE = 8; + + + public final int getNumber() { return value; } + + public static PrimitiveType valueOf(int value) { + switch (value) { + case 0: return VOID; + case 1: return BOOLEAN; + case 2: return CHAR; + case 3: return BYTE; + case 4: return SHORT; + case 5: return INT; + case 6: return FLOAT; + case 7: return LONG; + case 8: return DOUBLE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public PrimitiveType findValueByNumber(int number) { + return PrimitiveType.valueOf(number); + } + }; + + private final int value; + + private PrimitiveType(int index, int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:org.jetbrains.jet.descriptors.serialization.JavaType.PrimitiveType) + } + + private int bitField0_; + // optional .org.jetbrains.jet.descriptors.serialization.JavaType.PrimitiveType primitive_type = 1; + public static final int PRIMITIVE_TYPE_FIELD_NUMBER = 1; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType primitiveType_; + public boolean hasPrimitiveType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType getPrimitiveType() { + return primitiveType_; + } + + // optional int32 class_fq_name = 2; + public static final int CLASS_FQ_NAME_FIELD_NUMBER = 2; + private int classFqName_; + public boolean hasClassFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getClassFqName() { + return classFqName_; + } + + // optional int32 array_dimension = 3 [default = 0]; + public static final int ARRAY_DIMENSION_FIELD_NUMBER = 3; + private int arrayDimension_; + public boolean hasArrayDimension() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public int getArrayDimension() { + return arrayDimension_; + } + + private void initFields() { + primitiveType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType.VOID; + classFqName_ = 0; + arrayDimension_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeEnum(1, primitiveType_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, classFqName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeInt32(3, arrayDimension_); + } + } + + 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 + .computeEnumSize(1, primitiveType_.getNumber()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, classFqName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(3, arrayDimension_); + } + 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.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + public static final class Builder extends + com.google.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType, Builder> + implements org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaTypeOrBuilder { + // Construct using org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + primitiveType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType.VOID; + bitField0_ = (bitField0_ & ~0x00000001); + classFqName_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + arrayDimension_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getDefaultInstanceForType() { + return org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType build() { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType buildPartial() { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType result = new org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.primitiveType_ = primitiveType_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.classFqName_ = classFqName_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.arrayDimension_ = arrayDimension_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType other) { + if (other == org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance()) return this; + if (other.hasPrimitiveType()) { + setPrimitiveType(other.getPrimitiveType()); + } + if (other.hasClassFqName()) { + setClassFqName(other.getClassFqName()); + } + if (other.hasArrayDimension()) { + setArrayDimension(other.getArrayDimension()); + } + return this; + } + + public final boolean isInitialized() { + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + + return this; + default: { + if (!parseUnknownField(input, extensionRegistry, tag)) { + + return this; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType value = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType.valueOf(rawValue); + if (value != null) { + bitField0_ |= 0x00000001; + primitiveType_ = value; + } + break; + } + case 16: { + bitField0_ |= 0x00000002; + classFqName_ = input.readInt32(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + arrayDimension_ = input.readInt32(); + break; + } + } + } + } + + private int bitField0_; + + // optional .org.jetbrains.jet.descriptors.serialization.JavaType.PrimitiveType primitive_type = 1; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType primitiveType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType.VOID; + public boolean hasPrimitiveType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType getPrimitiveType() { + return primitiveType_; + } + public Builder setPrimitiveType(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + primitiveType_ = value; + + return this; + } + public Builder clearPrimitiveType() { + bitField0_ = (bitField0_ & ~0x00000001); + primitiveType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.PrimitiveType.VOID; + + return this; + } + + // optional int32 class_fq_name = 2; + private int classFqName_ ; + public boolean hasClassFqName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getClassFqName() { + return classFqName_; + } + public Builder setClassFqName(int value) { + bitField0_ |= 0x00000002; + classFqName_ = value; + + return this; + } + public Builder clearClassFqName() { + bitField0_ = (bitField0_ & ~0x00000002); + classFqName_ = 0; + + return this; + } + + // optional int32 array_dimension = 3 [default = 0]; + private int arrayDimension_ ; + public boolean hasArrayDimension() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public int getArrayDimension() { + return arrayDimension_; + } + public Builder setArrayDimension(int value) { + bitField0_ |= 0x00000004; + arrayDimension_ = value; + + return this; + } + public Builder clearArrayDimension() { + bitField0_ = (bitField0_ & ~0x00000004); + arrayDimension_ = 0; + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.jet.descriptors.serialization.JavaType) + } + + static { + defaultInstance = new JavaType(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.jet.descriptors.serialization.JavaType) + } + + public interface JavaMethodSignatureOrBuilder + extends com.google.protobuf.MessageLiteOrBuilder { + + // required int32 name = 1; + boolean hasName(); + int getName(); + + // required .org.jetbrains.jet.descriptors.serialization.JavaType return_type = 2; + boolean hasReturnType(); + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getReturnType(); + + // repeated .org.jetbrains.jet.descriptors.serialization.JavaType parameter_type = 3; + java.util.List + getParameterTypeList(); + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getParameterType(int index); + int getParameterTypeCount(); + } + public static final class JavaMethodSignature extends + com.google.protobuf.GeneratedMessageLite + implements JavaMethodSignatureOrBuilder { + // Use JavaMethodSignature.newBuilder() to construct. + private JavaMethodSignature(Builder builder) { + super(builder); + } + private JavaMethodSignature(boolean noInit) {} + + private static final JavaMethodSignature defaultInstance; + public static JavaMethodSignature getDefaultInstance() { + return defaultInstance; + } + + public JavaMethodSignature getDefaultInstanceForType() { + return defaultInstance; + } + + private int bitField0_; + // required int32 name = 1; + public static final int NAME_FIELD_NUMBER = 1; + private int name_; + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getName() { + return name_; + } + + // required .org.jetbrains.jet.descriptors.serialization.JavaType return_type = 2; + public static final int RETURN_TYPE_FIELD_NUMBER = 2; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType returnType_; + public boolean hasReturnType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getReturnType() { + return returnType_; + } + + // repeated .org.jetbrains.jet.descriptors.serialization.JavaType parameter_type = 3; + public static final int PARAMETER_TYPE_FIELD_NUMBER = 3; + private java.util.List parameterType_; + public java.util.List getParameterTypeList() { + return parameterType_; + } + public java.util.List + getParameterTypeOrBuilderList() { + return parameterType_; + } + public int getParameterTypeCount() { + return parameterType_.size(); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getParameterType(int index) { + return parameterType_.get(index); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaTypeOrBuilder getParameterTypeOrBuilder( + int index) { + return parameterType_.get(index); + } + + private void initFields() { + name_ = 0; + returnType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + parameterType_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasReturnType()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeInt32(1, name_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, returnType_); + } + for (int i = 0; i < parameterType_.size(); i++) { + output.writeMessage(3, parameterType_.get(i)); + } + } + + 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_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, returnType_); + } + for (int i = 0; i < parameterType_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, parameterType_.get(i)); + } + 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.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + public static final class Builder extends + com.google.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature, Builder> + implements org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignatureOrBuilder { + // Construct using org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + name_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + returnType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); + parameterType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getDefaultInstanceForType() { + return org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature build() { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature buildPartial() { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature result = new org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.returnType_ = returnType_; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + parameterType_ = java.util.Collections.unmodifiableList(parameterType_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.parameterType_ = parameterType_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature other) { + if (other == org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance()) return this; + if (other.hasName()) { + setName(other.getName()); + } + if (other.hasReturnType()) { + mergeReturnType(other.getReturnType()); + } + if (!other.parameterType_.isEmpty()) { + if (parameterType_.isEmpty()) { + parameterType_ = other.parameterType_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureParameterTypeIsMutable(); + parameterType_.addAll(other.parameterType_); + } + + } + return this; + } + + public final boolean isInitialized() { + if (!hasName()) { + + return false; + } + if (!hasReturnType()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + + return this; + default: { + if (!parseUnknownField(input, extensionRegistry, tag)) { + + return this; + } + break; + } + case 8: { + bitField0_ |= 0x00000001; + name_ = input.readInt32(); + break; + } + case 18: { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder subBuilder = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.newBuilder(); + if (hasReturnType()) { + subBuilder.mergeFrom(getReturnType()); + } + input.readMessage(subBuilder, extensionRegistry); + setReturnType(subBuilder.buildPartial()); + break; + } + case 26: { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder subBuilder = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.newBuilder(); + input.readMessage(subBuilder, extensionRegistry); + addParameterType(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // required int32 name = 1; + private int name_ ; + public boolean hasName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public int getName() { + return name_; + } + public Builder setName(int value) { + bitField0_ |= 0x00000001; + name_ = value; + + return this; + } + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = 0; + + return this; + } + + // required .org.jetbrains.jet.descriptors.serialization.JavaType return_type = 2; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType returnType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + public boolean hasReturnType() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getReturnType() { + return returnType_; + } + public Builder setReturnType(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType value) { + if (value == null) { + throw new NullPointerException(); + } + returnType_ = value; + + bitField0_ |= 0x00000002; + return this; + } + public Builder setReturnType( + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder builderForValue) { + returnType_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + public Builder mergeReturnType(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + returnType_ != org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance()) { + returnType_ = + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.newBuilder(returnType_).mergeFrom(value).buildPartial(); + } else { + returnType_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + public Builder clearReturnType() { + returnType_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + // repeated .org.jetbrains.jet.descriptors.serialization.JavaType parameter_type = 3; + private java.util.List parameterType_ = + java.util.Collections.emptyList(); + private void ensureParameterTypeIsMutable() { + if (!((bitField0_ & 0x00000004) == 0x00000004)) { + parameterType_ = new java.util.ArrayList(parameterType_); + bitField0_ |= 0x00000004; + } + } + + public java.util.List getParameterTypeList() { + return java.util.Collections.unmodifiableList(parameterType_); + } + public int getParameterTypeCount() { + return parameterType_.size(); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getParameterType(int index) { + return parameterType_.get(index); + } + public Builder setParameterType( + int index, org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureParameterTypeIsMutable(); + parameterType_.set(index, value); + + return this; + } + public Builder setParameterType( + int index, org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder builderForValue) { + ensureParameterTypeIsMutable(); + parameterType_.set(index, builderForValue.build()); + + return this; + } + public Builder addParameterType(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureParameterTypeIsMutable(); + parameterType_.add(value); + + return this; + } + public Builder addParameterType( + int index, org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType value) { + if (value == null) { + throw new NullPointerException(); + } + ensureParameterTypeIsMutable(); + parameterType_.add(index, value); + + return this; + } + public Builder addParameterType( + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder builderForValue) { + ensureParameterTypeIsMutable(); + parameterType_.add(builderForValue.build()); + + return this; + } + public Builder addParameterType( + int index, org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder builderForValue) { + ensureParameterTypeIsMutable(); + parameterType_.add(index, builderForValue.build()); + + return this; + } + public Builder addAllParameterType( + java.lang.Iterable values) { + ensureParameterTypeIsMutable(); + super.addAll(values, parameterType_); + + return this; + } + public Builder clearParameterType() { + parameterType_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + + return this; + } + public Builder removeParameterType(int index) { + ensureParameterTypeIsMutable(); + parameterType_.remove(index); + + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.jet.descriptors.serialization.JavaMethodSignature) + } + + static { + defaultInstance = new JavaMethodSignature(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.jet.descriptors.serialization.JavaMethodSignature) + } + + public interface JavaPropertySignatureOrBuilder + extends com.google.protobuf.MessageLiteOrBuilder { + + // required .org.jetbrains.jet.descriptors.serialization.JavaType type = 1; + boolean hasType(); + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getType(); + + // optional int32 field_name = 2; + boolean hasFieldName(); + int getFieldName(); + + // optional .org.jetbrains.jet.descriptors.serialization.JavaMethodSignature getter = 3; + boolean hasGetter(); + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getGetter(); + + // optional .org.jetbrains.jet.descriptors.serialization.JavaMethodSignature setter = 4; + boolean hasSetter(); + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getSetter(); + } + public static final class JavaPropertySignature extends + com.google.protobuf.GeneratedMessageLite + implements JavaPropertySignatureOrBuilder { + // Use JavaPropertySignature.newBuilder() to construct. + private JavaPropertySignature(Builder builder) { + super(builder); + } + private JavaPropertySignature(boolean noInit) {} + + private static final JavaPropertySignature defaultInstance; + public static JavaPropertySignature getDefaultInstance() { + return defaultInstance; + } + + public JavaPropertySignature getDefaultInstanceForType() { + return defaultInstance; + } + + private int bitField0_; + // required .org.jetbrains.jet.descriptors.serialization.JavaType type = 1; + public static final int TYPE_FIELD_NUMBER = 1; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType type_; + public boolean hasType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getType() { + return type_; + } + + // optional int32 field_name = 2; + public static final int FIELD_NAME_FIELD_NUMBER = 2; + private int fieldName_; + public boolean hasFieldName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getFieldName() { + return fieldName_; + } + + // optional .org.jetbrains.jet.descriptors.serialization.JavaMethodSignature getter = 3; + public static final int GETTER_FIELD_NUMBER = 3; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getter_; + public boolean hasGetter() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getGetter() { + return getter_; + } + + // optional .org.jetbrains.jet.descriptors.serialization.JavaMethodSignature setter = 4; + public static final int SETTER_FIELD_NUMBER = 4; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature setter_; + public boolean hasSetter() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getSetter() { + return setter_; + } + + private void initFields() { + type_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + fieldName_ = 0; + getter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + setter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasGetter()) { + if (!getGetter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSetter()) { + if (!getSetter().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, type_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeInt32(2, fieldName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, getter_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeMessage(4, setter_); + } + } + + 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 + .computeMessageSize(1, type_); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(2, fieldName_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getter_); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, setter_); + } + 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.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + public static final class Builder extends + com.google.protobuf.GeneratedMessageLite.Builder< + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature, Builder> + implements org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignatureOrBuilder { + // Construct using org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private void maybeForceBuilderInitialization() { + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + type_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); + fieldName_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + getter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); + setter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature getDefaultInstanceForType() { + return org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature.getDefaultInstance(); + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature build() { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature buildPartial() { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature result = new org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.fieldName_ = fieldName_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.getter_ = getter_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.setter_ = setter_; + result.bitField0_ = to_bitField0_; + return result; + } + + public Builder mergeFrom(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature other) { + if (other == org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature.getDefaultInstance()) return this; + if (other.hasType()) { + mergeType(other.getType()); + } + if (other.hasFieldName()) { + setFieldName(other.getFieldName()); + } + if (other.hasGetter()) { + mergeGetter(other.getGetter()); + } + if (other.hasSetter()) { + mergeSetter(other.getSetter()); + } + return this; + } + + public final boolean isInitialized() { + if (!hasType()) { + + return false; + } + if (hasGetter()) { + if (!getGetter().isInitialized()) { + + return false; + } + } + if (hasSetter()) { + if (!getSetter().isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + + return this; + default: { + if (!parseUnknownField(input, extensionRegistry, tag)) { + + return this; + } + break; + } + case 10: { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder subBuilder = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.newBuilder(); + if (hasType()) { + subBuilder.mergeFrom(getType()); + } + input.readMessage(subBuilder, extensionRegistry); + setType(subBuilder.buildPartial()); + break; + } + case 16: { + bitField0_ |= 0x00000002; + fieldName_ = input.readInt32(); + break; + } + case 26: { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.Builder subBuilder = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.newBuilder(); + if (hasGetter()) { + subBuilder.mergeFrom(getGetter()); + } + input.readMessage(subBuilder, extensionRegistry); + setGetter(subBuilder.buildPartial()); + break; + } + case 34: { + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.Builder subBuilder = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.newBuilder(); + if (hasSetter()) { + subBuilder.mergeFrom(getSetter()); + } + input.readMessage(subBuilder, extensionRegistry); + setSetter(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // required .org.jetbrains.jet.descriptors.serialization.JavaType type = 1; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType type_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + public boolean hasType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType getType() { + return type_; + } + public Builder setType(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType value) { + if (value == null) { + throw new NullPointerException(); + } + type_ = value; + + bitField0_ |= 0x00000001; + return this; + } + public Builder setType( + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.Builder builderForValue) { + type_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + public Builder mergeType(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + type_ != org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance()) { + type_ = + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.newBuilder(type_).mergeFrom(value).buildPartial(); + } else { + type_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + public Builder clearType() { + type_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaType.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + // optional int32 field_name = 2; + private int fieldName_ ; + public boolean hasFieldName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getFieldName() { + return fieldName_; + } + public Builder setFieldName(int value) { + bitField0_ |= 0x00000002; + fieldName_ = value; + + return this; + } + public Builder clearFieldName() { + bitField0_ = (bitField0_ & ~0x00000002); + fieldName_ = 0; + + return this; + } + + // optional .org.jetbrains.jet.descriptors.serialization.JavaMethodSignature getter = 3; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + public boolean hasGetter() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getGetter() { + return getter_; + } + public Builder setGetter(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature value) { + if (value == null) { + throw new NullPointerException(); + } + getter_ = value; + + bitField0_ |= 0x00000004; + return this; + } + public Builder setGetter( + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.Builder builderForValue) { + getter_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + public Builder mergeGetter(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + getter_ != org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance()) { + getter_ = + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.newBuilder(getter_).mergeFrom(value).buildPartial(); + } else { + getter_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + public Builder clearGetter() { + getter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + // optional .org.jetbrains.jet.descriptors.serialization.JavaMethodSignature setter = 4; + private org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature setter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + public boolean hasSetter() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature getSetter() { + return setter_; + } + public Builder setSetter(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature value) { + if (value == null) { + throw new NullPointerException(); + } + setter_ = value; + + bitField0_ |= 0x00000008; + return this; + } + public Builder setSetter( + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.Builder builderForValue) { + setter_ = builderForValue.build(); + + bitField0_ |= 0x00000008; + return this; + } + public Builder mergeSetter(org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature value) { + if (((bitField0_ & 0x00000008) == 0x00000008) && + setter_ != org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance()) { + setter_ = + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.newBuilder(setter_).mergeFrom(value).buildPartial(); + } else { + setter_ = value; + } + + bitField0_ |= 0x00000008; + return this; + } + public Builder clearSetter() { + setter_ = org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + // @@protoc_insertion_point(builder_scope:org.jetbrains.jet.descriptors.serialization.JavaPropertySignature) + } + + static { + defaultInstance = new JavaPropertySignature(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:org.jetbrains.jet.descriptors.serialization.JavaPropertySignature) + } + + public static final int METHOD_SIGNATURE_FIELD_NUMBER = 100; public static final com.google.protobuf.GeneratedMessageLite.GeneratedExtension< org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable, - java.lang.String> javaSignature = com.google.protobuf.GeneratedMessageLite + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature> methodSignature = com.google.protobuf.GeneratedMessageLite .newSingularGeneratedExtension( org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable.getDefaultInstance(), - "", - null, + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(), + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaMethodSignature.getDefaultInstance(), null, 100, - com.google.protobuf.WireFormat.FieldType.STRING); + com.google.protobuf.WireFormat.FieldType.MESSAGE); + public static final int PROPERTY_SIGNATURE_FIELD_NUMBER = 101; + public static final + com.google.protobuf.GeneratedMessageLite.GeneratedExtension< + org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable, + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature> propertySignature = com.google.protobuf.GeneratedMessageLite + .newSingularGeneratedExtension( + org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable.getDefaultInstance(), + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature.getDefaultInstance(), + org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.JavaPropertySignature.getDefaultInstance(), + null, + 101, + com.google.protobuf.WireFormat.FieldType.MESSAGE); static { } diff --git a/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBufUtil.java b/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBufUtil.java index 136797a00dd..ad4773f0017 100644 --- a/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBufUtil.java +++ b/compiler/frontend.java/serialization.java/src/org/jetbrains/jet/descriptors/serialization/JavaProtoBufUtil.java @@ -19,22 +19,138 @@ package org.jetbrains.jet.descriptors.serialization; import com.google.protobuf.ExtensionRegistryLite; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.asm4.Type; +import org.jetbrains.asm4.commons.Method; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.Name; -import static org.jetbrains.jet.descriptors.serialization.JavaProtoBuf.javaSignature; +import java.util.Arrays; + +import static org.jetbrains.asm4.Type.*; public class JavaProtoBufUtil { private JavaProtoBufUtil() { } @Nullable - public static String loadJavaSignature(@NotNull ProtoBuf.Callable callable) { - return callable.hasExtension(javaSignature) ? callable.getExtension(javaSignature) : null; + public static String loadMethodSignature(@NotNull ProtoBuf.Callable proto, @NotNull NameResolver nameResolver) { + if (!proto.hasExtension(JavaProtoBuf.methodSignature)) return null; + JavaProtoBuf.JavaMethodSignature signature = proto.getExtension(JavaProtoBuf.methodSignature); + return new Deserializer(nameResolver).methodSignature(signature).toString(); } - public static void saveJavaSignature(@NotNull ProtoBuf.Callable.Builder callable, @NotNull String signature) { - callable.setExtension(javaSignature, signature); + public static void saveMethodSignature( + @NotNull ProtoBuf.Callable.Builder proto, + @NotNull Method method, + @NotNull NameTable nameTable + ) { + proto.setExtension(JavaProtoBuf.methodSignature, new Serializer(nameTable).methodSignature(method)); } + private static class Serializer { + private final NameTable nameTable; + + public Serializer(@NotNull NameTable nameTable) { + this.nameTable = nameTable; + } + + @NotNull + public JavaProtoBuf.JavaMethodSignature methodSignature(@NotNull Method method) { + JavaProtoBuf.JavaMethodSignature.Builder signature = JavaProtoBuf.JavaMethodSignature.newBuilder(); + + signature.setName(nameTable.getSimpleNameIndex(Name.guess(method.getName()))); + + signature.setReturnType(type(method.getReturnType())); + + for (Type type : method.getArgumentTypes()) { + signature.addParameterType(type(type)); + } + + return signature.build(); + } + + @NotNull + private JavaProtoBuf.JavaType type(@NotNull Type givenType) { + JavaProtoBuf.JavaType.Builder builder = JavaProtoBuf.JavaType.newBuilder(); + + int arrayDimension = 0; + Type type = givenType; + while (type.getSort() == Type.ARRAY) { + arrayDimension++; + type = type.getElementType(); + } + if (arrayDimension != 0) { + builder.setArrayDimension(arrayDimension); + } + + if (type.getSort() == Type.OBJECT) { + FqName fqName = internalNameToFqName(type.getInternalName()); + builder.setClassFqName(nameTable.getFqNameIndex(fqName)); + } + else { + builder.setPrimitiveType(JavaProtoBuf.JavaType.PrimitiveType.valueOf(type.getSort())); + } + + return builder.build(); + } + + @NotNull + private static FqName internalNameToFqName(@NotNull String internalName) { + return FqName.fromSegments(Arrays.asList(internalName.split("/"))); + } + } + + private static class Deserializer { + // These types are ordered according to their sorts, this is significant for deserialization + private static final Type[] PRIMITIVE_TYPES = new Type[] + { VOID_TYPE, BOOLEAN_TYPE, CHAR_TYPE, BYTE_TYPE, SHORT_TYPE, INT_TYPE, FLOAT_TYPE, LONG_TYPE, DOUBLE_TYPE }; + + private final NameResolver nameResolver; + + public Deserializer(@NotNull NameResolver nameResolver) { + this.nameResolver = nameResolver; + } + + @NotNull + public Method methodSignature(@NotNull JavaProtoBuf.JavaMethodSignature signature) { + String name = nameResolver.getName(signature.getName()).asString(); + + Type returnType = type(signature.getReturnType()); + + int parameters = signature.getParameterTypeCount(); + Type[] parameterTypes = new Type[parameters]; + for (int i = 0; i < parameters; i++) { + parameterTypes[i] = type(signature.getParameterType(i)); + } + + return new Method(name, returnType, parameterTypes); + } + + @NotNull + private Type type(@NotNull JavaProtoBuf.JavaType type) { + Type result; + if (type.hasPrimitiveType()) { + result = PRIMITIVE_TYPES[type.getPrimitiveType().ordinal()]; + } + else { + result = Type.getObjectType(fqNameToInternalName(nameResolver.getFqName(type.getClassFqName()))); + } + + StringBuilder brackets = new StringBuilder(type.getArrayDimension()); + for (int i = 0; i < type.getArrayDimension(); i++) { + brackets.append('['); + } + + return Type.getType(brackets + result.getDescriptor()); + } + + @NotNull + private static String fqNameToInternalName(@NotNull FqName fqName) { + return fqName.asString().replace('.', '/'); + } + } + + @NotNull public static ExtensionRegistryLite getExtensionRegistry() { ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java index db772f71f79..f75d6ae7b85 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java @@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.asm4.*; import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil; +import org.jetbrains.jet.descriptors.serialization.NameResolver; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -175,17 +176,19 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer @Override public List loadCallableAnnotations( @NotNull ClassOrNamespaceDescriptor container, - @NotNull ProtoBuf.Callable callableProto + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind ) { + String signature = getCallableSignature(proto, nameResolver, kind); + if (signature == null) return Collections.emptyList(); + VirtualFile file = findVirtualFileByDescriptor(container); try { // TODO: calculate this only once for each container Map> memberAnnotations = loadMemberAnnotationsFromFile(file); - String signature = JavaProtoBufUtil.loadJavaSignature(callableProto); - if (signature == null) return Collections.emptyList(); - List annotations = memberAnnotations.get(signature); return annotations == null ? Collections.emptyList() : annotations; } @@ -194,6 +197,21 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer } } + @Nullable + private static String getCallableSignature( + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind + ) { + switch (kind) { + case FUNCTION: + return JavaProtoBufUtil.loadMethodSignature(proto, nameResolver); + // TODO: getters, setters + default: + return null; + } + } + @NotNull private Map> loadMemberAnnotationsFromFile(@NotNull VirtualFile file) throws IOException { final Map> memberAnnotations = new HashMap>(); diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java index e7209ff85e8..88197c4aeff 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java @@ -37,6 +37,7 @@ import java.util.List; import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable; import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter; import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE; +import static org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer.AnnotatedCallableKind; public class DescriptorDeserializer { @@ -153,7 +154,7 @@ public class DescriptorDeserializer { boolean isNotDefault = proto.hasGetterFlags() && Flags.IS_NOT_DEFAULT.get(getterFlags); if (isNotDefault) { getter = new PropertyGetterDescriptorImpl( - property, Collections.emptyList(), + property, getAnnotations(proto, getterFlags, AnnotatedCallableKind.PROPERTY_GETTER), modality(Flags.MODALITY.get(getterFlags)), visibility(Flags.VISIBILITY.get(getterFlags)), isNotDefault, !isNotDefault, property.getKind() ); @@ -169,7 +170,7 @@ public class DescriptorDeserializer { boolean isNotDefault = proto.hasSetterFlags() && Flags.IS_NOT_DEFAULT.get(setterFlags); if (isNotDefault) { setter = new PropertySetterDescriptorImpl( - property, getAnnotations(proto, setterFlags), + property, getAnnotations(proto, setterFlags, AnnotatedCallableKind.PROPERTY_SETTER), modality(Flags.MODALITY.get(setterFlags)), visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, !isNotDefault, property.getKind() ); @@ -192,7 +193,7 @@ public class DescriptorDeserializer { private PropertyDescriptorImpl createPropertyDescriptor(@NotNull Callable proto) { int flags = proto.getFlags(); Name name = nameResolver.getName(proto.getName()); - List annotations = getAnnotations(proto, proto.getFlags()); + List annotations = Collections.emptyList(); // TODO: getAnnotations(proto, flags, PROPERTY); Visibility visibility = visibility(Flags.VISIBILITY.get(flags)); Callable.CallableKind callableKind = Flags.CALLABLE_KIND.get(flags); @@ -221,7 +222,7 @@ public class DescriptorDeserializer { int flags = proto.getFlags(); SimpleFunctionDescriptorImpl function = new SimpleFunctionDescriptorImpl( containingDeclaration, - getAnnotations(proto, proto.getFlags()), + getAnnotations(proto, proto.getFlags(), AnnotatedCallableKind.FUNCTION), nameResolver.getName(proto.getName()), memberKind(Flags.MEMBER_KIND.get(flags)) ); @@ -252,7 +253,7 @@ public class DescriptorDeserializer { ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; ConstructorDescriptorImpl descriptor = new ConstructorDescriptorImpl( classDescriptor, - getAnnotations(proto, proto.getFlags()), + getAnnotations(proto, proto.getFlags(), AnnotatedCallableKind.FUNCTION), // TODO: primary true); List typeParameters = new ArrayList(proto.getTypeParameterCount()); @@ -268,11 +269,12 @@ public class DescriptorDeserializer { } @NotNull - private List getAnnotations(@NotNull Callable proto, int flags) { + private List getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) { assert containingDeclaration instanceof ClassOrNamespaceDescriptor : "Only members in classes or namespaces should be serialized: " + containingDeclaration; return Flags.HAS_ANNOTATIONS.get(flags) - ? annotationDeserializer.loadCallableAnnotations((ClassOrNamespaceDescriptor) containingDeclaration, proto) + ? annotationDeserializer + .loadCallableAnnotations((ClassOrNamespaceDescriptor) containingDeclaration, proto, nameResolver, kind) : Collections.emptyList(); } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java index 5414d89616f..e4216294e92 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java @@ -212,7 +212,7 @@ public class DescriptorSerializer { builder.setReturnType(local.type(getSerializableReturnType(descriptor.getReturnType()))); - extension.serializeCallable(descriptor, builder); + extension.serializeCallable(descriptor, builder, nameTable); return builder; } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameResolver.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameResolver.java index 75690ab6691..1416cd8e0a3 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameResolver.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameResolver.java @@ -76,11 +76,7 @@ public class NameResolver { } @Nullable - private QualifiedName renderFqName( - StringBuilder sb, - QualifiedName fqNameProto, - QualifiedName.Kind kind - ) { + private QualifiedName renderFqName(StringBuilder sb, QualifiedName fqNameProto, QualifiedName.Kind kind) { QualifiedName result = null; if (fqNameProto.hasParentQualifiedName()) { QualifiedName parentProto = qualifiedNames.getQualifiedName(fqNameProto.getParentQualifiedName()); @@ -95,4 +91,14 @@ public class NameResolver { sb.append(simpleNames.getName(fqNameProto.getShortName())); return result; } + + @NotNull + public FqName getFqName(int index) { + QualifiedName qualifiedName = qualifiedNames.getQualifiedName(index); + Name shortName = getName(qualifiedName.getShortName()); + if (!qualifiedName.hasParentQualifiedName()) { + return FqName.topLevel(shortName); + } + return getFqName(qualifiedName.getParentQualifiedName()).child(shortName); + } } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java index f84ba3be4ad..cda04195448 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java @@ -19,10 +19,11 @@ package org.jetbrains.jet.descriptors.serialization; import gnu.trove.TObjectHashingStrategy; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import java.util.List; @@ -42,9 +43,7 @@ public class NameTable { } @Override - public boolean equals( - QualifiedName.Builder o1, QualifiedName.Builder o2 - ) { + public boolean equals(QualifiedName.Builder o1, QualifiedName.Builder o2) { return o1.getParentQualifiedName() == o2.getParentQualifiedName() && o1.getShortName() == o2.getShortName() && o1.getKind() == o2.getKind(); @@ -71,18 +70,17 @@ public class NameTable { return simpleNames.intern(name.asString()); } - public int getFqNameIndex(@NotNull ClassDescriptor classDescriptor) { + public int getFqNameIndex(@NotNull ClassOrNamespaceDescriptor descriptor) { QualifiedName.Builder builder = QualifiedName.newBuilder(); - builder.setKind(QualifiedName.Kind.CLASS); - builder.setShortName(getSimpleNameIndex(classDescriptor.getName())); + if (descriptor instanceof ClassDescriptor) { + builder.setKind(QualifiedName.Kind.CLASS); + } + builder.setShortName(getSimpleNameIndex(descriptor.getName())); - DeclarationDescriptor containingDeclaration = classDescriptor.getContainingDeclaration(); + DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); if (containingDeclaration instanceof NamespaceDescriptor) { NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration; - if (DescriptorUtils.isRootNamespace(namespaceDescriptor)) { - builder.clearParentQualifiedName(); - } - else { + if (!DescriptorUtils.isRootNamespace(namespaceDescriptor)) { builder.setParentQualifiedName(getFqNameIndex(namespaceDescriptor)); } } @@ -91,28 +89,22 @@ public class NameTable { builder.setParentQualifiedName(getFqNameIndex(outerClass)); } else { - throw new IllegalStateException("FQ names are only stored for top-level or inner classes: " + classDescriptor); + throw new IllegalStateException("FQ names are only stored for top-level or inner classes: " + descriptor); } return qualifiedNames.intern(builder); } - public int getFqNameIndex(@NotNull NamespaceDescriptor namespaceDescriptor) { - QualifiedName.Builder builder = QualifiedName.newBuilder(); - //default: builder.setKind(QualifiedNameTable.QualifiedName.Kind.PACKAGE); - builder.setShortName(getSimpleNameIndex(namespaceDescriptor.getName())); - - NamespaceDescriptorParent containingDeclaration = namespaceDescriptor.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { - NamespaceDescriptor parentNamespace = (NamespaceDescriptor) containingDeclaration; - if (!DescriptorUtils.isRootNamespace(parentNamespace)) { - builder.setParentQualifiedName(getFqNameIndex(parentNamespace)); + public int getFqNameIndex(@NotNull FqName fqName) { + int result = -1; + for (Name segment : fqName.pathSegments()) { + QualifiedName.Builder builder = QualifiedName.newBuilder(); + builder.setShortName(getSimpleNameIndex(segment)); + if (result != -1) { + builder.setParentQualifiedName(result); } + result = qualifiedNames.intern(builder); } - else { - builder.clearParentQualifiedName(); - } - - return qualifiedNames.intern(builder); + return result; } } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/SerializerExtension.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/SerializerExtension.java index cb19039ca5c..53215e36252 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/SerializerExtension.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/SerializerExtension.java @@ -27,6 +27,10 @@ public abstract class SerializerExtension { return true; } - public void serializeCallable(@NotNull CallableMemberDescriptor callable, @NotNull ProtoBuf.Callable.Builder proto) { + public void serializeCallable( + @NotNull CallableMemberDescriptor callable, + @NotNull ProtoBuf.Callable.Builder proto, + @NotNull NameTable nameTable + ) { } } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java index a726690deda..20c2bf1e29e 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java @@ -1,6 +1,7 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.descriptors.serialization.NameResolver; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor; @@ -19,7 +20,10 @@ public interface AnnotationDeserializer { @NotNull @Override public List loadCallableAnnotations( - @NotNull ClassOrNamespaceDescriptor container, @NotNull ProtoBuf.Callable callableProto + @NotNull ClassOrNamespaceDescriptor container, + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind ) { return notSupported(); } @@ -30,18 +34,27 @@ public interface AnnotationDeserializer { return notSupported(); } + @NotNull private List notSupported() { throw new UnsupportedOperationException("Annotations are not supported"); } }; + enum AnnotatedCallableKind { + FUNCTION, + PROPERTY_GETTER, + PROPERTY_SETTER + } + @NotNull List loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto); @NotNull List loadCallableAnnotations( @NotNull ClassOrNamespaceDescriptor container, - @NotNull ProtoBuf.Callable callableProto + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind ); @NotNull diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java index 7fdc049b25b..d789686e38d 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java @@ -76,7 +76,10 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith @NotNull @Override public List loadCallableAnnotations( - @NotNull ClassOrNamespaceDescriptor container, @NotNull ProtoBuf.Callable callableProto + @NotNull ClassOrNamespaceDescriptor container, + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind ) { throw new UnsupportedOperationException(); // TODO }