From 39c10867a0df528e55c34866cea061b27f27fc46 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 24 Dec 2015 03:13:52 +0300 Subject: [PATCH] Drop 'index' JVM binary format extension Compute the JVM parameer index manually instead --- .../kotlin/codegen/FunctionCodegen.java | 4 --- .../JvmSerializationBindings.java | 3 --- .../serialization/JvmSerializerExtension.java | 8 ------ .../serialization/jvm/DebugJvmProtoBuf.java | 25 ++++--------------- .../src/jvm_descriptors.proto | 5 ---- ...tBinaryClassAnnotationAndConstantLoader.kt | 22 +++++++++++++--- .../kotlin/serialization/jvm/JvmProtoBuf.java | 16 ------------ .../deserialization/MemberDeserializer.kt | 23 +++++------------ .../deserialization/ProtoContainer.kt | 8 ++++-- .../DeserializedClassDescriptor.kt | 14 +++++------ .../stubBuilder/ClassClsStubBuilder.kt | 12 ++------- .../jps/incremental/ProtoCompareGenerated.kt | 9 ------- 12 files changed, 44 insertions(+), 105 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index b8ac1b0c4c8..13dbb5d164a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -77,7 +77,6 @@ import java.util.Set; import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isNullableAny; import static org.jetbrains.kotlin.codegen.AsmUtil.*; -import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.INDEX_FOR_VALUE_PARAMETER; import static org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION; import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION; import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget.*; @@ -271,9 +270,6 @@ public class FunctionCodegen { if (kind == JvmMethodParameterKind.VALUE) { ValueParameterDescriptor parameter = iterator.next(); - if (parameter.getIndex() != i) { - v.getSerializationBindings().put(INDEX_FOR_VALUE_PARAMETER, parameter, i); - } AnnotationCodegen annotationCodegen = AnnotationCodegen.forParameter(i, mv, typeMapper); if (functionDescriptor instanceof PropertySetterDescriptor) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java index 5d82ae28a0d..464a93dfa0a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializationBindings.java @@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.descriptors.PropertyDescriptor; -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice; import org.jetbrains.kotlin.util.slicedMap.MutableSlicedMap; import org.jetbrains.kotlin.util.slicedMap.SlicedMapImpl; @@ -36,8 +35,6 @@ public final class JvmSerializationBindings { SerializationMappingSlice.create(); public static final SerializationMappingSlice SYNTHETIC_METHOD_FOR_PROPERTY = SerializationMappingSlice.create(); - public static final SerializationMappingSlice INDEX_FOR_VALUE_PARAMETER = - SerializationMappingSlice.create(); private static final class SerializationMappingSlice extends BasicWritableSlice { public SerializationMappingSlice() { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java index 810556ecc18..4b5323b0ca0 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java @@ -60,14 +60,6 @@ public class JvmSerializerExtension extends SerializerExtension { return useTypeTable; } - @Override - public void serializeValueParameter(@NotNull ValueParameterDescriptor descriptor, @NotNull ProtoBuf.ValueParameter.Builder proto) { - Integer index = bindings.get(INDEX_FOR_VALUE_PARAMETER, descriptor); - if (index != null) { - proto.setExtension(JvmProtoBuf.index, index); - } - } - @Override public void serializeType(@NotNull KotlinType type, @NotNull ProtoBuf.Type.Builder proto) { // TODO: don't store type annotations in our binary metadata on Java 8, use *TypeAnnotations attributes instead diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java b/compiler/tests/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java index ebd8e91581a..eba2d827f44 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java +++ b/compiler/tests/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java @@ -13,7 +13,6 @@ public final class DebugJvmProtoBuf { registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.typeAnnotation); registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.isRaw); registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.typeParameterAnnotation); - registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.index); registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.classAnnotation); } public interface StringTableTypesOrBuilder @@ -4591,17 +4590,6 @@ public final class DebugJvmProtoBuf { .newFileScopedGeneratedExtension( org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.class, org.jetbrains.kotlin.serialization.DebugProtoBuf.Annotation.getDefaultInstance()); - public static final int INDEX_FIELD_NUMBER = 100; - /** - * extend .org.jetbrains.kotlin.serialization.ValueParameter { ... } - */ - public static final - com.google.protobuf.GeneratedMessage.GeneratedExtension< - org.jetbrains.kotlin.serialization.DebugProtoBuf.ValueParameter, - java.lang.Integer> index = com.google.protobuf.GeneratedMessage - .newFileScopedGeneratedExtension( - java.lang.Integer.class, - null); public static final int CLASS_ANNOTATION_FIELD_NUMBER = 100; /** * extend .org.jetbrains.kotlin.serialization.Class { ... } @@ -4692,12 +4680,10 @@ public final class DebugJvmProtoBuf { "rameter_annotation\0221.org.jetbrains.kotli" + "n.serialization.TypeParameter\030d \003(\0132..or" + "g.jetbrains.kotlin.serialization.Annotat" + - "ion:A\n\005index\0222.org.jetbrains.kotlin.seri" + - "alization.ValueParameter\030d \001(\005:s\n\020class_" + - "annotation\022).org.jetbrains.kotlin.serial" + - "ization.Class\030d \003(\0132..org.jetbrains.kotl" + - "in.serialization.AnnotationB\022B\020DebugJvmP", - "rotoBuf" + "ion:s\n\020class_annotation\022).org.jetbrains." + + "kotlin.serialization.Class\030d \003(\0132..org.j" + + "etbrains.kotlin.serialization.Annotation" + + "B\022B\020DebugJvmProtoBuf" }; com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @@ -4740,8 +4726,7 @@ public final class DebugJvmProtoBuf { typeAnnotation.internalInit(descriptor.getExtensions().get(3)); isRaw.internalInit(descriptor.getExtensions().get(4)); typeParameterAnnotation.internalInit(descriptor.getExtensions().get(5)); - index.internalInit(descriptor.getExtensions().get(6)); - classAnnotation.internalInit(descriptor.getExtensions().get(7)); + classAnnotation.internalInit(descriptor.getExtensions().get(6)); com.google.protobuf.ExtensionRegistry registry = com.google.protobuf.ExtensionRegistry.newInstance(); registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable); diff --git a/core/descriptor.loader.java/src/jvm_descriptors.proto b/core/descriptor.loader.java/src/jvm_descriptors.proto index 287fa66d7e8..a3e7d9f55b6 100644 --- a/core/descriptor.loader.java/src/jvm_descriptors.proto +++ b/core/descriptor.loader.java/src/jvm_descriptors.proto @@ -109,11 +109,6 @@ extend TypeParameter { repeated Annotation type_parameter_annotation = 100; } -extend ValueParameter { - // Index of the corresponding parameter of this method in JVM (counting receiver parameters, enum constructor synthetic parameters, etc.) - optional int32 index = 100; -} - extend Class { repeated Annotation class_annotation = 100; } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt index 6a89163eb6e..6f85356690d 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.load.kotlin import com.google.protobuf.MessageLite +import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.load.java.JvmAnnotationNames @@ -26,7 +27,6 @@ import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.* import org.jetbrains.kotlin.serialization.jvm.ClassMapperLite import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf -import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.index import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertySignature import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil import org.jetbrains.kotlin.storage.StorageManager @@ -139,7 +139,7 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader { val methodSignature = getCallableSignature(message, container.nameResolver, container.typeTable, kind) if (methodSignature != null) { - val index = if (proto.hasExtension(index)) proto.getExtension(index) else parameterIndex + val index = parameterIndex + computeJvmParameterIndexShift(container, message) val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, index) return findClassAndLoadMemberAnnotations(container, paramSignature) } @@ -147,6 +147,19 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader if (message.hasReceiver()) 1 else 0 + is ProtoBuf.Property -> if (message.hasReceiver()) 1 else 0 + is ProtoBuf.Constructor -> when { + (container as ProtoContainer.Class).kind == ProtoBuf.Class.Kind.ENUM_CLASS -> 2 + container.isInner -> 1 + else -> 0 + } + else -> throw UnsupportedOperationException("Unsupported message: ${message.javaClass}") + } + } + override fun loadExtensionReceiverParameterAnnotations( container: ProtoContainer, message: MessageLite, @@ -187,7 +200,8 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoaderextend .org.jetbrains.kotlin.serialization.ValueParameter { ... } - */ - public static final - com.google.protobuf.GeneratedMessageLite.GeneratedExtension< - org.jetbrains.kotlin.serialization.ProtoBuf.ValueParameter, - java.lang.Integer> index = com.google.protobuf.GeneratedMessageLite - .newSingularGeneratedExtension( - org.jetbrains.kotlin.serialization.ProtoBuf.ValueParameter.getDefaultInstance(), - 0, - null, - null, - 100, - com.google.protobuf.WireFormat.FieldType.INT32); public static final int CLASS_ANNOTATION_FIELD_NUMBER = 100; /** * extend .org.jetbrains.kotlin.serialization.Class { ... } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt index 36d4698a8f9..a94e2f7ccb2 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt @@ -25,7 +25,6 @@ import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.resolve.DescriptorFactory -import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.serialization.Flags import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.descriptors.* @@ -219,7 +218,11 @@ public class MemberDeserializer(private val c: DeserializationContext) { val flags = if (proto.hasFlags()) proto.flags else 0 ValueParameterDescriptorImpl( callableDescriptor, null, i, - containerOfCallable?.let { getParameterAnnotations(it, callable, kind, i, proto) } ?: Annotations.EMPTY, + containerOfCallable?.let { container -> + DeserializedAnnotations(c.storageManager) { + c.components.annotationAndConstantLoader.loadValueParameterAnnotations(container, callable, kind, i, proto) + } + } ?: Annotations.EMPTY, c.nameResolver.getName(proto.name), c.typeDeserializer.type(proto.type(c.typeTable)), Flags.DECLARES_DEFAULT_VALUE.get(flags), @@ -231,24 +234,10 @@ public class MemberDeserializer(private val c: DeserializationContext) { }.toReadOnlyList() } - private fun getParameterAnnotations( - container: ProtoContainer, - callable: MessageLite, - kind: AnnotatedCallableKind, - index: Int, - valueParameter: ProtoBuf.ValueParameter - ): Annotations { - return DeserializedAnnotations(c.storageManager) { - c.components.annotationAndConstantLoader.loadValueParameterAnnotations(container, callable, kind, index, valueParameter) - } - } - private fun DeclarationDescriptor.asProtoContainer(): ProtoContainer? = when (this) { is PackageFragmentDescriptor -> ProtoContainer.Package(fqName, c.nameResolver, c.typeTable, c.packagePartSource) is DeserializedClassDescriptor -> ProtoContainer.Class( - classProto, c.nameResolver, c.typeTable, - isCompanionOfClass = DescriptorUtils.isCompanionObject(this) && DescriptorUtils.isClassOrEnumClass(containingDeclaration), - isInterface = kind == ClassKind.INTERFACE + classProto, c.nameResolver, c.typeTable, (containingDeclaration as? ClassDescriptor)?.kind ) else -> null // TODO: support annotations on lambdas and their parameters } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoContainer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoContainer.kt index bb6908c3371..36b467c49b6 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoContainer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/ProtoContainer.kt @@ -16,8 +16,10 @@ package org.jetbrains.kotlin.serialization.deserialization +import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.serialization.Flags import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.descriptors.PackagePartSource @@ -29,11 +31,13 @@ sealed class ProtoContainer( val classProto: ProtoBuf.Class, nameResolver: NameResolver, typeTable: TypeTable, - val isCompanionOfClass: Boolean, - val isInterface: Boolean + val outerClassKind: ClassKind? ) : ProtoContainer(nameResolver, typeTable) { val classId: ClassId = nameResolver.getClassId(classProto.fqName) + val kind: ProtoBuf.Class.Kind = Flags.CLASS_KIND.get(classProto.flags) ?: ProtoBuf.Class.Kind.CLASS + val isInner: Boolean = Flags.IS_INNER.get(classProto.flags) + override fun debugFqName(): FqName = classId.asSingleFqName() } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index d69f1c61a5d..3161729bfb2 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt @@ -288,19 +288,19 @@ public class DeserializedClassDescriptor( private inner class EnumEntryClassDescriptors { private val enumEntryProtos = classProto.enumEntryList.toMapBy { c.nameResolver.getName(it.name) } + private val protoContainer = + ProtoContainer.Class(classProto, c.nameResolver, c.typeTable, (containingDeclaration as? ClassDescriptor)?.kind) val enumEntryByName = c.storageManager.createMemoizedFunctionWithNullableValues { name -> enumEntryProtos[name]?.let { proto -> - val annotations = DeserializedAnnotations(c.storageManager) { - c.components.annotationAndConstantLoader.loadEnumEntryAnnotations( - ProtoContainer.Class(classProto, c.nameResolver, c.typeTable, isCompanionOfClass = false, isInterface = false), - proto - ) - } EnumEntrySyntheticClassDescriptor.create( - c.storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, annotations, SourceElement.NO_SOURCE + c.storageManager, this@DeserializedClassDescriptor, name, enumMemberNames, + DeserializedAnnotations(c.storageManager) { + c.components.annotationAndConstantLoader.loadEnumEntryAnnotations(protoContainer, proto) + }, + SourceElement.NO_SOURCE ) } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt index f8f52b8f7ea..cbf40d1c1eb 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt @@ -35,10 +35,7 @@ import org.jetbrains.kotlin.psi.stubs.impl.KotlinObjectStubImpl import org.jetbrains.kotlin.psi.stubs.impl.KotlinPlaceHolderStubImpl import org.jetbrains.kotlin.serialization.Flags import org.jetbrains.kotlin.serialization.ProtoBuf -import org.jetbrains.kotlin.serialization.deserialization.NameResolver -import org.jetbrains.kotlin.serialization.deserialization.ProtoContainer -import org.jetbrains.kotlin.serialization.deserialization.TypeTable -import org.jetbrains.kotlin.serialization.deserialization.supertypes +import org.jetbrains.kotlin.serialization.deserialization.* fun createClassStub( parent: StubElement, @@ -76,12 +73,7 @@ private class ClassClsStubBuilder( if (classProto.hasCompanionObjectName()) c.nameResolver.getName(classProto.companionObjectName) else null private val thisAsProtoContainer = - ProtoContainer.Class( - classProto, c.nameResolver, c.typeTable, - classKind == ProtoBuf.Class.Kind.COMPANION_OBJECT && - (outerContext.classKind?.let { it == ProtoBuf.Class.Kind.CLASS || it == ProtoBuf.Class.Kind.ENUM_CLASS } ?: false), - classKind == ProtoBuf.Class.Kind.INTERFACE - ) + ProtoContainer.Class(classProto, c.nameResolver, c.typeTable, outerContext.classKind?.let { Deserialization.classKind(it) }) private val classOrObjectStub = createClassOrObjectStubAndModifierListStub() diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt index 81ea446d258..9dd6ea9ef24 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt @@ -430,11 +430,6 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi if (old.varargElementTypeId != new.varargElementTypeId) return false } - if (old.hasExtension(JvmProtoBuf.index) != new.hasExtension(JvmProtoBuf.index)) return false - if (old.hasExtension(JvmProtoBuf.index)) { - if (old.getExtension(JvmProtoBuf.index) != new.getExtension(JvmProtoBuf.index)) return false - } - return true } @@ -1123,10 +1118,6 @@ public fun ProtoBuf.ValueParameter.hashCode(stringIndexes: (Int) -> Int, fqNameI hashCode = 31 * hashCode + varargElementTypeId } - if (hasExtension(JvmProtoBuf.index)) { - hashCode = 31 * hashCode + getExtension(JvmProtoBuf.index) - } - return hashCode }