Introduced proper IrStatementOrigin serialization.

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

@@ -217,7 +217,7 @@ message IrBreak {
 }
 
 message IrBlock {
-  required bool is_lambda_origin = 1;
+  required IrStatementOrigin origin = 1;
   repeated IrStatement statement = 2;
 }
 
@@ -238,6 +238,7 @@ message IrCall {
   required IrSymbol symbol = 2;
   required MemberAccessCommon member_access = 3;
   optional IrSymbol super = 4;
+  required IrStatementOrigin origin = 5;
 }
 
 message IrConstructorCall {
@@ -248,7 +249,7 @@ message IrConstructorCall {
 
 message IrFunctionReference {
   required IrSymbol symbol = 1;
-  optional IrStatementOrigin origin = 2;
+  required IrStatementOrigin origin = 2;
   required MemberAccessCommon member_access = 3;
 }
 
@@ -263,13 +264,14 @@ message IrPropertyReference {
   optional IrSymbol field = 1;
   optional IrSymbol getter = 2;
   optional IrSymbol setter = 3;
-  optional IrStatementOrigin origin = 4;
+  required IrStatementOrigin origin = 4;
   required MemberAccessCommon member_access = 5;
   optional DescriptorReference descriptor_reference = 6; // IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
 }
 
 message IrComposite {
   repeated IrStatement statement = 1;
+  required IrStatementOrigin origin = 2;
 }
 
 message IrClassReference {
@@ -327,10 +329,12 @@ message FieldAccessCommon {
 
 message IrGetField {
   required FieldAccessCommon field_access = 1;
+  required IrStatementOrigin origin = 2;
 }
 
 message IrGetValue {
   required IrSymbol symbol = 1;
+  required IrStatementOrigin origin = 2;
 }
 
 message IrGetObject {
@@ -346,6 +350,7 @@ message Loop {
   required IrExpression condition = 2;
   optional String label = 3;
   optional IrExpression body = 4;
+  required IrStatementOrigin origin = 5;
 }
 
 message IrReturn {
@@ -356,11 +361,13 @@ message IrReturn {
 message IrSetField {
   required FieldAccessCommon field_access = 1;
   required IrExpression value = 2;
+  required IrStatementOrigin origin = 3;
 }
 
 message IrSetVariable {
   required IrSymbol symbol = 1;
   required IrExpression value = 2;
+  required IrStatementOrigin origin = 3;
 }
 
 message IrSpreadElement {
@@ -402,6 +409,7 @@ message IrVarargElement {
 
 message IrWhen {
   repeated IrStatement branch = 1;
+  required IrStatementOrigin origin = 2;
 }
 
 message IrWhile {

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

@@ -201,13 +201,13 @@ abstract class IrModuleDeserializer(
     private fun deserializeBlock(proto: KotlinIr.IrBlock, start: Int, end: Int, type: IrType): IrBlock {
         val statements = mutableListOf<IrStatement>()
         val statementProtos = proto.statementList
+        val origin = deserializeIrStatementOrigin(proto.origin)
+
         statementProtos.forEach {
             statements.add(deserializeStatement(it) as IrStatement)
         }
 
-        val isLambdaOrigin = if (proto.isLambdaOrigin) IrStatementOrigin.LAMBDA else null
-
-        return IrBlockImpl(start, end, type, isLambdaOrigin, statements)
+        return IrBlockImpl(start, end, type, origin, statements)
     }
 
     private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression, proto: KotlinIr.MemberAccessCommon) {
@@ -263,6 +263,8 @@ abstract class IrModuleDeserializer(
             deserializeIrSymbol(proto.`super`) as IrClassSymbol
         } else null
 
+        val origin = deserializeIrStatementOrigin(proto.origin)
+
         val call: IrCall = when (proto.kind) {
             KotlinIr.IrCall.Primitive.NOT_PRIMITIVE ->
                 // TODO: implement the last three args here.
@@ -271,12 +273,13 @@ abstract class IrModuleDeserializer(
                     symbol, symbol.descriptor,
                     proto.memberAccess.typeArguments.typeArgumentCount,
                     proto.memberAccess.valueArgumentList.size,
-                    null, superSymbol
+                    origin,
+                    superSymbol
                 )
             KotlinIr.IrCall.Primitive.NULLARY ->
-                IrNullaryPrimitiveImpl(start, end, type, null, symbol)
+                IrNullaryPrimitiveImpl(start, end, type, origin, symbol)
             KotlinIr.IrCall.Primitive.BINARY ->
-                IrBinaryPrimitiveImpl(start, end, type, null, symbol)
+                IrBinaryPrimitiveImpl(start, end, type, origin, symbol)
             else -> TODO("Unexpected primitive IrCall.")
         }
         deserializeMemberAccessCommon(call, proto.memberAccess)
@@ -286,10 +289,12 @@ abstract class IrModuleDeserializer(
     private fun deserializeComposite(proto: KotlinIr.IrComposite, start: Int, end: Int, type: IrType): IrComposite {
         val statements = mutableListOf<IrStatement>()
         val statementProtos = proto.statementList
+        val origin = deserializeIrStatementOrigin(proto.origin)
+
         statementProtos.forEach {
             statements.add(deserializeStatement(it) as IrStatement)
         }
-        return IrCompositeImpl(start, end, type, null, statements)
+        return IrCompositeImpl(start, end, type, origin, statements)
     }
 
     private fun deserializeDelegatingConstructorCall(
@@ -339,6 +344,7 @@ abstract class IrModuleDeserializer(
     ): IrFunctionReference {
 
         val symbol = deserializeIrSymbol(proto.symbol) as IrFunctionSymbol
+        val origin = deserializeIrStatementOrigin(proto.origin)
         val callable = IrFunctionReferenceImpl(
             start,
             end,
@@ -347,7 +353,7 @@ abstract class IrModuleDeserializer(
             symbol.descriptor,
             proto.memberAccess.typeArguments.typeArgumentCount,
             proto.memberAccess.valueArgumentCount,
-            null
+            origin
         )
         deserializeMemberAccessCommon(callable, proto.memberAccess)
 
@@ -362,6 +368,8 @@ abstract class IrModuleDeserializer(
     private fun deserializeGetField(proto: KotlinIr.IrGetField, start: Int, end: Int, type: IrType): IrGetField {
         val access = proto.fieldAccess
         val symbol = deserializeIrSymbol(access.symbol) as IrFieldSymbol
+        val origin = deserializeIrStatementOrigin(proto.origin)
+
         val superQualifier = if (access.hasSuper()) {
             deserializeIrSymbol(access.symbol) as IrClassSymbol
         } else null
@@ -369,21 +377,32 @@ abstract class IrModuleDeserializer(
             deserializeExpression(access.receiver)
         } else null
 
-        return IrGetFieldImpl(start, end, symbol, type, receiver, null, superQualifier)
+        return IrGetFieldImpl(start, end, symbol, type, receiver, origin, superQualifier)
     }
 
     private fun deserializeGetValue(proto: KotlinIr.IrGetValue, start: Int, end: Int, type: IrType): IrGetValue {
         val symbol = deserializeIrSymbol(proto.symbol) as IrValueSymbol
+        val origin = deserializeIrStatementOrigin(proto.origin)
         // TODO: origin!
-        return IrGetValueImpl(start, end, type, symbol, null)
+        return IrGetValueImpl(start, end, type, symbol, origin)
     }
 
-    private fun deserializeGetEnumValue(proto: KotlinIr.IrGetEnumValue, start: Int, end: Int, type: IrType): IrGetEnumValue {
+    private fun deserializeGetEnumValue(
+        proto: KotlinIr.IrGetEnumValue,
+        start: Int,
+        end: Int,
+        type: IrType
+    ): IrGetEnumValue {
         val symbol = deserializeIrSymbol(proto.symbol) as IrEnumEntrySymbol
         return IrGetEnumValueImpl(start, end, type, symbol)
     }
 
-    private fun deserializeGetObject(proto: KotlinIr.IrGetObject, start: Int, end: Int, type: IrType): IrGetObjectValue {
+    private fun deserializeGetObject(
+        proto: KotlinIr.IrGetObject,
+        start: Int,
+        end: Int,
+        type: IrType
+    ): IrGetObjectValue {
         val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol
         return IrGetObjectValueImpl(start, end, type, symbol)
     }
@@ -427,6 +446,8 @@ abstract class IrModuleDeserializer(
         val field = if (proto.hasField()) deserializeIrSymbol(proto.field) as IrFieldSymbol else null
         val getter = if (proto.hasGetter()) deserializeIrSymbol(proto.getter) as IrSimpleFunctionSymbol else null
         val setter = if (proto.hasSetter()) deserializeIrSymbol(proto.setter) as IrSimpleFunctionSymbol else null
+        val origin = deserializeIrStatementOrigin(proto.origin)
+
         val descriptor =
             if (proto.hasDescriptorReference())
                 deserializeDescriptorReference(proto.descriptorReference) as PropertyDescriptor
@@ -441,7 +462,7 @@ abstract class IrModuleDeserializer(
             field,
             getter,
             setter,
-            null
+            origin
         )
         deserializeMemberAccessCommon(callable, proto.memberAccess)
         return callable
@@ -463,14 +484,16 @@ abstract class IrModuleDeserializer(
             deserializeExpression(access.receiver)
         } else null
         val value = deserializeExpression(proto.value)
+        val origin = deserializeIrStatementOrigin(proto.origin)
 
-        return IrSetFieldImpl(start, end, symbol, receiver, value, builtIns.unitType, null, superQualifier)
+        return IrSetFieldImpl(start, end, symbol, receiver, value, builtIns.unitType, origin, superQualifier)
     }
 
     private fun deserializeSetVariable(proto: KotlinIr.IrSetVariable, start: Int, end: Int): IrSetVariable {
         val symbol = deserializeIrSymbol(proto.symbol) as IrVariableSymbol
         val value = deserializeExpression(proto.value)
-        return IrSetVariableImpl(start, end, builtIns.unitType, symbol, value, null)
+        val origin = deserializeIrStatementOrigin(proto.origin)
+        return IrSetVariableImpl(start, end, builtIns.unitType, symbol, value, origin)
     }
 
     private fun deserializeSpreadElement(proto: KotlinIr.IrSpreadElement): IrSpreadElement {
@@ -562,13 +585,14 @@ abstract class IrModuleDeserializer(
 
     private fun deserializeWhen(proto: KotlinIr.IrWhen, start: Int, end: Int, type: IrType): IrWhen {
         val branches = mutableListOf<IrBranch>()
+        val origin = deserializeIrStatementOrigin(proto.origin)
 
         proto.branchList.forEach {
             branches.add(deserializeStatement(it) as IrBranch)
         }
 
         // TODO: provide some origin!
-        return IrWhenImpl(start, end, type, null, branches)
+        return IrWhenImpl(start, end, type, origin, branches)
     }
 
     private fun deserializeLoop(proto: KotlinIr.Loop, loop: IrLoopBase): IrLoopBase {
@@ -586,63 +610,86 @@ abstract class IrModuleDeserializer(
     // we create the loop before deserializing the body, so that
     // IrBreak statements have something to put into 'loop' field.
     private fun deserializeDoWhile(proto: KotlinIr.IrDoWhile, start: Int, end: Int, type: IrType) =
-        deserializeLoop(proto.loop, deserializeLoopHeader(proto.loop.loopId) { IrDoWhileLoopImpl(start, end, type, null) })
+        deserializeLoop(proto.loop, deserializeLoopHeader(proto.loop.loopId) {
+            val origin = deserializeIrStatementOrigin(proto.loop.origin)
+            IrDoWhileLoopImpl(start, end, type, origin)
+        })
 
     private fun deserializeWhile(proto: KotlinIr.IrWhile, start: Int, end: Int, type: IrType) =
-        deserializeLoop(proto.loop, deserializeLoopHeader(proto.loop.loopId) { IrWhileLoopImpl(start, end, type, null) })
+        deserializeLoop(proto.loop, deserializeLoopHeader(proto.loop.loopId) {
+            val origin = deserializeIrStatementOrigin(proto.loop.origin)
+            IrWhileLoopImpl(start, end, type, origin)
+        })
 
-    private fun deserializeDynamicMemberExpression(proto: KotlinIr.IrDynamicMemberExpression, start: Int, end: Int, type: IrType) =
-        IrDynamicMemberExpressionImpl(start, end, type, deserializeString(proto.memberName), deserializeExpression(proto.receiver))
+    private fun deserializeDynamicMemberExpression(
+        proto: KotlinIr.IrDynamicMemberExpression,
+        start: Int,
+        end: Int,
+        type: IrType
+    ) =
+        IrDynamicMemberExpressionImpl(
+            start,
+            end,
+            type,
+            deserializeString(proto.memberName),
+            deserializeExpression(proto.receiver)
+        )
 
-    private fun deserializeDynamicOperatorExpression(proto: KotlinIr.IrDynamicOperatorExpression, start: Int, end: Int, type: IrType) =
+    private fun deserializeDynamicOperatorExpression(
+        proto: KotlinIr.IrDynamicOperatorExpression,
+        start: Int,
+        end: Int,
+        type: IrType
+    ) =
         IrDynamicOperatorExpressionImpl(start, end, type, deserializeDynamicOperator(proto.operator)).apply {
             receiver = deserializeExpression(proto.receiver)
             proto.argumentList.mapTo(arguments) { deserializeExpression(it) }
         }
 
-    private fun deserializeDynamicOperator(operator: KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator) = when (operator) {
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS -> IrDynamicOperator.UNARY_PLUS
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS -> IrDynamicOperator.UNARY_MINUS
+    private fun deserializeDynamicOperator(operator: KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator) =
+        when (operator) {
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS -> IrDynamicOperator.UNARY_PLUS
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS -> IrDynamicOperator.UNARY_MINUS
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCL -> IrDynamicOperator.EXCL
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCL -> IrDynamicOperator.EXCL
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT -> IrDynamicOperator.PREFIX_INCREMENT
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT -> IrDynamicOperator.PREFIX_DECREMENT
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_INCREMENT -> IrDynamicOperator.PREFIX_INCREMENT
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT -> IrDynamicOperator.PREFIX_DECREMENT
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT -> IrDynamicOperator.POSTFIX_INCREMENT
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT -> IrDynamicOperator.POSTFIX_DECREMENT
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT -> IrDynamicOperator.POSTFIX_INCREMENT
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT -> IrDynamicOperator.POSTFIX_DECREMENT
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS -> IrDynamicOperator.BINARY_PLUS
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS -> IrDynamicOperator.BINARY_MINUS
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MUL -> IrDynamicOperator.MUL
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIV -> IrDynamicOperator.DIV
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MOD -> IrDynamicOperator.MOD
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS -> IrDynamicOperator.BINARY_PLUS
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS -> IrDynamicOperator.BINARY_MINUS
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MUL -> IrDynamicOperator.MUL
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIV -> IrDynamicOperator.DIV
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MOD -> IrDynamicOperator.MOD
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GT -> IrDynamicOperator.GT
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LT -> IrDynamicOperator.LT
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GE -> IrDynamicOperator.GE
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LE -> IrDynamicOperator.LE
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GT -> IrDynamicOperator.GT
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LT -> IrDynamicOperator.LT
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GE -> IrDynamicOperator.GE
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LE -> IrDynamicOperator.LE
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ -> IrDynamicOperator.EQEQ
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ -> IrDynamicOperator.EXCLEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ -> IrDynamicOperator.EQEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ -> IrDynamicOperator.EXCLEQ
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ -> IrDynamicOperator.EQEQEQ
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ -> IrDynamicOperator.EXCLEQEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ -> IrDynamicOperator.EQEQEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ -> IrDynamicOperator.EXCLEQEQ
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND -> IrDynamicOperator.ANDAND
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.OROR -> IrDynamicOperator.OROR
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND -> IrDynamicOperator.ANDAND
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.OROR -> IrDynamicOperator.OROR
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQ -> IrDynamicOperator.EQ
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ -> IrDynamicOperator.PLUSEQ
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ -> IrDynamicOperator.MINUSEQ
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ -> IrDynamicOperator.MULEQ
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ -> IrDynamicOperator.DIVEQ
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ -> IrDynamicOperator.MODEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQ -> IrDynamicOperator.EQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ -> IrDynamicOperator.PLUSEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ -> IrDynamicOperator.MINUSEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ -> IrDynamicOperator.MULEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ -> IrDynamicOperator.DIVEQ
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ -> IrDynamicOperator.MODEQ
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS -> IrDynamicOperator.ARRAY_ACCESS
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ARRAY_ACCESS -> IrDynamicOperator.ARRAY_ACCESS
 
-        KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE -> IrDynamicOperator.INVOKE
-    }
+            KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.INVOKE -> IrDynamicOperator.INVOKE
+        }
 
     private fun deserializeBreak(proto: KotlinIr.IrBreak, start: Int, end: Int, type: IrType): IrBreak {
         val label = if (proto.hasLabel()) deserializeString(proto.label) else null
@@ -844,7 +891,12 @@ abstract class IrModuleDeserializer(
         return parameter
     }
 
-    private fun deserializeIrClass(proto: KotlinIr.IrClass, start: Int, end: Int, origin: IrDeclarationOrigin): IrClass {
+    private fun deserializeIrClass(
+        proto: KotlinIr.IrClass,
+        start: Int,
+        end: Int,
+        origin: IrDeclarationOrigin
+    ): IrClass {
 
         val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol
 
@@ -1045,27 +1097,32 @@ abstract class IrModuleDeserializer(
         return constructor
     }
 
-    private fun deserializeIrField(proto: KotlinIr.IrField, start: Int, end: Int, origin: IrDeclarationOrigin): IrField {
+    private fun deserializeIrField(
+        proto: KotlinIr.IrField,
+        start: Int,
+        end: Int,
+        origin: IrDeclarationOrigin
+    ): IrField {
 
         val symbol = deserializeIrSymbol(proto.symbol) as IrFieldSymbol
         val type = deserializeIrType(proto.type)
         val field = symbolTable.declareField(UNDEFINED_OFFSET,
-                                             UNDEFINED_OFFSET,
-                                             irrelevantOrigin,
-                                             symbol.descriptor,
-                                             type,
-                                             {
-                                                 IrFieldImpl(
-                                                     start, end, origin,
-                                                     it,
-                                                     deserializeName(proto.name),
-                                                     type,
-                                                     deserializeVisibility(proto.visibility),
-                                                     proto.isFinal,
-                                                     proto.isExternal,
-                                                     proto.isStatic
-                                                 )
-                                             }
+            UNDEFINED_OFFSET,
+            irrelevantOrigin,
+            symbol.descriptor,
+            type,
+            {
+                IrFieldImpl(
+                    start, end, origin,
+                    it,
+                    deserializeName(proto.name),
+                    type,
+                    deserializeVisibility(proto.visibility),
+                    proto.isFinal,
+                    proto.isExternal,
+                    proto.isStatic
+                )
+            }
         )
 
         val initializer = if (proto.hasInitializer()) deserializeExpression(proto.initializer) else null
@@ -1118,7 +1175,8 @@ abstract class IrModuleDeserializer(
         origin: IrDeclarationOrigin
     ): IrProperty {
 
-        val backingField = if (proto.hasBackingField()) deserializeIrField(proto.backingField, start, end, origin) else null
+        val backingField =
+            if (proto.hasBackingField()) deserializeIrField(proto.backingField, start, end, origin) else null
         val getter = if (proto.hasGetter()) deserializeIrFunction(proto.getter, start, end, origin) else null
         val setter = if (proto.hasSetter()) deserializeIrFunction(proto.setter, start, end, origin) else null
 
@@ -1168,13 +1226,38 @@ abstract class IrModuleDeserializer(
         return IrErrorDeclarationImpl(start, end, WrappedClassDescriptor())
     }
 
-    private val allKnownOrigins =
+    private val allKnownDeclarationOrigins =
         IrDeclarationOrigin::class.nestedClasses.toList() + DeclarationFactory.FIELD_FOR_OUTER_THIS::class
+<<<<<<< HEAD
     val originIndex = allKnownOrigins.map { it.objectInstance as IrDeclarationOriginImpl }.associateBy { it.name }
 
     fun deserializeIrDeclarationOrigin(proto: KotlinIr.IrDeclarationOrigin): IrDeclarationOriginImpl {
         val originName = deserializeString(proto.custom)
         return originIndex[originName] ?: object : IrDeclarationOriginImpl(originName) {}
+=======
+    val declarationOriginIndex =
+        allKnownDeclarationOrigins.map { it.objectInstance as IrDeclarationOriginImpl }.associateBy { it.name }
+
+    fun deserializeIrDeclarationOrigin(proto: KotlinIr.IrDeclarationOrigin) =
+        declarationOriginIndex[deserializeString(proto.custom)]!!
+
+    private val allKnownStatementOrigins =
+        IrStatementOrigin::class.nestedClasses.toList()
+    val statementOriginIndex =
+        allKnownStatementOrigins.map { it.objectInstance as? IrStatementOriginImpl }.filterNotNull().associateBy { it.debugName }
+
+    fun deserializeIrStatementOrigin(proto: KotlinIr.IrStatementOrigin): IrStatementOrigin? {
+        return deserializeString(proto.name).let {
+            val componentPrefix = "COMPONENT_"
+            when {
+                it == "" -> null
+                it.startsWith(componentPrefix) -> {
+                    IrStatementOrigin.COMPONENT_N.withIndex(it.removePrefix(componentPrefix).toInt())
+                }
+                else -> statementOriginIndex[it] ?: error("Unexpected statement origin: $it")
+            }
+        }
+>>>>>>> Introduced proper IrStatementOrigin serialization.
     }
 
     open fun deserializeDeclaration(proto: KotlinIr.IrDeclaration, parent: IrDeclarationParent?): IrDeclaration {

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

@@ -61,9 +61,10 @@ open class IrModuleSerializer(
             .setCustom(serializeString((origin as IrDeclarationOriginImpl).name))
             .build()
 
-    private fun serializeIrStatementOrigin(origin: IrStatementOrigin) =
+    private fun serializeIrStatementOrigin(origin: IrStatementOrigin?) =
         KotlinIr.IrStatementOrigin.newBuilder()
-            .setName(serializeString((origin as IrStatementOriginImpl).debugName))
+            //.setName(serializeString((origin as IrStatementOriginImpl).debugName))
+            .setName(serializeString((origin as IrStatementOriginImpl?)?.debugName ?: ""))
             .build()
 
     private fun serializeVisibility(visibility: Visibility) =
@@ -296,6 +297,13 @@ open class IrModuleSerializer(
 
     /* -------------------------------------------------------------------------- */
 
+    private fun serializeStatementOrigin(origin: IrStatementOrigin?): KotlinIr.IrStatementOrigin {
+        require(origin is IrStatementOriginImpl?)
+        return KotlinIr.IrStatementOrigin.newBuilder()
+            .setName(serializeString(origin?.debugName ?: ""))
+            .build()
+    }
+
     private fun serializeBlockBody(expression: IrBlockBody): KotlinIr.IrBlockBody {
         val proto = KotlinIr.IrBlockBody.newBuilder()
         expression.statements.forEach {
@@ -314,11 +322,9 @@ open class IrModuleSerializer(
     }
 
     private fun serializeBlock(block: IrBlock): KotlinIr.IrBlock {
-        val isLambdaOrigin =
-            block.origin == IrStatementOrigin.LAMBDA ||
-                    block.origin == IrStatementOrigin.ANONYMOUS_FUNCTION
         val proto = KotlinIr.IrBlock.newBuilder()
-            .setIsLambdaOrigin(isLambdaOrigin)
+            .setOrigin(serializeIrStatementOrigin(block.origin))
+
         block.statements.forEach {
             proto.addStatement(serializeStatement(it))
         }
@@ -327,6 +333,7 @@ open class IrModuleSerializer(
 
     private fun serializeComposite(composite: IrComposite): KotlinIr.IrComposite {
         val proto = KotlinIr.IrComposite.newBuilder()
+            .setOrigin(serializeIrStatementOrigin(composite.origin))
         composite.statements.forEach {
             proto.addStatement(serializeStatement(it))
         }
@@ -388,14 +395,15 @@ open class IrModuleSerializer(
 
     private fun serializeCall(call: IrCall): KotlinIr.IrCall {
         val proto = KotlinIr.IrCall.newBuilder()
-
         proto.kind = irCallToPrimitiveKind(call)
         proto.symbol = serializeIrSymbol(call.symbol)
+        proto.origin = serializeStatementOrigin(call.origin)
 
         call.superQualifierSymbol?.let {
             proto.`super` = serializeIrSymbol(it)
         }
         proto.memberAccess = serializeMemberAccessCommon(call)
+
         return proto.build()
     }
 
@@ -410,7 +418,8 @@ open class IrModuleSerializer(
         val proto = KotlinIr.IrFunctionReference.newBuilder()
             .setSymbol(serializeIrSymbol(callable.symbol))
             .setMemberAccess(serializeMemberAccessCommon(callable))
-        callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) }
+            .setOrigin(serializeIrStatementOrigin(callable.origin))
+
         return proto.build()
     }
 
@@ -430,10 +439,11 @@ open class IrModuleSerializer(
     private fun serializePropertyReference(callable: IrPropertyReference): KotlinIr.IrPropertyReference {
         val proto = KotlinIr.IrPropertyReference.newBuilder()
             .setMemberAccess(serializeMemberAccessCommon(callable))
+            .setOrigin(serializeIrStatementOrigin(callable.origin))
         callable.field?.let { proto.field = serializeIrSymbol(it) }
         callable.getter?.let { proto.getter = serializeIrSymbol(it) }
         callable.setter?.let { proto.setter = serializeIrSymbol(it) }
-        callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) }
+
         val property = callable.getter!!.owner.correspondingProperty!!
         descriptorReferenceSerializer.serializeDescriptorReference(property)?.let { proto.setDescriptorReference(it) }
         return proto.build()
@@ -470,12 +480,10 @@ open class IrModuleSerializer(
         return proto.build()
     }
 
-    private fun serializeDoWhile(expression: IrDoWhileLoop): KotlinIr.IrDoWhile {
-        val proto = KotlinIr.IrDoWhile.newBuilder()
+    private fun serializeDoWhile(expression: IrDoWhileLoop): KotlinIr.IrDoWhile  =
+        KotlinIr.IrDoWhile.newBuilder()
             .setLoop(serializeLoop(expression))
-
-        return proto.build()
-    }
+            .build()
 
     fun serializeEnumConstructorCall(call: IrEnumConstructorCall): KotlinIr.IrEnumConstructorCall {
         val proto = KotlinIr.IrEnumConstructorCall.newBuilder()
@@ -504,17 +512,17 @@ open class IrModuleSerializer(
         return proto.build()
     }
 
-    private fun serializeGetField(expression: IrGetField): KotlinIr.IrGetField {
-        val proto = KotlinIr.IrGetField.newBuilder()
+    private fun serializeGetField(expression: IrGetField): KotlinIr.IrGetField =
+        KotlinIr.IrGetField.newBuilder()
             .setFieldAccess(serializeFieldAccessCommon(expression))
-        return proto.build()
-    }
+            .setOrigin(serializeIrStatementOrigin(expression.origin))
+            .build()
 
-    private fun serializeGetValue(expression: IrGetValue): KotlinIr.IrGetValue {
-        val proto = KotlinIr.IrGetValue.newBuilder()
+    private fun serializeGetValue(expression: IrGetValue): KotlinIr.IrGetValue =
+        KotlinIr.IrGetValue.newBuilder()
             .setSymbol(serializeIrSymbol(expression.symbol))
-        return proto.build()
-    }
+            .setOrigin(serializeIrStatementOrigin(expression.origin))
+            .build()
 
     private fun serializeGetObject(expression: IrGetObjectValue): KotlinIr.IrGetObject {
         val proto = KotlinIr.IrGetObject.newBuilder()
@@ -537,19 +545,19 @@ open class IrModuleSerializer(
         return proto.build()
     }
 
-    private fun serializeSetField(expression: IrSetField): KotlinIr.IrSetField {
-        val proto = KotlinIr.IrSetField.newBuilder()
+    private fun serializeSetField(expression: IrSetField): KotlinIr.IrSetField =
+        KotlinIr.IrSetField.newBuilder()
             .setFieldAccess(serializeFieldAccessCommon(expression))
             .setValue(serializeExpression(expression.value))
-        return proto.build()
-    }
+            .setOrigin(serializeIrStatementOrigin(expression.origin))
+            .build()
 
-    private fun serializeSetVariable(expression: IrSetVariable): KotlinIr.IrSetVariable {
-        val proto = KotlinIr.IrSetVariable.newBuilder()
+    private fun serializeSetVariable(expression: IrSetVariable): KotlinIr.IrSetVariable =
+        KotlinIr.IrSetVariable.newBuilder()
             .setSymbol(serializeIrSymbol(expression.symbol))
             .setValue(serializeExpression(expression.value))
-        return proto.build()
-    }
+            .setOrigin(serializeIrStatementOrigin(expression.origin))
+            .build()
 
     private fun serializeSpreadElement(element: IrSpreadElement): KotlinIr.IrSpreadElement {
         val coordinates = serializeCoordinates(element.startOffset, element.endOffset)
@@ -641,6 +649,7 @@ open class IrModuleSerializer(
 
     private fun serializeWhen(expression: IrWhen): KotlinIr.IrWhen {
         val proto = KotlinIr.IrWhen.newBuilder()
+            .setOrigin(serializeIrStatementOrigin(expression.origin))
 
         val branches = expression.branches
         branches.forEach {
@@ -653,6 +662,8 @@ open class IrModuleSerializer(
     private fun serializeLoop(expression: IrLoop): KotlinIr.Loop {
         val proto = KotlinIr.Loop.newBuilder()
             .setCondition(serializeExpression(expression.condition))
+            .setOrigin(serializeIrStatementOrigin(expression.origin))
+
         val label = expression.label?.let { serializeString(it) }
         if (label != null) {
             proto.label = label