[IR] Unite inline class and multi-field value class representation

#KT-1179

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

@@ -533,6 +533,7 @@ message IrClass {
   repeated IrDeclaration declaration = 5;
   repeated int32 super_type = 6 [packed=true];
   optional IrInlineClassRepresentation inline_class_representation = 7;
+  optional IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;
   repeated int64 sealed_subclass = 8 [packed=true];
 }
 
@@ -621,3 +622,8 @@ message IrInlineClassRepresentation {
   required int32 underlying_property_name = 1;
   required int32 underlying_property_type = 2;
 }
+
+message IrMultiFieldValueClassRepresentation {
+  repeated int32 underlying_property_name = 1 [packed=true];
+  repeated int32 underlying_property_type = 2 [packed=true];
+}

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrType.KindCase.*
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.MultiFieldValueClassRepresentation
 import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
@@ -23,7 +24,6 @@ import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrPublicSymbolBase
-import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterPublicSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.types.impl.*
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunction as Pro
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionBase as ProtoFunctionBase
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation as ProtoIrInlineClassRepresentation
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedProperty as ProtoLocalDelegatedProperty
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation as ProtoIrMultiFieldValueClassRepresentation
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrProperty as ProtoProperty
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrSimpleType as ProtoSimpleType
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrStatement as ProtoStatement
@@ -347,14 +348,16 @@ class IrDeclarationDeserializer(
 
                 thisReceiver = deserializeIrValueParameter(proto.thisReceiver, -1)
 
-                inlineClassRepresentation = when {
-                    !(flags.isValue && primaryConstructor?.valueParameters?.size == 1) -> null
+                valueClassRepresentation = when {
+                    !flags.isValue -> null
+                    proto.hasMultiFieldValueClassRepresentation() && proto.hasInlineClassRepresentation() ->
+                        error("Class cannot be both inline and multi-field value: $name")
                     proto.hasInlineClassRepresentation() -> deserializeInlineClassRepresentation(proto.inlineClassRepresentation)
+                    proto.hasMultiFieldValueClassRepresentation() ->
+                        deserializeMultiFieldValueClassRepresentation(proto.multiFieldValueClassRepresentation)
                     else -> computeMissingInlineClassRepresentationForCompatibility(this)
                 }
 
-                // todo something when value classes
-
                 sealedSubclasses = proto.sealedSubclassList.map { deserializeIrSymbol(it) as IrClassSymbol }
 
                 fakeOverrideBuilder.enqueueClass(this, signature, compatibilityMode)
@@ -367,6 +370,12 @@ class IrDeclarationDeserializer(
             deserializeIrType(proto.underlyingPropertyType) as IrSimpleType,
         )
 
+    private fun deserializeMultiFieldValueClassRepresentation(proto: ProtoIrMultiFieldValueClassRepresentation): MultiFieldValueClassRepresentation<IrSimpleType> {
+        val names = proto.underlyingPropertyNameList.map { deserializeName(it) }
+        val types = proto.underlyingPropertyTypeList.map { deserializeIrType(it) as IrSimpleType }
+        return MultiFieldValueClassRepresentation(names zip types)
+    }
+
     private fun computeMissingInlineClassRepresentationForCompatibility(irClass: IrClass): InlineClassRepresentation<IrSimpleType> {
         // For inline classes compiled with 1.5.20 or earlier, try to reconstruct inline class representation from the single parameter of
         // the primary constructor. Something similar is happening in `DeserializedClassDescriptor.computeInlineClassRepresentation`.

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

@@ -6,10 +6,7 @@
 package org.jetbrains.kotlin.backend.common.serialization
 
 import org.jetbrains.kotlin.backend.common.serialization.encodings.*
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
-import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
-import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrFileEntry
 import org.jetbrains.kotlin.ir.declarations.*
@@ -83,6 +80,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepr
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrInstanceInitializerCall as ProtoInstanceInitializerCall
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedProperty as ProtoLocalDelegatedProperty
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedPropertyReference as ProtoLocalDelegatedPropertyReference
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation as ProtoIrMultiFieldValueClassRepresentation
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrOperation as ProtoOperation
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrProperty as ProtoProperty
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrPropertyReference as ProtoPropertyReference
@@ -1031,7 +1029,8 @@ open class IrFileSerializer(
             is IrGetEnumValue -> operationProto.getEnumValue = serializeGetEnumValue(expression)
             is IrGetObjectValue -> operationProto.getObject = serializeGetObject(expression)
             is IrInstanceInitializerCall -> operationProto.instanceInitializerCall = serializeInstanceInitializerCall(expression)
-            is IrLocalDelegatedPropertyReference -> operationProto.localDelegatedPropertyReference = serializeIrLocalDelegatedPropertyReference(expression)
+            is IrLocalDelegatedPropertyReference -> operationProto.localDelegatedPropertyReference =
+                serializeIrLocalDelegatedPropertyReference(expression)
             is IrPropertyReference -> operationProto.propertyReference = serializePropertyReference(expression)
             is IrReturn -> serializeReturn(operationProto, expression)
             is IrSetField -> operationProto.setField = serializeSetField(expression)
@@ -1234,9 +1233,12 @@ open class IrFileSerializer(
             .setBase(serializeIrDeclarationBase(clazz, ClassFlags.encode(clazz)))
             .setName(serializeName(clazz.name))
 
-        val representation = clazz.inlineClassRepresentation
-        if (representation != null) {
-            proto.inlineClassRepresentation = serializeInlineClassRepresentation(representation)
+
+        when (val representation = clazz.valueClassRepresentation) {
+            is MultiFieldValueClassRepresentation ->
+                proto.multiFieldValueClassRepresentation = serializeMultiFieldValueClassRepresentation(representation)
+            is InlineClassRepresentation -> proto.inlineClassRepresentation = serializeInlineClassRepresentation(representation)
+            null -> Unit
         }
 
         clazz.declarations.forEach {
@@ -1267,6 +1269,12 @@ open class IrFileSerializer(
             underlyingPropertyType = serializeIrType(representation.underlyingType)
         }.build()
 
+    private fun serializeMultiFieldValueClassRepresentation(representation: MultiFieldValueClassRepresentation<IrSimpleType>): ProtoIrMultiFieldValueClassRepresentation =
+        ProtoIrMultiFieldValueClassRepresentation.newBuilder().apply {
+            addAllUnderlyingPropertyName(representation.underlyingPropertyNamesToTypes.map { (name, _) -> serializeName(name) })
+            addAllUnderlyingPropertyType(representation.underlyingPropertyNamesToTypes.map { (_, irType) -> serializeIrType(irType) })
+        }.build()
+
     private fun serializeIrTypeAlias(typeAlias: IrTypeAlias): ProtoTypeAlias {
         val proto = ProtoTypeAlias.newBuilder()
 

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

@@ -135,9 +135,9 @@ public final class IrClass extends
             break;
           }
           case 64: {
-            if (!((mutable_bitField0_ & 0x00000080) == 0x00000080)) {
+            if (!((mutable_bitField0_ & 0x00000100) == 0x00000100)) {
               sealedSubclass_ = new java.util.ArrayList<java.lang.Long>();
-              mutable_bitField0_ |= 0x00000080;
+              mutable_bitField0_ |= 0x00000100;
             }
             sealedSubclass_.add(input.readInt64());
             break;
@@ -145,9 +145,9 @@ public final class IrClass extends
           case 66: {
             int length = input.readRawVarint32();
             int limit = input.pushLimit(length);
-            if (!((mutable_bitField0_ & 0x00000080) == 0x00000080) && input.getBytesUntilLimit() > 0) {
+            if (!((mutable_bitField0_ & 0x00000100) == 0x00000100) && input.getBytesUntilLimit() > 0) {
               sealedSubclass_ = new java.util.ArrayList<java.lang.Long>();
-              mutable_bitField0_ |= 0x00000080;
+              mutable_bitField0_ |= 0x00000100;
             }
             while (input.getBytesUntilLimit() > 0) {
               sealedSubclass_.add(input.readInt64());
@@ -155,6 +155,19 @@ public final class IrClass extends
             input.popLimit(limit);
             break;
           }
+          case 74: {
+            org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.Builder subBuilder = null;
+            if (((bitField0_ & 0x00000010) == 0x00000010)) {
+              subBuilder = multiFieldValueClassRepresentation_.toBuilder();
+            }
+            multiFieldValueClassRepresentation_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.PARSER, extensionRegistry);
+            if (subBuilder != null) {
+              subBuilder.mergeFrom(multiFieldValueClassRepresentation_);
+              multiFieldValueClassRepresentation_ = subBuilder.buildPartial();
+            }
+            bitField0_ |= 0x00000010;
+            break;
+          }
         }
       }
     } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
@@ -172,7 +185,7 @@ public final class IrClass extends
       if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
         superType_ = java.util.Collections.unmodifiableList(superType_);
       }
-      if (((mutable_bitField0_ & 0x00000080) == 0x00000080)) {
+      if (((mutable_bitField0_ & 0x00000100) == 0x00000100)) {
         sealedSubclass_ = java.util.Collections.unmodifiableList(sealedSubclass_);
       }
       try {
@@ -354,6 +367,21 @@ public final class IrClass extends
     return inlineClassRepresentation_;
   }
 
+  public static final int MULTI_FIELD_VALUE_CLASS_REPRESENTATION_FIELD_NUMBER = 9;
+  private org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multiFieldValueClassRepresentation_;
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+   */
+  public boolean hasMultiFieldValueClassRepresentation() {
+    return ((bitField0_ & 0x00000010) == 0x00000010);
+  }
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+   */
+  public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getMultiFieldValueClassRepresentation() {
+    return multiFieldValueClassRepresentation_;
+  }
+
   public static final int SEALED_SUBCLASS_FIELD_NUMBER = 8;
   private java.util.List<java.lang.Long> sealedSubclass_;
   /**
@@ -385,6 +413,7 @@ public final class IrClass extends
     declaration_ = java.util.Collections.emptyList();
     superType_ = java.util.Collections.emptyList();
     inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance();
+    multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
     sealedSubclass_ = java.util.Collections.emptyList();
   }
   private byte memoizedIsInitialized = -1;
@@ -468,6 +497,9 @@ public final class IrClass extends
     for (int i = 0; i < sealedSubclass_.size(); i++) {
       output.writeInt64NoTag(sealedSubclass_.get(i));
     }
+    if (((bitField0_ & 0x00000010) == 0x00000010)) {
+      output.writeMessage(9, multiFieldValueClassRepresentation_);
+    }
     output.writeRawBytes(unknownFields);
   }
 
@@ -529,6 +561,10 @@ public final class IrClass extends
       }
       sealedSubclassMemoizedSerializedSize = dataSize;
     }
+    if (((bitField0_ & 0x00000010) == 0x00000010)) {
+      size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+        .computeMessageSize(9, multiFieldValueClassRepresentation_);
+    }
     size += unknownFields.size();
     memoizedSerializedSize = size;
     return size;
@@ -637,8 +673,10 @@ public final class IrClass extends
       bitField0_ = (bitField0_ & ~0x00000020);
       inlineClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation.getDefaultInstance();
       bitField0_ = (bitField0_ & ~0x00000040);
-      sealedSubclass_ = java.util.Collections.emptyList();
+      multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
       bitField0_ = (bitField0_ & ~0x00000080);
+      sealedSubclass_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000100);
       return this;
     }
 
@@ -693,9 +731,13 @@ public final class IrClass extends
         to_bitField0_ |= 0x00000008;
       }
       result.inlineClassRepresentation_ = inlineClassRepresentation_;
-      if (((bitField0_ & 0x00000080) == 0x00000080)) {
+      if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
+        to_bitField0_ |= 0x00000010;
+      }
+      result.multiFieldValueClassRepresentation_ = multiFieldValueClassRepresentation_;
+      if (((bitField0_ & 0x00000100) == 0x00000100)) {
         sealedSubclass_ = java.util.Collections.unmodifiableList(sealedSubclass_);
-        bitField0_ = (bitField0_ & ~0x00000080);
+        bitField0_ = (bitField0_ & ~0x00000100);
       }
       result.sealedSubclass_ = sealedSubclass_;
       result.bitField0_ = to_bitField0_;
@@ -746,10 +788,13 @@ public final class IrClass extends
       if (other.hasInlineClassRepresentation()) {
         mergeInlineClassRepresentation(other.getInlineClassRepresentation());
       }
+      if (other.hasMultiFieldValueClassRepresentation()) {
+        mergeMultiFieldValueClassRepresentation(other.getMultiFieldValueClassRepresentation());
+      }
       if (!other.sealedSubclass_.isEmpty()) {
         if (sealedSubclass_.isEmpty()) {
           sealedSubclass_ = other.sealedSubclass_;
-          bitField0_ = (bitField0_ & ~0x00000080);
+          bitField0_ = (bitField0_ & ~0x00000100);
         } else {
           ensureSealedSubclassIsMutable();
           sealedSubclass_.addAll(other.sealedSubclass_);
@@ -1348,11 +1393,71 @@ public final class IrClass extends
       return this;
     }
 
+    private org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+     */
+    public boolean hasMultiFieldValueClassRepresentation() {
+      return ((bitField0_ & 0x00000080) == 0x00000080);
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+     */
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getMultiFieldValueClassRepresentation() {
+      return multiFieldValueClassRepresentation_;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+     */
+    public Builder setMultiFieldValueClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation value) {
+      if (value == null) {
+        throw new NullPointerException();
+      }
+      multiFieldValueClassRepresentation_ = value;
+
+      bitField0_ |= 0x00000080;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+     */
+    public Builder setMultiFieldValueClassRepresentation(
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.Builder builderForValue) {
+      multiFieldValueClassRepresentation_ = builderForValue.build();
+
+      bitField0_ |= 0x00000080;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+     */
+    public Builder mergeMultiFieldValueClassRepresentation(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation value) {
+      if (((bitField0_ & 0x00000080) == 0x00000080) &&
+          multiFieldValueClassRepresentation_ != org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance()) {
+        multiFieldValueClassRepresentation_ =
+          org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.newBuilder(multiFieldValueClassRepresentation_).mergeFrom(value).buildPartial();
+      } else {
+        multiFieldValueClassRepresentation_ = value;
+      }
+
+      bitField0_ |= 0x00000080;
+      return this;
+    }
+    /**
+     * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+     */
+    public Builder clearMultiFieldValueClassRepresentation() {
+      multiFieldValueClassRepresentation_ = org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
+
+      bitField0_ = (bitField0_ & ~0x00000080);
+      return this;
+    }
+
     private java.util.List<java.lang.Long> sealedSubclass_ = java.util.Collections.emptyList();
     private void ensureSealedSubclassIsMutable() {
-      if (!((bitField0_ & 0x00000080) == 0x00000080)) {
+      if (!((bitField0_ & 0x00000100) == 0x00000100)) {
         sealedSubclass_ = new java.util.ArrayList<java.lang.Long>(sealedSubclass_);
-        bitField0_ |= 0x00000080;
+        bitField0_ |= 0x00000100;
        }
     }
     /**
@@ -1409,7 +1514,7 @@ public final class IrClass extends
      */
     public Builder clearSealedSubclass() {
       sealedSubclass_ = java.util.Collections.emptyList();
-      bitField0_ = (bitField0_ & ~0x00000080);
+      bitField0_ = (bitField0_ & ~0x00000100);
       
       return this;
     }

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

@@ -84,6 +84,15 @@ public interface IrClassOrBuilder extends
    */
   org.jetbrains.kotlin.backend.common.serialization.proto.IrInlineClassRepresentation getInlineClassRepresentation();
 
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+   */
+  boolean hasMultiFieldValueClassRepresentation();
+  /**
+   * <code>optional .org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation multi_field_value_class_representation = 9;</code>
+   */
+  org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getMultiFieldValueClassRepresentation();
+
   /**
    * <code>repeated int64 sealed_subclass = 8 [packed = true];</code>
    */

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

@@ -0,0 +1,575 @@
+// 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.IrMultiFieldValueClassRepresentation}
+ */
+public final class IrMultiFieldValueClassRepresentation extends
+    org.jetbrains.kotlin.protobuf.GeneratedMessageLite implements
+    // @@protoc_insertion_point(message_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
+    IrMultiFieldValueClassRepresentationOrBuilder {
+  // Use IrMultiFieldValueClassRepresentation.newBuilder() to construct.
+  private IrMultiFieldValueClassRepresentation(org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder builder) {
+    super(builder);
+    this.unknownFields = builder.getUnknownFields();
+  }
+  private IrMultiFieldValueClassRepresentation(boolean noInit) { this.unknownFields = org.jetbrains.kotlin.protobuf.ByteString.EMPTY;}
+
+  private static final IrMultiFieldValueClassRepresentation defaultInstance;
+  public static IrMultiFieldValueClassRepresentation getDefaultInstance() {
+    return defaultInstance;
+  }
+
+  public IrMultiFieldValueClassRepresentation getDefaultInstanceForType() {
+    return defaultInstance;
+  }
+
+  private final org.jetbrains.kotlin.protobuf.ByteString unknownFields;
+  private IrMultiFieldValueClassRepresentation(
+      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: {
+            if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+              underlyingPropertyName_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000001;
+            }
+            underlyingPropertyName_.add(input.readInt32());
+            break;
+          }
+          case 10: {
+            int length = input.readRawVarint32();
+            int limit = input.pushLimit(length);
+            if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
+              underlyingPropertyName_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000001;
+            }
+            while (input.getBytesUntilLimit() > 0) {
+              underlyingPropertyName_.add(input.readInt32());
+            }
+            input.popLimit(limit);
+            break;
+          }
+          case 16: {
+            if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+              underlyingPropertyType_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000002;
+            }
+            underlyingPropertyType_.add(input.readInt32());
+            break;
+          }
+          case 18: {
+            int length = input.readRawVarint32();
+            int limit = input.pushLimit(length);
+            if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
+              underlyingPropertyType_ = new java.util.ArrayList<java.lang.Integer>();
+              mutable_bitField0_ |= 0x00000002;
+            }
+            while (input.getBytesUntilLimit() > 0) {
+              underlyingPropertyType_.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_ & 0x00000001) == 0x00000001)) {
+        underlyingPropertyName_ = java.util.Collections.unmodifiableList(underlyingPropertyName_);
+      }
+      if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+        underlyingPropertyType_ = java.util.Collections.unmodifiableList(underlyingPropertyType_);
+      }
+      try {
+        unknownFieldsCodedOutput.flush();
+      } catch (java.io.IOException e) {
+      // Should not happen
+      } finally {
+        unknownFields = unknownFieldsOutput.toByteString();
+      }
+      makeExtensionsImmutable();
+    }
+  }
+  public static org.jetbrains.kotlin.protobuf.Parser<IrMultiFieldValueClassRepresentation> PARSER =
+      new org.jetbrains.kotlin.protobuf.AbstractParser<IrMultiFieldValueClassRepresentation>() {
+    public IrMultiFieldValueClassRepresentation parsePartialFrom(
+        org.jetbrains.kotlin.protobuf.CodedInputStream input,
+        org.jetbrains.kotlin.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+      return new IrMultiFieldValueClassRepresentation(input, extensionRegistry);
+    }
+  };
+
+  @java.lang.Override
+  public org.jetbrains.kotlin.protobuf.Parser<IrMultiFieldValueClassRepresentation> getParserForType() {
+    return PARSER;
+  }
+
+  public static final int UNDERLYING_PROPERTY_NAME_FIELD_NUMBER = 1;
+  private java.util.List<java.lang.Integer> underlyingPropertyName_;
+  /**
+   * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+   */
+  public java.util.List<java.lang.Integer>
+      getUnderlyingPropertyNameList() {
+    return underlyingPropertyName_;
+  }
+  /**
+   * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+   */
+  public int getUnderlyingPropertyNameCount() {
+    return underlyingPropertyName_.size();
+  }
+  /**
+   * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+   */
+  public int getUnderlyingPropertyName(int index) {
+    return underlyingPropertyName_.get(index);
+  }
+  private int underlyingPropertyNameMemoizedSerializedSize = -1;
+
+  public static final int UNDERLYING_PROPERTY_TYPE_FIELD_NUMBER = 2;
+  private java.util.List<java.lang.Integer> underlyingPropertyType_;
+  /**
+   * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+   */
+  public java.util.List<java.lang.Integer>
+      getUnderlyingPropertyTypeList() {
+    return underlyingPropertyType_;
+  }
+  /**
+   * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+   */
+  public int getUnderlyingPropertyTypeCount() {
+    return underlyingPropertyType_.size();
+  }
+  /**
+   * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+   */
+  public int getUnderlyingPropertyType(int index) {
+    return underlyingPropertyType_.get(index);
+  }
+  private int underlyingPropertyTypeMemoizedSerializedSize = -1;
+
+  private void initFields() {
+    underlyingPropertyName_ = java.util.Collections.emptyList();
+    underlyingPropertyType_ = 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;
+
+    memoizedIsInitialized = 1;
+    return true;
+  }
+
+  public void writeTo(org.jetbrains.kotlin.protobuf.CodedOutputStream output)
+                      throws java.io.IOException {
+    getSerializedSize();
+    if (getUnderlyingPropertyNameList().size() > 0) {
+      output.writeRawVarint32(10);
+      output.writeRawVarint32(underlyingPropertyNameMemoizedSerializedSize);
+    }
+    for (int i = 0; i < underlyingPropertyName_.size(); i++) {
+      output.writeInt32NoTag(underlyingPropertyName_.get(i));
+    }
+    if (getUnderlyingPropertyTypeList().size() > 0) {
+      output.writeRawVarint32(18);
+      output.writeRawVarint32(underlyingPropertyTypeMemoizedSerializedSize);
+    }
+    for (int i = 0; i < underlyingPropertyType_.size(); i++) {
+      output.writeInt32NoTag(underlyingPropertyType_.get(i));
+    }
+    output.writeRawBytes(unknownFields);
+  }
+
+  private int memoizedSerializedSize = -1;
+  public int getSerializedSize() {
+    int size = memoizedSerializedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    {
+      int dataSize = 0;
+      for (int i = 0; i < underlyingPropertyName_.size(); i++) {
+        dataSize += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeInt32SizeNoTag(underlyingPropertyName_.get(i));
+      }
+      size += dataSize;
+      if (!getUnderlyingPropertyNameList().isEmpty()) {
+        size += 1;
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+            .computeInt32SizeNoTag(dataSize);
+      }
+      underlyingPropertyNameMemoizedSerializedSize = dataSize;
+    }
+    {
+      int dataSize = 0;
+      for (int i = 0; i < underlyingPropertyType_.size(); i++) {
+        dataSize += org.jetbrains.kotlin.protobuf.CodedOutputStream
+          .computeInt32SizeNoTag(underlyingPropertyType_.get(i));
+      }
+      size += dataSize;
+      if (!getUnderlyingPropertyTypeList().isEmpty()) {
+        size += 1;
+        size += org.jetbrains.kotlin.protobuf.CodedOutputStream
+            .computeInt32SizeNoTag(dataSize);
+      }
+      underlyingPropertyTypeMemoizedSerializedSize = dataSize;
+    }
+    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.IrMultiFieldValueClassRepresentation 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.IrMultiFieldValueClassRepresentation 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.IrMultiFieldValueClassRepresentation parseFrom(byte[] data)
+      throws org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation 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.IrMultiFieldValueClassRepresentation parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation 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.IrMultiFieldValueClassRepresentation parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return PARSER.parseDelimitedFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation 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.IrMultiFieldValueClassRepresentation parseFrom(
+      org.jetbrains.kotlin.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return PARSER.parseFrom(input);
+  }
+  public static org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation 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.IrMultiFieldValueClassRepresentation prototype) {
+    return newBuilder().mergeFrom(prototype);
+  }
+  public Builder toBuilder() { return newBuilder(this); }
+
+  /**
+   * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation}
+   */
+  public static final class Builder extends
+      org.jetbrains.kotlin.protobuf.GeneratedMessageLite.Builder<
+        org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation, Builder>
+      implements
+      // @@protoc_insertion_point(builder_implements:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentationOrBuilder {
+    // Construct using org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private void maybeForceBuilderInitialization() {
+    }
+    private static Builder create() {
+      return new Builder();
+    }
+
+    public Builder clear() {
+      super.clear();
+      underlyingPropertyName_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000001);
+      underlyingPropertyType_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000002);
+      return this;
+    }
+
+    public Builder clone() {
+      return create().mergeFrom(buildPartial());
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation getDefaultInstanceForType() {
+      return org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance();
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation build() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    public org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation buildPartial() {
+      org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation result = new org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation(this);
+      int from_bitField0_ = bitField0_;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        underlyingPropertyName_ = java.util.Collections.unmodifiableList(underlyingPropertyName_);
+        bitField0_ = (bitField0_ & ~0x00000001);
+      }
+      result.underlyingPropertyName_ = underlyingPropertyName_;
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        underlyingPropertyType_ = java.util.Collections.unmodifiableList(underlyingPropertyType_);
+        bitField0_ = (bitField0_ & ~0x00000002);
+      }
+      result.underlyingPropertyType_ = underlyingPropertyType_;
+      return result;
+    }
+
+    public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation other) {
+      if (other == org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation.getDefaultInstance()) return this;
+      if (!other.underlyingPropertyName_.isEmpty()) {
+        if (underlyingPropertyName_.isEmpty()) {
+          underlyingPropertyName_ = other.underlyingPropertyName_;
+          bitField0_ = (bitField0_ & ~0x00000001);
+        } else {
+          ensureUnderlyingPropertyNameIsMutable();
+          underlyingPropertyName_.addAll(other.underlyingPropertyName_);
+        }
+        
+      }
+      if (!other.underlyingPropertyType_.isEmpty()) {
+        if (underlyingPropertyType_.isEmpty()) {
+          underlyingPropertyType_ = other.underlyingPropertyType_;
+          bitField0_ = (bitField0_ & ~0x00000002);
+        } else {
+          ensureUnderlyingPropertyTypeIsMutable();
+          underlyingPropertyType_.addAll(other.underlyingPropertyType_);
+        }
+        
+      }
+      setUnknownFields(
+          getUnknownFields().concat(other.unknownFields));
+      return this;
+    }
+
+    public final boolean isInitialized() {
+      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.IrMultiFieldValueClassRepresentation parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation) e.getUnfinishedMessage();
+        throw e;
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+    private int bitField0_;
+
+    private java.util.List<java.lang.Integer> underlyingPropertyName_ = java.util.Collections.emptyList();
+    private void ensureUnderlyingPropertyNameIsMutable() {
+      if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+        underlyingPropertyName_ = new java.util.ArrayList<java.lang.Integer>(underlyingPropertyName_);
+        bitField0_ |= 0x00000001;
+       }
+    }
+    /**
+     * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+     */
+    public java.util.List<java.lang.Integer>
+        getUnderlyingPropertyNameList() {
+      return java.util.Collections.unmodifiableList(underlyingPropertyName_);
+    }
+    /**
+     * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+     */
+    public int getUnderlyingPropertyNameCount() {
+      return underlyingPropertyName_.size();
+    }
+    /**
+     * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+     */
+    public int getUnderlyingPropertyName(int index) {
+      return underlyingPropertyName_.get(index);
+    }
+    /**
+     * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+     */
+    public Builder setUnderlyingPropertyName(
+        int index, int value) {
+      ensureUnderlyingPropertyNameIsMutable();
+      underlyingPropertyName_.set(index, value);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+     */
+    public Builder addUnderlyingPropertyName(int value) {
+      ensureUnderlyingPropertyNameIsMutable();
+      underlyingPropertyName_.add(value);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+     */
+    public Builder addAllUnderlyingPropertyName(
+        java.lang.Iterable<? extends java.lang.Integer> values) {
+      ensureUnderlyingPropertyNameIsMutable();
+      org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+          values, underlyingPropertyName_);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+     */
+    public Builder clearUnderlyingPropertyName() {
+      underlyingPropertyName_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000001);
+      
+      return this;
+    }
+
+    private java.util.List<java.lang.Integer> underlyingPropertyType_ = java.util.Collections.emptyList();
+    private void ensureUnderlyingPropertyTypeIsMutable() {
+      if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+        underlyingPropertyType_ = new java.util.ArrayList<java.lang.Integer>(underlyingPropertyType_);
+        bitField0_ |= 0x00000002;
+       }
+    }
+    /**
+     * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+     */
+    public java.util.List<java.lang.Integer>
+        getUnderlyingPropertyTypeList() {
+      return java.util.Collections.unmodifiableList(underlyingPropertyType_);
+    }
+    /**
+     * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+     */
+    public int getUnderlyingPropertyTypeCount() {
+      return underlyingPropertyType_.size();
+    }
+    /**
+     * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+     */
+    public int getUnderlyingPropertyType(int index) {
+      return underlyingPropertyType_.get(index);
+    }
+    /**
+     * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+     */
+    public Builder setUnderlyingPropertyType(
+        int index, int value) {
+      ensureUnderlyingPropertyTypeIsMutable();
+      underlyingPropertyType_.set(index, value);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+     */
+    public Builder addUnderlyingPropertyType(int value) {
+      ensureUnderlyingPropertyTypeIsMutable();
+      underlyingPropertyType_.add(value);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+     */
+    public Builder addAllUnderlyingPropertyType(
+        java.lang.Iterable<? extends java.lang.Integer> values) {
+      ensureUnderlyingPropertyTypeIsMutable();
+      org.jetbrains.kotlin.protobuf.AbstractMessageLite.Builder.addAll(
+          values, underlyingPropertyType_);
+      
+      return this;
+    }
+    /**
+     * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+     */
+    public Builder clearUnderlyingPropertyType() {
+      underlyingPropertyType_ = java.util.Collections.emptyList();
+      bitField0_ = (bitField0_ & ~0x00000002);
+      
+      return this;
+    }
+
+    // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
+  }
+
+  static {
+    defaultInstance = new IrMultiFieldValueClassRepresentation(true);
+    defaultInstance.initFields();
+  }
+
+  // @@protoc_insertion_point(class_scope:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
+}

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

@@ -0,0 +1,35 @@
+// 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 IrMultiFieldValueClassRepresentationOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:org.jetbrains.kotlin.backend.common.serialization.proto.IrMultiFieldValueClassRepresentation)
+    org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder {
+
+  /**
+   * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+   */
+  java.util.List<java.lang.Integer> getUnderlyingPropertyNameList();
+  /**
+   * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+   */
+  int getUnderlyingPropertyNameCount();
+  /**
+   * <code>repeated int32 underlying_property_name = 1 [packed = true];</code>
+   */
+  int getUnderlyingPropertyName(int index);
+
+  /**
+   * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+   */
+  java.util.List<java.lang.Integer> getUnderlyingPropertyTypeList();
+  /**
+   * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+   */
+  int getUnderlyingPropertyTypeCount();
+  /**
+   * <code>repeated int32 underlying_property_type = 2 [packed = true];</code>
+   */
+  int getUnderlyingPropertyType(int index);
+}