JS IC: .proto update

compiler/ir/serialization.common/src/KotlinIr.proto

@@ -40,6 +40,21 @@ message AccessorIdSignature {
 message FileLocalIdSignature {
   required int32 container = 1;
   required int64 local_id = 2;
+  optional int32 file = 3;
+}
+
+message LoweredIdSignature {
+  required int32 parent_signature = 1;
+  required int32 stage = 2;
+  required int32 index = 3;
+}
+
+message FileSignature {
+}
+
+message ScopeLocalIdSignature {
+  required int32 id = 1;
+  optional int32 file = 2;
 }
 
 message IdSignature {
@@ -48,6 +63,11 @@ message IdSignature {
     FileLocalIdSignature private_sig = 2;
     AccessorIdSignature accessor_sig = 3;
     int32 scoped_local_sig = 4;
+
+    // JS IC related stuff below. Proto indices 100+ were chosen due to compatibility considerations.
+    LoweredIdSignature ic_sig = 105;
+    FileSignature file_sig = 106;
+    ScopeLocalIdSignature external_scoped_local_sig = 107;
   }
 }
 
@@ -107,6 +127,12 @@ message IrBlock {
   optional int32 origin_name = 2;
 }
 
+message IrReturnableBlock {
+  repeated IrStatement statement = 1;
+  optional int32 origin_name = 2;
+  optional int64 inline_function_symbol = 3;
+}
+
 message MemberAccessCommon {
   optional IrExpression dispatch_receiver = 1;
   optional IrExpression extension_receiver = 2;
@@ -135,6 +161,10 @@ message IrFunctionReference {
   optional int64 reflection_target_symbol = 4;
 }
 
+message IrRawFunctionReference {
+  required int64 symbol = 1;
+}
+
 message IrLocalDelegatedPropertyReference {
   required int64 delegate = 1;
   optional int64 getter = 2;
@@ -241,6 +271,11 @@ message IrReturn {
   required IrExpression value = 2;
 }
 
+message IrReturnableBlockReturn {
+  required uint32 upCnt = 1;
+  required IrExpression value = 2;
+}
+
 message IrSetField {
   required FieldAccessCommon field_access = 1;
   required IrExpression value = 2;
@@ -402,6 +437,10 @@ message IrOperation {
     // Error code
     IrErrorExpression error_expression = 34;
     IrErrorCallExpression error_call_expression = 35;
+
+    IrRawFunctionReference raw_function_reference = 36;
+    IrReturnableBlock returnable_block = 37;
+    IrReturnableBlockReturn returnable_block_return = 38;
   }
 }
 
@@ -493,12 +532,15 @@ message IrValueParameter {
   required int64 name_type = 2;
   optional int32 vararg_element_type = 3;
   optional int32 default_value = 4;
+  optional int32 index = 5;
 }
 
 message IrTypeParameter {
   required IrDeclarationBase base = 1;
   required int32 name = 2;
   repeated int32 super_type = 3 [packed=true];
+  optional int32 index = 4;
+  optional bool isGlobal = 5;
 }
 
 message IrClass {

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/FileLocalIdSignature.java

@@ -27,60 +27,7 @@ public final class FileLocalIdSignature extends
   }
 
   private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
-  private FileLocalIdSignature(
+  public static final int FILE_FIELD_NUMBER = 3;
-      org.jetbrains.kotlin.protobuf.CodedInputStream input,
-      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
-    initFields();
-    int mutable_bitField0_ = 0;
-    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
-        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
-    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
-        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
-            unknownFieldsOutput, 1);
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFieldsCodedOutput,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 8: {
-            bitField0_ |= 0x00000001;
-            container_ = input.readInt32();
-            break;
-          }
-          case 16: {
-            bitField0_ |= 0x00000002;
-            localId_ = input.readInt64();
-            break;
-          }
-        }
-      }
-    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
-          e.getMessage()).setUnfinishedMessage(this);
-    } finally {
-      try {
-        unknownFieldsCodedOutput.flush();
-      } catch (java.io.IOException e) {
-      // Should not happen
-      } finally {
-        unknownFields = unknownFieldsOutput.toByteString();
-      }
-      makeExtensionsImmutable();
-    }
-  }
   public static org.jetbrains.kotlin.protobuf.Parser<FileLocalIdSignature> PARSER =
       new org.jetbrains.kotlin.protobuf.AbstractParser<FileLocalIdSignature>() {
     public FileLocalIdSignature parsePartialFrom(
@@ -126,10 +73,84 @@ public final class FileLocalIdSignature extends
   public long getLocalId() {
     return localId_;
   }
+  private int file_;
+  private FileLocalIdSignature(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    initFields();
+    int mutable_bitField0_ = 0;
+    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
+        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
+    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
+            unknownFieldsOutput, 1);
+    try {
+      boolean done = false;
+      while (!done) {
+        int tag = input.readTag();
+        switch (tag) {
+          case 0:
+            done = true;
+            break;
+          default: {
+            if (!parseUnknownField(input, unknownFieldsCodedOutput,
+                                   extensionRegistry, tag)) {
+              done = true;
+            }
+            break;
+          }
+          case 8: {
+            bitField0_ |= 0x00000001;
+            container_ = input.readInt32();
+            break;
+          }
+          case 16: {
+            bitField0_ |= 0x00000002;
+            localId_ = input.readInt64();
+            break;
+          }
+          case 24: {
+            bitField0_ |= 0x00000004;
+            file_ = input.readInt32();
+            break;
+          }
+        }
+      }
+    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+      throw e.setUnfinishedMessage(this);
+    } catch (java.io.IOException e) {
+      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
+          e.getMessage()).setUnfinishedMessage(this);
+    } finally {
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+
+  /**
+   * <code>optional int32 file = 3;</code>
+   */
+  public boolean hasFile() {
+    return ((bitField0_ & 0x00000004) == 0x00000004);
+  }
+  /**
+   * <code>optional int32 file = 3;</code>
+   */
+  public int getFile() {
+    return file_;
+  }
 
   private void initFields() {
     container_ = 0;
     localId_ = 0L;
+    file_ = 0;
   }
   private byte memoizedIsInitialized = -1;
   public final boolean isInitialized() {
@@ -158,6 +179,9 @@ public final class FileLocalIdSignature extends
     if (((bitField0_ & 0x00000002) == 0x00000002)) {
       output.writeInt64(2, localId_);
     }
+    if (((bitField0_ & 0x00000004) == 0x00000004)) {
+      output.writeInt32(3, file_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -175,6 +199,10 @@ public final class FileLocalIdSignature extends
       size += org.jetbrains.kotlin.protobuf.CodedOutputStream
         .computeInt64Size(2, localId_);
     }
+    if (((bitField0_ & 0x00000004) == 0x00000004)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeInt32Size(3, file_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -267,14 +295,7 @@ public final class FileLocalIdSignature extends
       return new Builder();
     }
 
-    public Builder clear() {
+    private int file_ ;
-      super.clear();
-      container_ = 0;
-      bitField0_ = (bitField0_ & ~0x00000001);
-      localId_ = 0L;
-      bitField0_ = (bitField0_ & ~0x00000002);
-      return this;
-    }
 
     public Builder clone() {
       return create().mergeFrom(buildPartial());
@@ -292,6 +313,17 @@ public final class FileLocalIdSignature extends
       return result;
     }
 
+    public Builder clear() {
+      super.clear();
+      container_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000001);
+      localId_ = 0L;
+      bitField0_ = (bitField0_ & ~0x00000002);
+      file_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000004);
+      return this;
+    }
+
     public org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature buildPartial() {
       org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature result = new org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature(this);
       int from_bitField0_ = bitField0_;
@@ -304,23 +336,14 @@ public final class FileLocalIdSignature extends
         to_bitField0_ |= 0x00000002;
       }
       result.localId_ = localId_;
+      if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+        to_bitField0_ |= 0x00000004;
+      }
+      result.file_ = file_;
       result.bitField0_ = to_bitField0_;
       return result;
     }
 
-    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature other) {
-      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature.getDefaultInstance()) return this;
-      if (other.hasContainer()) {
-        setContainer(other.getContainer());
-      }
-      if (other.hasLocalId()) {
-        setLocalId(other.getLocalId());
-      }
-      setUnknownFields(
-          getUnknownFields().concat(other.unknownFields));
-      return this;
-    }
-
     public final boolean isInitialized() {
       if (!hasContainer()) {
         
@@ -406,12 +429,60 @@ public final class FileLocalIdSignature extends
       
       return this;
     }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature.getDefaultInstance()) return this;
+      if (other.hasContainer()) {
+        setContainer(other.getContainer());
+      }
+      if (other.hasLocalId()) {
+        setLocalId(other.getLocalId());
+      }
+      if (other.hasFile()) {
+        setFile(other.getFile());
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
     /**
      * <code>required int64 local_id = 2;</code>
      */
     public Builder clearLocalId() {
       bitField0_ = (bitField0_ & ~0x00000002);
       localId_ = 0L;
+
+      return this;
+    }
+
+    /**
+     * <code>optional int32 file = 3;</code>
+     */
+    public boolean hasFile() {
+      return ((bitField0_ & 0x00000004) == 0x00000004);
+    }
+    /**
+     * <code>optional int32 file = 3;</code>
+     */
+    public int getFile() {
+      return file_;
+    }
+    /**
+     * <code>optional int32 file = 3;</code>
+     */
+    public Builder setFile(int value) {
+      bitField0_ |= 0x00000004;
+      file_ = value;
+      
+      return this;
+    }
+    /**
+     * <code>optional int32 file = 3;</code>
+     */
+    public Builder clearFile() {
+      bitField0_ = (bitField0_ & ~0x00000004);
+      file_ = 0;
       
       return this;
     }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/FileLocalIdSignatureOrBuilder.java

@@ -24,4 +24,13 @@ public interface FileLocalIdSignatureOrBuilder extends
    * <code>required int64 local_id = 2;</code>
    */
   long getLocalId();
+
+  /**
+   * <code>optional int32 file = 3;</code>
+   */
+  boolean hasFile();
+  /**
+   * <code>optional int32 file = 3;</code>
+   */
+  int getFile();
 }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/FileSignature.java

@@ -32,7 +32,6 @@ public final class FileSignature extends
       org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
       throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
     initFields();
-    int mutable_bitField0_ = 0;
     org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
         org.jetbrains.kotlin.protobuf.ByteString.newOutput();
     org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
@@ -53,12 +52,6 @@ public final class FileSignature extends
             }
             break;
           }
-          case 10: {
-            org.jetbrains.kotlin.protobuf.ByteString bs = input.readBytes();
-            bitField0_ |= 0x00000001;
-            path_ = bs;
-            break;
-          }
         }
       }
     } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -92,51 +85,7 @@ public final class FileSignature extends
     return PARSER;
   }
 
-  private int bitField0_;
-  public static final int PATH_FIELD_NUMBER = 1;
-  private java.lang.Object path_;
-  /**
-   * <code>required string path = 1;</code>
-   */
-  public boolean hasPath() {
-    return ((bitField0_ & 0x00000001) == 0x00000001);
-  }
-  /**
-   * <code>required string path = 1;</code>
-   */
-  public java.lang.String getPath() {
-    java.lang.Object ref = path_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      org.jetbrains.kotlin.protobuf.ByteString bs = 
-          (org.jetbrains.kotlin.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (bs.isValidUtf8()) {
-        path_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <code>required string path = 1;</code>
-   */
-  public org.jetbrains.kotlin.protobuf.ByteString
-      getPathBytes() {
-    java.lang.Object ref = path_;
-    if (ref instanceof java.lang.String) {
-      org.jetbrains.kotlin.protobuf.ByteString b = 
-          org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      path_ = b;
-      return b;
-    } else {
-      return (org.jetbrains.kotlin.protobuf.ByteString) ref;
-    }
-  }
-
   private void initFields() {
-    path_ = "";
   }
   private byte memoizedIsInitialized = -1;
   public final boolean isInitialized() {
@@ -144,10 +93,6 @@ public final class FileSignature extends
     if (isInitialized == 1) return true;
     if (isInitialized == 0) return false;
 
-    if (!hasPath()) {
-      memoizedIsInitialized = 0;
-      return false;
-    }
     memoizedIsInitialized = 1;
     return true;
   }
@@ -155,9 +100,6 @@ public final class FileSignature extends
   public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output)
                       throws java.io.IOException {
     getSerializedSize();
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      output.writeBytes(1, getPathBytes());
-    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -167,10 +109,6 @@ public final class FileSignature extends
     if (size != -1) return size;
 
     size = 0;
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
-        .computeBytesSize(1, getPathBytes());
-    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -265,8 +203,6 @@ public final class FileSignature extends
 
     public Builder clear() {
       super.clear();
-      path_ = "";
-      bitField0_ = (bitField0_ & ~0x00000001);
       return this;
     }
 
@@ -288,33 +224,17 @@ public final class FileSignature extends
 
     public org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature buildPartial() {
       org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature result = new org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-        to_bitField0_ |= 0x00000001;
-      }
-      result.path_ = path_;
-      result.bitField0_ = to_bitField0_;
       return result;
     }
 
     public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature other) {
       if (other == org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.getDefaultInstance()) return this;
-      if (other.hasPath()) {
-        bitField0_ |= 0x00000001;
-        path_ = other.path_;
-        
-      }
       setUnknownFields(
           getUnknownFields().concat(other.unknownFields));
       return this;
     }
 
     public final boolean isInitialized() {
-      if (!hasPath()) {
-        
-        return false;
-      }
       return true;
     }
 
@@ -335,83 +255,6 @@ public final class FileSignature extends
       }
       return this;
     }
-    private int bitField0_;
-
-    private java.lang.Object path_ = "";
-    /**
-     * <code>required string path = 1;</code>
-     */
-    public boolean hasPath() {
-      return ((bitField0_ & 0x00000001) == 0x00000001);
-    }
-    /**
-     * <code>required string path = 1;</code>
-     */
-    public java.lang.String getPath() {
-      java.lang.Object ref = path_;
-      if (!(ref instanceof java.lang.String)) {
-        org.jetbrains.kotlin.protobuf.ByteString bs =
-            (org.jetbrains.kotlin.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (bs.isValidUtf8()) {
-          path_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>required string path = 1;</code>
-     */
-    public org.jetbrains.kotlin.protobuf.ByteString
-        getPathBytes() {
-      java.lang.Object ref = path_;
-      if (ref instanceof String) {
-        org.jetbrains.kotlin.protobuf.ByteString b = 
-            org.jetbrains.kotlin.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        path_ = b;
-        return b;
-      } else {
-        return (org.jetbrains.kotlin.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>required string path = 1;</code>
-     */
-    public Builder setPath(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      path_ = value;
-      
-      return this;
-    }
-    /**
-     * <code>required string path = 1;</code>
-     */
-    public Builder clearPath() {
-      bitField0_ = (bitField0_ & ~0x00000001);
-      path_ = getDefaultInstance().getPath();
-      
-      return this;
-    }
-    /**
-     * <code>required string path = 1;</code>
-     */
-    public Builder setPathBytes(
-        org.jetbrains.kotlin.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      path_ = value;
-      
-      return this;
-    }
 
     // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature)
   }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/FileSignatureOrBuilder.java

@@ -6,18 +6,4 @@ package org.jetbrains.kotlin.backend.common.serialization.proto;
 public interface FileSignatureOrBuilder extends
     // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature)
     org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
-
-  /**
-   * <code>required string path = 1;</code>
-   */
-  boolean hasPath();
-  /**
-   * <code>required string path = 1;</code>
-   */
-  java.lang.String getPath();
-  /**
-   * <code>required string path = 1;</code>
-   */
-  org.jetbrains.kotlin.protobuf.ByteString
-      getPathBytes();
 }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/FileWrappedIdSignature.java

@@ -0,0 +1,495 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: compiler/ir/serialization.common/src/KotlinIr.proto
+
+package org.jetbrains.kotlin.backend.common.serialization.proto;
+
+/**
+ * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature}
+ */
+public final class FileWrappedIdSignature extends
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+    // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature)
+    FileWrappedIdSignatureOrBuilder {
+  public static final int DELEGATE_FIELD_NUMBER = 1;
+  public static final int FILE_FIELD_NUMBER = 2;
+  private static final FileWrappedIdSignature defaultInstance;
+  private static final long serialVersionUID = 0L;
+  public static org.jetbrains.kotlin.protobuf.Parser<FileWrappedIdSignature> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<FileWrappedIdSignature>() {
+    public FileWrappedIdSignature parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new FileWrappedIdSignature(input, extensionRegistry);
+    }
+  };
+
+  static {
+    defaultInstance = new FileWrappedIdSignature(true);
+    defaultInstance.initFields();
+  }
+
+  private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  private int bitField0_;
+  private org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate_;
+  private int file_;
+  private byte memoizedIsInitialized = -1;
+  private int memoizedSerializedSize = -1;
+  // Use FileWrappedIdSignature.newBuilder() to construct.
+  private FileWrappedIdSignature(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+    super(builder);
+    this.unknownFields = builder.getUnknownFields();
+  }
+  private FileWrappedIdSignature(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+  private FileWrappedIdSignature(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    initFields();
+    int mutable_bitField0_ = 0;
+    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
+        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
+    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
+            unknownFieldsOutput, 1);
+    try {
+      boolean done = false;
+      while (!done) {
+        int tag = input.readTag();
+        switch (tag) {
+          case 0:
+            done = true;
+            break;
+          default: {
+            if (!parseUnknownField(input, unknownFieldsCodedOutput,
+                                   extensionRegistry, tag)) {
+              done = true;
+            }
+            break;
+          }
+          case 10: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.Builder subBuilder = null;
+            if (((bitField0_ & 0x00000001) == 0x00000001)) {
+              subBuilder = delegate_.toBuilder();
+            }
+            delegate_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom(delegate_);
+              delegate_ = subBuilder.buildPartial();
+            }
+            bitField0_ |= 0x00000001;
+            break;
+          }
+          case 16: {
+            bitField0_ |= 0x00000002;
+            file_ = input.readInt32();
+            break;
+          }
+        }
+      }
+    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+      throw e.setUnfinishedMessage(this);
+    } catch (java.io.IOException e) {
+      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
+          e.getMessage()).setUnfinishedMessage(this);
+    } finally {
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+
+  public static FileWrappedIdSignature getDefaultInstance() {
+    return defaultInstance;
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(
+      org.jetbrains.kotlin.protobuf.ByteString data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(
+      org.jetbrains.kotlin.protobuf.ByteString data,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(byte[] data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(
+      byte[] data,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(
+      java.io.InputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseDelimitedFrom(
+      java.io.InputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input, extensionRegistry);
+  }
+
+  public static Builder newBuilder() { return Builder.create(); }
+
+  public static Builder newBuilder(org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature prototype) {
+    return newBuilder().mergeFrom(prototype);
+  }
+
+  public FileWrappedIdSignature getDefaultInstanceForType() {
+    return defaultInstance;
+  }
+
+  @java.lang.Override
+  public org.jetbrains.kotlin.protobuf.Parser<FileWrappedIdSignature> getParserForType() {
+    return PARSER;
+  }
+
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+   */
+  public boolean hasDelegate() {
+    return ((bitField0_ & 0x00000001) == 0x00000001);
+  }
+
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature getDelegate() {
+    return delegate_;
+  }
+
+  /**
+   * <code>required int32 file = 2;</code>
+   */
+  public boolean hasFile() {
+    return ((bitField0_ & 0x00000002) == 0x00000002);
+  }
+
+  /**
+   * <code>required int32 file = 2;</code>
+   */
+  public int getFile() {
+    return file_;
+  }
+
+  private void initFields() {
+    delegate_ = org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.getDefaultInstance();
+    file_ = 0;
+  }
+
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    if (!hasDelegate()) {
+      memoizedIsInitialized = 0;
+      return false;
+    }
+    if (!hasFile()) {
+      memoizedIsInitialized = 0;
+      return false;
+    }
+    if (!getDelegate().isInitialized()) {
+      memoizedIsInitialized = 0;
+      return false;
+    }
+    memoizedIsInitialized = 1;
+    return true;
+  }
+
+  public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output)
+                      throws java.io.IOException {
+    getSerializedSize();
+    if (((bitField0_ & 0x00000001) == 0x00000001)) {
+      output.writeMessage(1, delegate_);
+    }
+    if (((bitField0_ & 0x00000002) == 0x00000002)) {
+      output.writeInt32(2, file_);
+    }
+    output.writeRawBytes(unknownFields);
+  }
+
+  public int getSerializedSize() {
+    int size = memoizedSerializedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    if (((bitField0_ & 0x00000001) == 0x00000001)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(1, delegate_);
+    }
+    if (((bitField0_ & 0x00000002) == 0x00000002)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeInt32Size(2, file_);
+    }
+    size += unknownFields.size();
+    memoizedSerializedSize = size;
+    return size;
+  }
+
+  @java.lang.Override
+  protected java.lang.Object writeReplace()
+      throws java.io.ObjectStreamException {
+    return super.writeReplace();
+  }
+
+  public Builder newBuilderForType() { return newBuilder(); }
+
+  public Builder toBuilder() { return newBuilder(this); }
+
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature}
+   */
+  public static final class Builder extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+        org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature, Builder>
+      implements
+      // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature)
+      org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignatureOrBuilder {
+    private int bitField0_;
+    private org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate_ = org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.getDefaultInstance();
+    private int file_ ;
+
+    // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private static Builder create() {
+      return new Builder();
+    }
+
+    private void maybeForceBuilderInitialization() {
+    }
+
+    public Builder clear() {
+      super.clear();
+      delegate_ = org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.getDefaultInstance();
+      bitField0_ = (bitField0_ & ~0x00000001);
+      file_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000002);
+      return this;
+    }
+
+    public Builder clone() {
+      return create().mergeFrom(buildPartial());
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature getDefaultInstanceForType() {
+      return org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature.getDefaultInstance();
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature build() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature result = new org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature(this);
+      int from_bitField0_ = bitField0_;
+      int to_bitField0_ = 0;
+      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+        to_bitField0_ |= 0x00000001;
+      }
+      result.delegate_ = delegate_;
+      if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+        to_bitField0_ |= 0x00000002;
+      }
+      result.file_ = file_;
+      result.bitField0_ = to_bitField0_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature.getDefaultInstance()) return this;
+      if (other.hasDelegate()) {
+        mergeDelegate(other.getDelegate());
+      }
+      if (other.hasFile()) {
+        setFile(other.getFile());
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
+    public final boolean isInitialized() {
+      if (!hasDelegate()) {
+
+        return false;
+      }
+      if (!hasFile()) {
+
+        return false;
+      }
+      if (!getDelegate().isInitialized()) {
+
+        return false;
+      }
+      return true;
+    }
+
+    public Builder mergeFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature) e.getUnfinishedMessage();
+        throw e;
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+     */
+    public boolean hasDelegate() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature getDelegate() {
+      return delegate_;
+    }
+
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+     */
+    public Builder setDelegate(org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      delegate_ = value;
+
+      bitField0_ |= 0x00000001;
+      return this;
+    }
+
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+     */
+    public Builder setDelegate(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.Builder builderForValue) {
+      delegate_ = builderForValue.build();
+
+      bitField0_ |= 0x00000001;
+      return this;
+    }
+
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+     */
+    public Builder mergeDelegate(org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature value) {
+      if (((bitField0_ & 0x00000001) == 0x00000001) &&
+          delegate_ != org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.getDefaultInstance()) {
+        delegate_ =
+          org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.newBuilder(delegate_).mergeFrom(value).buildPartial();
+      } else {
+        delegate_ = value;
+      }
+
+      bitField0_ |= 0x00000001;
+      return this;
+    }
+
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+     */
+    public Builder clearDelegate() {
+      delegate_ = org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature.getDefaultInstance();
+
+      bitField0_ = (bitField0_ & ~0x00000001);
+      return this;
+    }
+
+    /**
+     * <code>required int32 file = 2;</code>
+     */
+    public boolean hasFile() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required int32 file = 2;</code>
+     */
+    public int getFile() {
+      return file_;
+    }
+    /**
+     * <code>required int32 file = 2;</code>
+     */
+    public Builder setFile(int value) {
+      bitField0_ |= 0x00000002;
+      file_ = value;
+
+      return this;
+    }
+    /**
+     * <code>required int32 file = 2;</code>
+     */
+    public Builder clearFile() {
+      bitField0_ = (bitField0_ & ~0x00000002);
+      file_ = 0;
+
+      return this;
+    }
+
+    // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature)
+  }
+
+  // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature)
+}

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/FileWrappedIdSignatureOrBuilder.java

@@ -0,0 +1,27 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: compiler/ir/serialization.common/src/KotlinIr.proto
+
+package org.jetbrains.kotlin.backend.common.serialization.proto;
+
+public interface FileWrappedIdSignatureOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.FileWrappedIdSignature)
+    org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+   */
+  boolean hasDelegate();
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature delegate = 1;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature getDelegate();
+
+  /**
+   * <code>required int32 file = 2;</code>
+   */
+  boolean hasFile();
+  /**
+   * <code>required int32 file = 2;</code>
+   */
+  int getFile();
+}

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IdSignature.java

@@ -27,6 +27,26 @@ public final class IdSignature extends
   }
 
   private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  public static final int FILE_SIG_FIELD_NUMBER = 106;
+public static final int EXTERNAL_SCOPED_LOCAL_SIG_FIELD_NUMBER = 107;
+  public static final int PUBLIC_SIG_FIELD_NUMBER = 1;
+  public static final int PRIVATE_SIG_FIELD_NUMBER = 2;
+  public static final int ACCESSOR_SIG_FIELD_NUMBER = 3;
+  public static final int SCOPED_LOCAL_SIG_FIELD_NUMBER = 4;
+      public static final int IC_SIG_FIELD_NUMBER = 105;;
+  public static org.jetbrains.kotlin.protobuf.Parser<IdSignature> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<IdSignature>() {
+    public IdSignature parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new IdSignature(input, extensionRegistry);
+    }
+  };
+  private int bitField0_;
+  private int idsigCase_ = 0;
+  private java.lang.Object idsig_;
+  private int memoizedSerializedSize = -1;
   private IdSignature(
       org.jetbrains.kotlin.protobuf.CodedInputStream input,
       org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -97,6 +117,45 @@ public final class IdSignature extends
             idsig_ = input.readInt32();
             break;
           }
+          case 842: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature.Builder subBuilder = null;
+            if (idsigCase_ == 105) {
+              subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature) idsig_).toBuilder();
+            }
+            idsig_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature) idsig_);
+              idsig_ = subBuilder.buildPartial();
+            }
+            idsigCase_ = 105;
+            break;
+          }
+          case 850: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.Builder subBuilder = null;
+            if (idsigCase_ == 106) {
+              subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature) idsig_).toBuilder();
+            }
+            idsig_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature) idsig_);
+              idsig_ = subBuilder.buildPartial();
+            }
+            idsigCase_ = 106;
+            break;
+          }
+          case 858: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature.Builder subBuilder = null;
+            if (idsigCase_ == 107) {
+              subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature) idsig_).toBuilder();
+            }
+            idsig_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature) idsig_);
+              idsig_ = subBuilder.buildPartial();
+            }
+            idsigCase_ = 107;
+            break;
+          }
         }
       }
     } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -115,64 +174,25 @@ public final class IdSignature extends
       makeExtensionsImmutable();
     }
   }
-  public static org.jetbrains.kotlin.protobuf.Parser<IdSignature> PARSER =
-      new org.jetbrains.kotlin.protobuf.AbstractParser<IdSignature>() {
-    public IdSignature parsePartialFrom(
-        org.jetbrains.kotlin.protobuf.CodedInputStream input,
-        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
-      return new IdSignature(input, extensionRegistry);
-    }
-  };
 
   @java.lang.Override
   public org.jetbrains.kotlin.protobuf.Parser<IdSignature> getParserForType() {
     return PARSER;
   }
 
-  private int bitField0_;
-  private int idsigCase_ = 0;
-  private java.lang.Object idsig_;
-  public enum IdsigCase
-      implements org.jetbrains.kotlin.protobuf.Internal.EnumLite {
-    PUBLIC_SIG(1),
-    PRIVATE_SIG(2),
-    ACCESSOR_SIG(3),
-    SCOPED_LOCAL_SIG(4),
-    IDSIG_NOT_SET(0);
-    private int value = 0;
-    private IdsigCase(int value) {
-      this.value = value;
-    }
-    public static IdsigCase valueOf(int value) {
-      switch (value) {
-        case 1: return PUBLIC_SIG;
-        case 2: return PRIVATE_SIG;
-        case 3: return ACCESSOR_SIG;
-        case 4: return SCOPED_LOCAL_SIG;
-        case 0: return IDSIG_NOT_SET;
-        default: throw new java.lang.IllegalArgumentException(
-          "Value is undefined for this oneof enum.");
-      }
-    }
-    public int getNumber() {
-      return this.value;
-    }
-  };
-
   public IdsigCase
   getIdsigCase() {
     return IdsigCase.valueOf(
         idsigCase_);
   }
 
-  public static final int PUBLIC_SIG_FIELD_NUMBER = 1;
   /**
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.PublicIdSignature public_sig = 1;</code>
    */
   public boolean hasPublicSig() {
     return idsigCase_ == 1;
   }
+
   /**
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.PublicIdSignature public_sig = 1;</code>
    */
@@ -183,13 +203,13 @@ public final class IdSignature extends
     return org.jetbrains.kotlin.backend.common.serialization.proto.PublicIdSignature.getDefaultInstance();
   }
 
-  public static final int PRIVATE_SIG_FIELD_NUMBER = 2;
   /**
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature private_sig = 2;</code>
    */
   public boolean hasPrivateSig() {
     return idsigCase_ == 2;
   }
+
   /**
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature private_sig = 2;</code>
    */
@@ -200,13 +220,13 @@ public final class IdSignature extends
     return org.jetbrains.kotlin.backend.common.serialization.proto.FileLocalIdSignature.getDefaultInstance();
   }
 
-  public static final int ACCESSOR_SIG_FIELD_NUMBER = 3;
   /**
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.AccessorIdSignature accessor_sig = 3;</code>
    */
   public boolean hasAccessorSig() {
     return idsigCase_ == 3;
   }
+
   /**
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.AccessorIdSignature accessor_sig = 3;</code>
    */
@@ -217,13 +237,13 @@ public final class IdSignature extends
     return org.jetbrains.kotlin.backend.common.serialization.proto.AccessorIdSignature.getDefaultInstance();
   }
 
-  public static final int SCOPED_LOCAL_SIG_FIELD_NUMBER = 4;
   /**
    * <code>optional int32 scoped_local_sig = 4;</code>
    */
   public boolean hasScopedLocalSig() {
     return idsigCase_ == 4;
   }
+
   /**
    * <code>optional int32 scoped_local_sig = 4;</code>
    */
@@ -234,29 +254,60 @@ public final class IdSignature extends
     return 0;
   }
 
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+   */
+  public boolean hasIcSig() {
+    return idsigCase_ == 105;
+  }
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature getIcSig() {
+    if (idsigCase_ == 105) {
+       return (org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature) idsig_;
+    }
+    return org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature.getDefaultInstance();
+  }
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+   */
+  public boolean hasFileSig() {
+    return idsigCase_ == 106;
+  }
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature getFileSig() {
+    if (idsigCase_ == 106) {
+       return (org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature) idsig_;
+    }
+    return org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.getDefaultInstance();
+  }
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+   */
+  public boolean hasExternalScopedLocalSig() {
+    return idsigCase_ == 107;
+  }
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature getExternalScopedLocalSig() {
+    if (idsigCase_ == 107) {
+       return (org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature) idsig_;
+    }
+    return org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature.getDefaultInstance();
+  }
+
   private void initFields() {
   }
   private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    if (hasPrivateSig()) {
-      if (!getPrivateSig().isInitialized()) {
-        memoizedIsInitialized = 0;
-        return false;
-      }
-    }
-    if (hasAccessorSig()) {
-      if (!getAccessorSig().isInitialized()) {
-        memoizedIsInitialized = 0;
-        return false;
-      }
-    }
-    memoizedIsInitialized = 1;
-    return true;
-  }
 
   public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output)
                       throws java.io.IOException {
@@ -274,10 +325,51 @@ public final class IdSignature extends
       output.writeInt32(
           4, (int)((java.lang.Integer) idsig_));
     }
+    if (idsigCase_ == 105) {
+      output.writeMessage(105, (org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature) idsig_);
+    }
+    if (idsigCase_ == 106) {
+      output.writeMessage(106, (org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature) idsig_);
+    }
+    if (idsigCase_ == 107) {
+      output.writeMessage(107, (org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature) idsig_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
-  private int memoizedSerializedSize = -1;
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    if (hasPrivateSig()) {
+      if (!getPrivateSig().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
+    if (hasAccessorSig()) {
+      if (!getAccessorSig().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
+    if (hasIcSig()) {
+      if (!getIcSig().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
+    if (hasExternalScopedLocalSig()) {
+      if (!getExternalScopedLocalSig().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
+    memoizedIsInitialized = 1;
+    return true;
+  }
+
   public int getSerializedSize() {
     int size = memoizedSerializedSize;
     if (size != -1) return size;
@@ -300,10 +392,54 @@ public final class IdSignature extends
         .computeInt32Size(
             4, (int)((java.lang.Integer) idsig_));
     }
+    if (idsigCase_ == 105) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(105, (org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature) idsig_);
+    }
+    if (idsigCase_ == 106) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(106, (org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature) idsig_);
+    }
+    if (idsigCase_ == 107) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(107, (org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature) idsig_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
   }
+public enum IdsigCase
+      implements org.jetbrains.kotlin.protobuf.Internal.EnumLite {
+    PUBLIC_SIG(1),
+    PRIVATE_SIG(2),
+    ACCESSOR_SIG(3),
+    SCOPED_LOCAL_SIG(4),
+    IC_SIG(105),
+    FILE_SIG(106),
+    EXTERNAL_SCOPED_LOCAL_SIG(107),
+    IDSIG_NOT_SET(0);
+    private int value = 0;
+    private IdsigCase(int value) {
+      this.value = value;
+    }
+    public static IdsigCase valueOf(int value) {
+      switch (value) {
+        case 1: return PUBLIC_SIG;
+        case 2: return PRIVATE_SIG;
+        case 3: return ACCESSOR_SIG;
+        case 4: return SCOPED_LOCAL_SIG;
+        case 105: return IC_SIG;
+        case 106: return FILE_SIG;
+        case 107: return EXTERNAL_SCOPED_LOCAL_SIG;
+        case 0: return IDSIG_NOT_SET;
+        default: throw new java.lang.IllegalArgumentException(
+          "Value is undefined for this oneof enum.");
+      }
+    }
+    public int getNumber() {
+      return this.value;
+    }
+  }
 
   private static final long serialVersionUID = 0L;
   @java.lang.Override
@@ -431,6 +567,15 @@ public final class IdSignature extends
       if (idsigCase_ == 4) {
         result.idsig_ = idsig_;
       }
+      if (idsigCase_ == 105) {
+        result.idsig_ = idsig_;
+      }
+      if (idsigCase_ == 106) {
+        result.idsig_ = idsig_;
+      }
+      if (idsigCase_ == 107) {
+        result.idsig_ = idsig_;
+      }
       result.bitField0_ = to_bitField0_;
       result.idsigCase_ = idsigCase_;
       return result;
@@ -455,6 +600,18 @@ public final class IdSignature extends
           setScopedLocalSig(other.getScopedLocalSig());
           break;
         }
+        case IC_SIG: {
+          mergeIcSig(other.getIcSig());
+          break;
+        }
+        case FILE_SIG: {
+          mergeFileSig(other.getFileSig());
+          break;
+        }
+        case EXTERNAL_SCOPED_LOCAL_SIG: {
+          mergeExternalScopedLocalSig(other.getExternalScopedLocalSig());
+          break;
+        }
         case IDSIG_NOT_SET: {
           break;
         }
@@ -477,6 +634,18 @@ public final class IdSignature extends
           return false;
         }
       }
+      if (hasIcSig()) {
+        if (!getIcSig().isInitialized()) {
+          
+          return false;
+        }
+      }
+      if (hasExternalScopedLocalSig()) {
+        if (!getExternalScopedLocalSig().isInitialized()) {
+          
+          return false;
+        }
+      }
       return true;
     }
 
@@ -741,6 +910,198 @@ public final class IdSignature extends
       return this;
     }
 
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+     */
+    public boolean hasIcSig() {
+      return idsigCase_ == 105;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature getIcSig() {
+      if (idsigCase_ == 105) {
+        return (org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature) idsig_;
+      }
+      return org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature.getDefaultInstance();
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+     */
+    public Builder setIcSig(org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      idsig_ = value;
+
+      idsigCase_ = 105;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+     */
+    public Builder setIcSig(
+        org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature.Builder builderForValue) {
+      idsig_ = builderForValue.build();
+
+      idsigCase_ = 105;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+     */
+    public Builder mergeIcSig(org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature value) {
+      if (idsigCase_ == 105 &&
+          idsig_ != org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature.getDefaultInstance()) {
+        idsig_ = org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature.newBuilder((org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature) idsig_)
+            .mergeFrom(value).buildPartial();
+      } else {
+        idsig_ = value;
+      }
+
+      idsigCase_ = 105;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+     */
+    public Builder clearIcSig() {
+      if (idsigCase_ == 105) {
+        idsigCase_ = 0;
+        idsig_ = null;
+        
+      }
+      return this;
+    }
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+     */
+    public boolean hasFileSig() {
+      return idsigCase_ == 106;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature getFileSig() {
+      if (idsigCase_ == 106) {
+        return (org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature) idsig_;
+      }
+      return org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.getDefaultInstance();
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+     */
+    public Builder setFileSig(org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      idsig_ = value;
+
+      idsigCase_ = 106;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+     */
+    public Builder setFileSig(
+        org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.Builder builderForValue) {
+      idsig_ = builderForValue.build();
+
+      idsigCase_ = 106;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+     */
+    public Builder mergeFileSig(org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature value) {
+      if (idsigCase_ == 106 &&
+          idsig_ != org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.getDefaultInstance()) {
+        idsig_ = org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature.newBuilder((org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature) idsig_)
+            .mergeFrom(value).buildPartial();
+      } else {
+        idsig_ = value;
+      }
+
+      idsigCase_ = 106;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+     */
+    public Builder clearFileSig() {
+      if (idsigCase_ == 106) {
+        idsigCase_ = 0;
+        idsig_ = null;
+        
+      }
+      return this;
+    }
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+     */
+    public boolean hasExternalScopedLocalSig() {
+      return idsigCase_ == 107;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature getExternalScopedLocalSig() {
+      if (idsigCase_ == 107) {
+        return (org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature) idsig_;
+      }
+      return org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature.getDefaultInstance();
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+     */
+    public Builder setExternalScopedLocalSig(org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      idsig_ = value;
+
+      idsigCase_ = 107;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+     */
+    public Builder setExternalScopedLocalSig(
+        org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature.Builder builderForValue) {
+      idsig_ = builderForValue.build();
+
+      idsigCase_ = 107;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+     */
+    public Builder mergeExternalScopedLocalSig(org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature value) {
+      if (idsigCase_ == 107 &&
+          idsig_ != org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature.getDefaultInstance()) {
+        idsig_ = org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature.newBuilder((org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature) idsig_)
+            .mergeFrom(value).buildPartial();
+      } else {
+        idsig_ = value;
+      }
+
+      idsigCase_ = 107;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+     */
+    public Builder clearExternalScopedLocalSig() {
+      if (idsigCase_ == 107) {
+        idsigCase_ = 0;
+        idsig_ = null;
+        
+      }
+      return this;
+    }
+
     // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IdSignature)
   }
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IdSignatureOrBuilder.java

@@ -42,4 +42,31 @@ public interface IdSignatureOrBuilder extends
    * <code>optional int32 scoped_local_sig = 4;</code>
    */
   int getScopedLocalSig();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+   */
+  boolean hasIcSig();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature ic_sig = 105;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.LoweredIdSignature getIcSig();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+   */
+  boolean hasFileSig();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature file_sig = 106;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.FileSignature getFileSig();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+   */
+  boolean hasExternalScopedLocalSig();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature external_scoped_local_sig = 107;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.ScopeLocalIdSignature getExternalScopedLocalSig();
 }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrOperationOrBuilder.java

@@ -329,4 +329,31 @@ public interface IrOperationOrBuilder extends
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
    */
   org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression getErrorCallExpression();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrRawFunctionReference raw_function_reference = 36;</code>
+   */
+  boolean hasRawFunctionReference();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrRawFunctionReference raw_function_reference = 36;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrRawFunctionReference getRawFunctionReference();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlock returnable_block = 37;</code>
+   */
+  boolean hasReturnableBlock();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlock returnable_block = 37;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlock getReturnableBlock();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn returnable_block_return = 38;</code>
+   */
+  boolean hasReturnableBlockReturn();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn returnable_block_return = 38;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn getReturnableBlockReturn();
 }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrReturnableBlockReturn.java

@@ -0,0 +1,489 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: compiler/ir/serialization.common/src/KotlinIr.proto
+
+package org.jetbrains.kotlin.backend.common.serialization.proto;
+
+/**
+ * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn}
+ */
+public final class IrReturnableBlockReturn extends
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+    // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn)
+    IrReturnableBlockReturnOrBuilder {
+  public static final int UPCNT_FIELD_NUMBER = 1;
+  public static final int VALUE_FIELD_NUMBER = 2;
+  private static final IrReturnableBlockReturn defaultInstance;
+  private static final long serialVersionUID = 0L;
+  public static org.jetbrains.kotlin.protobuf.Parser<IrReturnableBlockReturn> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<IrReturnableBlockReturn>() {
+    public IrReturnableBlockReturn parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new IrReturnableBlockReturn(input, extensionRegistry);
+    }
+  };
+
+  static {
+    defaultInstance = new IrReturnableBlockReturn(true);
+    defaultInstance.initFields();
+  }
+
+  private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  private int bitField0_;
+  private int upCnt_;
+  private org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_;
+  private byte memoizedIsInitialized = -1;
+  private int memoizedSerializedSize = -1;
+  // Use IrReturnableBlockReturn.newBuilder() to construct.
+  private IrReturnableBlockReturn(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+    super(builder);
+    this.unknownFields = builder.getUnknownFields();
+  }
+  private IrReturnableBlockReturn(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+  private IrReturnableBlockReturn(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    initFields();
+    int mutable_bitField0_ = 0;
+    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
+        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
+    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
+            unknownFieldsOutput, 1);
+    try {
+      boolean done = false;
+      while (!done) {
+        int tag = input.readTag();
+        switch (tag) {
+          case 0:
+            done = true;
+            break;
+          default: {
+            if (!parseUnknownField(input, unknownFieldsCodedOutput,
+                                   extensionRegistry, tag)) {
+              done = true;
+            }
+            break;
+          }
+          case 8: {
+            bitField0_ |= 0x00000001;
+            upCnt_ = input.readUInt32();
+            break;
+          }
+          case 18: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.Builder subBuilder = null;
+            if (((bitField0_ & 0x00000002) == 0x00000002)) {
+              subBuilder = value_.toBuilder();
+            }
+            value_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom(value_);
+              value_ = subBuilder.buildPartial();
+            }
+            bitField0_ |= 0x00000002;
+            break;
+          }
+        }
+      }
+    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+      throw e.setUnfinishedMessage(this);
+    } catch (java.io.IOException e) {
+      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
+          e.getMessage()).setUnfinishedMessage(this);
+    } finally {
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+
+  public static IrReturnableBlockReturn getDefaultInstance() {
+    return defaultInstance;
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(
+      org.jetbrains.kotlin.protobuf.ByteString data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(
+      org.jetbrains.kotlin.protobuf.ByteString data,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(byte[] data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(
+      byte[] data,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(
+      java.io.InputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseDelimitedFrom(
+      java.io.InputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input, extensionRegistry);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input, extensionRegistry);
+  }
+
+  public static Builder newBuilder() { return Builder.create(); }
+
+  public static Builder newBuilder(org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn prototype) {
+    return newBuilder().mergeFrom(prototype);
+  }
+
+  @java.lang.Override
+  public org.jetbrains.kotlin.protobuf.Parser<IrReturnableBlockReturn> getParserForType() {
+    return PARSER;
+  }
+
+  /**
+   * <code>required uint32 upCnt = 1;</code>
+   */
+  public boolean hasUpCnt() {
+    return ((bitField0_ & 0x00000001) == 0x00000001);
+  }
+
+  /**
+   * <code>required uint32 upCnt = 1;</code>
+   */
+  public int getUpCnt() {
+    return upCnt_;
+  }
+
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+   */
+  public boolean hasValue() {
+    return ((bitField0_ & 0x00000002) == 0x00000002);
+  }
+
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getValue() {
+    return value_;
+  }
+
+  private void initFields() {
+    upCnt_ = 0;
+    value_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+  }
+
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    if (!hasUpCnt()) {
+      memoizedIsInitialized = 0;
+      return false;
+    }
+    if (!hasValue()) {
+      memoizedIsInitialized = 0;
+      return false;
+    }
+    if (!getValue().isInitialized()) {
+      memoizedIsInitialized = 0;
+      return false;
+    }
+    memoizedIsInitialized = 1;
+    return true;
+  }
+
+  public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output)
+                      throws java.io.IOException {
+    getSerializedSize();
+    if (((bitField0_ & 0x00000001) == 0x00000001)) {
+      output.writeUInt32(1, upCnt_);
+    }
+    if (((bitField0_ & 0x00000002) == 0x00000002)) {
+      output.writeMessage(2, value_);
+    }
+    output.writeRawBytes(unknownFields);
+  }
+
+  public int getSerializedSize() {
+    int size = memoizedSerializedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    if (((bitField0_ & 0x00000001) == 0x00000001)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeUInt32Size(1, upCnt_);
+    }
+    if (((bitField0_ & 0x00000002) == 0x00000002)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(2, value_);
+    }
+    size += unknownFields.size();
+    memoizedSerializedSize = size;
+    return size;
+  }
+
+  @java.lang.Override
+  protected java.lang.Object writeReplace()
+      throws java.io.ObjectStreamException {
+    return super.writeReplace();
+  }
+
+  public Builder newBuilderForType() { return newBuilder(); }
+
+  public Builder toBuilder() { return newBuilder(this); }
+
+  public IrReturnableBlockReturn getDefaultInstanceForType() {
+    return defaultInstance;
+  }
+
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn}
+   */
+  public static final class Builder extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn, Builder>
+      implements
+      // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn)
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturnOrBuilder {
+    private int bitField0_;
+    private int upCnt_ ;
+    private org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+
+    // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private static Builder create() {
+      return new Builder();
+    }
+
+    public Builder clear() {
+      super.clear();
+      upCnt_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000001);
+      value_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+      bitField0_ = (bitField0_ & ~0x00000002);
+      return this;
+    }
+
+    public Builder clone() {
+      return create().mergeFrom(buildPartial());
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn getDefaultInstanceForType() {
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn.getDefaultInstance();
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn build() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn(this);
+      int from_bitField0_ = bitField0_;
+      int to_bitField0_ = 0;
+      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+        to_bitField0_ |= 0x00000001;
+      }
+      result.upCnt_ = upCnt_;
+      if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+        to_bitField0_ |= 0x00000002;
+      }
+      result.value_ = value_;
+      result.bitField0_ = to_bitField0_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn.getDefaultInstance()) return this;
+      if (other.hasUpCnt()) {
+        setUpCnt(other.getUpCnt());
+      }
+      if (other.hasValue()) {
+        mergeValue(other.getValue());
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
+    public Builder mergeFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn) e.getUnfinishedMessage();
+        throw e;
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+
+    private void maybeForceBuilderInitialization() {
+    }
+    /**
+     * <code>required uint32 upCnt = 1;</code>
+     */
+    public boolean hasUpCnt() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required uint32 upCnt = 1;</code>
+     */
+    public int getUpCnt() {
+      return upCnt_;
+    }
+
+    /**
+     * <code>required uint32 upCnt = 1;</code>
+     */
+    public Builder setUpCnt(int value) {
+      bitField0_ |= 0x00000001;
+      upCnt_ = value;
+
+      return this;
+    }
+
+    public final boolean isInitialized() {
+      if (!hasUpCnt()) {
+
+        return false;
+      }
+      if (!hasValue()) {
+
+        return false;
+      }
+      if (!getValue().isInitialized()) {
+
+        return false;
+      }
+      return true;
+    }
+
+    /**
+     * <code>required uint32 upCnt = 1;</code>
+     */
+    public Builder clearUpCnt() {
+      bitField0_ = (bitField0_ & ~0x00000001);
+      upCnt_ = 0;
+
+      return this;
+    }
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+     */
+    public boolean hasValue() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getValue() {
+      return value_;
+    }
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+     */
+    public Builder setValue(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      value_ = value;
+
+      bitField0_ |= 0x00000002;
+      return this;
+    }
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+     */
+    public Builder setValue(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.Builder builderForValue) {
+      value_ = builderForValue.build();
+
+      bitField0_ |= 0x00000002;
+      return this;
+    }
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+     */
+    public Builder mergeValue(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value) {
+      if (((bitField0_ & 0x00000002) == 0x00000002) &&
+          value_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance()) {
+        value_ =
+          org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.newBuilder(value_).mergeFrom(value).buildPartial();
+      } else {
+        value_ = value;
+      }
+
+      bitField0_ |= 0x00000002;
+      return this;
+    }
+    /**
+     * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+     */
+    public Builder clearValue() {
+      value_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+
+      bitField0_ = (bitField0_ & ~0x00000002);
+      return this;
+    }
+
+    // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn)
+  }
+
+  // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn)
+}

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrReturnableBlockReturnOrBuilder.java

@@ -0,0 +1,27 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: compiler/ir/serialization.common/src/KotlinIr.proto
+
+package org.jetbrains.kotlin.backend.common.serialization.proto;
+
+public interface IrReturnableBlockReturnOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn)
+    org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+  /**
+   * <code>required uint32 upCnt = 1;</code>
+   */
+  boolean hasUpCnt();
+  /**
+   * <code>required uint32 upCnt = 1;</code>
+   */
+  int getUpCnt();
+
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+   */
+  boolean hasValue();
+  /**
+   * <code>required .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value = 2;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getValue();
+}

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrTypeParameter.java

@@ -27,92 +27,7 @@ public final class IrTypeParameter extends
   }
 
   private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
-  private IrTypeParameter(
+  public static final int INDEX_FIELD_NUMBER = 4;
-      org.jetbrains.kotlin.protobuf.CodedInputStream input,
-      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
-    initFields();
-    int mutable_bitField0_ = 0;
-    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
-        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
-    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
-        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
-            unknownFieldsOutput, 1);
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFieldsCodedOutput,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.Builder subBuilder = null;
-            if (((bitField0_ & 0x00000001) == 0x00000001)) {
-              subBuilder = base_.toBuilder();
-            }
-            base_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.PARSER, extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom(base_);
-              base_ = subBuilder.buildPartial();
-            }
-            bitField0_ |= 0x00000001;
-            break;
-          }
-          case 16: {
-            bitField0_ |= 0x00000002;
-            name_ = input.readInt32();
-            break;
-          }
-          case 24: {
-            if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
-              superType_ = new java.util.ArrayList<java.lang.Integer>();
-              mutable_bitField0_ |= 0x00000004;
-            }
-            superType_.add(input.readInt32());
-            break;
-          }
-          case 26: {
-            int length = input.readRawVarint32();
-            int limit = input.pushLimit(length);
-            if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
-              superType_ = new java.util.ArrayList<java.lang.Integer>();
-              mutable_bitField0_ |= 0x00000004;
-            }
-            while (input.getBytesUntilLimit() > 0) {
-              superType_.add(input.readInt32());
-            }
-            input.popLimit(limit);
-            break;
-          }
-        }
-      }
-    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
-          e.getMessage()).setUnfinishedMessage(this);
-    } finally {
-      if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
-        superType_ = java.util.Collections.unmodifiableList(superType_);
-      }
-      try {
-        unknownFieldsCodedOutput.flush();
-      } catch (java.io.IOException e) {
-      // Should not happen
-      } finally {
-        unknownFields = unknownFieldsOutput.toByteString();
-      }
-      makeExtensionsImmutable();
-    }
-  }
   public static org.jetbrains.kotlin.protobuf.Parser<IrTypeParameter> PARSER =
       new org.jetbrains.kotlin.protobuf.AbstractParser<IrTypeParameter>() {
     public IrTypeParameter parsePartialFrom(
@@ -181,11 +96,139 @@ public final class IrTypeParameter extends
     return superType_.get(index);
   }
   private int superTypeMemoizedSerializedSize = -1;
+  public static final int ISGLOBAL_FIELD_NUMBER = 5;
+  private int index_;
+  private boolean isGlobal_;
+  private IrTypeParameter(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    initFields();
+    int mutable_bitField0_ = 0;
+    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
+        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
+    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
+            unknownFieldsOutput, 1);
+    try {
+      boolean done = false;
+      while (!done) {
+        int tag = input.readTag();
+        switch (tag) {
+          case 0:
+            done = true;
+            break;
+          default: {
+            if (!parseUnknownField(input, unknownFieldsCodedOutput,
+                                   extensionRegistry, tag)) {
+              done = true;
+            }
+            break;
+          }
+          case 10: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.Builder subBuilder = null;
+            if (((bitField0_ & 0x00000001) == 0x00000001)) {
+              subBuilder = base_.toBuilder();
+            }
+            base_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom(base_);
+              base_ = subBuilder.buildPartial();
+            }
+            bitField0_ |= 0x00000001;
+            break;
+          }
+          case 16: {
+            bitField0_ |= 0x00000002;
+            name_ = input.readInt32();
+            break;
+          }
+          case 24: {
+            if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+              superType_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000004;
+            }
+            superType_.add(input.readInt32());
+            break;
+          }
+          case 26: {
+            int length = input.readRawVarint32();
+            int limit = input.pushLimit(length);
+            if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
+              superType_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000004;
+            }
+            while (input.getBytesUntilLimit() > 0) {
+              superType_.add(input.readInt32());
+            }
+            input.popLimit(limit);
+            break;
+          }
+          case 32: {
+            bitField0_ |= 0x00000004;
+            index_ = input.readInt32();
+            break;
+          }
+          case 40: {
+            bitField0_ |= 0x00000008;
+            isGlobal_ = input.readBool();
+            break;
+          }
+        }
+      }
+    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+      throw e.setUnfinishedMessage(this);
+    } catch (java.io.IOException e) {
+      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
+          e.getMessage()).setUnfinishedMessage(this);
+    } finally {
+      if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+        superType_ = java.util.Collections.unmodifiableList(superType_);
+      }
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+
+  /**
+   * <code>optional int32 index = 4;</code>
+   */
+  public boolean hasIndex() {
+    return ((bitField0_ & 0x00000004) == 0x00000004);
+  }
+
+  /**
+   * <code>optional int32 index = 4;</code>
+   */
+  public int getIndex() {
+    return index_;
+  }
+
+  /**
+   * <code>optional bool isGlobal = 5;</code>
+   */
+  public boolean hasIsGlobal() {
+    return ((bitField0_ & 0x00000008) == 0x00000008);
+  }
+  /**
+   * <code>optional bool isGlobal = 5;</code>
+   */
+  public boolean getIsGlobal() {
+    return isGlobal_;
+  }
 
   private void initFields() {
     base_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.getDefaultInstance();
     name_ = 0;
     superType_ = java.util.Collections.emptyList();
+    index_ = 0;
+    isGlobal_ = false;
   }
   private byte memoizedIsInitialized = -1;
   public final boolean isInitialized() {
@@ -225,6 +268,12 @@ public final class IrTypeParameter extends
     for (int i = 0; i < superType_.size(); i++) {
       output.writeInt32NoTag(superType_.get(i));
     }
+    if (((bitField0_ & 0x00000004) == 0x00000004)) {
+      output.writeInt32(4, index_);
+    }
+    if (((bitField0_ & 0x00000008) == 0x00000008)) {
+      output.writeBool(5, isGlobal_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -256,6 +305,14 @@ public final class IrTypeParameter extends
       }
       superTypeMemoizedSerializedSize = dataSize;
     }
+    if (((bitField0_ & 0x00000004) == 0x00000004)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeInt32Size(4, index_);
+    }
+    if (((bitField0_ & 0x00000008) == 0x00000008)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeBoolSize(5, isGlobal_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -348,16 +405,7 @@ public final class IrTypeParameter extends
       return new Builder();
     }
 
-    public Builder clear() {
+    private int index_ ;
-      super.clear();
-      base_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.getDefaultInstance();
-      bitField0_ = (bitField0_ & ~0x00000001);
-      name_ = 0;
-      bitField0_ = (bitField0_ & ~0x00000002);
-      superType_ = java.util.Collections.emptyList();
-      bitField0_ = (bitField0_ & ~0x00000004);
-      return this;
-    }
 
     public Builder clone() {
       return create().mergeFrom(buildPartial());
@@ -374,48 +422,20 @@ public final class IrTypeParameter extends
       }
       return result;
     }
+    private boolean isGlobal_ ;
 
-    public org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter buildPartial() {
+    public Builder clear() {
-      org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter(this);
+      super.clear();
-      int from_bitField0_ = bitField0_;
+      base_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.getDefaultInstance();
-      int to_bitField0_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000001);
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+      name_ = 0;
-        to_bitField0_ |= 0x00000001;
+      bitField0_ = (bitField0_ & ~0x00000002);
-      }
+      superType_ = java.util.Collections.emptyList();
-      result.base_ = base_;
+      bitField0_ = (bitField0_ & ~0x00000004);
-      if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+      index_ = 0;
-        to_bitField0_ |= 0x00000002;
+      bitField0_ = (bitField0_ & ~0x00000008);
-      }
+      isGlobal_ = false;
-      result.name_ = name_;
+      bitField0_ = (bitField0_ & ~0x00000010);
-      if (((bitField0_ & 0x00000004) == 0x00000004)) {
-        superType_ = java.util.Collections.unmodifiableList(superType_);
-        bitField0_ = (bitField0_ & ~0x00000004);
-      }
-      result.superType_ = superType_;
-      result.bitField0_ = to_bitField0_;
-      return result;
-    }
-
-    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter other) {
-      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter.getDefaultInstance()) return this;
-      if (other.hasBase()) {
-        mergeBase(other.getBase());
-      }
-      if (other.hasName()) {
-        setName(other.getName());
-      }
-      if (!other.superType_.isEmpty()) {
-        if (superType_.isEmpty()) {
-          superType_ = other.superType_;
-          bitField0_ = (bitField0_ & ~0x00000004);
-        } else {
-          ensureSuperTypeIsMutable();
-          superType_.addAll(other.superType_);
-        }
-        
-      }
-      setUnknownFields(
-          getUnknownFields().concat(other.unknownFields));
       return this;
     }
 
@@ -602,12 +622,136 @@ public final class IrTypeParameter extends
       
       return this;
     }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter(this);
+      int from_bitField0_ = bitField0_;
+      int to_bitField0_ = 0;
+      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+        to_bitField0_ |= 0x00000001;
+      }
+      result.base_ = base_;
+      if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+        to_bitField0_ |= 0x00000002;
+      }
+      result.name_ = name_;
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        superType_ = java.util.Collections.unmodifiableList(superType_);
+        bitField0_ = (bitField0_ & ~0x00000004);
+      }
+      result.superType_ = superType_;
+      if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+        to_bitField0_ |= 0x00000004;
+      }
+      result.index_ = index_;
+      if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+        to_bitField0_ |= 0x00000008;
+      }
+      result.isGlobal_ = isGlobal_;
+      result.bitField0_ = to_bitField0_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter.getDefaultInstance()) return this;
+      if (other.hasBase()) {
+        mergeBase(other.getBase());
+      }
+      if (other.hasName()) {
+        setName(other.getName());
+      }
+      if (!other.superType_.isEmpty()) {
+        if (superType_.isEmpty()) {
+          superType_ = other.superType_;
+          bitField0_ = (bitField0_ & ~0x00000004);
+        } else {
+          ensureSuperTypeIsMutable();
+          superType_.addAll(other.superType_);
+        }
+
+      }
+      if (other.hasIndex()) {
+        setIndex(other.getIndex());
+      }
+      if (other.hasIsGlobal()) {
+        setIsGlobal(other.getIsGlobal());
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
     /**
      * <code>repeated int32 super_type = 3 [packed = true];</code>
      */
     public Builder clearSuperType() {
       superType_ = java.util.Collections.emptyList();
       bitField0_ = (bitField0_ & ~0x00000004);
+
+      return this;
+    }
+
+    /**
+     * <code>optional int32 index = 4;</code>
+     */
+    public boolean hasIndex() {
+      return ((bitField0_ & 0x00000008) == 0x00000008);
+    }
+
+    /**
+     * <code>optional int32 index = 4;</code>
+     */
+    public int getIndex() {
+      return index_;
+    }
+
+    /**
+     * <code>optional int32 index = 4;</code>
+     */
+    public Builder setIndex(int value) {
+      bitField0_ |= 0x00000008;
+      index_ = value;
+
+      return this;
+    }
+
+    /**
+     * <code>optional int32 index = 4;</code>
+     */
+    public Builder clearIndex() {
+      bitField0_ = (bitField0_ & ~0x00000008);
+      index_ = 0;
+
+      return this;
+    }
+
+    /**
+     * <code>optional bool isGlobal = 5;</code>
+     */
+    public boolean hasIsGlobal() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional bool isGlobal = 5;</code>
+     */
+    public boolean getIsGlobal() {
+      return isGlobal_;
+    }
+    /**
+     * <code>optional bool isGlobal = 5;</code>
+     */
+    public Builder setIsGlobal(boolean value) {
+      bitField0_ |= 0x00000010;
+      isGlobal_ = value;
+      
+      return this;
+    }
+    /**
+     * <code>optional bool isGlobal = 5;</code>
+     */
+    public Builder clearIsGlobal() {
+      bitField0_ = (bitField0_ & ~0x00000010);
+      isGlobal_ = false;
       
       return this;
     }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrTypeParameterOrBuilder.java

@@ -37,4 +37,22 @@ public interface IrTypeParameterOrBuilder extends
    * <code>repeated int32 super_type = 3 [packed = true];</code>
    */
   int getSuperType(int index);
+
+  /**
+   * <code>optional int32 index = 4;</code>
+   */
+  boolean hasIndex();
+  /**
+   * <code>optional int32 index = 4;</code>
+   */
+  int getIndex();
+
+  /**
+   * <code>optional bool isGlobal = 5;</code>
+   */
+  boolean hasIsGlobal();
+  /**
+   * <code>optional bool isGlobal = 5;</code>
+   */
+  boolean getIsGlobal();
 }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrValueParameter.java

@@ -27,78 +27,7 @@ public final class IrValueParameter extends
   }
 
   private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
-  private IrValueParameter(
+  public static final int INDEX_FIELD_NUMBER = 5;
-      org.jetbrains.kotlin.protobuf.CodedInputStream input,
-      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
-    initFields();
-    int mutable_bitField0_ = 0;
-    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
-        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
-    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
-        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
-            unknownFieldsOutput, 1);
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFieldsCodedOutput,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.Builder subBuilder = null;
-            if (((bitField0_ & 0x00000001) == 0x00000001)) {
-              subBuilder = base_.toBuilder();
-            }
-            base_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.PARSER, extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom(base_);
-              base_ = subBuilder.buildPartial();
-            }
-            bitField0_ |= 0x00000001;
-            break;
-          }
-          case 16: {
-            bitField0_ |= 0x00000002;
-            nameType_ = input.readInt64();
-            break;
-          }
-          case 24: {
-            bitField0_ |= 0x00000004;
-            varargElementType_ = input.readInt32();
-            break;
-          }
-          case 32: {
-            bitField0_ |= 0x00000008;
-            defaultValue_ = input.readInt32();
-            break;
-          }
-        }
-      }
-    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
-          e.getMessage()).setUnfinishedMessage(this);
-    } finally {
-      try {
-        unknownFieldsCodedOutput.flush();
-      } catch (java.io.IOException e) {
-      // Should not happen
-      } finally {
-        unknownFields = unknownFieldsOutput.toByteString();
-      }
-      makeExtensionsImmutable();
-    }
-  }
   public static org.jetbrains.kotlin.protobuf.Parser<IrValueParameter> PARSER =
       new org.jetbrains.kotlin.protobuf.AbstractParser<IrValueParameter>() {
     public IrValueParameter parsePartialFrom(
@@ -174,12 +103,104 @@ public final class IrValueParameter extends
   public int getDefaultValue() {
     return defaultValue_;
   }
+  private int index_;
+  private IrValueParameter(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input,
+      org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    initFields();
+    int mutable_bitField0_ = 0;
+    org.jetbrains.kotlin.protobuf.ByteString.Output unknownFieldsOutput =
+        org.jetbrains.kotlin.protobuf.ByteString.newOutput();
+    org.jetbrains.kotlin.protobuf.CodedOutputStream unknownFieldsCodedOutput =
+        org.jetbrains.kotlin.protobuf.CodedOutputStream.newInstance(
+            unknownFieldsOutput, 1);
+    try {
+      boolean done = false;
+      while (!done) {
+        int tag = input.readTag();
+        switch (tag) {
+          case 0:
+            done = true;
+            break;
+          default: {
+            if (!parseUnknownField(input, unknownFieldsCodedOutput,
+                                   extensionRegistry, tag)) {
+              done = true;
+            }
+            break;
+          }
+          case 10: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.Builder subBuilder = null;
+            if (((bitField0_ & 0x00000001) == 0x00000001)) {
+              subBuilder = base_.toBuilder();
+            }
+            base_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom(base_);
+              base_ = subBuilder.buildPartial();
+            }
+            bitField0_ |= 0x00000001;
+            break;
+          }
+          case 16: {
+            bitField0_ |= 0x00000002;
+            nameType_ = input.readInt64();
+            break;
+          }
+          case 24: {
+            bitField0_ |= 0x00000004;
+            varargElementType_ = input.readInt32();
+            break;
+          }
+          case 32: {
+            bitField0_ |= 0x00000008;
+            defaultValue_ = input.readInt32();
+            break;
+          }
+          case 40: {
+            bitField0_ |= 0x00000010;
+            index_ = input.readInt32();
+            break;
+          }
+        }
+      }
+    } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+      throw e.setUnfinishedMessage(this);
+    } catch (java.io.IOException e) {
+      throw new org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException(
+          e.getMessage()).setUnfinishedMessage(this);
+    } finally {
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+
+  /**
+   * <code>optional int32 index = 5;</code>
+   */
+  public boolean hasIndex() {
+    return ((bitField0_ & 0x00000010) == 0x00000010);
+  }
+  /**
+   * <code>optional int32 index = 5;</code>
+   */
+  public int getIndex() {
+    return index_;
+  }
 
   private void initFields() {
     base_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.getDefaultInstance();
     nameType_ = 0L;
     varargElementType_ = 0;
     defaultValue_ = 0;
+    index_ = 0;
   }
   private byte memoizedIsInitialized = -1;
   public final boolean isInitialized() {
@@ -218,6 +239,9 @@ public final class IrValueParameter extends
     if (((bitField0_ & 0x00000008) == 0x00000008)) {
       output.writeInt32(4, defaultValue_);
     }
+    if (((bitField0_ & 0x00000010) == 0x00000010)) {
+      output.writeInt32(5, index_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -243,6 +267,10 @@ public final class IrValueParameter extends
       size += org.jetbrains.kotlin.protobuf.CodedOutputStream
         .computeInt32Size(4, defaultValue_);
     }
+    if (((bitField0_ & 0x00000010) == 0x00000010)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeInt32Size(5, index_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -335,18 +363,7 @@ public final class IrValueParameter extends
       return new Builder();
     }
 
-    public Builder clear() {
+    private int index_ ;
-      super.clear();
-      base_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.getDefaultInstance();
-      bitField0_ = (bitField0_ & ~0x00000001);
-      nameType_ = 0L;
-      bitField0_ = (bitField0_ & ~0x00000002);
-      varargElementType_ = 0;
-      bitField0_ = (bitField0_ & ~0x00000004);
-      defaultValue_ = 0;
-      bitField0_ = (bitField0_ & ~0x00000008);
-      return this;
-    }
 
     public Builder clone() {
       return create().mergeFrom(buildPartial());
@@ -364,6 +381,21 @@ public final class IrValueParameter extends
       return result;
     }
 
+    public Builder clear() {
+      super.clear();
+      base_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase.getDefaultInstance();
+      bitField0_ = (bitField0_ & ~0x00000001);
+      nameType_ = 0L;
+      bitField0_ = (bitField0_ & ~0x00000002);
+      varargElementType_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000004);
+      defaultValue_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000008);
+      index_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000010);
+      return this;
+    }
+
     public org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter buildPartial() {
       org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter(this);
       int from_bitField0_ = bitField0_;
@@ -384,29 +416,14 @@ public final class IrValueParameter extends
         to_bitField0_ |= 0x00000008;
       }
       result.defaultValue_ = defaultValue_;
+      if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+        to_bitField0_ |= 0x00000010;
+      }
+      result.index_ = index_;
       result.bitField0_ = to_bitField0_;
       return result;
     }
 
-    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter other) {
-      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter.getDefaultInstance()) return this;
-      if (other.hasBase()) {
-        mergeBase(other.getBase());
-      }
-      if (other.hasNameType()) {
-        setNameType(other.getNameType());
-      }
-      if (other.hasVarargElementType()) {
-        setVarargElementType(other.getVarargElementType());
-      }
-      if (other.hasDefaultValue()) {
-        setDefaultValue(other.getDefaultValue());
-      }
-      setUnknownFields(
-          getUnknownFields().concat(other.unknownFields));
-      return this;
-    }
-
     public final boolean isInitialized() {
       if (!hasBase()) {
         
@@ -588,12 +605,66 @@ public final class IrValueParameter extends
       
       return this;
     }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter.getDefaultInstance()) return this;
+      if (other.hasBase()) {
+        mergeBase(other.getBase());
+      }
+      if (other.hasNameType()) {
+        setNameType(other.getNameType());
+      }
+      if (other.hasVarargElementType()) {
+        setVarargElementType(other.getVarargElementType());
+      }
+      if (other.hasDefaultValue()) {
+        setDefaultValue(other.getDefaultValue());
+      }
+      if (other.hasIndex()) {
+        setIndex(other.getIndex());
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
     /**
      * <code>optional int32 default_value = 4;</code>
      */
     public Builder clearDefaultValue() {
       bitField0_ = (bitField0_ & ~0x00000008);
       defaultValue_ = 0;
+
+      return this;
+    }
+
+    /**
+     * <code>optional int32 index = 5;</code>
+     */
+    public boolean hasIndex() {
+      return ((bitField0_ & 0x00000010) == 0x00000010);
+    }
+    /**
+     * <code>optional int32 index = 5;</code>
+     */
+    public int getIndex() {
+      return index_;
+    }
+    /**
+     * <code>optional int32 index = 5;</code>
+     */
+    public Builder setIndex(int value) {
+      bitField0_ |= 0x00000010;
+      index_ = value;
+      
+      return this;
+    }
+    /**
+     * <code>optional int32 index = 5;</code>
+     */
+    public Builder clearIndex() {
+      bitField0_ = (bitField0_ & ~0x00000010);
+      index_ = 0;
       
       return this;
     }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/proto/IrValueParameterOrBuilder.java

@@ -42,4 +42,13 @@ public interface IrValueParameterOrBuilder extends
    * <code>optional int32 default_value = 4;</code>
    */
   int getDefaultValue();
+
+  /**
+   * <code>optional int32 index = 5;</code>
+   */
+  boolean hasIndex();
+  /**
+   * <code>optional int32 index = 5;</code>
+   */
+  int getIndex();
 }