[KLIB] Support IrError* nodes in klib proto

- add proto messages
 - regenerate java-proto
 - support in reader to make code compiled

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

@@ -303,6 +303,16 @@ message IrFunctionExpression {
   required int32 origin_name = 2;
 }
 
+message IrErrorExpression {
+  required int32 description = 1;
+}
+
+message IrErrorCallExpression {
+  required int32 description = 1;
+  optional IrExpression receiver = 2;
+  repeated IrExpression value_argument = 3;
+}
+
 /* ------ Dynamic expression --------------------------------------------- */
 
 message IrDynamicMemberExpression {
@@ -388,6 +398,9 @@ message IrOperation {
     IrLocalDelegatedPropertyReference local_delegated_property_reference = 31;
     IrConstructorCall constructor_call = 32;
     IrFunctionExpression function_expression = 33;
+    // Error code
+    IrErrorExpression error_expression = 34;
+    IrErrorCallExpression error_call_expression = 35;
   }
 }
 
@@ -501,6 +514,10 @@ message IrTypeAlias {
   repeated IrTypeParameter type_parameter = 3;
 }
 
+message IrErrorDeclaration {
+  required int64 coordinates = 1;
+}
+
 message IrEnumEntry {
   required IrDeclarationBase base = 1;
   required int32 name = 2;
@@ -530,6 +547,7 @@ message IrDeclaration {
     IrValueParameter ir_value_parameter = 10;
     IrLocalDelegatedProperty ir_local_delegated_property = 11;
     IrTypeAlias ir_type_alias = 12;
+    IrErrorDeclaration ir_error_declaration = 13;
   }
 }
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrFileDeserializer.kt

@@ -66,6 +66,9 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrField as ProtoF
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunction as ProtoFunction
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionBase as ProtoFunctionBase
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionExpression as ProtoFunctionExpression
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression as ProtoErrorExpression
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression as ProtoErrorCallExpression
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration as ProtoErrorDeclaration
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionReference as ProtoFunctionReference
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetClass as ProtoGetClass
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetEnumValue as ProtoGetEnumValue
@@ -461,6 +464,28 @@ abstract class IrFileDeserializer(
             deserializeIrStatementOrigin(functionExpression.originName)
         )
 
+    private fun deserializeErrorExpression(
+        proto: ProtoErrorExpression,
+        start: Int, end: Int, type: IrType
+    ): IrErrorExpression {
+        return IrErrorExpressionImpl(start, end, type, deserializeString(proto.description))
+    }
+
+    private fun deserializeErrorCallExpression(
+        proto: ProtoErrorCallExpression,
+        start: Int, end: Int, type: IrType
+    ): IrErrorCallExpression {
+        return IrErrorCallExpressionImpl(start, end, type, deserializeString(proto.description)).apply {
+            if (proto.hasReceiver()) {
+                explicitReceiver = deserializeExpression(proto.receiver)
+            }
+            proto.valueArgumentList.forEach {
+                addArgument(deserializeExpression(it))
+            }
+        }
+
+    }
+
     private fun deserializeFunctionReference(
         proto: ProtoFunctionReference,
         start: Int, end: Int, type: IrType
@@ -891,6 +916,8 @@ abstract class IrFileDeserializer(
             DYNAMIC_OPERATOR -> deserializeDynamicOperatorExpression(proto.dynamicOperator, start, end, type)
             CONSTRUCTOR_CALL -> deserializeConstructorCall(proto.constructorCall, start, end, type)
             FUNCTION_EXPRESSION -> deserializeFunctionExpression(proto.functionExpression, start, end, type)
+            ERROR_EXPRESSION -> deserializeErrorExpression(proto.errorExpression, start, end, type)
+            ERROR_CALL_EXPRESSION -> deserializeErrorCallExpression(proto.errorCallExpression, start, end, type)
             OPERATION_NOT_SET -> error("Expression deserialization not implemented: ${proto.operationCase}")
         }
 
@@ -1082,6 +1109,15 @@ abstract class IrFileDeserializer(
             }
         }
 
+    private fun deserializeErrorDeclaration(proto: ProtoErrorDeclaration): IrErrorDeclaration {
+        val coordinates = BinaryCoordinates.decode(proto.coordinates)
+        val descriptor = WrappedErrorDescriptor()
+        return irFactory.createErrorDeclaration(coordinates.startOffset, coordinates.endOffset, descriptor).also {
+            descriptor.bind(it)
+            it.parent = parentsStack.peek()!!
+        }
+    }
+
     private fun deserializeTypeParameters(protos: List<ProtoTypeParameter>, isGlobal: Boolean): List<IrTypeParameter> {
         // NOTE: fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(destination: C): C
         val result = ArrayList<IrTypeParameter>(protos.size)
@@ -1412,6 +1448,7 @@ abstract class IrFileDeserializer(
             IR_ENUM_ENTRY -> deserializeIrEnumEntry(proto.irEnumEntry)
             IR_LOCAL_DELEGATED_PROPERTY -> deserializeIrLocalDelegatedProperty(proto.irLocalDelegatedProperty)
             IR_TYPE_ALIAS -> deserializeIrTypeAlias(proto.irTypeAlias)
+            IR_ERROR_DECLARATION -> deserializeErrorDeclaration(proto.irErrorDeclaration)
             DECLARATOR_NOT_SET -> error("Declaration deserialization not implemented: ${proto.declaratorCase}")
         }
 

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

@@ -209,6 +209,19 @@ public final class IrDeclaration extends
             declaratorCase_ = 12;
             break;
           }
+          case 106: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.Builder subBuilder = null;
+            if (declaratorCase_ == 13) {
+              subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) declarator_).toBuilder();
+            }
+            declarator_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) declarator_);
+              declarator_ = subBuilder.buildPartial();
+            }
+            declaratorCase_ = 13;
+            break;
+          }
         }
       }
     } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -259,6 +272,7 @@ public final class IrDeclaration extends
     IR_VALUE_PARAMETER(10),
     IR_LOCAL_DELEGATED_PROPERTY(11),
     IR_TYPE_ALIAS(12),
+    IR_ERROR_DECLARATION(13),
     DECLARATOR_NOT_SET(0);
     private int value = 0;
     private DeclaratorCase(int value) {
@@ -278,6 +292,7 @@ public final class IrDeclaration extends
         case 10: return IR_VALUE_PARAMETER;
         case 11: return IR_LOCAL_DELEGATED_PROPERTY;
         case 12: return IR_TYPE_ALIAS;
+        case 13: return IR_ERROR_DECLARATION;
         case 0: return DECLARATOR_NOT_SET;
         default: throw new java.lang.IllegalArgumentException(
           "Value is undefined for this oneof enum.");
@@ -498,6 +513,23 @@ public final class IrDeclaration extends
     return org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeAlias.getDefaultInstance();
   }
 
+  public static final int IR_ERROR_DECLARATION_FIELD_NUMBER = 13;
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+   */
+  public boolean hasIrErrorDeclaration() {
+    return declaratorCase_ == 13;
+  }
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration getIrErrorDeclaration() {
+    if (declaratorCase_ == 13) {
+       return (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) declarator_;
+    }
+    return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.getDefaultInstance();
+  }
+
   private void initFields() {
   }
   private byte memoizedIsInitialized = -1;
@@ -578,6 +610,12 @@ public final class IrDeclaration extends
         return false;
       }
     }
+    if (hasIrErrorDeclaration()) {
+      if (!getIrErrorDeclaration().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
     memoizedIsInitialized = 1;
     return true;
   }
@@ -621,6 +659,9 @@ public final class IrDeclaration extends
     if (declaratorCase_ == 12) {
       output.writeMessage(12, (org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeAlias) declarator_);
     }
+    if (declaratorCase_ == 13) {
+      output.writeMessage(13, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) declarator_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -678,6 +719,10 @@ public final class IrDeclaration extends
       size += org.jetbrains.kotlin.protobuf.CodedOutputStream
         .computeMessageSize(12, (org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeAlias) declarator_);
     }
+    if (declaratorCase_ == 13) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(13, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) declarator_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -833,6 +878,9 @@ public final class IrDeclaration extends
       if (declaratorCase_ == 12) {
         result.declarator_ = declarator_;
       }
+      if (declaratorCase_ == 13) {
+        result.declarator_ = declarator_;
+      }
       result.bitField0_ = to_bitField0_;
       result.declaratorCase_ = declaratorCase_;
       return result;
@@ -889,6 +937,10 @@ public final class IrDeclaration extends
           mergeIrTypeAlias(other.getIrTypeAlias());
           break;
         }
+        case IR_ERROR_DECLARATION: {
+          mergeIrErrorDeclaration(other.getIrErrorDeclaration());
+          break;
+        }
         case DECLARATOR_NOT_SET: {
           break;
         }
@@ -971,6 +1023,12 @@ public final class IrDeclaration extends
           return false;
         }
       }
+      if (hasIrErrorDeclaration()) {
+        if (!getIrErrorDeclaration().isInitialized()) {
+          
+          return false;
+        }
+      }
       return true;
     }
 
@@ -1775,6 +1833,70 @@ public final class IrDeclaration extends
       return this;
     }
 
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+     */
+    public boolean hasIrErrorDeclaration() {
+      return declaratorCase_ == 13;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration getIrErrorDeclaration() {
+      if (declaratorCase_ == 13) {
+        return (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) declarator_;
+      }
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.getDefaultInstance();
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+     */
+    public Builder setIrErrorDeclaration(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      declarator_ = value;
+
+      declaratorCase_ = 13;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+     */
+    public Builder setIrErrorDeclaration(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.Builder builderForValue) {
+      declarator_ = builderForValue.build();
+
+      declaratorCase_ = 13;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+     */
+    public Builder mergeIrErrorDeclaration(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration value) {
+      if (declaratorCase_ == 13 &&
+          declarator_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.getDefaultInstance()) {
+        declarator_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.newBuilder((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) declarator_)
+            .mergeFrom(value).buildPartial();
+      } else {
+        declarator_ = value;
+      }
+
+      declaratorCase_ = 13;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+     */
+    public Builder clearIrErrorDeclaration() {
+      if (declaratorCase_ == 13) {
+        declaratorCase_ = 0;
+        declarator_ = null;
+        
+      }
+      return this;
+    }
+
     // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclaration)
   }
 

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

@@ -114,4 +114,13 @@ public interface IrDeclarationOrBuilder extends
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeAlias ir_type_alias = 12;</code>
    */
   org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeAlias getIrTypeAlias();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+   */
+  boolean hasIrErrorDeclaration();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration ir_error_declaration = 13;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration getIrErrorDeclaration();
 }

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

@@ -0,0 +1,676 @@
+// 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.IrErrorCallExpression}
+ */
+public final class IrErrorCallExpression extends
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+    // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression)
+    IrErrorCallExpressionOrBuilder {
+  // Use IrErrorCallExpression.newBuilder() to construct.
+  private IrErrorCallExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+    super(builder);
+    this.unknownFields = builder.getUnknownFields();
+  }
+  private IrErrorCallExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+  private static final IrErrorCallExpression defaultInstance;
+  public static IrErrorCallExpression getDefaultInstance() {
+    return defaultInstance;
+  }
+
+  public IrErrorCallExpression getDefaultInstanceForType() {
+    return defaultInstance;
+  }
+
+  private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  private IrErrorCallExpression(
+      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;
+            description_ = input.readInt32();
+            break;
+          }
+          case 18: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.Builder subBuilder = null;
+            if (((bitField0_ & 0x00000002) == 0x00000002)) {
+              subBuilder = receiver_.toBuilder();
+            }
+            receiver_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom(receiver_);
+              receiver_ = subBuilder.buildPartial();
+            }
+            bitField0_ |= 0x00000002;
+            break;
+          }
+          case 26: {
+            if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
+              valueArgument_ = new java.util.ArrayList<org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression>();
+              mutable_bitField0_ |= 0x00000004;
+            }
+            valueArgument_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.PARSER, extensionRegistry));
+            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)) {
+        valueArgument_ = java.util.Collections.unmodifiableList(valueArgument_);
+      }
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+  public static org.jetbrains.kotlin.protobuf.Parser<IrErrorCallExpression> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<IrErrorCallExpression>() {
+    public IrErrorCallExpression parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new IrErrorCallExpression(input, extensionRegistry);
+    }
+  };
+
+  @java.lang.Override
+  public org.jetbrains.kotlin.protobuf.Parser<IrErrorCallExpression> getParserForType() {
+    return PARSER;
+  }
+
+  private int bitField0_;
+  public static final int DESCRIPTION_FIELD_NUMBER = 1;
+  private int description_;
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  public boolean hasDescription() {
+    return ((bitField0_ & 0x00000001) == 0x00000001);
+  }
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  public int getDescription() {
+    return description_;
+  }
+
+  public static final int RECEIVER_FIELD_NUMBER = 2;
+  private org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver_;
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+   */
+  public boolean hasReceiver() {
+    return ((bitField0_ & 0x00000002) == 0x00000002);
+  }
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getReceiver() {
+    return receiver_;
+  }
+
+  public static final int VALUE_ARGUMENT_FIELD_NUMBER = 3;
+  private java.util.List<org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression> valueArgument_;
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  public java.util.List<org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression> getValueArgumentList() {
+    return valueArgument_;
+  }
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  public java.util.List<? extends org.jetbrains.kotlin.backend.common.serialization.proto.IrExpressionOrBuilder> 
+      getValueArgumentOrBuilderList() {
+    return valueArgument_;
+  }
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  public int getValueArgumentCount() {
+    return valueArgument_.size();
+  }
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getValueArgument(int index) {
+    return valueArgument_.get(index);
+  }
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrExpressionOrBuilder getValueArgumentOrBuilder(
+      int index) {
+    return valueArgument_.get(index);
+  }
+
+  private void initFields() {
+    description_ = 0;
+    receiver_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+    valueArgument_ = java.util.Collections.emptyList();
+  }
+  private byte memoizedIsInitialized = -1;
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    if (!hasDescription()) {
+      memoizedIsInitialized = 0;
+      return false;
+    }
+    if (hasReceiver()) {
+      if (!getReceiver().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
+    for (int i = 0; i < getValueArgumentCount(); i++) {
+      if (!getValueArgument(i).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.writeInt32(1, description_);
+    }
+    if (((bitField0_ & 0x00000002) == 0x00000002)) {
+      output.writeMessage(2, receiver_);
+    }
+    for (int i = 0; i < valueArgument_.size(); i++) {
+      output.writeMessage(3, valueArgument_.get(i));
+    }
+    output.writeRawBytes(unknownFields);
+  }
+
+  private int memoizedSerializedSize = -1;
+  public int getSerializedSize() {
+    int size = memoizedSerializedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    if (((bitField0_ & 0x00000001) == 0x00000001)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeInt32Size(1, description_);
+    }
+    if (((bitField0_ & 0x00000002) == 0x00000002)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(2, receiver_);
+    }
+    for (int i = 0; i < valueArgument_.size(); i++) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(3, valueArgument_.get(i));
+    }
+    size += unknownFields.size();
+    memoizedSerializedSize = size;
+    return size;
+  }
+
+  private static final long serialVersionUID = 0L;
+  @java.lang.Override
+  protected java.lang.Object writeReplace()
+      throws java.io.ObjectStreamException {
+    return super.writeReplace();
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression 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.IrErrorCallExpression 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.IrErrorCallExpression parseFrom(byte[] data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression 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.IrErrorCallExpression parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression 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.IrErrorCallExpression parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression 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.IrErrorCallExpression parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression 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 Builder newBuilderForType() { return newBuilder(); }
+  public static Builder newBuilder(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression prototype) {
+    return newBuilder().mergeFrom(prototype);
+  }
+  public Builder toBuilder() { return newBuilder(this); }
+
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression}
+   */
+  public static final class Builder extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression, Builder>
+      implements
+      // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression)
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpressionOrBuilder {
+    // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private void maybeForceBuilderInitialization() {
+    }
+    private static Builder create() {
+      return new Builder();
+    }
+
+    public Builder clear() {
+      super.clear();
+      description_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000001);
+      receiver_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+      bitField0_ = (bitField0_ & ~0x00000002);
+      valueArgument_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000004);
+      return this;
+    }
+
+    public Builder clone() {
+      return create().mergeFrom(buildPartial());
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression getDefaultInstanceForType() {
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.getDefaultInstance();
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression build() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression(this);
+      int from_bitField0_ = bitField0_;
+      int to_bitField0_ = 0;
+      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+        to_bitField0_ |= 0x00000001;
+      }
+      result.description_ = description_;
+      if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+        to_bitField0_ |= 0x00000002;
+      }
+      result.receiver_ = receiver_;
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        valueArgument_ = java.util.Collections.unmodifiableList(valueArgument_);
+        bitField0_ = (bitField0_ & ~0x00000004);
+      }
+      result.valueArgument_ = valueArgument_;
+      result.bitField0_ = to_bitField0_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.getDefaultInstance()) return this;
+      if (other.hasDescription()) {
+        setDescription(other.getDescription());
+      }
+      if (other.hasReceiver()) {
+        mergeReceiver(other.getReceiver());
+      }
+      if (!other.valueArgument_.isEmpty()) {
+        if (valueArgument_.isEmpty()) {
+          valueArgument_ = other.valueArgument_;
+          bitField0_ = (bitField0_ & ~0x00000004);
+        } else {
+          ensureValueArgumentIsMutable();
+          valueArgument_.addAll(other.valueArgument_);
+        }
+        
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
+    public final boolean isInitialized() {
+      if (!hasDescription()) {
+        
+        return false;
+      }
+      if (hasReceiver()) {
+        if (!getReceiver().isInitialized()) {
+          
+          return false;
+        }
+      }
+      for (int i = 0; i < getValueArgumentCount(); i++) {
+        if (!getValueArgument(i).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.IrErrorCallExpression parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) e.getUnfinishedMessage();
+        throw e;
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+    private int bitField0_;
+
+    private int description_ ;
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public boolean hasDescription() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public int getDescription() {
+      return description_;
+    }
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public Builder setDescription(int value) {
+      bitField0_ |= 0x00000001;
+      description_ = value;
+      
+      return this;
+    }
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public Builder clearDescription() {
+      bitField0_ = (bitField0_ & ~0x00000001);
+      description_ = 0;
+      
+      return this;
+    }
+
+    private org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+     */
+    public boolean hasReceiver() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getReceiver() {
+      return receiver_;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+     */
+    public Builder setReceiver(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      receiver_ = value;
+
+      bitField0_ |= 0x00000002;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+     */
+    public Builder setReceiver(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.Builder builderForValue) {
+      receiver_ = builderForValue.build();
+
+      bitField0_ |= 0x00000002;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+     */
+    public Builder mergeReceiver(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value) {
+      if (((bitField0_ & 0x00000002) == 0x00000002) &&
+          receiver_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance()) {
+        receiver_ =
+          org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.newBuilder(receiver_).mergeFrom(value).buildPartial();
+      } else {
+        receiver_ = value;
+      }
+
+      bitField0_ |= 0x00000002;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+     */
+    public Builder clearReceiver() {
+      receiver_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.getDefaultInstance();
+
+      bitField0_ = (bitField0_ & ~0x00000002);
+      return this;
+    }
+
+    private java.util.List<org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression> valueArgument_ =
+      java.util.Collections.emptyList();
+    private void ensureValueArgumentIsMutable() {
+      if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+        valueArgument_ = new java.util.ArrayList<org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression>(valueArgument_);
+        bitField0_ |= 0x00000004;
+       }
+    }
+
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public java.util.List<org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression> getValueArgumentList() {
+      return java.util.Collections.unmodifiableList(valueArgument_);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public int getValueArgumentCount() {
+      return valueArgument_.size();
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getValueArgument(int index) {
+      return valueArgument_.get(index);
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder setValueArgument(
+        int index, org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      ensureValueArgumentIsMutable();
+      valueArgument_.set(index, value);
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder setValueArgument(
+        int index, org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.Builder builderForValue) {
+      ensureValueArgumentIsMutable();
+      valueArgument_.set(index, builderForValue.build());
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder addValueArgument(org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      ensureValueArgumentIsMutable();
+      valueArgument_.add(value);
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder addValueArgument(
+        int index, org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      ensureValueArgumentIsMutable();
+      valueArgument_.add(index, value);
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder addValueArgument(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.Builder builderForValue) {
+      ensureValueArgumentIsMutable();
+      valueArgument_.add(builderForValue.build());
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder addValueArgument(
+        int index, org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression.Builder builderForValue) {
+      ensureValueArgumentIsMutable();
+      valueArgument_.add(index, builderForValue.build());
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder addAllValueArgument(
+        java.lang.Iterable<? extends org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression> values) {
+      ensureValueArgumentIsMutable();
+      org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+          values, valueArgument_);
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder clearValueArgument() {
+      valueArgument_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000004);
+
+      return this;
+    }
+    /**
+     * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+     */
+    public Builder removeValueArgument(int index) {
+      ensureValueArgumentIsMutable();
+      valueArgument_.remove(index);
+
+      return this;
+    }
+
+    // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression)
+  }
+
+  static {
+    defaultInstance = new IrErrorCallExpression(true);
+    defaultInstance.initFields();
+  }
+
+  // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression)
+}

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

@@ -0,0 +1,41 @@
+// 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 IrErrorCallExpressionOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression)
+    org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  boolean hasDescription();
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  int getDescription();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+   */
+  boolean hasReceiver();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression receiver = 2;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getReceiver();
+
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  java.util.List<org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression> 
+      getValueArgumentList();
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression getValueArgument(int index);
+  /**
+   * <code>repeated .org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression value_argument = 3;</code>
+   */
+  int getValueArgumentCount();
+}

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

@@ -0,0 +1,351 @@
+// 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.IrErrorDeclaration}
+ */
+public final class IrErrorDeclaration extends
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+    // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration)
+    IrErrorDeclarationOrBuilder {
+  // Use IrErrorDeclaration.newBuilder() to construct.
+  private IrErrorDeclaration(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+    super(builder);
+    this.unknownFields = builder.getUnknownFields();
+  }
+  private IrErrorDeclaration(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+  private static final IrErrorDeclaration defaultInstance;
+  public static IrErrorDeclaration getDefaultInstance() {
+    return defaultInstance;
+  }
+
+  public IrErrorDeclaration getDefaultInstanceForType() {
+    return defaultInstance;
+  }
+
+  private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  private IrErrorDeclaration(
+      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;
+            coordinates_ = 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<IrErrorDeclaration> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<IrErrorDeclaration>() {
+    public IrErrorDeclaration parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new IrErrorDeclaration(input, extensionRegistry);
+    }
+  };
+
+  @java.lang.Override
+  public org.jetbrains.kotlin.protobuf.Parser<IrErrorDeclaration> getParserForType() {
+    return PARSER;
+  }
+
+  private int bitField0_;
+  public static final int COORDINATES_FIELD_NUMBER = 1;
+  private long coordinates_;
+  /**
+   * <code>required int64 coordinates = 1;</code>
+   */
+  public boolean hasCoordinates() {
+    return ((bitField0_ & 0x00000001) == 0x00000001);
+  }
+  /**
+   * <code>required int64 coordinates = 1;</code>
+   */
+  public long getCoordinates() {
+    return coordinates_;
+  }
+
+  private void initFields() {
+    coordinates_ = 0L;
+  }
+  private byte memoizedIsInitialized = -1;
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    if (!hasCoordinates()) {
+      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.writeInt64(1, coordinates_);
+    }
+    output.writeRawBytes(unknownFields);
+  }
+
+  private int memoizedSerializedSize = -1;
+  public int getSerializedSize() {
+    int size = memoizedSerializedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    if (((bitField0_ & 0x00000001) == 0x00000001)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeInt64Size(1, coordinates_);
+    }
+    size += unknownFields.size();
+    memoizedSerializedSize = size;
+    return size;
+  }
+
+  private static final long serialVersionUID = 0L;
+  @java.lang.Override
+  protected java.lang.Object writeReplace()
+      throws java.io.ObjectStreamException {
+    return super.writeReplace();
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration 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.IrErrorDeclaration 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.IrErrorDeclaration parseFrom(byte[] data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration 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.IrErrorDeclaration parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration 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.IrErrorDeclaration parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration 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.IrErrorDeclaration parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration 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 Builder newBuilderForType() { return newBuilder(); }
+  public static Builder newBuilder(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration prototype) {
+    return newBuilder().mergeFrom(prototype);
+  }
+  public Builder toBuilder() { return newBuilder(this); }
+
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration}
+   */
+  public static final class Builder extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration, Builder>
+      implements
+      // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration)
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclarationOrBuilder {
+    // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private void maybeForceBuilderInitialization() {
+    }
+    private static Builder create() {
+      return new Builder();
+    }
+
+    public Builder clear() {
+      super.clear();
+      coordinates_ = 0L;
+      bitField0_ = (bitField0_ & ~0x00000001);
+      return this;
+    }
+
+    public Builder clone() {
+      return create().mergeFrom(buildPartial());
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration getDefaultInstanceForType() {
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.getDefaultInstance();
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration build() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration(this);
+      int from_bitField0_ = bitField0_;
+      int to_bitField0_ = 0;
+      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+        to_bitField0_ |= 0x00000001;
+      }
+      result.coordinates_ = coordinates_;
+      result.bitField0_ = to_bitField0_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration.getDefaultInstance()) return this;
+      if (other.hasCoordinates()) {
+        setCoordinates(other.getCoordinates());
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
+    public final boolean isInitialized() {
+      if (!hasCoordinates()) {
+        
+        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.IrErrorDeclaration parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration) e.getUnfinishedMessage();
+        throw e;
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+    private int bitField0_;
+
+    private long coordinates_ ;
+    /**
+     * <code>required int64 coordinates = 1;</code>
+     */
+    public boolean hasCoordinates() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required int64 coordinates = 1;</code>
+     */
+    public long getCoordinates() {
+      return coordinates_;
+    }
+    /**
+     * <code>required int64 coordinates = 1;</code>
+     */
+    public Builder setCoordinates(long value) {
+      bitField0_ |= 0x00000001;
+      coordinates_ = value;
+      
+      return this;
+    }
+    /**
+     * <code>required int64 coordinates = 1;</code>
+     */
+    public Builder clearCoordinates() {
+      bitField0_ = (bitField0_ & ~0x00000001);
+      coordinates_ = 0L;
+      
+      return this;
+    }
+
+    // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration)
+  }
+
+  static {
+    defaultInstance = new IrErrorDeclaration(true);
+    defaultInstance.initFields();
+  }
+
+  // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration)
+}

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

@@ -0,0 +1,18 @@
+// 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 IrErrorDeclarationOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorDeclaration)
+    org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+  /**
+   * <code>required int64 coordinates = 1;</code>
+   */
+  boolean hasCoordinates();
+  /**
+   * <code>required int64 coordinates = 1;</code>
+   */
+  long getCoordinates();
+}

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

@@ -0,0 +1,351 @@
+// 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.IrErrorExpression}
+ */
+public final class IrErrorExpression extends
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+    // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression)
+    IrErrorExpressionOrBuilder {
+  // Use IrErrorExpression.newBuilder() to construct.
+  private IrErrorExpression(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+    super(builder);
+    this.unknownFields = builder.getUnknownFields();
+  }
+  private IrErrorExpression(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+  private static final IrErrorExpression defaultInstance;
+  public static IrErrorExpression getDefaultInstance() {
+    return defaultInstance;
+  }
+
+  public IrErrorExpression getDefaultInstanceForType() {
+    return defaultInstance;
+  }
+
+  private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  private IrErrorExpression(
+      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;
+            description_ = 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<IrErrorExpression> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<IrErrorExpression>() {
+    public IrErrorExpression parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new IrErrorExpression(input, extensionRegistry);
+    }
+  };
+
+  @java.lang.Override
+  public org.jetbrains.kotlin.protobuf.Parser<IrErrorExpression> getParserForType() {
+    return PARSER;
+  }
+
+  private int bitField0_;
+  public static final int DESCRIPTION_FIELD_NUMBER = 1;
+  private int description_;
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  public boolean hasDescription() {
+    return ((bitField0_ & 0x00000001) == 0x00000001);
+  }
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  public int getDescription() {
+    return description_;
+  }
+
+  private void initFields() {
+    description_ = 0;
+  }
+  private byte memoizedIsInitialized = -1;
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    if (!hasDescription()) {
+      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.writeInt32(1, description_);
+    }
+    output.writeRawBytes(unknownFields);
+  }
+
+  private int memoizedSerializedSize = -1;
+  public int getSerializedSize() {
+    int size = memoizedSerializedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    if (((bitField0_ & 0x00000001) == 0x00000001)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeInt32Size(1, description_);
+    }
+    size += unknownFields.size();
+    memoizedSerializedSize = size;
+    return size;
+  }
+
+  private static final long serialVersionUID = 0L;
+  @java.lang.Override
+  protected java.lang.Object writeReplace()
+      throws java.io.ObjectStreamException {
+    return super.writeReplace();
+  }
+
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression 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.IrErrorExpression 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.IrErrorExpression parseFrom(byte[] data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression 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.IrErrorExpression parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression 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.IrErrorExpression parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression 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.IrErrorExpression parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression 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 Builder newBuilderForType() { return newBuilder(); }
+  public static Builder newBuilder(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression prototype) {
+    return newBuilder().mergeFrom(prototype);
+  }
+  public Builder toBuilder() { return newBuilder(this); }
+
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression}
+   */
+  public static final class Builder extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression, Builder>
+      implements
+      // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression)
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpressionOrBuilder {
+    // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private void maybeForceBuilderInitialization() {
+    }
+    private static Builder create() {
+      return new Builder();
+    }
+
+    public Builder clear() {
+      super.clear();
+      description_ = 0;
+      bitField0_ = (bitField0_ & ~0x00000001);
+      return this;
+    }
+
+    public Builder clone() {
+      return create().mergeFrom(buildPartial());
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression getDefaultInstanceForType() {
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.getDefaultInstance();
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression build() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression(this);
+      int from_bitField0_ = bitField0_;
+      int to_bitField0_ = 0;
+      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+        to_bitField0_ |= 0x00000001;
+      }
+      result.description_ = description_;
+      result.bitField0_ = to_bitField0_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.getDefaultInstance()) return this;
+      if (other.hasDescription()) {
+        setDescription(other.getDescription());
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
+    public final boolean isInitialized() {
+      if (!hasDescription()) {
+        
+        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.IrErrorExpression parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) e.getUnfinishedMessage();
+        throw e;
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+    private int bitField0_;
+
+    private int description_ ;
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public boolean hasDescription() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public int getDescription() {
+      return description_;
+    }
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public Builder setDescription(int value) {
+      bitField0_ |= 0x00000001;
+      description_ = value;
+      
+      return this;
+    }
+    /**
+     * <code>required int32 description = 1;</code>
+     */
+    public Builder clearDescription() {
+      bitField0_ = (bitField0_ & ~0x00000001);
+      description_ = 0;
+      
+      return this;
+    }
+
+    // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression)
+  }
+
+  static {
+    defaultInstance = new IrErrorExpression(true);
+    defaultInstance.initFields();
+  }
+
+  // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression)
+}

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

@@ -0,0 +1,18 @@
+// 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 IrErrorExpressionOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression)
+    org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  boolean hasDescription();
+  /**
+   * <code>required int32 description = 1;</code>
+   */
+  int getDescription();
+}

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

@@ -488,6 +488,32 @@ public final class IrOperation extends
             operationCase_ = 33;
             break;
           }
+          case 274: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.Builder subBuilder = null;
+            if (operationCase_ == 34) {
+              subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) operation_).toBuilder();
+            }
+            operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) operation_);
+              operation_ = subBuilder.buildPartial();
+            }
+            operationCase_ = 34;
+            break;
+          }
+          case 282: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.Builder subBuilder = null;
+            if (operationCase_ == 35) {
+              subBuilder = ((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) operation_).toBuilder();
+            }
+            operation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) operation_);
+              operation_ = subBuilder.buildPartial();
+            }
+            operationCase_ = 35;
+            break;
+          }
         }
       }
     } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -560,6 +586,8 @@ public final class IrOperation extends
     LOCAL_DELEGATED_PROPERTY_REFERENCE(31),
     CONSTRUCTOR_CALL(32),
     FUNCTION_EXPRESSION(33),
+    ERROR_EXPRESSION(34),
+    ERROR_CALL_EXPRESSION(35),
     OPERATION_NOT_SET(0);
     private int value = 0;
     private OperationCase(int value) {
@@ -600,6 +628,8 @@ public final class IrOperation extends
         case 31: return LOCAL_DELEGATED_PROPERTY_REFERENCE;
         case 32: return CONSTRUCTOR_CALL;
         case 33: return FUNCTION_EXPRESSION;
+        case 34: return ERROR_EXPRESSION;
+        case 35: return ERROR_CALL_EXPRESSION;
         case 0: return OPERATION_NOT_SET;
         default: throw new java.lang.IllegalArgumentException(
           "Value is undefined for this oneof enum.");
@@ -1177,6 +1207,48 @@ public final class IrOperation extends
     return org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionExpression.getDefaultInstance();
   }
 
+  public static final int ERROR_EXPRESSION_FIELD_NUMBER = 34;
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+   *
+   * <pre>
+   * Error code
+   * </pre>
+   */
+  public boolean hasErrorExpression() {
+    return operationCase_ == 34;
+  }
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+   *
+   * <pre>
+   * Error code
+   * </pre>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression getErrorExpression() {
+    if (operationCase_ == 34) {
+       return (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) operation_;
+    }
+    return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.getDefaultInstance();
+  }
+
+  public static final int ERROR_CALL_EXPRESSION_FIELD_NUMBER = 35;
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+   */
+  public boolean hasErrorCallExpression() {
+    return operationCase_ == 35;
+  }
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression getErrorCallExpression() {
+    if (operationCase_ == 35) {
+       return (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) operation_;
+    }
+    return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.getDefaultInstance();
+  }
+
   private void initFields() {
   }
   private byte memoizedIsInitialized = -1;
@@ -1377,6 +1449,18 @@ public final class IrOperation extends
         return false;
       }
     }
+    if (hasErrorExpression()) {
+      if (!getErrorExpression().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
+    if (hasErrorCallExpression()) {
+      if (!getErrorCallExpression().isInitialized()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+    }
     memoizedIsInitialized = 1;
     return true;
   }
@@ -1483,6 +1567,12 @@ public final class IrOperation extends
     if (operationCase_ == 33) {
       output.writeMessage(33, (org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionExpression) operation_);
     }
+    if (operationCase_ == 34) {
+      output.writeMessage(34, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) operation_);
+    }
+    if (operationCase_ == 35) {
+      output.writeMessage(35, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) operation_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -1624,6 +1714,14 @@ public final class IrOperation extends
       size += org.jetbrains.kotlin.protobuf.CodedOutputStream
         .computeMessageSize(33, (org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionExpression) operation_);
     }
+    if (operationCase_ == 34) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(34, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) operation_);
+    }
+    if (operationCase_ == 35) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(35, (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) operation_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -1849,6 +1947,12 @@ public final class IrOperation extends
       if (operationCase_ == 33) {
         result.operation_ = operation_;
       }
+      if (operationCase_ == 34) {
+        result.operation_ = operation_;
+      }
+      if (operationCase_ == 35) {
+        result.operation_ = operation_;
+      }
       result.bitField0_ = to_bitField0_;
       result.bitField1_ = to_bitField1_;
       result.operationCase_ = operationCase_;
@@ -1990,6 +2094,14 @@ public final class IrOperation extends
           mergeFunctionExpression(other.getFunctionExpression());
           break;
         }
+        case ERROR_EXPRESSION: {
+          mergeErrorExpression(other.getErrorExpression());
+          break;
+        }
+        case ERROR_CALL_EXPRESSION: {
+          mergeErrorCallExpression(other.getErrorCallExpression());
+          break;
+        }
         case OPERATION_NOT_SET: {
           break;
         }
@@ -2192,6 +2304,18 @@ public final class IrOperation extends
           return false;
         }
       }
+      if (hasErrorExpression()) {
+        if (!getErrorExpression().isInitialized()) {
+          
+          return false;
+        }
+      }
+      if (hasErrorCallExpression()) {
+        if (!getErrorCallExpression().isInitialized()) {
+          
+          return false;
+        }
+      }
       return true;
     }
 
@@ -4341,6 +4465,158 @@ public final class IrOperation extends
       return this;
     }
 
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+     *
+     * <pre>
+     * Error code
+     * </pre>
+     */
+    public boolean hasErrorExpression() {
+      return operationCase_ == 34;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+     *
+     * <pre>
+     * Error code
+     * </pre>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression getErrorExpression() {
+      if (operationCase_ == 34) {
+        return (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) operation_;
+      }
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.getDefaultInstance();
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+     *
+     * <pre>
+     * Error code
+     * </pre>
+     */
+    public Builder setErrorExpression(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      operation_ = value;
+
+      operationCase_ = 34;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+     *
+     * <pre>
+     * Error code
+     * </pre>
+     */
+    public Builder setErrorExpression(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.Builder builderForValue) {
+      operation_ = builderForValue.build();
+
+      operationCase_ = 34;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+     *
+     * <pre>
+     * Error code
+     * </pre>
+     */
+    public Builder mergeErrorExpression(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression value) {
+      if (operationCase_ == 34 &&
+          operation_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.getDefaultInstance()) {
+        operation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression.newBuilder((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression) operation_)
+            .mergeFrom(value).buildPartial();
+      } else {
+        operation_ = value;
+      }
+
+      operationCase_ = 34;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+     *
+     * <pre>
+     * Error code
+     * </pre>
+     */
+    public Builder clearErrorExpression() {
+      if (operationCase_ == 34) {
+        operationCase_ = 0;
+        operation_ = null;
+        
+      }
+      return this;
+    }
+
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+     */
+    public boolean hasErrorCallExpression() {
+      return operationCase_ == 35;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression getErrorCallExpression() {
+      if (operationCase_ == 35) {
+        return (org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) operation_;
+      }
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.getDefaultInstance();
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+     */
+    public Builder setErrorCallExpression(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      operation_ = value;
+
+      operationCase_ = 35;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+     */
+    public Builder setErrorCallExpression(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.Builder builderForValue) {
+      operation_ = builderForValue.build();
+
+      operationCase_ = 35;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+     */
+    public Builder mergeErrorCallExpression(org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression value) {
+      if (operationCase_ == 35 &&
+          operation_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.getDefaultInstance()) {
+        operation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression.newBuilder((org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression) operation_)
+            .mergeFrom(value).buildPartial();
+      } else {
+        operation_ = value;
+      }
+
+      operationCase_ = 35;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+     */
+    public Builder clearErrorCallExpression() {
+      if (operationCase_ == 35) {
+        operationCase_ = 0;
+        operation_ = null;
+        
+      }
+      return this;
+    }
+
     // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrOperation)
   }
 

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

@@ -303,4 +303,30 @@ public interface IrOperationOrBuilder extends
    * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionExpression function_expression = 33;</code>
    */
   org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionExpression getFunctionExpression();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+   *
+   * <pre>
+   * Error code
+   * </pre>
+   */
+  boolean hasErrorExpression();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression error_expression = 34;</code>
+   *
+   * <pre>
+   * Error code
+   * </pre>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression getErrorExpression();
+
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+   */
+  boolean hasErrorCallExpression();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression error_call_expression = 35;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorCallExpression getErrorCallExpression();
 }