Drop 'index' JVM binary format extension

Compute the JVM parameer index manually instead

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) {

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<PropertyDescriptor, Method> SYNTHETIC_METHOD_FOR_PROPERTY =
             SerializationMappingSlice.create();
-    public static final SerializationMappingSlice<ValueParameterDescriptor, Integer> INDEX_FOR_VALUE_PARAMETER =
-            SerializationMappingSlice.create();
 
     private static final class SerializationMappingSlice<K, V> extends BasicWritableSlice<K, V> {
         public SerializationMappingSlice() {

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

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;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.ValueParameter { ... }</code>
-   */
-  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;
   /**
    * <code>extend .org.jetbrains.kotlin.serialization.Class { ... }</code>
@@ -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);

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;
 }

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<A : Any, C
     ): List<A> {
         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<A : Any, C
         return listOf()
     }
 
+    private fun computeJvmParameterIndexShift(container: ProtoContainer, message: MessageLite): Int {
+        return when (message) {
+            is ProtoBuf.Function -> 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 AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         }
 
         if (container is ProtoContainer.Class) {
-            if (field && container.isCompanionOfClass) {
+            if (field && container.kind == ProtoBuf.Class.Kind.COMPANION_OBJECT &&
+                (container.outerClassKind == ClassKind.CLASS || container.outerClassKind == ClassKind.ENUM_CLASS)) {
                 // Backing fields of properties of a companion object in a class are generated in the outer class
                 return kotlinClassFinder.findKotlinClass(container.classId.outerClassId)
             }
@@ -199,7 +213,7 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
     }
 
     private fun getImplClassName(container: ProtoContainer, property: Boolean): ClassId? {
-        if (property && container is ProtoContainer.Class && container.isInterface) {
+        if (property && container is ProtoContainer.Class && container.kind == ProtoBuf.Class.Kind.INTERFACE) {
             return container.classId.createNestedClassId(Name.identifier(JvmAbi.DEFAULT_IMPLS_CLASS_NAME))
         }
         return ((container as? ProtoContainer.Package)?.packagePartSource as? JvmPackagePartSource)?.classId

core/descriptor.loader.java/src/org/jetbrains/kotlin/serialization/jvm/JvmProtoBuf.java

@@ -13,7 +13,6 @@ public final class JvmProtoBuf {
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.typeAnnotation);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.isRaw);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.typeParameterAnnotation);
-    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.index);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.classAnnotation);
   }
   public interface StringTableTypesOrBuilder
@@ -3802,21 +3801,6 @@ public final class JvmProtoBuf {
         100,
         com.google.protobuf.WireFormat.FieldType.MESSAGE,
         false);
-  public static final int INDEX_FIELD_NUMBER = 100;
-  /**
-   * <code>extend .org.jetbrains.kotlin.serialization.ValueParameter { ... }</code>
-   */
-  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;
   /**
    * <code>extend .org.jetbrains.kotlin.serialization.Class { ... }</code>

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
     }

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()
     }
 

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, ClassDescriptor> {
             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
                 )
             }
         }

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<out PsiElement>,
@@ -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()
 

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
 }