Write JVM signatures to new protobuf messages

compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.codegen.serialization;
 
+import com.google.protobuf.MessageLite;
 import com.intellij.openapi.util.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -89,6 +90,89 @@ public class JvmSerializerExtension extends SerializerExtension {
         }
     }
 
+    @Override
+    public void serializeConstructor(@NotNull ConstructorDescriptor descriptor, @NotNull ProtoBuf.Constructor.Builder proto) {
+        Method method = bindings.get(METHOD_FOR_FUNCTION, descriptor);
+        if (method != null) {
+            JvmProtoBuf.JvmMethodSignature signature = new SignatureSerializer().methodSignature(method);
+            proto.setExtension(JvmProtoBuf.constructorSignature, signature);
+        }
+
+        saveImplClassName(descriptor, proto);
+    }
+
+    @Override
+    public void serializeFunction(@NotNull FunctionDescriptor descriptor, @NotNull ProtoBuf.Function.Builder proto) {
+        SignatureSerializer signatureSerializer = new SignatureSerializer();
+
+        JvmProtoBuf.JvmMethodSignature signature;
+        if (descriptor instanceof DeserializedSimpleFunctionDescriptor) {
+            DeserializedSimpleFunctionDescriptor deserialized = (DeserializedSimpleFunctionDescriptor) descriptor;
+            signature = signatureSerializer.copyMethodSignature(
+                    deserialized.getProto().getExtension(JvmProtoBuf.oldMethodSignature), deserialized.getNameResolver()
+            );
+        }
+        else {
+            Method method = bindings.get(METHOD_FOR_FUNCTION, descriptor);
+            signature = method != null ? signatureSerializer.methodSignature(method) : null;
+        }
+
+        if (signature != null) {
+            proto.setExtension(JvmProtoBuf.methodSignature, signature);
+        }
+
+        saveImplClassName(descriptor, proto);
+    }
+
+    @Override
+    public void serializeProperty(@NotNull PropertyDescriptor descriptor, @NotNull ProtoBuf.Property.Builder proto) {
+        SignatureSerializer signatureSerializer = new SignatureSerializer();
+
+        PropertyGetterDescriptor getter = descriptor.getGetter();
+        PropertySetterDescriptor setter = descriptor.getSetter();
+        Method getterMethod = getter == null ? null : bindings.get(METHOD_FOR_FUNCTION, getter);
+        Method setterMethod = setter == null ? null : bindings.get(METHOD_FOR_FUNCTION, setter);
+
+        Pair<Type, String> field = bindings.get(FIELD_FOR_PROPERTY, descriptor);
+        String fieldName;
+        String fieldDesc;
+        boolean isStaticInOuter;
+        if (field != null) {
+            fieldName = field.second;
+            fieldDesc = field.first.getDescriptor();
+            isStaticInOuter = bindings.get(STATIC_FIELD_IN_OUTER_CLASS, descriptor);
+        }
+        else {
+            fieldName = null;
+            fieldDesc = null;
+            isStaticInOuter = false;
+        }
+
+        Method syntheticMethod = bindings.get(SYNTHETIC_METHOD_FOR_PROPERTY, descriptor);
+
+        JvmProtoBuf.JvmPropertySignature signature;
+        if (descriptor instanceof DeserializedPropertyDescriptor) {
+            DeserializedPropertyDescriptor deserializedCallable = (DeserializedPropertyDescriptor) descriptor;
+            signature = signatureSerializer.copyPropertySignature(
+                    deserializedCallable.getProto().getExtension(JvmProtoBuf.oldPropertySignature),
+                    deserializedCallable.getNameResolver()
+            );
+        }
+        else {
+            signature = signatureSerializer.propertySignature(
+                    fieldName, fieldDesc, isStaticInOuter,
+                    syntheticMethod != null ? signatureSerializer.methodSignature(syntheticMethod) : null,
+                    getterMethod != null ? signatureSerializer.methodSignature(getterMethod) : null,
+                    setterMethod != null ? signatureSerializer.methodSignature(setterMethod) : null
+            );
+        }
+
+        proto.setExtension(JvmProtoBuf.propertySignature, signature);
+
+        saveImplClassName(descriptor, proto);
+    }
+
+    // TODO: delete
     private void saveSignature(@NotNull CallableMemberDescriptor callable, @NotNull ProtoBuf.Callable.Builder proto) {
         SignatureSerializer signatureSerializer = new SignatureSerializer();
         if (callable instanceof FunctionDescriptor) {
@@ -96,7 +180,7 @@ public class JvmSerializerExtension extends SerializerExtension {
             if (callable instanceof DeserializedSimpleFunctionDescriptor) {
                 DeserializedSimpleFunctionDescriptor deserialized = (DeserializedSimpleFunctionDescriptor) callable;
                 signature = signatureSerializer.copyMethodSignature(
-                        deserialized.getProto().getExtension(JvmProtoBuf.methodSignature), deserialized.getNameResolver()
+                        deserialized.getProto().getExtension(JvmProtoBuf.oldMethodSignature), deserialized.getNameResolver()
                 );
             }
             else {
@@ -104,7 +188,7 @@ public class JvmSerializerExtension extends SerializerExtension {
                 signature = method != null ? signatureSerializer.methodSignature(method) : null;
             }
             if (signature != null) {
-                proto.setExtension(JvmProtoBuf.methodSignature, signature);
+                proto.setExtension(JvmProtoBuf.oldMethodSignature, signature);
             }
         }
         else if (callable instanceof PropertyDescriptor) {
@@ -136,7 +220,7 @@ public class JvmSerializerExtension extends SerializerExtension {
             if (callable instanceof DeserializedPropertyDescriptor) {
                 DeserializedPropertyDescriptor deserializedCallable = (DeserializedPropertyDescriptor) callable;
                 signature = signatureSerializer.copyPropertySignature(
-                        deserializedCallable.getProto().getExtension(JvmProtoBuf.propertySignature),
+                        deserializedCallable.getProto().getExtension(JvmProtoBuf.oldPropertySignature),
                         deserializedCallable.getNameResolver()
                 );
             }
@@ -148,14 +232,23 @@ public class JvmSerializerExtension extends SerializerExtension {
                         setterMethod != null ? signatureSerializer.methodSignature(setterMethod) : null
                 );
             }
-            proto.setExtension(JvmProtoBuf.propertySignature, signature);
+            proto.setExtension(JvmProtoBuf.oldPropertySignature, signature);
         }
     }
 
-    private void saveImplClassName(@NotNull CallableMemberDescriptor callable, @NotNull ProtoBuf.Callable.Builder proto) {
+    private void saveImplClassName(@NotNull CallableMemberDescriptor callable, @NotNull MessageLite.Builder proto) {
         String name = bindings.get(IMPL_CLASS_NAME_FOR_CALLABLE, callable);
-        if (name != null) {
+        if (name == null) return;
-            proto.setExtension(JvmProtoBuf.implClassName, stringTable.getStringIndex(name));
+
+        int index = stringTable.getStringIndex(name);
+        if (proto instanceof ProtoBuf.Callable.Builder) {
+            ((ProtoBuf.Callable.Builder) proto).setExtension(JvmProtoBuf.oldImplClassName, index);
+        }
+        else if (proto instanceof ProtoBuf.Function.Builder) {
+            ((ProtoBuf.Function.Builder) proto).setExtension(JvmProtoBuf.methodImplClassName, index);
+        }
+        else if (proto instanceof ProtoBuf.Property.Builder) {
+            ((ProtoBuf.Property.Builder) proto).setExtension(JvmProtoBuf.propertyImplClassName, index);
         }
     }
 

compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt

@@ -60,14 +60,18 @@ public object JvmFileClassUtil {
 
     @JvmStatic
     public fun getPartFqNameForDeserializedCallable(callable: DeserializedCallableMemberDescriptor): FqName {
-        val implClassName = getImplClassName(callable)
+        val implClassName = getImplClassName(callable) ?: error("No implClassName for $callable")
         val packageFqName = (callable.containingDeclaration as PackageFragmentDescriptor).fqName
         return packageFqName.child(implClassName)
     }
 
     @JvmStatic
-    public fun getImplClassName(callable: DeserializedCallableMemberDescriptor): Name =
+    public fun getImplClassName(callable: DeserializedCallableMemberDescriptor): Name? =
-            callable.nameResolver.getName(callable.proto.getExtension(JvmProtoBuf.implClassName))
+            with(callable) {
+                if (proto.hasExtension(JvmProtoBuf.oldImplClassName))
+                    nameResolver.getName(proto.getExtension(JvmProtoBuf.oldImplClassName))
+                else null
+            }
 
     @JvmStatic
     public fun getHiddenPartFqName(file: JetFile, jvmFileClassAnnotations: ParsedJmvFileClassAnnotations): FqName =

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -168,7 +168,7 @@ public class IncrementalPackageFragmentProvider(
         ) {
             override fun filteredMemberProtos(allMemberProtos: Collection<ProtoBuf.Callable>): Collection<ProtoBuf.Callable> {
                 fun getPackagePart(callable: ProtoBuf.Callable) =
-                        callable.getExtension(JvmProtoBuf.implClassName)?.let { packageData.nameResolver.getName(it) }
+                        callable.getExtension(JvmProtoBuf.oldImplClassName)?.let { packageData.nameResolver.getName(it) }
 
                 fun shouldSkipPackagePart(name: Name) =
                         JvmClassName.byFqNameWithoutInnerClasses(fqName.child(name)).getInternalName() in obsoletePackageParts

compiler/tests/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java

@@ -7,9 +7,14 @@ public final class DebugJvmProtoBuf {
   private DebugJvmProtoBuf() {}
   public static void registerAllExtensions(
       com.google.protobuf.ExtensionRegistry registry) {
+    registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.constructorSignature);
     registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.methodSignature);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.methodImplClassName);
     registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.propertySignature);
-    registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.implClassName);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.propertyImplClassName);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.oldMethodSignature);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.oldPropertySignature);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.oldImplClassName);
     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.index);
@@ -4521,36 +4526,91 @@ public final class DebugJvmProtoBuf {
     // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.jvm.JvmPropertySignature)
   }
 
-  public static final int METHOD_SIGNATURE_FIELD_NUMBER = 100;
+  public static final int CONSTRUCTOR_SIGNATURE_FIELD_NUMBER = 100;
   /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
+   * <code>extend .org.jetbrains.kotlin.serialization.Constructor { ... }</code>
    */
   public static final
     com.google.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Callable,
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Constructor,
+      org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature> constructorSignature = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.class,
+        org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance());
+  public static final int METHOD_SIGNATURE_FIELD_NUMBER = 100;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Function { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Function,
       org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature> methodSignature = com.google.protobuf.GeneratedMessage
           .newFileScopedGeneratedExtension(
         org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.class,
         org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance());
-  public static final int PROPERTY_SIGNATURE_FIELD_NUMBER = 101;
+  public static final int METHOD_IMPL_CLASS_NAME_FIELD_NUMBER = 101;
   /**
-   * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
+   * <code>extend .org.jetbrains.kotlin.serialization.Function { ... }</code>
    */
   public static final
     com.google.protobuf.GeneratedMessage.GeneratedExtension<
-      org.jetbrains.kotlin.serialization.DebugProtoBuf.Callable,
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Function,
+      java.lang.Integer> methodImplClassName = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Integer.class,
+        null);
+  public static final int PROPERTY_SIGNATURE_FIELD_NUMBER = 100;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Property { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Property,
       org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmPropertySignature> propertySignature = com.google.protobuf.GeneratedMessage
           .newFileScopedGeneratedExtension(
         org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmPropertySignature.class,
         org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmPropertySignature.getDefaultInstance());
-  public static final int IMPL_CLASS_NAME_FIELD_NUMBER = 102;
+  public static final int PROPERTY_IMPL_CLASS_NAME_FIELD_NUMBER = 101;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Property { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Property,
+      java.lang.Integer> propertyImplClassName = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        java.lang.Integer.class,
+        null);
+  public static final int OLD_METHOD_SIGNATURE_FIELD_NUMBER = 100;
   /**
    * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
    */
   public static final
     com.google.protobuf.GeneratedMessage.GeneratedExtension<
       org.jetbrains.kotlin.serialization.DebugProtoBuf.Callable,
-      java.lang.Integer> implClassName = com.google.protobuf.GeneratedMessage
+      org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature> oldMethodSignature = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.class,
+        org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance());
+  public static final int OLD_PROPERTY_SIGNATURE_FIELD_NUMBER = 101;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Callable,
+      org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmPropertySignature> oldPropertySignature = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmPropertySignature.class,
+        org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmPropertySignature.getDefaultInstance());
+  public static final int OLD_IMPL_CLASS_NAME_FIELD_NUMBER = 102;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Callable,
+      java.lang.Integer> oldImplClassName = com.google.protobuf.GeneratedMessage
           .newFileScopedGeneratedExtension(
         java.lang.Integer.class,
         null);
@@ -4659,25 +4719,40 @@ public final class DebugJvmProtoBuf {
       "r\030\003 \001(\0132:.org.jetbrains.kotlin.serializa" +
       "tion.jvm.JvmMethodSignature\022J\n\006setter\030\004 " +
       "\001(\0132:.org.jetbrains.kotlin.serialization" +
-      ".jvm.JvmMethodSignature:\202\001\n\020method_signa" +
+      ".jvm.JvmMethodSignature:\212\001\n\025constructor_" +
+      "signature\022/.org.jetbrains.kotlin.seriali" +
+      "zation.Constructor\030d \001(\0132:.org.jetbrains",
+      ".kotlin.serialization.jvm.JvmMethodSigna" +
+      "ture:\202\001\n\020method_signature\022,.org.jetbrain" +
+      "s.kotlin.serialization.Function\030d \001(\0132:." +
+      "org.jetbrains.kotlin.serialization.jvm.J" +
+      "vmMethodSignature:R\n\026method_impl_class_n" +
+      "ame\022,.org.jetbrains.kotlin.serialization" +
+      ".Function\030e \001(\005B\004\230\265\030\001:\206\001\n\022property_signa" +
       "ture\022,.org.jetbrains.kotlin.serializatio" +
-      "n.Callable\030d \001(\0132:.org.jetbrains.kotlin.",
+      "n.Property\030d \001(\0132<.org.jetbrains.kotlin." +
-      "serialization.jvm.JvmMethodSignature:\206\001\n" +
+      "serialization.jvm.JvmPropertySignature:T",
-      "\022property_signature\022,.org.jetbrains.kotl" +
+      "\n\030property_impl_class_name\022,.org.jetbrai" +
-      "in.serialization.Callable\030e \001(\0132<.org.je" +
+      "ns.kotlin.serialization.Property\030e \001(\005B\004" +
-      "tbrains.kotlin.serialization.jvm.JvmProp" +
+      "\230\265\030\001:\206\001\n\024old_method_signature\022,.org.jetb" +
-      "ertySignature:K\n\017impl_class_name\022,.org.j" +
+      "rains.kotlin.serialization.Callable\030d \001(" +
-      "etbrains.kotlin.serialization.Callable\030f" +
+      "\0132:.org.jetbrains.kotlin.serialization.j" +
-      " \001(\005B\004\210\265\030\001:q\n\017type_annotation\022(.org.jetb" +
+      "vm.JvmMethodSignature:\212\001\n\026old_property_s" +
-      "rains.kotlin.serialization.Type\030d \003(\0132.." +
+      "ignature\022,.org.jetbrains.kotlin.serializ" +
-      "org.jetbrains.kotlin.serialization.Annot" +
+      "ation.Callable\030e \001(\0132<.org.jetbrains.kot" +
-      "ation:8\n\006is_raw\022(.org.jetbrains.kotlin.s",
+      "lin.serialization.jvm.JvmPropertySignatu" +
-      "erialization.Type\030e \001(\010:A\n\005index\0222.org.j" +
+      "re:O\n\023old_impl_class_name\022,.org.jetbrain",
-      "etbrains.kotlin.serialization.ValueParam" +
+      "s.kotlin.serialization.Callable\030f \001(\005B\004\210" +
-      "eter\030d \001(\005:s\n\020class_annotation\022).org.jet" +
+      "\265\030\001:q\n\017type_annotation\022(.org.jetbrains.k" +
-      "brains.kotlin.serialization.Class\030d \003(\0132" +
+      "otlin.serialization.Type\030d \003(\0132..org.jet" +
-      "..org.jetbrains.kotlin.serialization.Ann" +
+      "brains.kotlin.serialization.Annotation:8" +
-      "otationB\022B\020DebugJvmProtoBuf"
+      "\n\006is_raw\022(.org.jetbrains.kotlin.serializ" +
+      "ation.Type\030e \001(\010:A\n\005index\0222.org.jetbrain" +
+      "s.kotlin.serialization.ValueParameter\030d " +
+      "\001(\005: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() {
@@ -4714,19 +4789,26 @@ public final class DebugJvmProtoBuf {
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_org_jetbrains_kotlin_serialization_jvm_JvmPropertySignature_descriptor,
               new java.lang.String[] { "Field", "SyntheticMethod", "Getter", "Setter", });
-          methodSignature.internalInit(descriptor.getExtensions().get(0));
+          constructorSignature.internalInit(descriptor.getExtensions().get(0));
-          propertySignature.internalInit(descriptor.getExtensions().get(1));
+          methodSignature.internalInit(descriptor.getExtensions().get(1));
-          implClassName.internalInit(descriptor.getExtensions().get(2));
+          methodImplClassName.internalInit(descriptor.getExtensions().get(2));
-          typeAnnotation.internalInit(descriptor.getExtensions().get(3));
+          propertySignature.internalInit(descriptor.getExtensions().get(3));
-          isRaw.internalInit(descriptor.getExtensions().get(4));
+          propertyImplClassName.internalInit(descriptor.getExtensions().get(4));
-          index.internalInit(descriptor.getExtensions().get(5));
+          oldMethodSignature.internalInit(descriptor.getExtensions().get(5));
-          classAnnotation.internalInit(descriptor.getExtensions().get(6));
+          oldPropertySignature.internalInit(descriptor.getExtensions().get(6));
+          oldImplClassName.internalInit(descriptor.getExtensions().get(7));
+          typeAnnotation.internalInit(descriptor.getExtensions().get(8));
+          isRaw.internalInit(descriptor.getExtensions().get(9));
+          index.internalInit(descriptor.getExtensions().get(10));
+          classAnnotation.internalInit(descriptor.getExtensions().get(11));
           com.google.protobuf.ExtensionRegistry registry =
             com.google.protobuf.ExtensionRegistry.newInstance();
           registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
           registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
           registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
           registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
+          registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
+          registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
           registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.nameIdInTable);
           return registry;
         }

core/descriptor.loader.java/src/jvm_descriptors.proto

@@ -89,29 +89,45 @@ message JvmPropertySignature {
   optional JvmMethodSignature setter = 4;
 }
 
-extend org.jetbrains.kotlin.serialization.Callable {
+extend Constructor {
-  optional JvmMethodSignature method_signature = 100;
+  optional JvmMethodSignature constructor_signature = 100;
+}
 
-  optional JvmPropertySignature property_signature = 101;
+extend Function {
+  optional JvmMethodSignature method_signature = 100;
 
   // Package-less name of the class with the callable's body and annotations, if it differs from the class it's serialized into.
   // E.g. for a class "A/B/C$D" this would be "C$D".
   // This is needed to find the class to load annotations from in the following cases:
   // 1) annotations on top-level members are written to compiled package part classes
   // 2) annotations on properties in traits are written to TImpl classes
-  optional int32 impl_class_name = 102 [(name_id_in_table) = true];
+  optional int32 method_impl_class_name = 101 [(string_id_in_table) = true];
 }
 
-extend org.jetbrains.kotlin.serialization.Type {
+extend Property {
+  optional JvmPropertySignature property_signature = 100;
+
+  // see Function#method_impl_class_name
+  optional int32 property_impl_class_name = 101 [(string_id_in_table) = true];
+}
+
+// TODO: drop
+extend Callable {
+  optional JvmMethodSignature old_method_signature = 100;
+  optional JvmPropertySignature old_property_signature = 101;
+  optional int32 old_impl_class_name = 102 [(name_id_in_table) = true];
+}
+
+extend Type {
   repeated Annotation type_annotation = 100;
   optional bool is_raw = 101;
 }
 
-extend org.jetbrains.kotlin.serialization.ValueParameter {
+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 org.jetbrains.kotlin.serialization.Class {
+extend Class {
   repeated Annotation class_annotation = 100;
 }

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.load.kotlin
 
+import com.google.protobuf.MessageLite
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.name.ClassId
@@ -23,10 +24,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.implClassName
+import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.*
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.index
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.methodSignature
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertySignature
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.JetType
 import java.util.*
@@ -85,24 +83,48 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         return result
     }
 
-    override fun loadCallableAnnotations(container: ProtoContainer, proto: ProtoBuf.Callable, kind: AnnotatedCallableKind): List<T> {
+    override fun loadCallableAnnotations(container: ProtoContainer, proto: MessageLite, kind: AnnotatedCallableKind): List<T> {
-        val nameResolver = container.nameResolver
+        return when (proto) {
-        if (kind == AnnotatedCallableKind.PROPERTY) {
+            is ProtoBuf.Constructor, is ProtoBuf.Function -> {
-            val syntheticFunctionSignature = getPropertySignature(proto, nameResolver, synthetic = true)
+                val signature = getCallableSignature(proto, container.nameResolver, kind) ?: return emptyList()
-            val fieldSignature = getPropertySignature(proto, nameResolver, field = true)
+                transformAnnotations(findClassAndLoadMemberAnnotations(container, proto, signature))
+            }
+            is ProtoBuf.Property -> {
+                val nameResolver = container.nameResolver
+                val syntheticFunctionSignature = getPropertySignature(proto, nameResolver, synthetic = true)
+                val fieldSignature = getPropertySignature(proto, nameResolver, field = true)
 
-            val propertyAnnotations = syntheticFunctionSignature?.let { sig ->
+                val propertyAnnotations = syntheticFunctionSignature?.let { sig ->
-                findClassAndLoadMemberAnnotations(container, proto, sig)
+                    findClassAndLoadMemberAnnotations(container, proto, sig)
-            } ?: listOf()
+                } ?: listOf()
 
-            val fieldAnnotations = fieldSignature?.let { sig ->
+                val fieldAnnotations = fieldSignature?.let { sig ->
-                findClassAndLoadMemberAnnotations(container, proto, sig, isStaticFieldInOuter(proto))
+                    findClassAndLoadMemberAnnotations(container, proto, sig, isStaticFieldInOuter(proto))
-            } ?: listOf()
+                } ?: listOf()
 
-            return loadPropertyAnnotations(propertyAnnotations, fieldAnnotations)
+                loadPropertyAnnotations(propertyAnnotations, fieldAnnotations)
+            }
+            is ProtoBuf.Callable -> {
+                val nameResolver = container.nameResolver
+                if (kind == AnnotatedCallableKind.PROPERTY) {
+                    val syntheticFunctionSignature = getPropertySignature(proto, nameResolver, synthetic = true)
+                    val fieldSignature = getPropertySignature(proto, nameResolver, field = true)
+
+                    val propertyAnnotations = syntheticFunctionSignature?.let { sig ->
+                        findClassAndLoadMemberAnnotations(container, proto, sig)
+                    } ?: listOf()
+
+                    val fieldAnnotations = fieldSignature?.let { sig ->
+                        findClassAndLoadMemberAnnotations(container, proto, sig, isStaticFieldInOuter(proto))
+                    } ?: listOf()
+
+                    return loadPropertyAnnotations(propertyAnnotations, fieldAnnotations)
+                }
+                val signature = getCallableSignature(proto, nameResolver, kind) ?: return emptyList()
+                transformAnnotations(findClassAndLoadMemberAnnotations(container, proto, signature))
+            }
+            else -> emptyList()
         }
-        val signature = getCallableSignature(proto, nameResolver, kind) ?: return listOf()
-        return transformAnnotations(findClassAndLoadMemberAnnotations(container, proto, signature))
     }
 
     protected abstract fun loadPropertyAnnotations(propertyAnnotations: List<A>, fieldAnnotations: List<A>): List<T>
@@ -111,7 +133,7 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
 
     private fun findClassAndLoadMemberAnnotations(
             container: ProtoContainer,
-            proto: ProtoBuf.Callable,
+            proto: MessageLite,
             signature: MemberSignature,
             isStaticFieldInOuter: Boolean = false
     ): List<A> {
@@ -128,16 +150,16 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
 
     override fun loadValueParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind,
             parameterIndex: Int,
             proto: ProtoBuf.ValueParameter
     ): List<A> {
-        val methodSignature = getCallableSignature(callable, container.nameResolver, kind)
+        val methodSignature = getCallableSignature(message, container.nameResolver, kind)
         if (methodSignature != null) {
             val index = if (proto.hasExtension(index)) proto.getExtension(index) else parameterIndex
             val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, index)
-            return findClassAndLoadMemberAnnotations(container, callable, paramSignature)
+            return findClassAndLoadMemberAnnotations(container, message, paramSignature)
         }
 
         return listOf()
@@ -145,14 +167,13 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
 
     override fun loadExtensionReceiverParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind
     ): List<A> {
-        if (!callable.hasReceiverType()) return emptyList()
+        val methodSignature = getCallableSignature(message, container.nameResolver, kind)
-        val methodSignature = getCallableSignature(callable, container.nameResolver, kind)
         if (methodSignature != null) {
             val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, 0)
-            return findClassAndLoadMemberAnnotations(container, callable, paramSignature)
+            return findClassAndLoadMemberAnnotations(container, message, paramSignature)
         }
 
         return emptyList()
@@ -204,14 +225,25 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         }
     }
 
-    private fun getImplClassName(proto: ProtoBuf.Callable, nameResolver: NameResolver): Name? {
+    private fun getImplClassName(proto: MessageLite, nameResolver: NameResolver): Name? =
-        return if (proto.hasExtension(implClassName)) nameResolver.getName(proto.getExtension(implClassName)) else null
+            when {
-    }
+                proto is ProtoBuf.Function && proto.hasExtension(methodImplClassName) ->
+                    nameResolver.getName(proto.getExtension(methodImplClassName))
+                proto is ProtoBuf.Property && proto.hasExtension(propertyImplClassName) ->
+                    nameResolver.getName(proto.getExtension(propertyImplClassName))
+                proto is ProtoBuf.Callable && proto.hasExtension(oldImplClassName) ->
+                    nameResolver.getName(proto.getExtension(oldImplClassName))
+                else -> null
+            }
 
-    private fun isStaticFieldInOuter(proto: ProtoBuf.Callable): Boolean {
+    private fun isStaticFieldInOuter(proto: MessageLite): Boolean =
-        return proto.hasExtension(propertySignature) &&
+            when {
-               proto.getExtension(propertySignature).let { it.hasField() && it.field.isStaticInOuter }
+                proto is ProtoBuf.Property && proto.hasExtension(propertySignature) ->
-    }
+                    proto.getExtension(propertySignature).let { it.hasField() && it.field.isStaticInOuter }
+                proto is ProtoBuf.Callable && proto.hasExtension(oldPropertySignature) ->
+                    proto.getExtension(oldPropertySignature).let { it.hasField() && it.field.isStaticInOuter }
+                else -> false
+            }
 
     private fun loadAnnotationsAndInitializers(kotlinClass: KotlinJvmBinaryClass): Storage<A, C> {
         val memberAnnotations = HashMap<MemberSignature, MutableList<A>>()
@@ -268,14 +300,17 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
     }
 
     private fun getPropertySignature(
-            proto: ProtoBuf.Callable,
+            proto: MessageLite,
             nameResolver: NameResolver,
             field: Boolean = false,
             synthetic: Boolean = false
     ): MemberSignature? {
-        if (!proto.hasExtension(propertySignature)) return null
+        val signature =
-
+                if (proto is ProtoBuf.Property && proto.hasExtension(propertySignature))
-        val signature = proto.getExtension(propertySignature)
+                    proto.getExtension(propertySignature)
+                else if (proto is ProtoBuf.Callable && proto.hasExtension(oldPropertySignature))
+                    proto.getExtension(oldPropertySignature)
+                else return null
 
         if (field && signature.hasField()) {
             return MemberSignature.fromFieldNameAndDesc(
@@ -290,24 +325,40 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         return null
     }
 
-    private fun getCallableSignature(
+    private fun getCallableSignature(proto: MessageLite, nameResolver: NameResolver, kind: AnnotatedCallableKind): MemberSignature? {
-            proto: ProtoBuf.Callable,
+        return when {
-            nameResolver: NameResolver,
+            proto is ProtoBuf.Function && proto.hasExtension(methodSignature) -> {
-            kind: AnnotatedCallableKind
+                MemberSignature.fromMethod(nameResolver, proto.getExtension(methodSignature))
-    ): MemberSignature? {
-        when (kind) {
-            AnnotatedCallableKind.FUNCTION -> if (proto.hasExtension(methodSignature)) {
-                return MemberSignature.fromMethod(nameResolver, proto.getExtension(methodSignature))
             }
-            AnnotatedCallableKind.PROPERTY_GETTER -> if (proto.hasExtension(propertySignature)) {
+            proto is ProtoBuf.Property && proto.hasExtension(propertySignature) -> {
-                return MemberSignature.fromMethod(nameResolver, proto.getExtension(propertySignature).getter)
+                val signature = proto.getExtension(propertySignature)
+                when (kind) {
+                    AnnotatedCallableKind.PROPERTY_GETTER -> MemberSignature.fromMethod(nameResolver, signature.getter)
+                    AnnotatedCallableKind.PROPERTY_SETTER -> MemberSignature.fromMethod(nameResolver, signature.setter)
+                    AnnotatedCallableKind.PROPERTY -> getPropertySignature(proto, nameResolver, true, true)
+                    else -> null
+                }
             }
-            AnnotatedCallableKind.PROPERTY_SETTER -> if (proto.hasExtension(propertySignature)) {
+            proto is ProtoBuf.Callable -> {
-                return MemberSignature.fromMethod(nameResolver, proto.getExtension(propertySignature).setter)
+                when (kind) {
+                    AnnotatedCallableKind.FUNCTION ->
+                        if (proto.hasExtension(oldMethodSignature))
+                            MemberSignature.fromMethod(nameResolver, proto.getExtension(oldMethodSignature))
+                        else null
+                    AnnotatedCallableKind.PROPERTY_GETTER ->
+                        if (proto.hasExtension(oldPropertySignature))
+                            MemberSignature.fromMethod(nameResolver, proto.getExtension(oldPropertySignature).getter)
+                        else null
+                    AnnotatedCallableKind.PROPERTY_SETTER ->
+                        if (proto.hasExtension(oldPropertySignature))
+                            MemberSignature.fromMethod(nameResolver, proto.getExtension(oldPropertySignature).setter)
+                        else null
+                    AnnotatedCallableKind.PROPERTY ->
+                        getPropertySignature(proto, nameResolver, true, true)
+                }
             }
-            AnnotatedCallableKind.PROPERTY -> return getPropertySignature(proto, nameResolver, true, true)
+            else -> null
         }
-        return null
     }
 
     private class Storage<A, C>(

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

@@ -7,9 +7,14 @@ public final class JvmProtoBuf {
   private JvmProtoBuf() {}
   public static void registerAllExtensions(
       com.google.protobuf.ExtensionRegistryLite registry) {
+    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.constructorSignature);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.methodSignature);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.methodImplClassName);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertySignature);
-    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.implClassName);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertyImplClassName);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.oldMethodSignature);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.oldPropertySignature);
+    registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.oldImplClassName);
     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.index);
@@ -3708,14 +3713,89 @@ public final class JvmProtoBuf {
     // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.serialization.jvm.JvmPropertySignature)
   }
 
+  public static final int CONSTRUCTOR_SIGNATURE_FIELD_NUMBER = 100;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Constructor { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.ProtoBuf.Constructor,
+      org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature> constructorSignature = com.google.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.serialization.ProtoBuf.Constructor.getDefaultInstance(),
+        org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature.getDefaultInstance(),
+        org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature.getDefaultInstance(),
+        null,
+        100,
+        com.google.protobuf.WireFormat.FieldType.MESSAGE);
   public static final int METHOD_SIGNATURE_FIELD_NUMBER = 100;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Function { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.ProtoBuf.Function,
+      org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature> methodSignature = com.google.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.serialization.ProtoBuf.Function.getDefaultInstance(),
+        org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature.getDefaultInstance(),
+        org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature.getDefaultInstance(),
+        null,
+        100,
+        com.google.protobuf.WireFormat.FieldType.MESSAGE);
+  public static final int METHOD_IMPL_CLASS_NAME_FIELD_NUMBER = 101;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Function { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.ProtoBuf.Function,
+      java.lang.Integer> methodImplClassName = com.google.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.serialization.ProtoBuf.Function.getDefaultInstance(),
+        0,
+        null,
+        null,
+        101,
+        com.google.protobuf.WireFormat.FieldType.INT32);
+  public static final int PROPERTY_SIGNATURE_FIELD_NUMBER = 100;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Property { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.ProtoBuf.Property,
+      org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmPropertySignature> propertySignature = com.google.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.serialization.ProtoBuf.Property.getDefaultInstance(),
+        org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmPropertySignature.getDefaultInstance(),
+        org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmPropertySignature.getDefaultInstance(),
+        null,
+        100,
+        com.google.protobuf.WireFormat.FieldType.MESSAGE);
+  public static final int PROPERTY_IMPL_CLASS_NAME_FIELD_NUMBER = 101;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Property { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.ProtoBuf.Property,
+      java.lang.Integer> propertyImplClassName = com.google.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.serialization.ProtoBuf.Property.getDefaultInstance(),
+        0,
+        null,
+        null,
+        101,
+        com.google.protobuf.WireFormat.FieldType.INT32);
+  public static final int OLD_METHOD_SIGNATURE_FIELD_NUMBER = 100;
   /**
    * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
    */
   public static final
     com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
       org.jetbrains.kotlin.serialization.ProtoBuf.Callable,
-      org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature> methodSignature = com.google.protobuf.GeneratedMessageLite
+      org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature> oldMethodSignature = com.google.protobuf.GeneratedMessageLite
           .newSingularGeneratedExtension(
         org.jetbrains.kotlin.serialization.ProtoBuf.Callable.getDefaultInstance(),
         org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature.getDefaultInstance(),
@@ -3723,14 +3803,14 @@ public final class JvmProtoBuf {
         null,
         100,
         com.google.protobuf.WireFormat.FieldType.MESSAGE);
-  public static final int PROPERTY_SIGNATURE_FIELD_NUMBER = 101;
+  public static final int OLD_PROPERTY_SIGNATURE_FIELD_NUMBER = 101;
   /**
    * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
    */
   public static final
     com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
       org.jetbrains.kotlin.serialization.ProtoBuf.Callable,
-      org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmPropertySignature> propertySignature = com.google.protobuf.GeneratedMessageLite
+      org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmPropertySignature> oldPropertySignature = com.google.protobuf.GeneratedMessageLite
           .newSingularGeneratedExtension(
         org.jetbrains.kotlin.serialization.ProtoBuf.Callable.getDefaultInstance(),
         org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmPropertySignature.getDefaultInstance(),
@@ -3738,14 +3818,14 @@ public final class JvmProtoBuf {
         null,
         101,
         com.google.protobuf.WireFormat.FieldType.MESSAGE);
-  public static final int IMPL_CLASS_NAME_FIELD_NUMBER = 102;
+  public static final int OLD_IMPL_CLASS_NAME_FIELD_NUMBER = 102;
   /**
    * <code>extend .org.jetbrains.kotlin.serialization.Callable { ... }</code>
    */
   public static final
     com.google.protobuf.GeneratedMessageLite.GeneratedExtension<
       org.jetbrains.kotlin.serialization.ProtoBuf.Callable,
-      java.lang.Integer> implClassName = com.google.protobuf.GeneratedMessageLite
+      java.lang.Integer> oldImplClassName = com.google.protobuf.GeneratedMessageLite
           .newSingularGeneratedExtension(
         org.jetbrains.kotlin.serialization.ProtoBuf.Callable.getDefaultInstance(),
         0,

core/descriptors/src/org/jetbrains/kotlin/builtins/BuiltInsAnnotationAndConstantLoader.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.builtins
 
+import com.google.protobuf.MessageLite
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
@@ -40,16 +41,18 @@ class BuiltInsAnnotationAndConstantLoader(
 
     override fun loadCallableAnnotations(
             container: ProtoContainer,
-            proto: ProtoBuf.Callable,
+            proto: MessageLite,
             kind: AnnotatedCallableKind
     ): List<AnnotationWithTarget> {
+        proto as ProtoBuf.Callable // TODO
+
         val annotations = proto.getExtension(BuiltInsProtoBuf.callableAnnotation).orEmpty()
         return annotations.map { proto -> AnnotationWithTarget(deserializer.deserializeAnnotation(proto, container.nameResolver), null) }
     }
 
     override fun loadValueParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind,
             parameterIndex: Int,
             proto: ProtoBuf.ValueParameter
@@ -60,7 +63,7 @@ class BuiltInsAnnotationAndConstantLoader(
 
     override fun loadExtensionReceiverParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind
     ): List<AnnotationDescriptor> = emptyList()
 

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationAndConstantLoader.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.serialization.deserialization;
 
+import com.google.protobuf.MessageLite;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.serialization.ProtoBuf;
@@ -23,6 +24,8 @@ import org.jetbrains.kotlin.types.JetType;
 
 import java.util.List;
 
+// The MessageLite instance everywhere should be Constructor, Function or Property
+// TODO: simplify this interface
 public interface AnnotationAndConstantLoader<A, C, T> {
     @NotNull
     List<A> loadClassAnnotations(
@@ -33,14 +36,14 @@ public interface AnnotationAndConstantLoader<A, C, T> {
     @NotNull
     List<T> loadCallableAnnotations(
             @NotNull ProtoContainer container,
-            @NotNull ProtoBuf.Callable proto,
+            @NotNull MessageLite message,
             @NotNull AnnotatedCallableKind kind
     );
 
     @NotNull
     List<A> loadValueParameterAnnotations(
             @NotNull ProtoContainer container,
-            @NotNull ProtoBuf.Callable callable,
+            @NotNull MessageLite message,
             @NotNull AnnotatedCallableKind kind,
             int parameterIndex,
             @NotNull ProtoBuf.ValueParameter proto
@@ -49,7 +52,7 @@ public interface AnnotationAndConstantLoader<A, C, T> {
     @NotNull
     List<A> loadExtensionReceiverParameterAnnotations(
             @NotNull ProtoContainer container,
-            @NotNull ProtoBuf.Callable callable,
+            @NotNull MessageLite message,
             @NotNull AnnotatedCallableKind kind
     );
 

core/reflection.jvm/src/kotlin/reflect/jvm/internal/KDeclarationContainerImpl.kt

@@ -294,9 +294,9 @@ internal abstract class KDeclarationContainerImpl : ClassBasedDeclarationContain
     // Returns the JVM class which contains this callable. This class may be different from the one represented by descriptors
     // in case of top level functions (their bodies are in package parts), methods with implementations in interfaces, etc.
     private fun implClassForCallable(nameResolver: NameResolver, proto: ProtoBuf.Callable): Class<*>? {
-        if (!proto.hasExtension(JvmProtoBuf.implClassName)) return null
+        if (!proto.hasExtension(JvmProtoBuf.oldImplClassName)) return null
 
-        val implClassName = nameResolver.getName(proto.getExtension(JvmProtoBuf.implClassName))
+        val implClassName = nameResolver.getName(proto.getExtension(JvmProtoBuf.oldImplClassName))
         // TODO: store fq name of impl class name in jvm_descriptors.proto
         val classId = ClassId(jClass.classId.getPackageFqName(), implClassName)
         return jClass.safeClassLoader.loadClass(classId.asSingleFqName().asString())

core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt

@@ -124,8 +124,8 @@ internal object RuntimeTypeMapper {
         when (function) {
             is DeserializedCallableMemberDescriptor -> {
                 val proto = function.proto
-                if (proto.hasExtension(JvmProtoBuf.methodSignature)) {
+                if (proto.hasExtension(JvmProtoBuf.oldMethodSignature)) {
-                    val signature = proto.getExtension(JvmProtoBuf.methodSignature)
+                    val signature = proto.getExtension(JvmProtoBuf.oldMethodSignature)
                     return JvmFunctionSignature.KotlinFunction(proto, signature, function.nameResolver)
                 }
                 // If it's a deserialized function but has no JVM signature, it must be from built-ins
@@ -153,10 +153,10 @@ internal object RuntimeTypeMapper {
         val property = DescriptorUtils.unwrapFakeOverride(possiblyOverriddenProperty)
         if (property is DeserializedPropertyDescriptor) {
             val proto = property.proto
-            if (!proto.hasExtension(JvmProtoBuf.propertySignature)) {
+            if (!proto.hasExtension(JvmProtoBuf.oldPropertySignature)) {
                 throw KotlinReflectionInternalError("No metadata found for $property")
             }
-            return JvmPropertySignature.KotlinProperty(proto, proto.getExtension(JvmProtoBuf.propertySignature), property.nameResolver)
+            return JvmPropertySignature.KotlinProperty(proto, proto.getExtension(JvmProtoBuf.oldPropertySignature), property.nameResolver)
         }
         else if (property is JavaPropertyDescriptor) {
             val field = ((property.source as? JavaSourceElement)?.javaElement as? ReflectJavaField)?.member ?:

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/AnnotationLoaderForKotlinJavaScriptStubBuilder.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.decompiler
 
+import com.google.protobuf.MessageLite
 import org.jetbrains.kotlin.idea.decompiler.stubBuilder.ClassIdWithTarget
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.serialization.ProtoBuf
@@ -35,16 +36,19 @@ public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndCon
 
     override fun loadCallableAnnotations(
             container: ProtoContainer,
-            proto: ProtoBuf.Callable,
+            proto: MessageLite,
             kind: AnnotatedCallableKind
-    ): List<ClassIdWithTarget> =
+    ): List<ClassIdWithTarget> {
-            proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map {
+        proto as ProtoBuf.Callable // TODO
-                ClassIdWithTarget(container.nameResolver.getClassId(it.id), null)
+
-            }
+        return proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty().map {
+            ClassIdWithTarget(container.nameResolver.getClassId(it.id), null)
+        }
+    }
 
     override fun loadValueParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind,
             parameterIndex: Int,
             proto: ProtoBuf.ValueParameter
@@ -55,7 +59,7 @@ public class AnnotationLoaderForKotlinJavaScriptStubBuilder() : AnnotationAndCon
 
     override fun loadExtensionReceiverParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind
     ): List<ClassId> = emptyList()
 

jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt

@@ -203,19 +203,19 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi
 
         if (!checkEquals(old.returnType, new.returnType)) return false
 
-        if (old.hasExtension(JvmProtoBuf.methodSignature) != new.hasExtension(JvmProtoBuf.methodSignature)) return false
+        if (old.hasExtension(JvmProtoBuf.oldMethodSignature) != new.hasExtension(JvmProtoBuf.oldMethodSignature)) return false
-        if (old.hasExtension(JvmProtoBuf.methodSignature)) {
+        if (old.hasExtension(JvmProtoBuf.oldMethodSignature)) {
-            if (!checkEquals(old.getExtension(JvmProtoBuf.methodSignature), new.getExtension(JvmProtoBuf.methodSignature))) return false
+            if (!checkEquals(old.getExtension(JvmProtoBuf.oldMethodSignature), new.getExtension(JvmProtoBuf.oldMethodSignature))) return false
         }
 
-        if (old.hasExtension(JvmProtoBuf.propertySignature) != new.hasExtension(JvmProtoBuf.propertySignature)) return false
+        if (old.hasExtension(JvmProtoBuf.oldPropertySignature) != new.hasExtension(JvmProtoBuf.oldPropertySignature)) return false
-        if (old.hasExtension(JvmProtoBuf.propertySignature)) {
+        if (old.hasExtension(JvmProtoBuf.oldPropertySignature)) {
-            if (!checkEquals(old.getExtension(JvmProtoBuf.propertySignature), new.getExtension(JvmProtoBuf.propertySignature))) return false
+            if (!checkEquals(old.getExtension(JvmProtoBuf.oldPropertySignature), new.getExtension(JvmProtoBuf.oldPropertySignature))) return false
         }
 
-        if (old.hasExtension(JvmProtoBuf.implClassName) != new.hasExtension(JvmProtoBuf.implClassName)) return false
+        if (old.hasExtension(JvmProtoBuf.oldImplClassName) != new.hasExtension(JvmProtoBuf.oldImplClassName)) return false
-        if (old.hasExtension(JvmProtoBuf.implClassName)) {
+        if (old.hasExtension(JvmProtoBuf.oldImplClassName)) {
-            if (!checkStringEquals(old.getExtension(JvmProtoBuf.implClassName), new.getExtension(JvmProtoBuf.implClassName))) return false
+            if (!checkStringEquals(old.getExtension(JvmProtoBuf.oldImplClassName), new.getExtension(JvmProtoBuf.oldImplClassName))) return false
         }
 
         return true
@@ -229,6 +229,11 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi
 
         if (!checkEqualsConstructorValueParameter(old, new)) return false
 
+        if (old.hasExtension(JvmProtoBuf.constructorSignature) != new.hasExtension(JvmProtoBuf.constructorSignature)) return false
+        if (old.hasExtension(JvmProtoBuf.constructorSignature)) {
+            if (!checkEquals(old.getExtension(JvmProtoBuf.constructorSignature), new.getExtension(JvmProtoBuf.constructorSignature))) return false
+        }
+
         return true
     }
 
@@ -251,6 +256,16 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi
 
         if (!checkEqualsFunctionValueParameter(old, new)) return false
 
+        if (old.hasExtension(JvmProtoBuf.methodSignature) != new.hasExtension(JvmProtoBuf.methodSignature)) return false
+        if (old.hasExtension(JvmProtoBuf.methodSignature)) {
+            if (!checkEquals(old.getExtension(JvmProtoBuf.methodSignature), new.getExtension(JvmProtoBuf.methodSignature))) return false
+        }
+
+        if (old.hasExtension(JvmProtoBuf.methodImplClassName) != new.hasExtension(JvmProtoBuf.methodImplClassName)) return false
+        if (old.hasExtension(JvmProtoBuf.methodImplClassName)) {
+            if (!checkStringEquals(old.getExtension(JvmProtoBuf.methodImplClassName), new.getExtension(JvmProtoBuf.methodImplClassName))) return false
+        }
+
         return true
     }
 
@@ -286,6 +301,16 @@ open class ProtoCompareGenerated(public val oldNameResolver: NameResolver, publi
             if (old.setterFlags != new.setterFlags) return false
         }
 
+        if (old.hasExtension(JvmProtoBuf.propertySignature) != new.hasExtension(JvmProtoBuf.propertySignature)) return false
+        if (old.hasExtension(JvmProtoBuf.propertySignature)) {
+            if (!checkEquals(old.getExtension(JvmProtoBuf.propertySignature), new.getExtension(JvmProtoBuf.propertySignature))) return false
+        }
+
+        if (old.hasExtension(JvmProtoBuf.propertyImplClassName) != new.hasExtension(JvmProtoBuf.propertyImplClassName)) return false
+        if (old.hasExtension(JvmProtoBuf.propertyImplClassName)) {
+            if (!checkStringEquals(old.getExtension(JvmProtoBuf.propertyImplClassName), new.getExtension(JvmProtoBuf.propertyImplClassName))) return false
+        }
+
         return true
     }
 
@@ -878,16 +903,16 @@ public fun ProtoBuf.Callable.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes
 
     hashCode = 31 * hashCode + returnType.hashCode(stringIndexes, fqNameIndexes)
 
-    if (hasExtension(JvmProtoBuf.methodSignature)) {
+    if (hasExtension(JvmProtoBuf.oldMethodSignature)) {
-        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.methodSignature).hashCode(stringIndexes, fqNameIndexes)
+        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.oldMethodSignature).hashCode(stringIndexes, fqNameIndexes)
     }
 
-    if (hasExtension(JvmProtoBuf.propertySignature)) {
+    if (hasExtension(JvmProtoBuf.oldPropertySignature)) {
-        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.propertySignature).hashCode(stringIndexes, fqNameIndexes)
+        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.oldPropertySignature).hashCode(stringIndexes, fqNameIndexes)
     }
 
-    if (hasExtension(JvmProtoBuf.implClassName)) {
+    if (hasExtension(JvmProtoBuf.oldImplClassName)) {
-        hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.implClassName))
+        hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.oldImplClassName))
     }
 
     return hashCode
@@ -904,6 +929,10 @@ public fun ProtoBuf.Constructor.hashCode(stringIndexes: (Int) -> Int, fqNameInde
         hashCode = 31 * hashCode + getValueParameter(i).hashCode(stringIndexes, fqNameIndexes)
     }
 
+    if (hasExtension(JvmProtoBuf.constructorSignature)) {
+        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.constructorSignature).hashCode(stringIndexes, fqNameIndexes)
+    }
+
     return hashCode
 }
 
@@ -930,6 +959,14 @@ public fun ProtoBuf.Function.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes
         hashCode = 31 * hashCode + getValueParameter(i).hashCode(stringIndexes, fqNameIndexes)
     }
 
+    if (hasExtension(JvmProtoBuf.methodSignature)) {
+        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.methodSignature).hashCode(stringIndexes, fqNameIndexes)
+    }
+
+    if (hasExtension(JvmProtoBuf.methodImplClassName)) {
+        hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.methodImplClassName))
+    }
+
     return hashCode
 }
 
@@ -964,6 +1001,14 @@ public fun ProtoBuf.Property.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes
         hashCode = 31 * hashCode + setterFlags
     }
 
+    if (hasExtension(JvmProtoBuf.propertySignature)) {
+        hashCode = 31 * hashCode + getExtension(JvmProtoBuf.propertySignature).hashCode(stringIndexes, fqNameIndexes)
+    }
+
+    if (hasExtension(JvmProtoBuf.propertyImplClassName)) {
+        hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.propertyImplClassName))
+    }
+
     return hashCode
 }
 

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptAnnotationAndConstantLoader.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.serialization.js
 
+import com.google.protobuf.MessageLite
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
@@ -39,16 +40,18 @@ class KotlinJavascriptAnnotationAndConstantLoader(
 
     override fun loadCallableAnnotations(
             container: ProtoContainer,
-            proto: ProtoBuf.Callable,
+            proto: MessageLite,
             kind: AnnotatedCallableKind
     ): List<AnnotationWithTarget> {
+        proto as ProtoBuf.Callable // TODO
+
         val annotations = proto.getExtension(JsProtoBuf.callableAnnotation).orEmpty()
         return annotations.map { proto -> AnnotationWithTarget(deserializer.deserializeAnnotation(proto, container.nameResolver), null) }
     }
 
     override fun loadValueParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind,
             parameterIndex: Int,
             proto: ProtoBuf.ValueParameter
@@ -59,7 +62,7 @@ class KotlinJavascriptAnnotationAndConstantLoader(
 
     override fun loadExtensionReceiverParameterAnnotations(
             container: ProtoContainer,
-            callable: ProtoBuf.Callable,
+            message: MessageLite,
             kind: AnnotatedCallableKind
     ): List<AnnotationDescriptor> = emptyList()