Introduce binary representation for annotations

Will be used where annotations can't be stored elsewhere: for example, built-ins, JS, type annotations on JDK<8
2014-11-28 23:24:54 +03:00
parent 9a86318908
commit 63bfa004fd
30 changed files with 6958 additions and 164 deletions
@@ -21,7 +21,7 @@ import com.intellij.openapi.util.Disposer
 import org.jetbrains.jet.config.CompilerConfiguration
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment
 import org.jetbrains.jet.descriptors.serialization.*
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.lang.descriptors.*
 import org.jetbrains.jet.lang.resolve.name.Name
 import java.io.ByteArrayOutputStream
 import org.jetbrains.jet.lang.types.lang.BuiltInsSerializationUtil
@@ -29,7 +29,6 @@ import com.intellij.openapi.Disposable
 import org.jetbrains.jet.cli.common.CLIConfigurationKeys
 import org.jetbrains.jet.config.CommonConfigurationKeys
 import org.jetbrains.jet.cli.common.messages.MessageCollector
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.resolve.name.FqName
 import org.jetbrains.jet.utils.recursePostOrder
 import com.intellij.psi.search.GlobalSearchScope
@@ -41,9 +40,15 @@ import org.jetbrains.jet.analyzer.ModuleContent
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.jet.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
+import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys

 private object BuiltInsSerializerExtension : SerializerExtension() {
+    override fun serializeClass(descriptor: ClassDescriptor, proto: ProtoBuf.Class.Builder, stringTable: StringTable) {
+        for (annotation in descriptor.getAnnotations()) {
+            proto.addExtension(BuiltInsProtoBuf.classAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+        }
+    }
+
    override fun serializePackage(
            packageFragments: Collection<PackageFragmentDescriptor>,
            proto: ProtoBuf.Package.Builder,
@@ -57,16 +62,41 @@ private object BuiltInsSerializerExtension : SerializerExtension() {
            proto.addExtension(BuiltInsProtoBuf.className, stringTable.getSimpleNameIndex(descriptor.getName()))
        }
    }
+
+    override fun serializeCallable(
+            callable: CallableMemberDescriptor,
+            proto: ProtoBuf.Callable.Builder,
+            stringTable: StringTable
+    ) {
+        for (annotation in callable.getAnnotations()) {
+            proto.addExtension(BuiltInsProtoBuf.callableAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+        }
+    }
+
+    override fun serializeValueParameter(
+            descriptor: ValueParameterDescriptor,
+            proto: ProtoBuf.Callable.ValueParameter.Builder,
+            stringTable: StringTable
+    ) {
+        for (annotation in descriptor.getAnnotations()) {
+            proto.addExtension(BuiltInsProtoBuf.parameterAnnotation, AnnotationSerializer.serializeAnnotation(annotation, stringTable))
+        }
+    }
 }

 public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
    private var totalSize = 0
    private var totalFiles = 0

-    public fun serialize(destDir: File, srcDirs: Collection<File>, onComplete: (totalSize: Int, totalFiles: Int) -> Unit) {
+    public fun serialize(
+            destDir: File,
+            srcDirs: Collection<File>,
+            extraClassPath: Collection<File>,
+            onComplete: (totalSize: Int, totalFiles: Int) -> Unit
+    ) {
        val rootDisposable = Disposer.newDisposable()
        try {
-            serialize(rootDisposable, destDir, srcDirs)
+            serialize(rootDisposable, destDir, srcDirs, extraClassPath)
            onComplete(totalSize, totalFiles)
        }
        finally {
@@ -81,13 +111,17 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
                if (dependOnOldBuiltIns) ModuleInfo.DependenciesOnBuiltins.LAST else ModuleInfo.DependenciesOnBuiltins.NONE
    }

-    fun serialize(disposable: Disposable, destDir: File, srcDirs: Collection<File>) {
+    fun serialize(disposable: Disposable, destDir: File, srcDirs: Collection<File>, extraClassPath: Collection<File>) {
        val configuration = CompilerConfiguration()
        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)

        val sourceRoots = srcDirs map { it.path }
        configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, sourceRoots)

+        for (path in extraClassPath) {
+            configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, path)
+        }
+
        val environment = JetCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)

        val files = environment.getSourceFiles()
@@ -21,7 +21,7 @@ import java.io.File
 fun main(args: Array<String>) {
    System.setProperty("java.awt.headless", "true")

-    if (args.size < 2) {
+    if (args.size() < 2) {
        println(
 """Kotlin built-ins serializer

@@ -42,7 +42,7 @@ found top-level declarations to <destination dir> (files such as
    val missing = srcDirs filterNot { it.exists() }
    assert(missing.isEmpty()) { "These source directories are missing: $missing" }

-    BuiltInsSerializer(dependOnOldBuiltIns = false).serialize(destDir, srcDirs) { (totalSize, totalFiles) ->
+    BuiltInsSerializer(dependOnOldBuiltIns = false).serialize(destDir, srcDirs, listOf()) { (totalSize, totalFiles) ->
        println("Total bytes written: $totalSize to $totalFiles files")
    }
 }
@@ -0,0 +1,14 @@
+package test
+
+annotation class Empty
+
+annotation class JustAnnotation(val annotation: Empty)
+
+annotation class AnnotationArray(val annotationArray: Array<JustAnnotation>)
+
+JustAnnotation(Empty())
+AnnotationArray(array())
+class C1
+
+AnnotationArray(array(JustAnnotation(Empty()), JustAnnotation(Empty())))
+class C2
@@ -0,0 +1,23 @@
+package test
+
+internal final annotation class AnnotationArray : kotlin.Annotation {
+    public constructor AnnotationArray(/*0*/ annotationArray: kotlin.Array<test.JustAnnotation>)
+    internal final val annotationArray: kotlin.Array<test.JustAnnotation>
+}
+
+test.JustAnnotation(annotation = test.Empty(): test.Empty) test.AnnotationArray(annotationArray = {}: kotlin.Array<test.JustAnnotation>) internal final class C1 {
+    public constructor C1()
+}
+
+test.AnnotationArray(annotationArray = {test.JustAnnotation(annotation = test.Empty(): test.Empty), test.JustAnnotation(annotation = test.Empty(): test.Empty)}: kotlin.Array<test.JustAnnotation>) internal final class C2 {
+    public constructor C2()
+}
+
+internal final annotation class Empty : kotlin.Annotation {
+    public constructor Empty()
+}
+
+internal final annotation class JustAnnotation : kotlin.Annotation {
+    public constructor JustAnnotation(/*0*/ annotation: test.Empty)
+    internal final val annotation: test.Empty
+}
@@ -0,0 +1,18 @@
+package test
+
+enum class Weapon {
+    ROCK
+    PAPER
+    SCISSORS
+}
+
+annotation class JustEnum(val weapon: Weapon)
+
+annotation class EnumArray(val enumArray: Array<Weapon>)
+
+JustEnum(Weapon.SCISSORS)
+EnumArray(array())
+class C1
+
+EnumArray(array(Weapon.PAPER, Weapon.ROCK))
+class C2
@@ -0,0 +1,72 @@
+package test
+
+test.JustEnum(weapon = Weapon.SCISSORS: test.Weapon) test.EnumArray(enumArray = {}: kotlin.Array<test.Weapon>) internal final class C1 {
+    public constructor C1()
+}
+
+test.EnumArray(enumArray = {Weapon.PAPER, Weapon.ROCK}: kotlin.Array<test.Weapon>) internal final class C2 {
+    public constructor C2()
+}
+
+internal final annotation class EnumArray : kotlin.Annotation {
+    public constructor EnumArray(/*0*/ enumArray: kotlin.Array<test.Weapon>)
+    internal final val enumArray: kotlin.Array<test.Weapon>
+}
+
+internal final annotation class JustEnum : kotlin.Annotation {
+    public constructor JustEnum(/*0*/ weapon: test.Weapon)
+    internal final val weapon: test.Weapon
+}
+
+internal final enum class Weapon : kotlin.Enum<test.Weapon> {
+    public enum entry ROCK : test.Weapon {
+        private constructor ROCK()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Weapon): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+
+        public class object <class-object-for-ROCK> : test.Weapon.ROCK {
+            private constructor <class-object-for-ROCK>()
+            public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Weapon): kotlin.Int
+            public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+            public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        }
+    }
+
+    public enum entry PAPER : test.Weapon {
+        private constructor PAPER()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Weapon): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+
+        public class object <class-object-for-PAPER> : test.Weapon.PAPER {
+            private constructor <class-object-for-PAPER>()
+            public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Weapon): kotlin.Int
+            public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+            public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        }
+    }
+
+    public enum entry SCISSORS : test.Weapon {
+        private constructor SCISSORS()
+        public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Weapon): kotlin.Int
+        public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+        public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+
+        public class object <class-object-for-SCISSORS> : test.Weapon.SCISSORS {
+            private constructor <class-object-for-SCISSORS>()
+            public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Weapon): kotlin.Int
+            public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+            public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+        }
+    }
+
+    private constructor Weapon()
+    public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: test.Weapon): kotlin.Int
+    public final override /*1*/ /*fake_override*/ fun name(): kotlin.String
+    public final override /*1*/ /*fake_override*/ fun ordinal(): kotlin.Int
+
+    // Static members
+    public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): test.Weapon
+    public final /*synthesized*/ fun values(): kotlin.Array<test.Weapon>
+}
@@ -0,0 +1,36 @@
+package test
+
+annotation class PrimitiveArrays(
+        val byteArray: ByteArray
+        val charArray: CharArray,
+        val shortArray: ShortArray,
+        val intArray: IntArray,
+        val longArray: LongArray,
+        val floatArray: FloatArray,
+        val doubleArray: DoubleArray,
+        val booleanArray: BooleanArray
+)
+
+PrimitiveArrays(
+        byteArray = byteArray(-7, 7),
+        charArray = charArray('%', 'z'),
+        shortArray = shortArray(239),
+        intArray = intArray(239017, -1),
+        longArray = longArray(123456789123456789L),
+        floatArray = floatArray(2.72f, 0f),
+        doubleArray = doubleArray(-3.14),
+        booleanArray = booleanArray(true, false, true)
+)
+class C1
+
+PrimitiveArrays(
+        byteArray = byteArray(),
+        charArray = charArray(),
+        shortArray = shortArray(),
+        intArray = intArray(),
+        longArray = longArray(),
+        floatArray = floatArray(),
+        doubleArray = doubleArray(),
+        booleanArray = booleanArray()
+)
+class C2
@@ -0,0 +1,21 @@
+package test
+
+test.PrimitiveArrays(booleanArray = {true, false, true}: kotlin.BooleanArray, byteArray = {-7.toByte(), 7.toByte()}: kotlin.ByteArray, charArray = {\u0025 ('%'), \u007A ('z')}: kotlin.CharArray, doubleArray = {-3.14.toDouble()}: kotlin.DoubleArray, floatArray = {2.72.toFloat(), 0.0.toFloat()}: kotlin.FloatArray, intArray = {239017, -1}: kotlin.IntArray, longArray = {123456789123456789.toLong()}: kotlin.LongArray, shortArray = {239.toShort()}: kotlin.ShortArray) internal final class C1 {
+    public constructor C1()
+}
+
+test.PrimitiveArrays(booleanArray = {}: kotlin.BooleanArray, byteArray = {}: kotlin.ByteArray, charArray = {}: kotlin.CharArray, doubleArray = {}: kotlin.DoubleArray, floatArray = {}: kotlin.FloatArray, intArray = {}: kotlin.IntArray, longArray = {}: kotlin.LongArray, shortArray = {}: kotlin.ShortArray) internal final class C2 {
+    public constructor C2()
+}
+
+internal final annotation class PrimitiveArrays : kotlin.Annotation {
+    public constructor PrimitiveArrays(/*0*/ byteArray: kotlin.ByteArray, /*1*/ charArray: kotlin.CharArray, /*2*/ shortArray: kotlin.ShortArray, /*3*/ intArray: kotlin.IntArray, /*4*/ longArray: kotlin.LongArray, /*5*/ floatArray: kotlin.FloatArray, /*6*/ doubleArray: kotlin.DoubleArray, /*7*/ booleanArray: kotlin.BooleanArray)
+    internal final val booleanArray: kotlin.BooleanArray
+    internal final val byteArray: kotlin.ByteArray
+    internal final val charArray: kotlin.CharArray
+    internal final val doubleArray: kotlin.DoubleArray
+    internal final val floatArray: kotlin.FloatArray
+    internal final val intArray: kotlin.IntArray
+    internal final val longArray: kotlin.LongArray
+    internal final val shortArray: kotlin.ShortArray
+}
@@ -0,0 +1,24 @@
+package test
+
+annotation class Primitives(
+        val byte: Byte,
+        val char: Char,
+        val short: Short,
+        val int: Int,
+        val long: Long,
+        val float: Float,
+        val double: Double,
+        val boolean: Boolean
+)
+
+Primitives(
+        byte = 7,
+        char = '%',
+        short = 239,
+        int = 239017,
+        long = 123456789123456789L,
+        float = 2.72f,
+        double = -3.14,
+        boolean = true
+)
+class C
@@ -0,0 +1,17 @@
+package test
+
+test.Primitives(boolean = true: kotlin.Boolean, byte = 7.toByte(): kotlin.Byte, char = \u0025 ('%'): kotlin.Char, double = -3.14.toDouble(): kotlin.Double, float = 2.72.toFloat(): kotlin.Float, int = 239017: kotlin.Int, long = 123456789123456789.toLong(): kotlin.Long, short = 239.toShort(): kotlin.Short) internal final class C {
+    public constructor C()
+}
+
+internal final annotation class Primitives : kotlin.Annotation {
+    public constructor Primitives(/*0*/ byte: kotlin.Byte, /*1*/ char: kotlin.Char, /*2*/ short: kotlin.Short, /*3*/ int: kotlin.Int, /*4*/ long: kotlin.Long, /*5*/ float: kotlin.Float, /*6*/ double: kotlin.Double, /*7*/ boolean: kotlin.Boolean)
+    internal final val boolean: kotlin.Boolean
+    internal final val byte: kotlin.Byte
+    internal final val char: kotlin.Char
+    internal final val double: kotlin.Double
+    internal final val float: kotlin.Float
+    internal final val int: kotlin.Int
+    internal final val long: kotlin.Long
+    internal final val short: kotlin.Short
+}
@@ -0,0 +1,12 @@
+package test
+
+annotation class JustString(val string: String)
+
+annotation class StringArray(val stringArray: Array<String>)
+
+JustString("kotlin")
+StringArray(array())
+class C1
+
+StringArray(array("java", ""))
+class C2
@@ -0,0 +1,19 @@
+package test
+
+test.JustString(string = "kotlin": kotlin.String) test.StringArray(stringArray = {}: kotlin.Array<kotlin.String>) internal final class C1 {
+    public constructor C1()
+}
+
+test.StringArray(stringArray = {"java", ""}: kotlin.Array<kotlin.String>) internal final class C2 {
+    public constructor C2()
+}
+
+internal final annotation class JustString : kotlin.Annotation {
+    public constructor JustString(/*0*/ string: kotlin.String)
+    internal final val string: kotlin.String
+}
+
+internal final annotation class StringArray : kotlin.Annotation {
+    public constructor StringArray(/*0*/ stringArray: kotlin.Array<kotlin.String>)
+    internal final val stringArray: kotlin.Array<kotlin.String>
+}
@@ -0,0 +1,37 @@
+package test
+
+annotation class anno(val x: String)
+
+
+anno("top level function")
+fun f1(anno("top level function parameter") p: Int) {}
+
+anno("top level property")
+val p1 = null
+
+anno("extension function")
+fun Long.f2(anno("extension function parameter") p: Int) {}
+
+anno("extension property")
+val Double.p2: Double get() = null
+
+anno("top level class")
+class C1 [anno("constructor")] () {
+    anno("member function")
+    fun f3(anno("member function parameter") p: Int) {}
+
+    anno("member property")
+    val p3 = null
+
+    anno("member extension function")
+    fun String.f4() {}
+
+    anno("member extension property")
+    val Int.v4: Int get() = this
+
+    anno("nested class")
+    class C2
+
+    anno("class object")
+    class object {}
+}
@@ -0,0 +1,27 @@
+package test
+
+test.anno(x = "top level property": kotlin.String) internal val p1: kotlin.Nothing?
+test.anno(x = "extension property": kotlin.String) internal val kotlin.Double.p2: kotlin.Double
+test.anno(x = "top level function": kotlin.String) internal fun f1(/*0*/ test.anno(x = "top level function parameter": kotlin.String) p: kotlin.Int): kotlin.Unit
+test.anno(x = "extension function": kotlin.String) internal fun kotlin.Long.f2(/*0*/ test.anno(x = "extension function parameter": kotlin.String) p: kotlin.Int): kotlin.Unit
+
+test.anno(x = "top level class": kotlin.String) internal final class C1 {
+    test.anno(x = "constructor": kotlin.String) public constructor C1()
+    test.anno(x = "member property": kotlin.String) internal final val p3: kotlin.Nothing?
+    test.anno(x = "member extension property": kotlin.String) internal final val kotlin.Int.v4: kotlin.Int
+    test.anno(x = "member function": kotlin.String) internal final fun f3(/*0*/ test.anno(x = "member function parameter": kotlin.String) p: kotlin.Int): kotlin.Unit
+    test.anno(x = "member extension function": kotlin.String) internal final fun kotlin.String.f4(): kotlin.Unit
+
+    test.anno(x = "class object": kotlin.String) internal class object <class-object-for-C1> {
+        private constructor <class-object-for-C1>()
+    }
+
+    test.anno(x = "nested class": kotlin.String) internal final class C2 {
+        public constructor C2()
+    }
+}
+
+internal final annotation class anno : kotlin.Annotation {
+    public constructor anno(/*0*/ x: kotlin.String)
+    internal final val x: kotlin.String
+}
@@ -26,20 +26,24 @@ import org.jetbrains.jet.JetTestUtils
 import java.io.FileInputStream
 import org.jetbrains.jet.test.util.RecursiveDescriptorComparator
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
+import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime

 public class BuiltInsSerializerTest : TestCaseWithTmpdir() {
    private fun doTest(fileName: String) {
        val source = "compiler/testData/serialization/$fileName"
        BuiltInsSerializer(dependOnOldBuiltIns = true).serialize(
                tmpdir,
-                listOf(File(source)),
-                { totalSize, totalFiles -> }
+                srcDirs = listOf(File(source)),
+                extraClassPath = listOf(ForTestCompileRuntime.runtimeJarForTests()),
+                onComplete = { totalSize, totalFiles -> }
        )

        val module = JetTestUtils.createEmptyModule("<module>")

        val packageFragment = BuiltinsPackageFragment(TEST_PACKAGE_FQNAME, LockBasedStorageManager(), module) {
-            path -> FileInputStream(File(tmpdir, path))
+            path ->
+            val file = File(tmpdir, path)
+            if (file.exists()) FileInputStream(file) else null
        }

        module.initialize(packageFragment.provider)
@@ -57,4 +61,28 @@ public class BuiltInsSerializerTest : TestCaseWithTmpdir() {
    fun testSimple() {
        doTest("simple.kt")
    }
+
+    fun testAnnotationTargets() {
+        doTest("annotationTargets.kt")
+    }
+
+    fun testPrimitives() {
+        doTest("annotationArguments/primitives.kt")
+    }
+
+    fun testPrimitiveArrays() {
+        doTest("annotationArguments/primitiveArrays.kt")
+    }
+
+    fun testString() {
+        doTest("annotationArguments/string.kt")
+    }
+
+    fun testAnnotation() {
+        doTest("annotationArguments/annotation.kt")
+    }
+
+    fun testEnum() {
+        doTest("annotationArguments/enum.kt")
+    }
 }
@@ -8,6 +8,9 @@ public final class DebugBuiltInsProtoBuf {
  public static void registerAllExtensions(
      com.google.protobuf.ExtensionRegistry registry) {
    registry.add(org.jetbrains.jet.descriptors.serialization.DebugBuiltInsProtoBuf.className);
+    registry.add(org.jetbrains.jet.descriptors.serialization.DebugBuiltInsProtoBuf.classAnnotation);
+    registry.add(org.jetbrains.jet.descriptors.serialization.DebugBuiltInsProtoBuf.callableAnnotation);
+    registry.add(org.jetbrains.jet.descriptors.serialization.DebugBuiltInsProtoBuf.parameterAnnotation);
  }
  public static final int CLASS_NAME_FIELD_NUMBER = 150;
  /**
@@ -20,6 +23,39 @@ public final class DebugBuiltInsProtoBuf {
          .newFileScopedGeneratedExtension(
        java.lang.Integer.class,
        null);
+  public static final int CLASS_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.jet.descriptors.serialization.Class { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Class,
+      java.util.List<org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation>> classAnnotation = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation.class,
+        org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int CALLABLE_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.jet.descriptors.serialization.Callable { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Callable,
+      java.util.List<org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation>> callableAnnotation = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation.class,
+        org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation.getDefaultInstance());
+  public static final int PARAMETER_ANNOTATION_FIELD_NUMBER = 150;
+  /**
+   * <code>extend .org.jetbrains.jet.descriptors.serialization.Callable.ValueParameter { ... }</code>
+   */
+  public static final
+    com.google.protobuf.GeneratedMessage.GeneratedExtension<
+      org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Callable.ValueParameter,
+      java.util.List<org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation>> parameterAnnotation = com.google.protobuf.GeneratedMessage
+          .newFileScopedGeneratedExtension(
+        org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation.class,
+        org.jetbrains.jet.descriptors.serialization.DebugProtoBuf.Annotation.getDefaultInstance());

  public static com.google.protobuf.Descriptors.FileDescriptor
      getDescriptor() {
@@ -34,8 +70,19 @@ public final class DebugBuiltInsProtoBuf {
      "ialization\032.core/serialization/src/descr" +
      "iptors.debug.proto:M\n\nclass_name\0224.org.j" +
      "etbrains.jet.descriptors.serialization.P" +
-      "ackage\030\226\001 \003(\005B\002\020\001B\027B\025DebugBuiltInsProtoB" +
-      "uf"
+      "ackage\030\226\001 \003(\005B\002\020\001:\206\001\n\020class_annotation\0222" +
+      ".org.jetbrains.jet.descriptors.serializa" +
+      "tion.Class\030\226\001 \003(\01327.org.jetbrains.jet.de" +
+      "scriptors.serialization.Annotation:\214\001\n\023c" +
+      "allable_annotation\0225.org.jetbrains.jet.d",
+      "escriptors.serialization.Callable\030\226\001 \003(\013" +
+      "27.org.jetbrains.jet.descriptors.seriali" +
+      "zation.Annotation:\234\001\n\024parameter_annotati" +
+      "on\022D.org.jetbrains.jet.descriptors.seria" +
+      "lization.Callable.ValueParameter\030\226\001 \003(\0132" +
+      "7.org.jetbrains.jet.descriptors.serializ" +
+      "ation.AnnotationB\027B\025DebugBuiltInsProtoBu" +
+      "f"
    };
    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
      new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
@@ -43,6 +90,9 @@ public final class DebugBuiltInsProtoBuf {
            com.google.protobuf.Descriptors.FileDescriptor root) {
          descriptor = root;
          className.internalInit(descriptor.getExtensions().get(0));
+          classAnnotation.internalInit(descriptor.getExtensions().get(1));
+          callableAnnotation.internalInit(descriptor.getExtensions().get(2));
+          parameterAnnotation.internalInit(descriptor.getExtensions().get(3));
          return null;
        }
      };