Made IrStatementOrigin serialization field optional for all statements

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

@@ -125,7 +125,6 @@ enum IrSymbolKind {
   TYPE_PARAMETER_SYMBOL = 8;
   VARIABLE_SYMBOL = 9;
   ANONYMOUS_INIT_SYMBOL = 10;
-
   STANDALONE_FIELD_SYMBOL = 11; // For fields without properties. WrappedFieldDescriptor, rather than WrappedPropertyDescriptor.
   RECEIVER_PARAMETER_SYMBOL = 12; // ReceiverParameterDescriptor rather than ValueParameterDescriptor.
 }
@@ -217,7 +216,7 @@ message IrBreak {
 }
 
 message IrBlock {
-  required IrStatementOrigin origin = 1;
+  optional IrStatementOrigin origin = 1;
   repeated IrStatement statement = 2;
 }
 
@@ -238,7 +237,7 @@ message IrCall {
   required IrSymbol symbol = 2;
   required MemberAccessCommon member_access = 3;
   optional IrSymbol super = 4;
-  required IrStatementOrigin origin = 5;
+  optional IrStatementOrigin origin = 5;
 }
 
 message IrConstructorCall {
@@ -249,7 +248,7 @@ message IrConstructorCall {
 
 message IrFunctionReference {
   required IrSymbol symbol = 1;
-  required IrStatementOrigin origin = 2;
+  optional IrStatementOrigin origin = 2;
   required MemberAccessCommon member_access = 3;
 }
 
@@ -258,21 +257,21 @@ message IrLocalDelegatedPropertyReference {
   optional IrSymbol getter = 2;
   optional IrSymbol setter = 3;
   required IrSymbol symbol = 4;
-  required IrStatementOrigin origin = 5;
+  optional IrStatementOrigin origin = 5;
 }
 
 message IrPropertyReference {
   optional IrSymbol field = 1;
   optional IrSymbol getter = 2;
   optional IrSymbol setter = 3;
-  required IrStatementOrigin origin = 4;
+  optional 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;
+  optional IrStatementOrigin origin = 2;
 }
 
 message IrClassReference {
@@ -330,12 +329,12 @@ message FieldAccessCommon {
 
 message IrGetField {
   required FieldAccessCommon field_access = 1;
-  required IrStatementOrigin origin = 2;
+  optional IrStatementOrigin origin = 2;
 }
 
 message IrGetValue {
   required IrSymbol symbol = 1;
-  required IrStatementOrigin origin = 2;
+  optional IrStatementOrigin origin = 2;
 }
 
 message IrGetObject {
@@ -351,7 +350,7 @@ message Loop {
   required IrExpression condition = 2;
   optional String label = 3;
   optional IrExpression body = 4;
-  required IrStatementOrigin origin = 5;
+  optional IrStatementOrigin origin = 5;
 }
 
 message IrReturn {
@@ -362,13 +361,13 @@ message IrReturn {
 message IrSetField {
   required FieldAccessCommon field_access = 1;
   required IrExpression value = 2;
-  required IrStatementOrigin origin = 3;
+  optional IrStatementOrigin origin = 3;
 }
 
 message IrSetVariable {
   required IrSymbol symbol = 1;
   required IrExpression value = 2;
-  required IrStatementOrigin origin = 3;
+  optional IrStatementOrigin origin = 3;
 }
 
 message IrSpreadElement {
@@ -410,7 +409,7 @@ message IrVarargElement {
 
 message IrWhen {
   repeated IrStatement branch = 1;
-  required IrStatementOrigin origin = 2;
+  optional IrStatementOrigin origin = 2;
 }
 
 message IrWhile {

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

@@ -201,7 +201,7 @@ 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)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         statementProtos.forEach {
             statements.add(deserializeStatement(it) as IrStatement)
@@ -263,7 +263,7 @@ abstract class IrModuleDeserializer(
             deserializeIrSymbol(proto.`super`) as IrClassSymbol
         } else null
 
-        val origin = deserializeIrStatementOrigin(proto.origin)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         val call: IrCall = when (proto.kind) {
             KotlinIr.IrCall.Primitive.NOT_PRIMITIVE ->
@@ -289,7 +289,7 @@ 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)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         statementProtos.forEach {
             statements.add(deserializeStatement(it) as IrStatement)
@@ -344,7 +344,7 @@ abstract class IrModuleDeserializer(
     ): IrFunctionReference {
 
         val symbol = deserializeIrSymbol(proto.symbol) as IrFunctionSymbol
-        val origin = deserializeIrStatementOrigin(proto.origin)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
         val callable = IrFunctionReferenceImpl(
             start,
             end,
@@ -368,7 +368,7 @@ 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 origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         val superQualifier = if (access.hasSuper()) {
             deserializeIrSymbol(access.symbol) as IrClassSymbol
@@ -382,7 +382,7 @@ abstract class IrModuleDeserializer(
 
     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)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
         // TODO: origin!
         return IrGetValueImpl(start, end, type, symbol, origin)
     }
@@ -427,7 +427,7 @@ abstract class IrModuleDeserializer(
         val getter = deserializeIrSymbol(proto.getter) as IrSimpleFunctionSymbol
         val setter = if (proto.hasSetter()) deserializeIrSymbol(proto.setter) as IrSimpleFunctionSymbol else null
         val symbol = deserializeIrSymbol(proto.symbol) as IrLocalDelegatedPropertySymbol
-        val origin = deserializeIrStatementOrigin(proto.origin)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         return IrLocalDelegatedPropertyReferenceImpl(
             start, end, type,
@@ -449,7 +449,7 @@ 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 origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         val descriptor =
             if (proto.hasDescriptorReference())
@@ -487,7 +487,7 @@ abstract class IrModuleDeserializer(
             deserializeExpression(access.receiver)
         } else null
         val value = deserializeExpression(proto.value)
-        val origin = deserializeIrStatementOrigin(proto.origin)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         return IrSetFieldImpl(start, end, symbol, receiver, value, builtIns.unitType, origin, superQualifier)
     }
@@ -495,7 +495,7 @@ abstract class IrModuleDeserializer(
     private fun deserializeSetVariable(proto: KotlinIr.IrSetVariable, start: Int, end: Int): IrSetVariable {
         val symbol = deserializeIrSymbol(proto.symbol) as IrVariableSymbol
         val value = deserializeExpression(proto.value)
-        val origin = deserializeIrStatementOrigin(proto.origin)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
         return IrSetVariableImpl(start, end, builtIns.unitType, symbol, value, origin)
     }
 
@@ -588,7 +588,7 @@ 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)
+        val origin = if (proto.hasOrigin()) deserializeIrStatementOrigin(proto.origin) else null
 
         proto.branchList.forEach {
             branches.add(deserializeStatement(it) as IrBranch)
@@ -614,13 +614,13 @@ abstract class IrModuleDeserializer(
     // 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) {
-            val origin = deserializeIrStatementOrigin(proto.loop.origin)
+            val origin = if (proto.loop.hasOrigin()) deserializeIrStatementOrigin(proto.loop.origin) else null
             IrDoWhileLoopImpl(start, end, type, origin)
         })
 
     private fun deserializeWhile(proto: KotlinIr.IrWhile, start: Int, end: Int, type: IrType) =
         deserializeLoop(proto.loop, deserializeLoopHeader(proto.loop.loopId) {
-            val origin = deserializeIrStatementOrigin(proto.loop.origin)
+            val origin = if (proto.loop.hasOrigin()) deserializeIrStatementOrigin(proto.loop.origin) else null
             IrWhileLoopImpl(start, end, type, origin)
         })
 
@@ -1249,11 +1249,10 @@ abstract class IrModuleDeserializer(
     val statementOriginIndex =
         allKnownStatementOrigins.map { it.objectInstance as? IrStatementOriginImpl }.filterNotNull().associateBy { it.debugName }
 
-    fun deserializeIrStatementOrigin(proto: KotlinIr.IrStatementOrigin): IrStatementOrigin? {
+    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())
                 }

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

@@ -61,10 +61,9 @@ 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) =
@@ -297,13 +296,6 @@ 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 {
@@ -323,7 +315,8 @@ open class IrModuleSerializer(
 
     private fun serializeBlock(block: IrBlock): KotlinIr.IrBlock {
         val proto = KotlinIr.IrBlock.newBuilder()
-            .setOrigin(serializeIrStatementOrigin(block.origin))
+
+        block.origin?.let { proto.setOrigin(serializeIrStatementOrigin(it)) }
 
         block.statements.forEach {
             proto.addStatement(serializeStatement(it))
@@ -333,7 +326,8 @@ open class IrModuleSerializer(
 
     private fun serializeComposite(composite: IrComposite): KotlinIr.IrComposite {
         val proto = KotlinIr.IrComposite.newBuilder()
-            .setOrigin(serializeIrStatementOrigin(composite.origin))
+
+        composite.origin?.let { proto.setOrigin(serializeIrStatementOrigin(it)) }
         composite.statements.forEach {
             proto.addStatement(serializeStatement(it))
         }
@@ -397,7 +391,7 @@ open class IrModuleSerializer(
         val proto = KotlinIr.IrCall.newBuilder()
         proto.kind = irCallToPrimitiveKind(call)
         proto.symbol = serializeIrSymbol(call.symbol)
-        proto.origin = serializeStatementOrigin(call.origin)
+        call.origin?.let { proto.origin = serializeIrStatementOrigin(it) }
 
         call.superQualifierSymbol?.let {
             proto.`super` = serializeIrSymbol(it)
@@ -418,8 +412,8 @@ open class IrModuleSerializer(
         val proto = KotlinIr.IrFunctionReference.newBuilder()
             .setSymbol(serializeIrSymbol(callable.symbol))
             .setMemberAccess(serializeMemberAccessCommon(callable))
-            .setOrigin(serializeIrStatementOrigin(callable.origin))
 
+        callable.origin?.let { proto.setOrigin(serializeIrStatementOrigin(it)) }
         return proto.build()
     }
 
@@ -430,8 +424,8 @@ open class IrModuleSerializer(
             .setDelegate(serializeIrSymbol(callable.delegate))
             .setGetter(serializeIrSymbol(callable.getter))
             .setSymbol(serializeIrSymbol(callable.symbol))
-            .setOrigin(serializeIrStatementOrigin(callable.origin))
 
+        callable.origin?.let { proto.setOrigin(serializeIrStatementOrigin(it)) }
         callable.setter?.let { proto.setSetter(serializeIrSymbol(it)) }
 
         return proto.build()
@@ -440,7 +434,7 @@ open class IrModuleSerializer(
     private fun serializePropertyReference(callable: IrPropertyReference): KotlinIr.IrPropertyReference {
         val proto = KotlinIr.IrPropertyReference.newBuilder()
             .setMemberAccess(serializeMemberAccessCommon(callable))
-            .setOrigin(serializeIrStatementOrigin(callable.origin))
+        callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) }
         callable.field?.let { proto.field = serializeIrSymbol(it) }
         callable.getter?.let { proto.getter = serializeIrSymbol(it) }
         callable.setter?.let { proto.setter = serializeIrSymbol(it) }
@@ -515,14 +509,16 @@ open class IrModuleSerializer(
 
     private fun serializeGetField(expression: IrGetField): KotlinIr.IrGetField =
         KotlinIr.IrGetField.newBuilder()
-            .setFieldAccess(serializeFieldAccessCommon(expression))
+            .setFieldAccess(serializeFieldAccessCommon(expression)).apply {
-            .setOrigin(serializeIrStatementOrigin(expression.origin))
+                expression.origin?.let { setOrigin(serializeIrStatementOrigin(it)) }
+            }
             .build()
 
     private fun serializeGetValue(expression: IrGetValue): KotlinIr.IrGetValue =
         KotlinIr.IrGetValue.newBuilder()
-            .setSymbol(serializeIrSymbol(expression.symbol))
+            .setSymbol(serializeIrSymbol(expression.symbol)).apply {
-            .setOrigin(serializeIrStatementOrigin(expression.origin))
+                expression.origin?.let { setOrigin(serializeIrStatementOrigin(it)) }
+            }
             .build()
 
     private fun serializeGetObject(expression: IrGetObjectValue): KotlinIr.IrGetObject {
@@ -549,15 +545,17 @@ open class IrModuleSerializer(
     private fun serializeSetField(expression: IrSetField): KotlinIr.IrSetField =
         KotlinIr.IrSetField.newBuilder()
             .setFieldAccess(serializeFieldAccessCommon(expression))
-            .setValue(serializeExpression(expression.value))
+            .setValue(serializeExpression(expression.value)).apply {
-            .setOrigin(serializeIrStatementOrigin(expression.origin))
+                expression.origin?.let{ setOrigin(serializeIrStatementOrigin(it)) }
+            }
             .build()
 
     private fun serializeSetVariable(expression: IrSetVariable): KotlinIr.IrSetVariable =
         KotlinIr.IrSetVariable.newBuilder()
             .setSymbol(serializeIrSymbol(expression.symbol))
-            .setValue(serializeExpression(expression.value))
+            .setValue(serializeExpression(expression.value)).apply {
-            .setOrigin(serializeIrStatementOrigin(expression.origin))
+                expression.origin?.let{ setOrigin(serializeIrStatementOrigin(it)) }
+            }
             .build()
 
     private fun serializeSpreadElement(element: IrSpreadElement): KotlinIr.IrSpreadElement {
@@ -650,7 +648,8 @@ open class IrModuleSerializer(
 
     private fun serializeWhen(expression: IrWhen): KotlinIr.IrWhen {
         val proto = KotlinIr.IrWhen.newBuilder()
-            .setOrigin(serializeIrStatementOrigin(expression.origin))
+
+        expression.origin?.let{ proto.setOrigin(serializeIrStatementOrigin(it)) }
 
         val branches = expression.branches
         branches.forEach {
@@ -662,8 +661,9 @@ open class IrModuleSerializer(
 
     private fun serializeLoop(expression: IrLoop): KotlinIr.Loop {
         val proto = KotlinIr.Loop.newBuilder()
-            .setCondition(serializeExpression(expression.condition))
+            .setCondition(serializeExpression(expression.condition)).apply {
-            .setOrigin(serializeIrStatementOrigin(expression.origin))
+                expression.origin?.let{ setOrigin(serializeIrStatementOrigin(it)) }
+            }
 
         val label = expression.label?.let { serializeString(it) }
         if (label != null) {