azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduced proper IrStatementOrigin serialization.

Browse Source
This commit is contained in:
Alexander Gorshenev
2019-04-24 03:58:02 +03:00
committed by alexander-gorshenev
parent 0794ab9432
commit 19bd01cc8a
4 changed files with 1382 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/ir/serialization.common/src/KotlinIr.proto
+11 -3
View File
@@ -217,7 +217,7 @@ message IrBreak {
} }
message IrBlock { message IrBlock {
required bool is_lambda_origin = 1; required IrStatementOrigin origin = 1;
repeated IrStatement statement = 2; repeated IrStatement statement = 2;
} }
@@ -238,6 +238,7 @@ message IrCall {
required IrSymbol symbol = 2; required IrSymbol symbol = 2;
required MemberAccessCommon member_access = 3; required MemberAccessCommon member_access = 3;
optional IrSymbol super = 4; optional IrSymbol super = 4;
required IrStatementOrigin origin = 5;
} }
message IrConstructorCall { message IrConstructorCall {
@@ -248,7 +249,7 @@ message IrConstructorCall {
message IrFunctionReference { message IrFunctionReference {
required IrSymbol symbol = 1; required IrSymbol symbol = 1;
optional IrStatementOrigin origin = 2; required IrStatementOrigin origin = 2;
required MemberAccessCommon member_access = 3; required MemberAccessCommon member_access = 3;
} }
@@ -263,13 +264,14 @@ message IrPropertyReference {
optional IrSymbol field = 1; optional IrSymbol field = 1;
optional IrSymbol getter = 2; optional IrSymbol getter = 2;
optional IrSymbol setter = 3; optional IrSymbol setter = 3;
optional IrStatementOrigin origin = 4; required IrStatementOrigin origin = 4;
required MemberAccessCommon member_access = 5; required MemberAccessCommon member_access = 5;
optional DescriptorReference descriptor_reference = 6; // IrProperty doesn't have a symbol at all. Preserve this rudiment for now. optional DescriptorReference descriptor_reference = 6; // IrProperty doesn't have a symbol at all. Preserve this rudiment for now.
} }
message IrComposite { message IrComposite {
repeated IrStatement statement = 1; repeated IrStatement statement = 1;
required IrStatementOrigin origin = 2;
} }
message IrClassReference { message IrClassReference {
@@ -327,10 +329,12 @@ message FieldAccessCommon {
message IrGetField { message IrGetField {
required FieldAccessCommon field_access = 1; required FieldAccessCommon field_access = 1;
required IrStatementOrigin origin = 2;
} }
message IrGetValue { message IrGetValue {
required IrSymbol symbol = 1; required IrSymbol symbol = 1;
required IrStatementOrigin origin = 2;
} }
message IrGetObject { message IrGetObject {
@@ -346,6 +350,7 @@ message Loop {
required IrExpression condition = 2; required IrExpression condition = 2;
optional String label = 3; optional String label = 3;
optional IrExpression body = 4; optional IrExpression body = 4;
required IrStatementOrigin origin = 5;
} }
message IrReturn { message IrReturn {
@@ -356,11 +361,13 @@ message IrReturn {
message IrSetField { message IrSetField {
required FieldAccessCommon field_access = 1; required FieldAccessCommon field_access = 1;
required IrExpression value = 2; required IrExpression value = 2;
required IrStatementOrigin origin = 3;
} }
message IrSetVariable { message IrSetVariable {
required IrSymbol symbol = 1; required IrSymbol symbol = 1;
required IrExpression value = 2; required IrExpression value = 2;
required IrStatementOrigin origin = 3;
} }
message IrSpreadElement { message IrSpreadElement {
@@ -402,6 +409,7 @@ message IrVarargElement {
message IrWhen { message IrWhen {
repeated IrStatement branch = 1; repeated IrStatement branch = 1;
required IrStatementOrigin origin = 2;
} }
message IrWhile { message IrWhile {
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt
+156 -73
View File
@@ -201,13 +201,13 @@ abstract class IrModuleDeserializer(
private fun deserializeBlock(proto: KotlinIr.IrBlock, start: Int, end: Int, type: IrType): IrBlock { private fun deserializeBlock(proto: KotlinIr.IrBlock, start: Int, end: Int, type: IrType): IrBlock {
val statements = mutableListOf<IrStatement>() val statements = mutableListOf<IrStatement>()
val statementProtos = proto.statementList val statementProtos = proto.statementList
val origin = deserializeIrStatementOrigin(proto.origin)
statementProtos.forEach { statementProtos.forEach {
statements.add(deserializeStatement(it) as IrStatement) statements.add(deserializeStatement(it) as IrStatement)
} }
val isLambdaOrigin = if (proto.isLambdaOrigin) IrStatementOrigin.LAMBDA else null return IrBlockImpl(start, end, type, origin, statements)
return IrBlockImpl(start, end, type, isLambdaOrigin, statements)
} }
private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression, proto: KotlinIr.MemberAccessCommon) { private fun deserializeMemberAccessCommon(access: IrMemberAccessExpression, proto: KotlinIr.MemberAccessCommon) {
@@ -263,6 +263,8 @@ abstract class IrModuleDeserializer(
deserializeIrSymbol(proto.`super`) as IrClassSymbol deserializeIrSymbol(proto.`super`) as IrClassSymbol
} else null } else null
val origin = deserializeIrStatementOrigin(proto.origin)
val call: IrCall = when (proto.kind) { val call: IrCall = when (proto.kind) {
KotlinIr.IrCall.Primitive.NOT_PRIMITIVE -> KotlinIr.IrCall.Primitive.NOT_PRIMITIVE ->
// TODO: implement the last three args here. // TODO: implement the last three args here.
@@ -271,12 +273,13 @@ abstract class IrModuleDeserializer(
symbol, symbol.descriptor, symbol, symbol.descriptor,
proto.memberAccess.typeArguments.typeArgumentCount, proto.memberAccess.typeArguments.typeArgumentCount,
proto.memberAccess.valueArgumentList.size, proto.memberAccess.valueArgumentList.size,
null, superSymbol origin,
superSymbol
) )
KotlinIr.IrCall.Primitive.NULLARY -> KotlinIr.IrCall.Primitive.NULLARY ->
IrNullaryPrimitiveImpl(start, end, type, null, symbol) IrNullaryPrimitiveImpl(start, end, type, origin, symbol)
KotlinIr.IrCall.Primitive.BINARY -> KotlinIr.IrCall.Primitive.BINARY ->
IrBinaryPrimitiveImpl(start, end, type, null, symbol) IrBinaryPrimitiveImpl(start, end, type, origin, symbol)
else -> TODO("Unexpected primitive IrCall.") else -> TODO("Unexpected primitive IrCall.")
} }
deserializeMemberAccessCommon(call, proto.memberAccess) deserializeMemberAccessCommon(call, proto.memberAccess)
@@ -286,10 +289,12 @@ abstract class IrModuleDeserializer(
private fun deserializeComposite(proto: KotlinIr.IrComposite, start: Int, end: Int, type: IrType): IrComposite { private fun deserializeComposite(proto: KotlinIr.IrComposite, start: Int, end: Int, type: IrType): IrComposite {
val statements = mutableListOf<IrStatement>() val statements = mutableListOf<IrStatement>()
val statementProtos = proto.statementList val statementProtos = proto.statementList
val origin = deserializeIrStatementOrigin(proto.origin)
statementProtos.forEach { statementProtos.forEach {
statements.add(deserializeStatement(it) as IrStatement) statements.add(deserializeStatement(it) as IrStatement)
} }
return IrCompositeImpl(start, end, type, null, statements) return IrCompositeImpl(start, end, type, origin, statements)
} }
private fun deserializeDelegatingConstructorCall( private fun deserializeDelegatingConstructorCall(
@@ -339,6 +344,7 @@ abstract class IrModuleDeserializer(
): IrFunctionReference { ): IrFunctionReference {
val symbol = deserializeIrSymbol(proto.symbol) as IrFunctionSymbol val symbol = deserializeIrSymbol(proto.symbol) as IrFunctionSymbol
val origin = deserializeIrStatementOrigin(proto.origin)
val callable = IrFunctionReferenceImpl( val callable = IrFunctionReferenceImpl(
start, start,
end, end,
@@ -347,7 +353,7 @@ abstract class IrModuleDeserializer(
symbol.descriptor, symbol.descriptor,
proto.memberAccess.typeArguments.typeArgumentCount, proto.memberAccess.typeArguments.typeArgumentCount,
proto.memberAccess.valueArgumentCount, proto.memberAccess.valueArgumentCount,
null origin
) )
deserializeMemberAccessCommon(callable, proto.memberAccess) deserializeMemberAccessCommon(callable, proto.memberAccess)
@@ -362,6 +368,8 @@ abstract class IrModuleDeserializer(
private fun deserializeGetField(proto: KotlinIr.IrGetField, start: Int, end: Int, type: IrType): IrGetField { private fun deserializeGetField(proto: KotlinIr.IrGetField, start: Int, end: Int, type: IrType): IrGetField {
val access = proto.fieldAccess val access = proto.fieldAccess
val symbol = deserializeIrSymbol(access.symbol) as IrFieldSymbol val symbol = deserializeIrSymbol(access.symbol) as IrFieldSymbol
val origin = deserializeIrStatementOrigin(proto.origin)
val superQualifier = if (access.hasSuper()) { val superQualifier = if (access.hasSuper()) {
deserializeIrSymbol(access.symbol) as IrClassSymbol deserializeIrSymbol(access.symbol) as IrClassSymbol
} else null } else null
@@ -369,21 +377,32 @@ abstract class IrModuleDeserializer(
deserializeExpression(access.receiver) deserializeExpression(access.receiver)
} else null } 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 { private fun deserializeGetValue(proto: KotlinIr.IrGetValue, start: Int, end: Int, type: IrType): IrGetValue {
val symbol = deserializeIrSymbol(proto.symbol) as IrValueSymbol val symbol = deserializeIrSymbol(proto.symbol) as IrValueSymbol
val origin = deserializeIrStatementOrigin(proto.origin)
// TODO: 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 val symbol = deserializeIrSymbol(proto.symbol) as IrEnumEntrySymbol
return IrGetEnumValueImpl(start, end, type, symbol) 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 val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol
return IrGetObjectValueImpl(start, end, type, symbol) 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 field = if (proto.hasField()) deserializeIrSymbol(proto.field) as IrFieldSymbol else null
val getter = if (proto.hasGetter()) deserializeIrSymbol(proto.getter) as IrSimpleFunctionSymbol 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 setter = if (proto.hasSetter()) deserializeIrSymbol(proto.setter) as IrSimpleFunctionSymbol else null
val origin = deserializeIrStatementOrigin(proto.origin)
val descriptor = val descriptor =
if (proto.hasDescriptorReference()) if (proto.hasDescriptorReference())
deserializeDescriptorReference(proto.descriptorReference) as PropertyDescriptor deserializeDescriptorReference(proto.descriptorReference) as PropertyDescriptor
@@ -441,7 +462,7 @@ abstract class IrModuleDeserializer(
field, field,
getter, getter,
setter, setter,
null origin
) )
deserializeMemberAccessCommon(callable, proto.memberAccess) deserializeMemberAccessCommon(callable, proto.memberAccess)
return callable return callable
@@ -463,14 +484,16 @@ abstract class IrModuleDeserializer(
deserializeExpression(access.receiver) deserializeExpression(access.receiver)
} else null } else null
val value = deserializeExpression(proto.value) 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 { private fun deserializeSetVariable(proto: KotlinIr.IrSetVariable, start: Int, end: Int): IrSetVariable {
val symbol = deserializeIrSymbol(proto.symbol) as IrVariableSymbol val symbol = deserializeIrSymbol(proto.symbol) as IrVariableSymbol
val value = deserializeExpression(proto.value) 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 { 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 { private fun deserializeWhen(proto: KotlinIr.IrWhen, start: Int, end: Int, type: IrType): IrWhen {
val branches = mutableListOf<IrBranch>() val branches = mutableListOf<IrBranch>()
val origin = deserializeIrStatementOrigin(proto.origin)
proto.branchList.forEach { proto.branchList.forEach {
branches.add(deserializeStatement(it) as IrBranch) branches.add(deserializeStatement(it) as IrBranch)
} }
// TODO: provide some origin! // 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 { 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 // we create the loop before deserializing the body, so that
// IrBreak statements have something to put into 'loop' field. // IrBreak statements have something to put into 'loop' field.
private fun deserializeDoWhile(proto: KotlinIr.IrDoWhile, start: Int, end: Int, type: IrType) = 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) = 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) = private fun deserializeDynamicMemberExpression(
IrDynamicMemberExpressionImpl(start, end, type, deserializeString(proto.memberName), deserializeExpression(proto.receiver)) 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 { IrDynamicOperatorExpressionImpl(start, end, type, deserializeDynamicOperator(proto.operator)).apply {
receiver = deserializeExpression(proto.receiver) receiver = deserializeExpression(proto.receiver)
proto.argumentList.mapTo(arguments) { deserializeExpression(it) } proto.argumentList.mapTo(arguments) { deserializeExpression(it) }
} }
private fun deserializeDynamicOperator(operator: KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator) = when (operator) { private fun deserializeDynamicOperator(operator: KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator) =
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_PLUS -> IrDynamicOperator.UNARY_PLUS when (operator) {
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.UNARY_MINUS -> IrDynamicOperator.UNARY_MINUS 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_INCREMENT -> IrDynamicOperator.PREFIX_INCREMENT
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT -> IrDynamicOperator.PREFIX_DECREMENT KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PREFIX_DECREMENT -> IrDynamicOperator.PREFIX_DECREMENT
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT -> IrDynamicOperator.POSTFIX_INCREMENT KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_INCREMENT -> IrDynamicOperator.POSTFIX_INCREMENT
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT -> IrDynamicOperator.POSTFIX_DECREMENT KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.POSTFIX_DECREMENT -> IrDynamicOperator.POSTFIX_DECREMENT
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS -> IrDynamicOperator.BINARY_PLUS KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_PLUS -> IrDynamicOperator.BINARY_PLUS
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS -> IrDynamicOperator.BINARY_MINUS KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.BINARY_MINUS -> IrDynamicOperator.BINARY_MINUS
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MUL -> IrDynamicOperator.MUL KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MUL -> IrDynamicOperator.MUL
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIV -> IrDynamicOperator.DIV KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIV -> IrDynamicOperator.DIV
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MOD -> IrDynamicOperator.MOD KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MOD -> IrDynamicOperator.MOD
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GT -> IrDynamicOperator.GT KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GT -> IrDynamicOperator.GT
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LT -> IrDynamicOperator.LT KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LT -> IrDynamicOperator.LT
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GE -> IrDynamicOperator.GE KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.GE -> IrDynamicOperator.GE
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LE -> IrDynamicOperator.LE KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.LE -> IrDynamicOperator.LE
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ -> IrDynamicOperator.EQEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQ -> IrDynamicOperator.EQEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ -> IrDynamicOperator.EXCLEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQ -> IrDynamicOperator.EXCLEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ -> IrDynamicOperator.EQEQEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQEQEQ -> IrDynamicOperator.EQEQEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ -> IrDynamicOperator.EXCLEQEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EXCLEQEQ -> IrDynamicOperator.EXCLEQEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND -> IrDynamicOperator.ANDAND KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.ANDAND -> IrDynamicOperator.ANDAND
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.OROR -> IrDynamicOperator.OROR KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.OROR -> IrDynamicOperator.OROR
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQ -> IrDynamicOperator.EQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.EQ -> IrDynamicOperator.EQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ -> IrDynamicOperator.PLUSEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.PLUSEQ -> IrDynamicOperator.PLUSEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ -> IrDynamicOperator.MINUSEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MINUSEQ -> IrDynamicOperator.MINUSEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ -> IrDynamicOperator.MULEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MULEQ -> IrDynamicOperator.MULEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ -> IrDynamicOperator.DIVEQ KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.DIVEQ -> IrDynamicOperator.DIVEQ
KotlinIr.IrDynamicOperatorExpression.IrDynamicOperator.MODEQ -> IrDynamicOperator.MODEQ 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 { private fun deserializeBreak(proto: KotlinIr.IrBreak, start: Int, end: Int, type: IrType): IrBreak {
val label = if (proto.hasLabel()) deserializeString(proto.label) else null val label = if (proto.hasLabel()) deserializeString(proto.label) else null
@@ -844,7 +891,12 @@ abstract class IrModuleDeserializer(
return parameter 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 val symbol = deserializeIrSymbol(proto.symbol) as IrClassSymbol
@@ -1045,27 +1097,32 @@ abstract class IrModuleDeserializer(
return constructor 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 symbol = deserializeIrSymbol(proto.symbol) as IrFieldSymbol
val type = deserializeIrType(proto.type) val type = deserializeIrType(proto.type)
val field = symbolTable.declareField(UNDEFINED_OFFSET, val field = symbolTable.declareField(UNDEFINED_OFFSET,
UNDEFINED_OFFSET, UNDEFINED_OFFSET,
irrelevantOrigin, irrelevantOrigin,
symbol.descriptor, symbol.descriptor,
type, type,
{ {
IrFieldImpl( IrFieldImpl(
start, end, origin, start, end, origin,
it, it,
deserializeName(proto.name), deserializeName(proto.name),
type, type,
deserializeVisibility(proto.visibility), deserializeVisibility(proto.visibility),
proto.isFinal, proto.isFinal,
proto.isExternal, proto.isExternal,
proto.isStatic proto.isStatic
) )
} }
) )
val initializer = if (proto.hasInitializer()) deserializeExpression(proto.initializer) else null val initializer = if (proto.hasInitializer()) deserializeExpression(proto.initializer) else null
@@ -1118,7 +1175,8 @@ abstract class IrModuleDeserializer(
origin: IrDeclarationOrigin origin: IrDeclarationOrigin
): IrProperty { ): 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 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 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()) return IrErrorDeclarationImpl(start, end, WrappedClassDescriptor())
} }
private val allKnownOrigins = private val allKnownDeclarationOrigins =
IrDeclarationOrigin::class.nestedClasses.toList() + DeclarationFactory.FIELD_FOR_OUTER_THIS::class IrDeclarationOrigin::class.nestedClasses.toList() + DeclarationFactory.FIELD_FOR_OUTER_THIS::class
<<<<<<< HEAD
val originIndex = allKnownOrigins.map { it.objectInstance as IrDeclarationOriginImpl }.associateBy { it.name } val originIndex = allKnownOrigins.map { it.objectInstance as IrDeclarationOriginImpl }.associateBy { it.name }
fun deserializeIrDeclarationOrigin(proto: KotlinIr.IrDeclarationOrigin): IrDeclarationOriginImpl { fun deserializeIrDeclarationOrigin(proto: KotlinIr.IrDeclarationOrigin): IrDeclarationOriginImpl {
val originName = deserializeString(proto.custom) val originName = deserializeString(proto.custom)
return originIndex[originName] ?: object : IrDeclarationOriginImpl(originName) {} 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 { open fun deserializeDeclaration(proto: KotlinIr.IrDeclaration, parent: IrDeclarationParent?): IrDeclaration {
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleSerializer.kt
+41 -30
View File
@@ -61,9 +61,10 @@ open class IrModuleSerializer(
.setCustom(serializeString((origin as IrDeclarationOriginImpl).name)) .setCustom(serializeString((origin as IrDeclarationOriginImpl).name))
.build() .build()
private fun serializeIrStatementOrigin(origin: IrStatementOrigin) = private fun serializeIrStatementOrigin(origin: IrStatementOrigin?) =
KotlinIr.IrStatementOrigin.newBuilder() KotlinIr.IrStatementOrigin.newBuilder()
.setName(serializeString((origin as IrStatementOriginImpl).debugName)) //.setName(serializeString((origin as IrStatementOriginImpl).debugName))
.setName(serializeString((origin as IrStatementOriginImpl?)?.debugName ?: ""))
.build() .build()
private fun serializeVisibility(visibility: Visibility) = 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 { private fun serializeBlockBody(expression: IrBlockBody): KotlinIr.IrBlockBody {
val proto = KotlinIr.IrBlockBody.newBuilder() val proto = KotlinIr.IrBlockBody.newBuilder()
expression.statements.forEach { expression.statements.forEach {
@@ -314,11 +322,9 @@ open class IrModuleSerializer(
} }
private fun serializeBlock(block: IrBlock): KotlinIr.IrBlock { private fun serializeBlock(block: IrBlock): KotlinIr.IrBlock {
val isLambdaOrigin =
block.origin == IrStatementOrigin.LAMBDA ||
block.origin == IrStatementOrigin.ANONYMOUS_FUNCTION
val proto = KotlinIr.IrBlock.newBuilder() val proto = KotlinIr.IrBlock.newBuilder()
.setIsLambdaOrigin(isLambdaOrigin) .setOrigin(serializeIrStatementOrigin(block.origin))
block.statements.forEach { block.statements.forEach {
proto.addStatement(serializeStatement(it)) proto.addStatement(serializeStatement(it))
} }
@@ -327,6 +333,7 @@ open class IrModuleSerializer(
private fun serializeComposite(composite: IrComposite): KotlinIr.IrComposite { private fun serializeComposite(composite: IrComposite): KotlinIr.IrComposite {
val proto = KotlinIr.IrComposite.newBuilder() val proto = KotlinIr.IrComposite.newBuilder()
.setOrigin(serializeIrStatementOrigin(composite.origin))
composite.statements.forEach { composite.statements.forEach {
proto.addStatement(serializeStatement(it)) proto.addStatement(serializeStatement(it))
} }
@@ -388,14 +395,15 @@ open class IrModuleSerializer(
private fun serializeCall(call: IrCall): KotlinIr.IrCall { private fun serializeCall(call: IrCall): KotlinIr.IrCall {
val proto = KotlinIr.IrCall.newBuilder() val proto = KotlinIr.IrCall.newBuilder()
proto.kind = irCallToPrimitiveKind(call) proto.kind = irCallToPrimitiveKind(call)
proto.symbol = serializeIrSymbol(call.symbol) proto.symbol = serializeIrSymbol(call.symbol)
proto.origin = serializeStatementOrigin(call.origin)
call.superQualifierSymbol?.let { call.superQualifierSymbol?.let {
proto.`super` = serializeIrSymbol(it) proto.`super` = serializeIrSymbol(it)
} }
proto.memberAccess = serializeMemberAccessCommon(call) proto.memberAccess = serializeMemberAccessCommon(call)
return proto.build() return proto.build()
} }
@@ -410,7 +418,8 @@ open class IrModuleSerializer(
val proto = KotlinIr.IrFunctionReference.newBuilder() val proto = KotlinIr.IrFunctionReference.newBuilder()
.setSymbol(serializeIrSymbol(callable.symbol)) .setSymbol(serializeIrSymbol(callable.symbol))
.setMemberAccess(serializeMemberAccessCommon(callable)) .setMemberAccess(serializeMemberAccessCommon(callable))
callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) } .setOrigin(serializeIrStatementOrigin(callable.origin))
return proto.build() return proto.build()
} }
@@ -430,10 +439,11 @@ open class IrModuleSerializer(
private fun serializePropertyReference(callable: IrPropertyReference): KotlinIr.IrPropertyReference { private fun serializePropertyReference(callable: IrPropertyReference): KotlinIr.IrPropertyReference {
val proto = KotlinIr.IrPropertyReference.newBuilder() val proto = KotlinIr.IrPropertyReference.newBuilder()
.setMemberAccess(serializeMemberAccessCommon(callable)) .setMemberAccess(serializeMemberAccessCommon(callable))
.setOrigin(serializeIrStatementOrigin(callable.origin))
callable.field?.let { proto.field = serializeIrSymbol(it) } callable.field?.let { proto.field = serializeIrSymbol(it) }
callable.getter?.let { proto.getter = serializeIrSymbol(it) } callable.getter?.let { proto.getter = serializeIrSymbol(it) }
callable.setter?.let { proto.setter = serializeIrSymbol(it) } callable.setter?.let { proto.setter = serializeIrSymbol(it) }
callable.origin?.let { proto.origin = serializeIrStatementOrigin(it) }
val property = callable.getter!!.owner.correspondingProperty!! val property = callable.getter!!.owner.correspondingProperty!!
descriptorReferenceSerializer.serializeDescriptorReference(property)?.let { proto.setDescriptorReference(it) } descriptorReferenceSerializer.serializeDescriptorReference(property)?.let { proto.setDescriptorReference(it) }
return proto.build() return proto.build()
@@ -470,12 +480,10 @@ open class IrModuleSerializer(
return proto.build() return proto.build()
} }
private fun serializeDoWhile(expression: IrDoWhileLoop): KotlinIr.IrDoWhile { private fun serializeDoWhile(expression: IrDoWhileLoop): KotlinIr.IrDoWhile =
val proto = KotlinIr.IrDoWhile.newBuilder() KotlinIr.IrDoWhile.newBuilder()
.setLoop(serializeLoop(expression)) .setLoop(serializeLoop(expression))
.build()
return proto.build()
}
fun serializeEnumConstructorCall(call: IrEnumConstructorCall): KotlinIr.IrEnumConstructorCall { fun serializeEnumConstructorCall(call: IrEnumConstructorCall): KotlinIr.IrEnumConstructorCall {
val proto = KotlinIr.IrEnumConstructorCall.newBuilder() val proto = KotlinIr.IrEnumConstructorCall.newBuilder()
@@ -504,17 +512,17 @@ open class IrModuleSerializer(
return proto.build() return proto.build()
} }
private fun serializeGetField(expression: IrGetField): KotlinIr.IrGetField { private fun serializeGetField(expression: IrGetField): KotlinIr.IrGetField =
val proto = KotlinIr.IrGetField.newBuilder() KotlinIr.IrGetField.newBuilder()
.setFieldAccess(serializeFieldAccessCommon(expression)) .setFieldAccess(serializeFieldAccessCommon(expression))
return proto.build() .setOrigin(serializeIrStatementOrigin(expression.origin))
} .build()
private fun serializeGetValue(expression: IrGetValue): KotlinIr.IrGetValue { private fun serializeGetValue(expression: IrGetValue): KotlinIr.IrGetValue =
val proto = KotlinIr.IrGetValue.newBuilder() KotlinIr.IrGetValue.newBuilder()
.setSymbol(serializeIrSymbol(expression.symbol)) .setSymbol(serializeIrSymbol(expression.symbol))
return proto.build() .setOrigin(serializeIrStatementOrigin(expression.origin))
} .build()
private fun serializeGetObject(expression: IrGetObjectValue): KotlinIr.IrGetObject { private fun serializeGetObject(expression: IrGetObjectValue): KotlinIr.IrGetObject {
val proto = KotlinIr.IrGetObject.newBuilder() val proto = KotlinIr.IrGetObject.newBuilder()
@@ -537,19 +545,19 @@ open class IrModuleSerializer(
return proto.build() return proto.build()
} }
private fun serializeSetField(expression: IrSetField): KotlinIr.IrSetField { private fun serializeSetField(expression: IrSetField): KotlinIr.IrSetField =
val proto = KotlinIr.IrSetField.newBuilder() KotlinIr.IrSetField.newBuilder()
.setFieldAccess(serializeFieldAccessCommon(expression)) .setFieldAccess(serializeFieldAccessCommon(expression))
.setValue(serializeExpression(expression.value)) .setValue(serializeExpression(expression.value))
return proto.build() .setOrigin(serializeIrStatementOrigin(expression.origin))
} .build()
private fun serializeSetVariable(expression: IrSetVariable): KotlinIr.IrSetVariable { private fun serializeSetVariable(expression: IrSetVariable): KotlinIr.IrSetVariable =
val proto = KotlinIr.IrSetVariable.newBuilder() KotlinIr.IrSetVariable.newBuilder()
.setSymbol(serializeIrSymbol(expression.symbol)) .setSymbol(serializeIrSymbol(expression.symbol))
.setValue(serializeExpression(expression.value)) .setValue(serializeExpression(expression.value))
return proto.build() .setOrigin(serializeIrStatementOrigin(expression.origin))
} .build()
private fun serializeSpreadElement(element: IrSpreadElement): KotlinIr.IrSpreadElement { private fun serializeSpreadElement(element: IrSpreadElement): KotlinIr.IrSpreadElement {
val coordinates = serializeCoordinates(element.startOffset, element.endOffset) val coordinates = serializeCoordinates(element.startOffset, element.endOffset)
@@ -641,6 +649,7 @@ open class IrModuleSerializer(
private fun serializeWhen(expression: IrWhen): KotlinIr.IrWhen { private fun serializeWhen(expression: IrWhen): KotlinIr.IrWhen {
val proto = KotlinIr.IrWhen.newBuilder() val proto = KotlinIr.IrWhen.newBuilder()
.setOrigin(serializeIrStatementOrigin(expression.origin))
val branches = expression.branches val branches = expression.branches
branches.forEach { branches.forEach {
@@ -653,6 +662,8 @@ open class IrModuleSerializer(
private fun serializeLoop(expression: IrLoop): KotlinIr.Loop { private fun serializeLoop(expression: IrLoop): KotlinIr.Loop {
val proto = KotlinIr.Loop.newBuilder() val proto = KotlinIr.Loop.newBuilder()
.setCondition(serializeExpression(expression.condition)) .setCondition(serializeExpression(expression.condition))
.setOrigin(serializeIrStatementOrigin(expression.origin))
val label = expression.label?.let { serializeString(it) } val label = expression.label?.let { serializeString(it) }
if (label != null) { if (label != null) {
proto.label = label proto.label = label
compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIr.java
+1174 -76
View File
File diff suppressed because it is too large Load Diff