Write lambdaClassOriginName for lambdas copied during inline

Similarly to anonymousObjectOriginName which is written for copied
anonymous objects

 #KT-21320

build-common/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt

@@ -418,6 +418,11 @@ open class ProtoCompareGenerated(val oldNameResolver: NameResolver, val newNameR
             if (!checkEquals(old.getExtension(JvmProtoBuf.methodSignature), new.getExtension(JvmProtoBuf.methodSignature))) return false
         }
 
+        if (old.hasExtension(JvmProtoBuf.lambdaClassOriginName) != new.hasExtension(JvmProtoBuf.lambdaClassOriginName)) return false
+        if (old.hasExtension(JvmProtoBuf.lambdaClassOriginName)) {
+            if (!checkStringEquals(old.getExtension(JvmProtoBuf.lambdaClassOriginName), new.getExtension(JvmProtoBuf.lambdaClassOriginName))) return false
+        }
+
         if (old.getExtensionCount(JsProtoBuf.functionAnnotation) != new.getExtensionCount(JsProtoBuf.functionAnnotation)) {
             return false
         }
@@ -1638,6 +1643,10 @@ fun ProtoBuf.Function.hashCode(stringIndexes: (Int) -> Int, fqNameIndexes: (Int)
         hashCode = 31 * hashCode + getExtension(JvmProtoBuf.methodSignature).hashCode(stringIndexes, fqNameIndexes)
     }
 
+    if (hasExtension(JvmProtoBuf.lambdaClassOriginName)) {
+        hashCode = 31 * hashCode + stringIndexes(getExtension(JvmProtoBuf.lambdaClassOriginName))
+    }
+
     for(i in 0..getExtensionCount(JsProtoBuf.functionAnnotation) - 1) {
         hashCode = 31 * hashCode + getExtension(JsProtoBuf.functionAnnotation, i).hashCode(stringIndexes, fqNameIndexes)
     }

build-common/test/org/jetbrains/kotlin/serialization/jvm/DebugJvmProtoBuf.java

@@ -9,6 +9,7 @@ public final class DebugJvmProtoBuf {
       org.jetbrains.kotlin.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.lambdaClassOriginName);
     registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.propertySignature);
     registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.typeAnnotation);
     registry.add(org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.isRaw);
@@ -4530,6 +4531,22 @@ public final class DebugJvmProtoBuf {
           .newFileScopedGeneratedExtension(
         org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.class,
         org.jetbrains.kotlin.serialization.jvm.DebugJvmProtoBuf.JvmMethodSignature.getDefaultInstance());
+  public static final int LAMBDA_CLASS_ORIGIN_NAME_FIELD_NUMBER = 101;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Function { ... }</code>
+   *
+   * <pre>
+   * For lambdas from bodies of inline functions copied to the use site, the JVM internal name of the original
+   * lambda class this class is copied from
+   * </pre>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.DebugProtoBuf.Function,
+      java.lang.Integer> lambdaClassOriginName = org.jetbrains.kotlin.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>
@@ -4705,31 +4722,33 @@ public final class DebugJvmProtoBuf {
       "JvmMethodSignature:\202\001\n\020method_signature\022" +
       ",.org.jetbrains.kotlin.serialization.Fun" +
       "ction\030d \001(\0132:.org.jetbrains.kotlin.seria" +
-      "lization.jvm.JvmMethodSignature:\206\001\n\022prop" +
+      "lization.jvm.JvmMethodSignature:T\n\030lambd" +
-      "erty_signature\022,.org.jetbrains.kotlin.se" +
+      "a_class_origin_name\022,.org.jetbrains.kotl" +
-      "rialization.Property\030d \001(\0132<.org.jetbrai" +
+      "in.serialization.Function\030e \001(\005B\004\230\265\030\001:\206\001" +
-      "ns.kotlin.serialization.jvm.JvmPropertyS" +
+      "\n\022property_signature\022,.org.jetbrains.kot" +
-      "ignature:q\n\017type_annotation\022(.org.jetbra" +
+      "lin.serialization.Property\030d \001(\0132<.org.j" +
-      "ins.kotlin.serialization.Type\030d \003(\0132..or" +
+      "etbrains.kotlin.serialization.jvm.JvmPro" +
-      "g.jetbrains.kotlin.serialization.Annotat",
+      "pertySignature:q\n\017type_annotation\022(.org.",
-      "ion:8\n\006is_raw\022(.org.jetbrains.kotlin.ser" +
+      "jetbrains.kotlin.serialization.Type\030d \003(" +
-      "ialization.Type\030e \001(\010:\204\001\n\031type_parameter" +
+      "\0132..org.jetbrains.kotlin.serialization.A" +
-      "_annotation\0221.org.jetbrains.kotlin.seria" +
+      "nnotation:8\n\006is_raw\022(.org.jetbrains.kotl" +
-      "lization.TypeParameter\030d \003(\0132..org.jetbr" +
+      "in.serialization.Type\030e \001(\010:\204\001\n\031type_par" +
-      "ains.kotlin.serialization.Annotation:J\n\021" +
+      "ameter_annotation\0221.org.jetbrains.kotlin" +
-      "class_module_name\022).org.jetbrains.kotlin" +
+      ".serialization.TypeParameter\030d \003(\0132..org" +
-      ".serialization.Class\030e \001(\005B\004\230\265\030\001:u\n\024clas" +
+      ".jetbrains.kotlin.serialization.Annotati" +
-      "s_local_variable\022).org.jetbrains.kotlin." +
+      "on:J\n\021class_module_name\022).org.jetbrains." +
-      "serialization.Class\030f \003(\0132,.org.jetbrain" +
+      "kotlin.serialization.Class\030e \001(\005B\004\230\265\030\001:u" +
-      "s.kotlin.serialization.Property:U\n\034anony",
+      "\n\024class_local_variable\022).org.jetbrains.k",
-      "mous_object_origin_name\022).org.jetbrains." +
+      "otlin.serialization.Class\030f \003(\0132,.org.je" +
-      "kotlin.serialization.Class\030g \001(\005B\004\230\265\030\001:N" +
+      "tbrains.kotlin.serialization.Property:U\n" +
-      "\n\023package_module_name\022+.org.jetbrains.ko" +
+      "\034anonymous_object_origin_name\022).org.jetb" +
-      "tlin.serialization.Package\030e \001(\005B\004\230\265\030\001:y" +
+      "rains.kotlin.serialization.Class\030g \001(\005B\004" +
-      "\n\026package_local_variable\022+.org.jetbrains" +
+      "\230\265\030\001:N\n\023package_module_name\022+.org.jetbra" +
-      ".kotlin.serialization.Package\030f \003(\0132,.or" +
+      "ins.kotlin.serialization.Package\030e \001(\005B\004" +
-      "g.jetbrains.kotlin.serialization.Propert" +
+      "\230\265\030\001:y\n\026package_local_variable\022+.org.jet" +
-      "yB\022B\020DebugJvmProtoBuf"
+      "brains.kotlin.serialization.Package\030f \003(" +
+      "\0132,.org.jetbrains.kotlin.serialization.P" +
+      "ropertyB\022B\020DebugJvmProtoBuf"
     };
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
         new org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
@@ -4777,15 +4796,16 @@ public final class DebugJvmProtoBuf {
         new java.lang.String[] { "Field", "SyntheticMethod", "Getter", "Setter", });
     constructorSignature.internalInit(descriptor.getExtensions().get(0));
     methodSignature.internalInit(descriptor.getExtensions().get(1));
-    propertySignature.internalInit(descriptor.getExtensions().get(2));
+    lambdaClassOriginName.internalInit(descriptor.getExtensions().get(2));
-    typeAnnotation.internalInit(descriptor.getExtensions().get(3));
+    propertySignature.internalInit(descriptor.getExtensions().get(3));
-    isRaw.internalInit(descriptor.getExtensions().get(4));
+    typeAnnotation.internalInit(descriptor.getExtensions().get(4));
-    typeParameterAnnotation.internalInit(descriptor.getExtensions().get(5));
+    isRaw.internalInit(descriptor.getExtensions().get(5));
-    classModuleName.internalInit(descriptor.getExtensions().get(6));
+    typeParameterAnnotation.internalInit(descriptor.getExtensions().get(6));
-    classLocalVariable.internalInit(descriptor.getExtensions().get(7));
+    classModuleName.internalInit(descriptor.getExtensions().get(7));
-    anonymousObjectOriginName.internalInit(descriptor.getExtensions().get(8));
+    classLocalVariable.internalInit(descriptor.getExtensions().get(8));
-    packageModuleName.internalInit(descriptor.getExtensions().get(9));
+    anonymousObjectOriginName.internalInit(descriptor.getExtensions().get(9));
-    packageLocalVariable.internalInit(descriptor.getExtensions().get(10));
+    packageModuleName.internalInit(descriptor.getExtensions().get(10));
+    packageLocalVariable.internalInit(descriptor.getExtensions().get(11));
     org.jetbrains.kotlin.protobuf.ExtensionRegistry registry =
         org.jetbrains.kotlin.protobuf.ExtensionRegistry.newInstance();
     registry.add(org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.stringIdInTable);
@@ -4795,6 +4815,7 @@ public final class DebugJvmProtoBuf {
     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);
     org.jetbrains.kotlin.protobuf.Descriptors.FileDescriptor
         .internalUpdateFileDescriptor(descriptor, registry);
     org.jetbrains.kotlin.serialization.DebugExtOptionsProtoBuf.getDescriptor();

compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java

@@ -45,7 +45,10 @@ import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isBoolean;
 import static org.jetbrains.kotlin.builtins.KotlinBuiltIns.isPrimitiveClass;
@@ -878,7 +881,12 @@ public class AsmUtil {
     public static void writeAnnotationData(
             @NotNull AnnotationVisitor av, @NotNull MessageLite message, @NotNull JvmStringTable stringTable
     ) {
-        String[] data = BitEncoding.encodeBytes(DescriptorSerializer.serialize(message, stringTable));
+        writeAnnotationData(av, BitEncoding.encodeBytes(DescriptorSerializer.serialize(message, stringTable)), stringTable.getStrings());
+    }
+
+    public static void writeAnnotationData(
+            @NotNull AnnotationVisitor av, @NotNull String[] data, @NotNull List<String> strings
+    ) {
         AnnotationVisitor dataVisitor = av.visitArray(JvmAnnotationNames.METADATA_DATA_FIELD_NAME);
         for (String string : data) {
             dataVisitor.visit(null, string);
@@ -886,7 +894,7 @@ public class AsmUtil {
         dataVisitor.visitEnd();
 
         AnnotationVisitor stringsVisitor = av.visitArray(JvmAnnotationNames.METADATA_STRINGS_FIELD_NAME);
-        for (String string : stringTable.getStrings()) {
+        for (String string : strings) {
             stringsVisitor.visit(null, string);
         }
         stringsVisitor.visitEnd();

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt

@@ -172,7 +172,7 @@ class AnonymousObjectTransformer(
 
         val header = metadataReader.createHeader()
         if (header != null) {
-            transformMetadata(header, classBuilder)
+            writeTransformedMetadata(header, classBuilder)
         }
 
         writeOuterInfo(visitor)
@@ -182,26 +182,45 @@ class AnonymousObjectTransformer(
         return transformationResult
     }
 
-    private fun transformMetadata(header: KotlinClassHeader, classBuilder: ClassBuilder) {
+    private fun writeTransformedMetadata(header: KotlinClassHeader, classBuilder: ClassBuilder) {
-        val newProto: MessageLite
+        writeKotlinMetadata(classBuilder, state, header.kind, header.extraInt) action@ { av ->
-        val newStringTable: JvmStringTable
+            val (newProto, newStringTable) = transformMetadata(header) ?: run {
-
+                val data = header.data
-        if (header.kind == KotlinClassHeader.Kind.CLASS) {
+                val strings = header.strings
-            val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(header.data!!, header.strings!!)
+                if (data != null && strings != null) {
-            newStringTable = JvmStringTable(state.typeMapper, nameResolver as JvmNameResolver)
+                    AsmUtil.writeAnnotationData(av, data, strings.asList())
-            newProto = classProto.toBuilder().apply {
+                }
-                setExtension(JvmProtoBuf.anonymousObjectOriginName, newStringTable.getStringIndex(oldObjectType.internalName))
+                return@action
-            }.build()
+            }
-        } else if (header.kind == KotlinClassHeader.Kind.SYNTHETIC_CLASS) {
-            // TODO: transform metadata for synthetic classes
-            return
-        } else return
-
-        writeKotlinMetadata(classBuilder, state, header.kind, header.extraInt) { av ->
             AsmUtil.writeAnnotationData(av, newProto, newStringTable)
         }
     }
 
+    private fun transformMetadata(header: KotlinClassHeader): Pair<MessageLite, JvmStringTable>? {
+        val data = header.data ?: return null
+        val strings = header.strings ?: return null
+
+        when (header.kind) {
+            KotlinClassHeader.Kind.CLASS -> {
+                val (nameResolver, classProto) = JvmProtoBufUtil.readClassDataFrom(data, strings)
+                val newStringTable = JvmStringTable(state.typeMapper, nameResolver as JvmNameResolver)
+                val newProto = classProto.toBuilder().apply {
+                    setExtension(JvmProtoBuf.anonymousObjectOriginName, newStringTable.getStringIndex(oldObjectType.internalName))
+                }.build()
+                return newProto to newStringTable
+            }
+            KotlinClassHeader.Kind.SYNTHETIC_CLASS -> {
+                val (nameResolver, functionProto) = JvmProtoBufUtil.readFunctionDataFrom(data, strings)
+                val newStringTable = JvmStringTable(state.typeMapper, nameResolver)
+                val newProto = functionProto.toBuilder().apply {
+                    setExtension(JvmProtoBuf.lambdaClassOriginName, newStringTable.getStringIndex(oldObjectType.internalName))
+                }.build()
+                return newProto to newStringTable
+            }
+            else -> return null
+        }
+    }
+
     private fun writeOuterInfo(visitor: ClassVisitor) {
         val info = inliningContext.callSiteInfo
         visitor.visitOuterClass(info.ownerClassName, info.functionName, info.functionDesc)

core/descriptors.jvm/src/jvm_descriptors.proto

@@ -94,6 +94,10 @@ extend Constructor {
 
 extend Function {
   optional JvmMethodSignature method_signature = 100;
+
+  // For lambdas from bodies of inline functions copied to the use site, the JVM internal name of the original
+  // lambda class this class is copied from
+  optional int32 lambda_class_origin_name = 101 [(string_id_in_table) = true];
 }
 
 extend Property {

core/descriptors.jvm/src/org/jetbrains/kotlin/serialization/jvm/JvmProtoBuf.java

@@ -9,6 +9,7 @@ public final class JvmProtoBuf {
       org.jetbrains.kotlin.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.lambdaClassOriginName);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.propertySignature);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.typeAnnotation);
     registry.add(org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.isRaw);
@@ -3820,6 +3821,27 @@ public final class JvmProtoBuf {
         100,
         org.jetbrains.kotlin.protobuf.WireFormat.FieldType.MESSAGE,
         org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.JvmMethodSignature.class);
+  public static final int LAMBDA_CLASS_ORIGIN_NAME_FIELD_NUMBER = 101;
+  /**
+   * <code>extend .org.jetbrains.kotlin.serialization.Function { ... }</code>
+   *
+   * <pre>
+   * For lambdas from bodies of inline functions copied to the use site, the JVM internal name of the original
+   * lambda class this class is copied from
+   * </pre>
+   */
+  public static final
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite.GeneratedExtension<
+      org.jetbrains.kotlin.serialization.ProtoBuf.Function,
+      java.lang.Integer> lambdaClassOriginName = org.jetbrains.kotlin.protobuf.GeneratedMessageLite
+          .newSingularGeneratedExtension(
+        org.jetbrains.kotlin.serialization.ProtoBuf.Function.getDefaultInstance(),
+        0,
+        null,
+        null,
+        101,
+        org.jetbrains.kotlin.protobuf.WireFormat.FieldType.INT32,
+        java.lang.Integer.class);
   public static final int PROPERTY_SIGNATURE_FIELD_NUMBER = 100;
   /**
    * <code>extend .org.jetbrains.kotlin.serialization.Property { ... }</code>

core/descriptors.jvm/src/org/jetbrains/kotlin/serialization/jvm/JvmProtoBufUtil.kt

@@ -23,34 +23,40 @@ import org.jetbrains.kotlin.serialization.PackageData
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.*
 import java.io.ByteArrayInputStream
+import java.io.InputStream
 
 object JvmProtoBufUtil {
-    val EXTENSION_REGISTRY: ExtensionRegistryLite = run {
+    val EXTENSION_REGISTRY: ExtensionRegistryLite = ExtensionRegistryLite.newInstance().apply(JvmProtoBuf::registerAllExtensions)
-        val registry = ExtensionRegistryLite.newInstance()
-        JvmProtoBuf.registerAllExtensions(registry)
-        registry
-    }
 
-    @JvmStatic fun readClassDataFrom(data: Array<String>, strings: Array<String>): ClassData =
+    @JvmStatic
-            readClassDataFrom(BitEncoding.decodeBytes(data), strings)
+    fun readClassDataFrom(data: Array<String>, strings: Array<String>): ClassData =
+        readClassDataFrom(BitEncoding.decodeBytes(data), strings)
 
-    @JvmStatic fun readClassDataFrom(bytes: ByteArray, strings: Array<String>): ClassData {
+    @JvmStatic
+    fun readClassDataFrom(bytes: ByteArray, strings: Array<String>): ClassData {
         val input = ByteArrayInputStream(bytes)
-        val nameResolver = JvmNameResolver(JvmProtoBuf.StringTableTypes.parseDelimitedFrom(input, EXTENSION_REGISTRY), strings)
+        return ClassData(input.readNameResolver(strings), ProtoBuf.Class.parseFrom(input, EXTENSION_REGISTRY))
-        val classProto = ProtoBuf.Class.parseFrom(input, EXTENSION_REGISTRY)
-        return ClassData(nameResolver, classProto)
     }
 
-    @JvmStatic fun readPackageDataFrom(data: Array<String>, strings: Array<String>): PackageData =
+    @JvmStatic
-            readPackageDataFrom(BitEncoding.decodeBytes(data), strings)
+    fun readPackageDataFrom(data: Array<String>, strings: Array<String>): PackageData =
+        readPackageDataFrom(BitEncoding.decodeBytes(data), strings)
 
-    @JvmStatic fun readPackageDataFrom(bytes: ByteArray, strings: Array<String>): PackageData {
+    @JvmStatic
+    fun readPackageDataFrom(bytes: ByteArray, strings: Array<String>): PackageData {
         val input = ByteArrayInputStream(bytes)
-        val nameResolver = JvmNameResolver(JvmProtoBuf.StringTableTypes.parseDelimitedFrom(input, EXTENSION_REGISTRY), strings)
+        return PackageData(input.readNameResolver(strings), ProtoBuf.Package.parseFrom(input, EXTENSION_REGISTRY))
-        val packageProto = ProtoBuf.Package.parseFrom(input, EXTENSION_REGISTRY)
-        return PackageData(nameResolver, packageProto)
     }
 
+    @JvmStatic
+    fun readFunctionDataFrom(data: Array<String>, strings: Array<String>): Pair<JvmNameResolver, ProtoBuf.Function> {
+        val input = ByteArrayInputStream(BitEncoding.decodeBytes(data))
+        return Pair(input.readNameResolver(strings), ProtoBuf.Function.parseFrom(input, EXTENSION_REGISTRY))
+    }
+
+    private fun InputStream.readNameResolver(strings: Array<String>): JvmNameResolver =
+        JvmNameResolver(JvmProtoBuf.StringTableTypes.parseDelimitedFrom(this, EXTENSION_REGISTRY), strings)
+
     // returns JVM signature in the format: "equals(Ljava/lang/Object;)Z"
     fun getJvmMethodSignature(
             proto: ProtoBuf.Function,

core/reflection.jvm/src/kotlin/reflect/jvm/reflectLambda.kt

@@ -18,12 +18,8 @@
 
 package kotlin.reflect.jvm
 
-import org.jetbrains.kotlin.load.kotlin.JvmNameResolver
-import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.deserialization.MemberDeserializer
 import org.jetbrains.kotlin.serialization.deserialization.TypeTable
-import org.jetbrains.kotlin.serialization.jvm.BitEncoding
-import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
 import kotlin.reflect.KFunction
 import kotlin.reflect.jvm.internal.EmptyContainerForLocal
@@ -38,10 +34,7 @@ import kotlin.reflect.jvm.internal.deserializeToDescriptor
 fun <R> Function<R>.reflect(): KFunction<R>? {
     val annotation = javaClass.getAnnotation(Metadata::class.java) ?: return null
     val data = annotation.d1.takeUnless(Array<String>::isEmpty) ?: return null
-    val input = BitEncoding.decodeBytes(data).inputStream()
+    val (nameResolver, proto) = JvmProtoBufUtil.readFunctionDataFrom(data, annotation.d2)
-    val stringTableTypes = JvmProtoBuf.StringTableTypes.parseDelimitedFrom(input, JvmProtoBufUtil.EXTENSION_REGISTRY)
-    val nameResolver = JvmNameResolver(stringTableTypes, annotation.d2)
-    val proto = ProtoBuf.Function.parseFrom(input, JvmProtoBufUtil.EXTENSION_REGISTRY)
 
     val descriptor = deserializeToDescriptor(javaClass, proto, nameResolver, TypeTable(proto.typeTable), MemberDeserializer::loadFunction)
                      ?: return null