diff --git a/compiler/ir/serialization.common/src/KotlinIr.proto b/compiler/ir/serialization.common/src/KotlinIr.proto index 9311b2dc34b..8e9cf88bb04 100644 --- a/compiler/ir/serialization.common/src/KotlinIr.proto +++ b/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 { diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt index 515abd82faa..ec71073a5c9 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt +++ b/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() 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() 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() + 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 { diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleSerializer.kt index 653da0f8bf1..4cb2697558b 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleSerializer.kt +++ b/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 diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java index 1cd9ce53a07..ed2d226753d 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java @@ -16373,13 +16373,13 @@ public final class KotlinIr { org.jetbrains.kotlin.protobuf.MessageLiteOrBuilder { /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - boolean hasIsLambdaOrigin(); + boolean hasOrigin(); /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - boolean getIsLambdaOrigin(); + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); /** * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 2; @@ -16445,9 +16445,17 @@ public final class KotlinIr { } break; } - case 8: { + case 10: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } bitField0_ |= 0x00000001; - isLambdaOrigin_ = input.readBool(); break; } case 18: { @@ -16495,19 +16503,19 @@ public final class KotlinIr { } private int bitField0_; - public static final int IS_LAMBDA_ORIGIN_FIELD_NUMBER = 1; - private boolean isLambdaOrigin_; + public static final int ORIGIN_FIELD_NUMBER = 1; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - public boolean hasIsLambdaOrigin() { + public boolean hasOrigin() { return ((bitField0_ & 0x00000001) == 0x00000001); } /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - public boolean getIsLambdaOrigin() { - return isLambdaOrigin_; + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; } public static final int STATEMENT_FIELD_NUMBER = 2; @@ -16546,7 +16554,7 @@ public final class KotlinIr { } private void initFields() { - isLambdaOrigin_ = false; + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); statement_ = java.util.Collections.emptyList(); } private byte memoizedIsInitialized = -1; @@ -16555,7 +16563,11 @@ public final class KotlinIr { if (isInitialized == 1) return true; if (isInitialized == 0) return false; - if (!hasIsLambdaOrigin()) { + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } + if (!getOrigin().isInitialized()) { memoizedIsInitialized = 0; return false; } @@ -16573,7 +16585,7 @@ public final class KotlinIr { throws java.io.IOException { getSerializedSize(); if (((bitField0_ & 0x00000001) == 0x00000001)) { - output.writeBool(1, isLambdaOrigin_); + output.writeMessage(1, origin_); } for (int i = 0; i < statement_.size(); i++) { output.writeMessage(2, statement_.get(i)); @@ -16589,7 +16601,7 @@ public final class KotlinIr { size = 0; if (((bitField0_ & 0x00000001) == 0x00000001)) { size += org.jetbrains.kotlin.protobuf.CodedOutputStream - .computeBoolSize(1, isLambdaOrigin_); + .computeMessageSize(1, origin_); } for (int i = 0; i < statement_.size(); i++) { size += org.jetbrains.kotlin.protobuf.CodedOutputStream @@ -16689,7 +16701,7 @@ public final class KotlinIr { public Builder clear() { super.clear(); - isLambdaOrigin_ = false; + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000001); statement_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000002); @@ -16719,7 +16731,7 @@ public final class KotlinIr { if (((from_bitField0_ & 0x00000001) == 0x00000001)) { to_bitField0_ |= 0x00000001; } - result.isLambdaOrigin_ = isLambdaOrigin_; + result.origin_ = origin_; if (((bitField0_ & 0x00000002) == 0x00000002)) { statement_ = java.util.Collections.unmodifiableList(statement_); bitField0_ = (bitField0_ & ~0x00000002); @@ -16731,8 +16743,8 @@ public final class KotlinIr { public Builder mergeFrom(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock other) { if (other == org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrBlock.getDefaultInstance()) return this; - if (other.hasIsLambdaOrigin()) { - setIsLambdaOrigin(other.getIsLambdaOrigin()); + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); } if (!other.statement_.isEmpty()) { if (statement_.isEmpty()) { @@ -16750,7 +16762,11 @@ public final class KotlinIr { } public final boolean isInitialized() { - if (!hasIsLambdaOrigin()) { + if (!hasOrigin()) { + + return false; + } + if (!getOrigin().isInitialized()) { return false; } @@ -16782,35 +16798,63 @@ public final class KotlinIr { } private int bitField0_; - private boolean isLambdaOrigin_ ; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - public boolean hasIsLambdaOrigin() { + public boolean hasOrigin() { return ((bitField0_ & 0x00000001) == 0x00000001); } /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - public boolean getIsLambdaOrigin() { - return isLambdaOrigin_; + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; } /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - public Builder setIsLambdaOrigin(boolean value) { + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + bitField0_ |= 0x00000001; - isLambdaOrigin_ = value; - return this; } /** - * required bool is_lambda_origin = 1; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; */ - public Builder clearIsLambdaOrigin() { + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000001; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 1; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000001); - isLambdaOrigin_ = false; - return this; } @@ -17867,6 +17911,15 @@ public final class KotlinIr { * optional .org.jetbrains.kotlin.backend.common.serialization.IrSymbol super = 4; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSuper(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrCall} @@ -17969,6 +18022,19 @@ public final class KotlinIr { bitField0_ |= 0x00000008; break; } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -18128,11 +18194,27 @@ public final class KotlinIr { return super_; } + public static final int ORIGIN_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { kind_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrCall.Primitive.NOT_PRIMITIVE; symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); memberAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.MemberAccessCommon.getDefaultInstance(); super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -18152,6 +18234,10 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!getSymbol().isInitialized()) { memoizedIsInitialized = 0; return false; @@ -18166,6 +18252,10 @@ public final class KotlinIr { return false; } } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -18185,6 +18275,9 @@ public final class KotlinIr { if (((bitField0_ & 0x00000008) == 0x00000008)) { output.writeMessage(4, super_); } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, origin_); + } output.writeRawBytes(unknownFields); } @@ -18210,6 +18303,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(4, super_); } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -18312,6 +18409,8 @@ public final class KotlinIr { bitField0_ = (bitField0_ & ~0x00000004); super_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000008); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); return this; } @@ -18351,6 +18450,10 @@ public final class KotlinIr { to_bitField0_ |= 0x00000008; } result.super_ = super_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.origin_ = origin_; result.bitField0_ = to_bitField0_; return result; } @@ -18369,6 +18472,9 @@ public final class KotlinIr { if (other.hasSuper()) { mergeSuper(other.getSuper()); } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; @@ -18387,6 +18493,10 @@ public final class KotlinIr { return false; } + if (!hasOrigin()) { + + return false; + } if (!getSymbol().isInitialized()) { return false; @@ -18401,6 +18511,10 @@ public final class KotlinIr { return false; } } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -18638,6 +18752,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrCall) } @@ -19283,11 +19457,11 @@ public final class KotlinIr { org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ boolean hasOrigin(); /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); @@ -19441,13 +19615,13 @@ public final class KotlinIr { public static final int ORIGIN_FIELD_NUMBER = 2; private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public boolean hasOrigin() { return ((bitField0_ & 0x00000002) == 0x00000002); } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { return origin_; @@ -19483,6 +19657,10 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!hasMemberAccess()) { memoizedIsInitialized = 0; return false; @@ -19491,11 +19669,9 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } - if (hasOrigin()) { - if (!getOrigin().isInitialized()) { - memoizedIsInitialized = 0; - return false; - } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; } if (!getMemberAccess().isInitialized()) { memoizedIsInitialized = 0; @@ -19698,6 +19874,10 @@ public final class KotlinIr { return false; } + if (!hasOrigin()) { + + return false; + } if (!hasMemberAccess()) { return false; @@ -19706,11 +19886,9 @@ public final class KotlinIr { return false; } - if (hasOrigin()) { - if (!getOrigin().isInitialized()) { - - return false; - } + if (!getOrigin().isInitialized()) { + + return false; } if (!getMemberAccess().isInitialized()) { @@ -19800,19 +19978,19 @@ public final class KotlinIr { private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public boolean hasOrigin() { return ((bitField0_ & 0x00000002) == 0x00000002); } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { return origin_; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { if (value == null) { @@ -19824,7 +20002,7 @@ public final class KotlinIr { return this; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public Builder setOrigin( org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { @@ -19834,7 +20012,7 @@ public final class KotlinIr { return this; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { if (((bitField0_ & 0x00000002) == 0x00000002) && @@ -19849,7 +20027,7 @@ public final class KotlinIr { return this; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; */ public Builder clearOrigin() { origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); @@ -20747,11 +20925,11 @@ public final class KotlinIr { org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSetter(); /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ boolean hasOrigin(); /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); @@ -20991,13 +21169,13 @@ public final class KotlinIr { public static final int ORIGIN_FIELD_NUMBER = 4; private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public boolean hasOrigin() { return ((bitField0_ & 0x00000008) == 0x00000008); } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { return origin_; @@ -21055,6 +21233,10 @@ public final class KotlinIr { if (isInitialized == 1) return true; if (isInitialized == 0) return false; + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!hasMemberAccess()) { memoizedIsInitialized = 0; return false; @@ -21077,11 +21259,9 @@ public final class KotlinIr { return false; } } - if (hasOrigin()) { - if (!getOrigin().isInitialized()) { - memoizedIsInitialized = 0; - return false; - } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; } if (!getMemberAccess().isInitialized()) { memoizedIsInitialized = 0; @@ -21334,6 +21514,10 @@ public final class KotlinIr { } public final boolean isInitialized() { + if (!hasOrigin()) { + + return false; + } if (!hasMemberAccess()) { return false; @@ -21356,11 +21540,9 @@ public final class KotlinIr { return false; } } - if (hasOrigin()) { - if (!getOrigin().isInitialized()) { - - return false; - } + if (!getOrigin().isInitialized()) { + + return false; } if (!getMemberAccess().isInitialized()) { @@ -21576,19 +21758,19 @@ public final class KotlinIr { private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public boolean hasOrigin() { return ((bitField0_ & 0x00000008) == 0x00000008); } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { return origin_; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { if (value == null) { @@ -21600,7 +21782,7 @@ public final class KotlinIr { return this; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public Builder setOrigin( org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { @@ -21610,7 +21792,7 @@ public final class KotlinIr { return this; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { if (((bitField0_ & 0x00000008) == 0x00000008) && @@ -21625,7 +21807,7 @@ public final class KotlinIr { return this; } /** - * optional .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 4; */ public Builder clearOrigin() { origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); @@ -21806,6 +21988,15 @@ public final class KotlinIr { * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement statement = 1; */ int getStatementCount(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrComposite} @@ -21865,6 +22056,19 @@ public final class KotlinIr { statement_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry)); break; } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -21901,6 +22105,7 @@ public final class KotlinIr { return PARSER; } + private int bitField0_; public static final int STATEMENT_FIELD_NUMBER = 1; private java.util.List statement_; /** @@ -21936,8 +22141,24 @@ public final class KotlinIr { return statement_.get(index); } + public static final int ORIGIN_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { statement_ = java.util.Collections.emptyList(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -21945,12 +22166,20 @@ public final class KotlinIr { if (isInitialized == 1) return true; if (isInitialized == 0) return false; + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } for (int i = 0; i < getStatementCount(); i++) { if (!getStatement(i).isInitialized()) { memoizedIsInitialized = 0; return false; } } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -21961,6 +22190,9 @@ public final class KotlinIr { for (int i = 0; i < statement_.size(); i++) { output.writeMessage(1, statement_.get(i)); } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(2, origin_); + } output.writeRawBytes(unknownFields); } @@ -21974,6 +22206,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(1, statement_.get(i)); } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -22070,6 +22306,8 @@ public final class KotlinIr { super.clear(); statement_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000001); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); return this; } @@ -22092,11 +22330,17 @@ public final class KotlinIr { public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite buildPartial() { org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrComposite(this); int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; if (((bitField0_ & 0x00000001) == 0x00000001)) { statement_ = java.util.Collections.unmodifiableList(statement_); bitField0_ = (bitField0_ & ~0x00000001); } result.statement_ = statement_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000001; + } + result.origin_ = origin_; + result.bitField0_ = to_bitField0_; return result; } @@ -22112,18 +22356,29 @@ public final class KotlinIr { } } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; } public final boolean isInitialized() { + if (!hasOrigin()) { + + return false; + } for (int i = 0; i < getStatementCount(); i++) { if (!getStatement(i).isInitialized()) { return false; } } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -22271,6 +22526,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrComposite) } @@ -27469,6 +27784,15 @@ public final class KotlinIr { * required .org.jetbrains.kotlin.backend.common.serialization.FieldAccessCommon field_access = 1; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon getFieldAccess(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetField} @@ -27533,6 +27857,19 @@ public final class KotlinIr { bitField0_ |= 0x00000001; break; } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -27582,8 +27919,24 @@ public final class KotlinIr { return fieldAccess_; } + public static final int ORIGIN_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -27595,10 +27948,18 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!getFieldAccess().isInitialized()) { memoizedIsInitialized = 0; return false; } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -27609,6 +27970,9 @@ public final class KotlinIr { if (((bitField0_ & 0x00000001) == 0x00000001)) { output.writeMessage(1, fieldAccess_); } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, origin_); + } output.writeRawBytes(unknownFields); } @@ -27622,6 +27986,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(1, fieldAccess_); } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -27718,6 +28086,8 @@ public final class KotlinIr { super.clear(); fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000001); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); return this; } @@ -27745,6 +28115,10 @@ public final class KotlinIr { to_bitField0_ |= 0x00000001; } result.fieldAccess_ = fieldAccess_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.origin_ = origin_; result.bitField0_ = to_bitField0_; return result; } @@ -27754,6 +28128,9 @@ public final class KotlinIr { if (other.hasFieldAccess()) { mergeFieldAccess(other.getFieldAccess()); } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; @@ -27764,10 +28141,18 @@ public final class KotlinIr { return false; } + if (!hasOrigin()) { + + return false; + } if (!getFieldAccess().isInitialized()) { return false; } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -27850,6 +28235,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetField) } @@ -27873,6 +28318,15 @@ public final class KotlinIr { * required .org.jetbrains.kotlin.backend.common.serialization.IrSymbol symbol = 1; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol getSymbol(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrGetValue} @@ -27937,6 +28391,19 @@ public final class KotlinIr { bitField0_ |= 0x00000001; break; } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -27986,8 +28453,24 @@ public final class KotlinIr { return symbol_; } + public static final int ORIGIN_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -27999,10 +28482,18 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!getSymbol().isInitialized()) { memoizedIsInitialized = 0; return false; } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -28013,6 +28504,9 @@ public final class KotlinIr { if (((bitField0_ & 0x00000001) == 0x00000001)) { output.writeMessage(1, symbol_); } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(2, origin_); + } output.writeRawBytes(unknownFields); } @@ -28026,6 +28520,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(1, symbol_); } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -28122,6 +28620,8 @@ public final class KotlinIr { super.clear(); symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000001); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); return this; } @@ -28149,6 +28649,10 @@ public final class KotlinIr { to_bitField0_ |= 0x00000001; } result.symbol_ = symbol_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.origin_ = origin_; result.bitField0_ = to_bitField0_; return result; } @@ -28158,6 +28662,9 @@ public final class KotlinIr { if (other.hasSymbol()) { mergeSymbol(other.getSymbol()); } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; @@ -28168,10 +28675,18 @@ public final class KotlinIr { return false; } + if (!hasOrigin()) { + + return false; + } if (!getSymbol().isInitialized()) { return false; } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -28254,6 +28769,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrGetValue) } @@ -29112,6 +29687,15 @@ public final class KotlinIr { * optional .org.jetbrains.kotlin.backend.common.serialization.IrExpression body = 4; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getBody(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.Loop} @@ -29207,6 +29791,19 @@ public final class KotlinIr { bitField0_ |= 0x00000008; break; } + case 42: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -29301,11 +29898,27 @@ public final class KotlinIr { return body_; } + public static final int ORIGIN_FIELD_NUMBER = 5; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { loopId_ = 0; condition_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); label_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.String.getDefaultInstance(); body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -29321,6 +29934,10 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!getCondition().isInitialized()) { memoizedIsInitialized = 0; return false; @@ -29337,6 +29954,10 @@ public final class KotlinIr { return false; } } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -29356,6 +29977,9 @@ public final class KotlinIr { if (((bitField0_ & 0x00000008) == 0x00000008)) { output.writeMessage(4, body_); } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeMessage(5, origin_); + } output.writeRawBytes(unknownFields); } @@ -29381,6 +30005,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(4, body_); } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(5, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -29483,6 +30111,8 @@ public final class KotlinIr { bitField0_ = (bitField0_ & ~0x00000004); body_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000008); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000010); return this; } @@ -29522,6 +30152,10 @@ public final class KotlinIr { to_bitField0_ |= 0x00000008; } result.body_ = body_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000010; + } + result.origin_ = origin_; result.bitField0_ = to_bitField0_; return result; } @@ -29540,6 +30174,9 @@ public final class KotlinIr { if (other.hasBody()) { mergeBody(other.getBody()); } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; @@ -29554,6 +30191,10 @@ public final class KotlinIr { return false; } + if (!hasOrigin()) { + + return false; + } if (!getCondition().isInitialized()) { return false; @@ -29570,6 +30211,10 @@ public final class KotlinIr { return false; } } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -29804,6 +30449,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000010) == 0x00000010) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000010; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 5; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.Loop) } @@ -30370,6 +31075,15 @@ public final class KotlinIr { * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSetField} @@ -30447,6 +31161,19 @@ public final class KotlinIr { bitField0_ |= 0x00000002; break; } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -30511,9 +31238,25 @@ public final class KotlinIr { return value_; } + public static final int ORIGIN_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { fieldAccess_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.FieldAccessCommon.getDefaultInstance(); value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -30529,6 +31272,10 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!getFieldAccess().isInitialized()) { memoizedIsInitialized = 0; return false; @@ -30537,6 +31284,10 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -30550,6 +31301,9 @@ public final class KotlinIr { if (((bitField0_ & 0x00000002) == 0x00000002)) { output.writeMessage(2, value_); } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, origin_); + } output.writeRawBytes(unknownFields); } @@ -30567,6 +31321,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(2, value_); } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -30665,6 +31423,8 @@ public final class KotlinIr { bitField0_ = (bitField0_ & ~0x00000001); value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000002); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); return this; } @@ -30696,6 +31456,10 @@ public final class KotlinIr { to_bitField0_ |= 0x00000002; } result.value_ = value_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.origin_ = origin_; result.bitField0_ = to_bitField0_; return result; } @@ -30708,6 +31472,9 @@ public final class KotlinIr { if (other.hasValue()) { mergeValue(other.getValue()); } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; @@ -30722,6 +31489,10 @@ public final class KotlinIr { return false; } + if (!hasOrigin()) { + + return false; + } if (!getFieldAccess().isInitialized()) { return false; @@ -30730,6 +31501,10 @@ public final class KotlinIr { return false; } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -30872,6 +31647,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSetField) } @@ -30904,6 +31739,15 @@ public final class KotlinIr { * required .org.jetbrains.kotlin.backend.common.serialization.IrExpression value = 2; */ org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression getValue(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrSetVariable} @@ -30981,6 +31825,19 @@ public final class KotlinIr { bitField0_ |= 0x00000002; break; } + case 26: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -31045,9 +31902,25 @@ public final class KotlinIr { return value_; } + public static final int ORIGIN_FIELD_NUMBER = 3; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { symbol_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrSymbol.getDefaultInstance(); value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -31063,6 +31936,10 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } if (!getSymbol().isInitialized()) { memoizedIsInitialized = 0; return false; @@ -31071,6 +31948,10 @@ public final class KotlinIr { memoizedIsInitialized = 0; return false; } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -31084,6 +31965,9 @@ public final class KotlinIr { if (((bitField0_ & 0x00000002) == 0x00000002)) { output.writeMessage(2, value_); } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, origin_); + } output.writeRawBytes(unknownFields); } @@ -31101,6 +31985,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(2, value_); } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(3, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -31199,6 +32087,8 @@ public final class KotlinIr { bitField0_ = (bitField0_ & ~0x00000001); value_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrExpression.getDefaultInstance(); bitField0_ = (bitField0_ & ~0x00000002); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000004); return this; } @@ -31230,6 +32120,10 @@ public final class KotlinIr { to_bitField0_ |= 0x00000002; } result.value_ = value_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.origin_ = origin_; result.bitField0_ = to_bitField0_; return result; } @@ -31242,6 +32136,9 @@ public final class KotlinIr { if (other.hasValue()) { mergeValue(other.getValue()); } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; @@ -31256,6 +32153,10 @@ public final class KotlinIr { return false; } + if (!hasOrigin()) { + + return false; + } if (!getSymbol().isInitialized()) { return false; @@ -31264,6 +32165,10 @@ public final class KotlinIr { return false; } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -31406,6 +32311,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000004; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 3; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrSetVariable) } @@ -35458,6 +36423,15 @@ public final class KotlinIr { * repeated .org.jetbrains.kotlin.backend.common.serialization.IrStatement branch = 1; */ int getBranchCount(); + + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + boolean hasOrigin(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin(); } /** * Protobuf type {@code org.jetbrains.kotlin.backend.common.serialization.IrWhen} @@ -35517,6 +36491,19 @@ public final class KotlinIr { branch_.add(input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatement.PARSER, extensionRegistry)); break; } + case 18: { + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + subBuilder = origin_.toBuilder(); + } + origin_ = input.readMessage(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(origin_); + origin_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } } } } catch (org.jetbrains.kotlin.protobuf.InvalidProtocolBufferException e) { @@ -35553,6 +36540,7 @@ public final class KotlinIr { return PARSER; } + private int bitField0_; public static final int BRANCH_FIELD_NUMBER = 1; private java.util.List branch_; /** @@ -35588,8 +36576,24 @@ public final class KotlinIr { return branch_.get(index); } + public static final int ORIGIN_FIELD_NUMBER = 2; + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_; + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + private void initFields() { branch_ = java.util.Collections.emptyList(); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { @@ -35597,12 +36601,20 @@ public final class KotlinIr { if (isInitialized == 1) return true; if (isInitialized == 0) return false; + if (!hasOrigin()) { + memoizedIsInitialized = 0; + return false; + } for (int i = 0; i < getBranchCount(); i++) { if (!getBranch(i).isInitialized()) { memoizedIsInitialized = 0; return false; } } + if (!getOrigin().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } memoizedIsInitialized = 1; return true; } @@ -35613,6 +36625,9 @@ public final class KotlinIr { for (int i = 0; i < branch_.size(); i++) { output.writeMessage(1, branch_.get(i)); } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(2, origin_); + } output.writeRawBytes(unknownFields); } @@ -35626,6 +36641,10 @@ public final class KotlinIr { size += org.jetbrains.kotlin.protobuf.CodedOutputStream .computeMessageSize(1, branch_.get(i)); } + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += org.jetbrains.kotlin.protobuf.CodedOutputStream + .computeMessageSize(2, origin_); + } size += unknownFields.size(); memoizedSerializedSize = size; return size; @@ -35722,6 +36741,8 @@ public final class KotlinIr { super.clear(); branch_ = java.util.Collections.emptyList(); bitField0_ = (bitField0_ & ~0x00000001); + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + bitField0_ = (bitField0_ & ~0x00000002); return this; } @@ -35744,11 +36765,17 @@ public final class KotlinIr { public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen buildPartial() { org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen result = new org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrWhen(this); int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; if (((bitField0_ & 0x00000001) == 0x00000001)) { branch_ = java.util.Collections.unmodifiableList(branch_); bitField0_ = (bitField0_ & ~0x00000001); } result.branch_ = branch_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000001; + } + result.origin_ = origin_; + result.bitField0_ = to_bitField0_; return result; } @@ -35764,18 +36791,29 @@ public final class KotlinIr { } } + if (other.hasOrigin()) { + mergeOrigin(other.getOrigin()); + } setUnknownFields( getUnknownFields().concat(other.unknownFields)); return this; } public final boolean isInitialized() { + if (!hasOrigin()) { + + return false; + } for (int i = 0; i < getBranchCount(); i++) { if (!getBranch(i).isInitialized()) { return false; } } + if (!getOrigin().isInitialized()) { + + return false; + } return true; } @@ -35923,6 +36961,66 @@ public final class KotlinIr { return this; } + private org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public boolean hasOrigin() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin getOrigin() { + return origin_; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (value == null) { + throw new NullPointerException(); + } + origin_ = value; + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder setOrigin( + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.Builder builderForValue) { + origin_ = builderForValue.build(); + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder mergeOrigin(org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin value) { + if (((bitField0_ & 0x00000002) == 0x00000002) && + origin_ != org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance()) { + origin_ = + org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.newBuilder(origin_).mergeFrom(value).buildPartial(); + } else { + origin_ = value; + } + + bitField0_ |= 0x00000002; + return this; + } + /** + * required .org.jetbrains.kotlin.backend.common.serialization.IrStatementOrigin origin = 2; + */ + public Builder clearOrigin() { + origin_ = org.jetbrains.kotlin.backend.common.serialization.KotlinIr.IrStatementOrigin.getDefaultInstance(); + + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + // @@protoc_insertion_point(builder_scope:org.jetbrains.kotlin.backend.common.serialization.IrWhen) }