From 3155f56d8a1967b5a72dca19db9848124634c81e Mon Sep 17 00:00:00 2001 From: Ivan Kylchik Date: Wed, 10 Jun 2020 15:36:51 +0300 Subject: [PATCH] Change the way of receiving fields Before that, interpreted values for fields were taken by backing field's symbol. For now, they will be taken by property's symbol. It was done because not all properties contain backing field. For example, Throwable class in FIR2IR. --- .../common/interpreter/IrInterpreter.kt | 12 ++++----- .../interpreter/state/ExceptionState.kt | 27 +++++++++---------- 2 files changed, 19 insertions(+), 20 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrInterpreter.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrInterpreter.kt index 52236afee5b..f276e78cb02 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrInterpreter.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrInterpreter.kt @@ -337,7 +337,7 @@ class IrInterpreter(irModule: IrModuleFragment, private val bodyMap: Map { val owner = expression.type.classOrNull!!.owner val storageProperty = owner.declarations.filterIsInstance().first { it.name.asString() == "storage" } - val storageField = storageProperty.backingField!! val primitiveArray = args.map { ((it as Common).fields.single().state as Primitive<*>).value } - val unsignedArray = primitiveArray.toPrimitiveStateArray(storageField.type) + val unsignedArray = primitiveArray.toPrimitiveStateArray(storageProperty.backingField!!.type) Common(owner).apply { setSuperClassRecursive() - fields.add(Variable(storageField.symbol, unsignedArray)) + fields.add(Variable(storageProperty.symbol, unsignedArray)) } } else -> args.toPrimitiveStateArray(expression.type) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt index db3c380dcca..9d00a6e9e7d 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.backend.common.interpreter.getLastOverridden import org.jetbrains.kotlin.backend.common.interpreter.stack.Variable import org.jetbrains.kotlin.backend.common.interpreter.toState import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.declarations.IrField import org.jetbrains.kotlin.ir.declarations.IrProperty import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction import org.jetbrains.kotlin.ir.util.isSubclassOf @@ -22,15 +21,15 @@ class ExceptionState private constructor( private lateinit var exceptionFqName: String private val exceptionHierarchy = mutableListOf() - private val messageField = irClass.getFieldByName("message") - private val causeField = irClass.getFieldByName("cause") + private val messageProperty = irClass.getPropertyByName("message") + private val causeProperty = irClass.getPropertyByName("cause") private val stackTrace: List = stackTrace.reversed() init { if (!this::exceptionFqName.isInitialized) this.exceptionFqName = irClassFqName() - if (fields.none { it.symbol == messageField.symbol }) { + if (fields.none { it.symbol == messageProperty.symbol }) { setMessage() } } @@ -81,17 +80,17 @@ class ExceptionState private constructor( } private fun setMessage(messageValue: String? = null) { - setField(Variable(messageField.symbol, Primitive(messageValue, messageField.type))) + setField(Variable(messageProperty.symbol, Primitive(messageValue, messageProperty.getter!!.returnType))) } private fun setCause(causeValue: State?) { - setField(Variable(causeField.symbol, causeValue ?: Primitive(null, causeField.type))) + setField(Variable(causeProperty.symbol, causeValue ?: Primitive(null, causeProperty.getter!!.returnType))) } - fun getMessage(): String? = (getState(messageField.symbol) as Primitive<*>).value as String? + fun getMessage(): String? = (getState(messageProperty.symbol) as Primitive<*>).value as String? private fun getMessageWithName(): String = getMessage()?.let { "$exceptionFqName: $it" } ?: exceptionFqName - fun getCause(): ExceptionState? = getState(causeField.symbol)?.let { if (it is ExceptionState) it else null } + fun getCause(): ExceptionState? = getState(causeProperty.symbol)?.let { if (it is ExceptionState) it else null } fun getFullDescription(): String { // TODO remainder of the stack trace with "..." @@ -107,18 +106,18 @@ class ExceptionState private constructor( fun getThisAsCauseForException() = ExceptionData(this) companion object { - private fun IrClass.getFieldByName(name: String): IrField { + private fun IrClass.getPropertyByName(name: String): IrProperty { val property = this.declarations.single { it.nameForIrSerialization.asString() == name } as IrProperty - return (property.getter!!.getLastOverridden() as IrSimpleFunction).correspondingPropertySymbol!!.owner.backingField!! + return (property.getter!!.getLastOverridden() as IrSimpleFunction).correspondingPropertySymbol!!.owner } private fun evaluateFields(exception: Throwable, irClass: IrClass, stackTrace: List): MutableList { - val messageField = irClass.getFieldByName("message") - val causeField = irClass.getFieldByName("cause") + val messageProperty = irClass.getPropertyByName("message") + val causeProperty = irClass.getPropertyByName("cause") - val messageVar = Variable(messageField.symbol, exception.message.toState(messageField.type)) + val messageVar = Variable(messageProperty.symbol, exception.message.toState(messageProperty.getter!!.returnType)) val causeVar = exception.cause?.let { - Variable(causeField.symbol, ExceptionState(it, irClass, stackTrace + it.stackTrace.reversed().map { "at $it" })) + Variable(causeProperty.symbol, ExceptionState(it, irClass, stackTrace + it.stackTrace.reversed().map { "at $it" })) } return listOfNotNull(messageVar, causeVar).toMutableList() }