From 49124709b8c5db08ab8976a523991c3532181ad2 Mon Sep 17 00:00:00 2001 From: Ivan Kylchik Date: Thu, 18 Jun 2020 21:16:14 +0300 Subject: [PATCH] Remove all usages of descriptors from interpreter --- .../interpreter/IrCompileTimeChecker.kt | 3 +-- .../common/interpreter/IrInterpreter.kt | 26 ++++++++++++------- .../backend/common/interpreter/Utils.kt | 4 +-- .../common/interpreter/state/Common.kt | 4 +-- .../common/interpreter/state/Primitive.kt | 3 ++- 5 files changed, 24 insertions(+), 16 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrCompileTimeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrCompileTimeChecker.kt index efd532a1ec5..0530c5a85d7 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrCompileTimeChecker.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/IrCompileTimeChecker.kt @@ -52,8 +52,7 @@ class IrCompileTimeChecker( private fun IrDeclaration.isMarkedWith(annotation: FqName): Boolean { if (this is IrClass && this.isCompanion) return false - // must check descriptor annotations too because ir builtins operators don't have annotation on ir element - if (this.hasAnnotation(annotation) || this.descriptor.annotations.hasAnnotation(annotation)) return true + if (this.hasAnnotation(annotation)) return true return (this.parent as? IrClass)?.isMarkedWith(annotation) ?: false } 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 4769240d47f..09796d0917f 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 @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.backend.common.interpreter.intrinsics.IntrinsicEvalu import org.jetbrains.kotlin.backend.common.interpreter.stack.StackImpl import org.jetbrains.kotlin.backend.common.interpreter.stack.Variable import org.jetbrains.kotlin.backend.common.interpreter.state.* -import org.jetbrains.kotlin.builtins.UnsignedTypes import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.declarations.* @@ -27,6 +26,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.types.impl.originalKotlinType import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -169,15 +169,14 @@ class IrInterpreter(irModule: IrModuleFragment, private val bodyMap: Map descriptor.name.asString() + null -> irFunction.name.asString() else -> property.owner.name.asString() } val args = stack.getAll().map { it.state } - val receiverType = descriptor.dispatchReceiverParameter?.type - val argsType = listOfNotNull(receiverType) + descriptor.valueParameters.map { it.original.type } + val receiverType = irFunction.dispatchReceiverParameter?.type + val argsType = listOfNotNull(receiverType) + irFunction.valueParameters.map { it.type } val argsValues = args.map { when (it) { is Complex -> when (irFunction.fqNameWhenAvailable?.asString()) { @@ -190,7 +189,16 @@ class IrInterpreter(irModule: IrModuleFragment, private val bodyMap: Map TODO("unsupported type of argument for builtins calculations: ${it::class.java}") } } - val signature = CompileTimeFunction(methodName, argsType.map { it.toString() }) + + fun IrType.getOnlyName(): String { + return when { + this.originalKotlinType != null -> this.originalKotlinType.toString() + this is IrSimpleType -> (this.classifierOrFail.owner as IrDeclarationWithName).name.asString() + (if (this.hasQuestionMark) "?" else "") + else -> this.render() + } + } + + val signature = CompileTimeFunction(methodName, argsType.map { it.getOnlyName() }) // TODO replace unary, binary, ternary functions with vararg val result = when (argsType.size) { @@ -424,7 +432,7 @@ class IrInterpreter(irModule: IrModuleFragment, private val bodyMap: Map enumSuperCall.putValueArgument(index, irConst) } } val executionResult = enumEntry.initializerExpression?.interpret()?.check { return it } - enumSuperCall?.mapValueParameters { null } // restore to null + enumSuperCall?.apply { (0 until this.valueArgumentsCount).forEach { putValueArgument(it, null) } } // restore to null return executionResult ?: throw InterpreterException("Initializer at enum entry ${enumEntry.fqNameWhenAvailable} is null") } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt index 73d67a0383e..c7cac0cd63c 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt @@ -43,9 +43,9 @@ internal fun State.toIrExpression(expression: IrExpression): IrExpression { else -> expression // TODO support for arrays } is Complex -> { - val stateType = this.irClass.defaultType.toKotlinType() + val stateType = this.irClass.defaultType when { - UnsignedTypes.isUnsignedType(stateType) -> (this.fields.single().state as Primitive<*>).value.toIrConst(type, start, end) + stateType.isUnsigned() -> (this.fields.single().state as Primitive<*>).value.toIrConst(type, start, end) else -> expression } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt index d208ea78966..fb8039de8fb 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt @@ -43,8 +43,8 @@ internal class Common private constructor( fun getToStringFunction(): IrFunction { return irClass.declarations.filterIsInstance() - .filter { it.descriptor.name.asString() == "toString" } - .first { it.descriptor.valueParameters.isEmpty() } + .filter { it.name.asString() == "toString" } + .first { it.valueParameters.isEmpty() } .let { getOverridden(it as IrSimpleFunction, this) } } diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt index 386fa24dbe6..266e88288fb 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classOrNull +import org.jetbrains.kotlin.ir.util.defaultType import org.jetbrains.kotlin.ir.util.isFakeOverride import org.jetbrains.kotlin.ir.util.overrides @@ -57,6 +58,6 @@ internal class Primitive(var value: T, val type: IrType) : State { } override fun toString(): String { - return "Primitive(value=$value, type=${irClass.descriptor.defaultType})" + return "Primitive(value=$value, type=${irClass.defaultType})" } }