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 }