[IR] Print evaluated const directly into interpreter's tests

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java

@@ -329,12 +329,6 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
             runTest("compiler/testData/codegen/box/annotations/noTypeUseIfFlagIsSpecified.kt");
         }
 
-        @Test
-        @TestMetadata("objectConstValInAnnotationArgument.kt")
-        public void testObjectConstValInAnnotationArgument() throws Exception {
-            runTest("compiler/testData/codegen/box/annotations/objectConstValInAnnotationArgument.kt");
-        }
-
         @Test
         @TestMetadata("parameterAnnotationInDefaultImpls.kt")
         public void testParameterAnnotationInDefaultImpls() throws Exception {
@@ -28454,6 +28448,12 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
                 runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/longOperations.kt");
             }
 
+            @Test
+            @TestMetadata("objectConstValInAnnotationArgument.kt")
+            public void testObjectConstValInAnnotationArgument() throws Exception {
+                runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/objectConstValInAnnotationArgument.kt");
+            }
+
             @Test
             @TestMetadata("shortOperations.kt")
             public void testShortOperations() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java

@@ -329,12 +329,6 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
             runTest("compiler/testData/codegen/box/annotations/noTypeUseIfFlagIsSpecified.kt");
         }
 
-        @Test
-        @TestMetadata("objectConstValInAnnotationArgument.kt")
-        public void testObjectConstValInAnnotationArgument() throws Exception {
-            runTest("compiler/testData/codegen/box/annotations/objectConstValInAnnotationArgument.kt");
-        }
-
         @Test
         @TestMetadata("parameterAnnotationInDefaultImpls.kt")
         public void testParameterAnnotationInDefaultImpls() throws Exception {
@@ -28454,6 +28448,12 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
                 runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/longOperations.kt");
             }
 
+            @Test
+            @TestMetadata("objectConstValInAnnotationArgument.kt")
+            public void testObjectConstValInAnnotationArgument() throws Exception {
+                runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/objectConstValInAnnotationArgument.kt");
+            }
+
             @Test
             @TestMetadata("shortOperations.kt")
             public void testShortOperations() throws Exception {

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt

@@ -316,7 +316,7 @@ internal val functionInliningPhase = makeIrModulePhase(
     )
 )
 
-val constEvaluationPhase = makeIrModulePhase<JvmBackendContext>(
+private val constEvaluationPhase = makeIrModulePhase<JvmBackendContext>(
     {
         ConstEvaluationLowering(
             it,

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/EvaluationMode.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.ir.interpreter.checker
 
+import org.jetbrains.kotlin.ir.BuiltInOperatorNames
 import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
@@ -16,6 +17,7 @@ import org.jetbrains.kotlin.ir.types.isString
 import org.jetbrains.kotlin.ir.types.isUnsignedType
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
 
 enum class EvaluationMode(protected val mustCheckBody: Boolean) {
     FULL(mustCheckBody = true) {
@@ -51,9 +53,14 @@ enum class EvaluationMode(protected val mustCheckBody: Boolean) {
         private val forbiddenMethodsOnPrimitives = setOf("inc", "dec", "rangeTo", "rangeUntil", "hashCode")
         private val forbiddenMethodsOnStrings = setOf("subSequence", "hashCode", "<init>")
         private val allowedExtensionFunctions = setOf(
-            "kotlin.floorDiv", "kotlin.mod", "kotlin.NumbersKt.floorDiv", "kotlin.NumbersKt.mod", "kotlin.<get-code>",
+            "kotlin.floorDiv", "kotlin.mod", "kotlin.NumbersKt.floorDiv", "kotlin.NumbersKt.mod", "kotlin.<get-code>"
-            "kotlin.internal.ir.EQEQ", "kotlin.internal.ir.ieee754equals",
         )
+        private val allowedBuiltinExtensionFunctions = listOf(
+            BuiltInOperatorNames.LESS, BuiltInOperatorNames.LESS_OR_EQUAL,
+            BuiltInOperatorNames.GREATER, BuiltInOperatorNames.GREATER_OR_EQUAL,
+            BuiltInOperatorNames.EQEQ, BuiltInOperatorNames.IEEE754_EQUALS,
+            BuiltInOperatorNames.ANDAND, BuiltInOperatorNames.OROR
+        ).map { IrBuiltIns.KOTLIN_INTERNAL_IR_FQN.child(Name.identifier(it)).asString() }.toSet()
 
         override fun canEvaluateFunction(function: IrFunction, context: IrCall?): Boolean {
             if ((function as? IrSimpleFunction)?.correspondingPropertySymbol?.owner?.isConst == true) return true
@@ -62,13 +69,13 @@ enum class EvaluationMode(protected val mustCheckBody: Boolean) {
             val parent = function.parentClassOrNull
             val parentType = parent?.defaultType
             return when {
-                parentType == null -> fqName in allowedExtensionFunctions
+                parentType == null -> fqName in allowedExtensionFunctions || fqName in allowedBuiltinExtensionFunctions
                 parentType.isPrimitiveType() -> function.name.asString() !in forbiddenMethodsOnPrimitives
                 parentType.isString() -> function.name.asString() !in forbiddenMethodsOnStrings
                 parentType.isAny() -> function.name.asString() == "toString" && context?.dispatchReceiver !is IrGetObjectValue
                 parent.isObject -> parent.parentClassOrNull?.defaultType?.let { it.isPrimitiveType() || it.isUnsigned() } == true
                 parentType.isUnsignedType() && function is IrConstructor -> true
-                else -> fqName in allowedExtensionFunctions
+                else -> fqName in allowedExtensionFunctions || fqName in allowedBuiltinExtensionFunctions
             }
         }
 

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/IrConstTransformer.kt

@@ -76,7 +76,7 @@ class IrConstTransformer(
         }
 
         evaluatedConstTracker?.save(
-            this.startOffset, this.endOffset,
+            result.startOffset, result.endOffset,
             constant = if (result is IrErrorExpression) ErrorValue.create(result.description)
             else (result as IrConst<*>).toConstantValue()
         )
@@ -95,7 +95,6 @@ class IrConstTransformer(
 
         val initializer = declaration.initializer
         val expression = initializer?.expression ?: return declaration
-        if (expression is IrConst<*>) return declaration
         val isConst = declaration.correspondingPropertySymbol?.owner?.isConst == true
         if (!isConst) return super.visitField(declaration)
 

compiler/testData/codegen/box/annotations/objectConstValInAnnotationArgument.kt

@@ -1,14 +0,0 @@
-// TARGET_BACKEND: JVM_IR
-annotation class Key(val value: String)
-
-object Messanger {
-    const val DEFAULT_TEXT = "OK"
-
-    fun message(@Key(value = DEFAULT_TEXT) text: String = DEFAULT_TEXT): String {
-        return text
-    }
-}
-
-fun box(): String {
-    return Messanger.message()
-}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/booleanOperations.kt

@@ -1,73 +1,73 @@
 // TARGET_BACKEND: JVM_IR
-// TARGET_BACKEND: NATIVE
 // TARGET_BACKEND: JS_IR
+// TARGET_BACKEND: NATIVE
 // `Boolean.equals(Boolean)` will not be evaluated in K1
 // IGNORE_BACKEND_K1: NATIVE
 
-const val trueVal = true
+const val trueVal = <!EVALUATED("true")!>true<!>
-const val falseVal = false
+const val falseVal = <!EVALUATED("false")!>false<!>
 
-const val not1 = trueVal.not()
+const val not1 = trueVal.<!EVALUATED("false")!>not()<!>
-const val not2 = falseVal.not()
+const val not2 = falseVal.<!EVALUATED("true")!>not()<!>
 
-const val and1 = trueVal.and(trueVal)
+const val and1 = trueVal.<!EVALUATED("true")!>and(trueVal)<!>
-const val and2 = trueVal.and(falseVal)
+const val and2 = trueVal.<!EVALUATED("false")!>and(falseVal)<!>
-const val and3 = falseVal.and(trueVal)
+const val and3 = falseVal.<!EVALUATED("false")!>and(trueVal)<!>
-const val and4 = falseVal.and(falseVal)
+const val and4 = falseVal.<!EVALUATED("false")!>and(falseVal)<!>
 
-const val or1 = trueVal.or(trueVal)
+const val or1 = trueVal.<!EVALUATED("true")!>or(trueVal)<!>
-const val or2 = trueVal.or(falseVal)
+const val or2 = trueVal.<!EVALUATED("true")!>or(falseVal)<!>
-const val or3 = falseVal.or(trueVal)
+const val or3 = falseVal.<!EVALUATED("true")!>or(trueVal)<!>
-const val or4 = falseVal.or(falseVal)
+const val or4 = falseVal.<!EVALUATED("false")!>or(falseVal)<!>
 
-const val xor1 = trueVal.xor(trueVal)
+const val xor1 = trueVal.<!EVALUATED("false")!>xor(trueVal)<!>
-const val xor2 = trueVal.xor(falseVal)
+const val xor2 = trueVal.<!EVALUATED("true")!>xor(falseVal)<!>
-const val xor3 = falseVal.xor(trueVal)
+const val xor3 = falseVal.<!EVALUATED("true")!>xor(trueVal)<!>
-const val xor4 = falseVal.xor(falseVal)
+const val xor4 = falseVal.<!EVALUATED("false")!>xor(falseVal)<!>
 
-const val compareTo1 = trueVal.compareTo(trueVal)
+const val compareTo1 = trueVal.<!EVALUATED("0")!>compareTo(trueVal)<!>
-const val compareTo2 = trueVal.compareTo(falseVal)
+const val compareTo2 = trueVal.<!EVALUATED("1")!>compareTo(falseVal)<!>
-const val compareTo3 = falseVal.compareTo(trueVal)
+const val compareTo3 = falseVal.<!EVALUATED("-1")!>compareTo(trueVal)<!>
-const val compareTo4 = falseVal.compareTo(falseVal)
+const val compareTo4 = falseVal.<!EVALUATED("0")!>compareTo(falseVal)<!>
 
-const val equals1 = trueVal == trueVal
+const val equals1 = <!EVALUATED("true")!>trueVal == trueVal<!>
-const val equals2 = trueVal == falseVal
+const val equals2 = <!EVALUATED("false")!>trueVal == falseVal<!>
-const val equals3 = falseVal == trueVal
+const val equals3 = <!EVALUATED("false")!>falseVal == trueVal<!>
-const val equals4 = falseVal == falseVal
+const val equals4 = <!EVALUATED("true")!>falseVal == falseVal<!>
 
-const val toString1 = trueVal.toString()
+const val toString1 = trueVal.<!EVALUATED("true")!>toString()<!>
-const val toString2 = falseVal.toString()
+const val toString2 = falseVal.<!EVALUATED("false")!>toString()<!>
 
 fun box(): String {
-    if (not1 != false)  return "Fail 1.1"
+    if (<!EVALUATED("false")!>not1 != false<!>)  return "Fail 1.1"
-    if (not2 != true)   return "Fail 1.2"
+    if (<!EVALUATED("false")!>not2 != true<!>)   return "Fail 1.2"
 
-    if (and1 != true)   return "Fail 2.1"
+    if (<!EVALUATED("false")!>and1 != true<!>)   return "Fail 2.1"
-    if (and2 != false)  return "Fail 2.2"
+    if (<!EVALUATED("false")!>and2 != false<!>)  return "Fail 2.2"
-    if (and3 != false)  return "Fail 2.3"
+    if (<!EVALUATED("false")!>and3 != false<!>)  return "Fail 2.3"
-    if (and4 != false)  return "Fail 2.4"
+    if (<!EVALUATED("false")!>and4 != false<!>)  return "Fail 2.4"
 
-    if (or1 != true)    return "Fail 3.1"
+    if (<!EVALUATED("false")!>or1 != true<!>)    return "Fail 3.1"
-    if (or2 != true)    return "Fail 3.2"
+    if (<!EVALUATED("false")!>or2 != true<!>)    return "Fail 3.2"
-    if (or3 != true)    return "Fail 3.3"
+    if (<!EVALUATED("false")!>or3 != true<!>)    return "Fail 3.3"
-    if (or4 != false)   return "Fail 3.4"
+    if (<!EVALUATED("false")!>or4 != false<!>)   return "Fail 3.4"
 
-    if (xor1 != false)  return "Fail 4.1"
+    if (<!EVALUATED("false")!>xor1 != false<!>)  return "Fail 4.1"
-    if (xor2 != true)   return "Fail 4.2"
+    if (<!EVALUATED("false")!>xor2 != true<!>)   return "Fail 4.2"
-    if (xor3 != true)   return "Fail 4.3"
+    if (<!EVALUATED("false")!>xor3 != true<!>)   return "Fail 4.3"
-    if (xor4 != false)  return "Fail 4.4"
+    if (<!EVALUATED("false")!>xor4 != false<!>)  return "Fail 4.4"
 
-    if (compareTo1 != 0)    return "Fail 5.1"
+    if (<!EVALUATED("false")!>compareTo1 != 0<!>)    return "Fail 5.1"
-    if (compareTo2 != 1)    return "Fail 5.2"
+    if (<!EVALUATED("false")!>compareTo2 != 1<!>)    return "Fail 5.2"
-    if (compareTo3 != -1)   return "Fail 5.3"
+    if (<!EVALUATED("false")!>compareTo3 != -1<!>)   return "Fail 5.3"
-    if (compareTo4 != 0)    return "Fail 5.4"
+    if (<!EVALUATED("false")!>compareTo4 != 0<!>)    return "Fail 5.4"
 
-    if (equals1 != true)    return "Fail 6.1"
+    if (<!EVALUATED("false")!>equals1 != true<!>)    return "Fail 6.1"
-    if (equals2 != false)   return "Fail 6.2"
+    if (<!EVALUATED("false")!>equals2 != false<!>)   return "Fail 6.2"
-    if (equals3 != false)   return "Fail 6.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 6.3"
-    if (equals4 != true)    return "Fail 6.4"
+    if (<!EVALUATED("false")!>equals4 != true<!>)    return "Fail 6.4"
 
-    if (toString1 != "true")    return "Fail 7.1"
+    if (<!EVALUATED("false")!>toString1 != "true"<!>)    return "Fail 7.1"
-    if (toString2 != "false")   return "Fail 7.2"
+    if (<!EVALUATED("false")!>toString2 != "false"<!>)   return "Fail 7.2"
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/byteOperations.kt

@@ -3,169 +3,169 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: NATIVE
 
-const val minusOneVal = (-1).toByte()
+const val minusOneVal = (-1).<!EVALUATED("-1")!>toByte()<!>
-const val oneVal = 1.toByte()
+const val oneVal = 1.<!EVALUATED("1")!>toByte()<!>
-const val twoVal = 2.toByte()
+const val twoVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val threeVal = 3.toByte()
+const val threeVal = 3.<!EVALUATED("3")!>toByte()<!>
-const val fourVal = 4.toByte()
+const val fourVal = 4.<!EVALUATED("4")!>toByte()<!>
 
-const val byteVal = 2.toByte()
+const val byteVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val shortVal = 2.toShort()
+const val shortVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val intVal = 2
+const val intVal = <!EVALUATED("2")!>2<!>
-const val longVal = 2L
+const val longVal = <!EVALUATED("2")!>2L<!>
-const val floatVal = 2.0f
+const val floatVal = <!EVALUATED("2.0")!>2.0f<!>
-const val doubleVal = 2.0
+const val doubleVal = <!EVALUATED("2.0")!>2.0<!>
 
-const val compareTo1 = oneVal.compareTo(twoVal)
+const val compareTo1 = oneVal.<!EVALUATED("-1")!>compareTo(twoVal)<!>
-const val compareTo2 = twoVal.compareTo(twoVal)
+const val compareTo2 = twoVal.<!EVALUATED("0")!>compareTo(twoVal)<!>
-const val compareTo3 = threeVal.compareTo(twoVal)
+const val compareTo3 = threeVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
-const val compareTo4 = twoVal.compareTo(shortVal)
+const val compareTo4 = twoVal.<!EVALUATED("0")!>compareTo(shortVal)<!>
-const val compareTo5 = twoVal.compareTo(intVal)
+const val compareTo5 = twoVal.<!EVALUATED("0")!>compareTo(intVal)<!>
-const val compareTo6 = twoVal.compareTo(longVal)
+const val compareTo6 = twoVal.<!EVALUATED("0")!>compareTo(longVal)<!>
-const val compareTo7 = twoVal.compareTo(floatVal)
+const val compareTo7 = twoVal.<!EVALUATED("0")!>compareTo(floatVal)<!>
-const val compareTo8 = twoVal.compareTo(doubleVal)
+const val compareTo8 = twoVal.<!EVALUATED("0")!>compareTo(doubleVal)<!>
 
-const val plus1 = oneVal.plus(twoVal)
+const val plus1 = oneVal.<!EVALUATED("3")!>plus(twoVal)<!>
-const val plus2 = twoVal.plus(twoVal)
+const val plus2 = twoVal.<!EVALUATED("4")!>plus(twoVal)<!>
-const val plus3 = threeVal.plus(twoVal)
+const val plus3 = threeVal.<!EVALUATED("5")!>plus(twoVal)<!>
-const val plus4 = twoVal.plus(shortVal)
+const val plus4 = twoVal.<!EVALUATED("4")!>plus(shortVal)<!>
-const val plus5 = twoVal.plus(intVal)
+const val plus5 = twoVal.<!EVALUATED("4")!>plus(intVal)<!>
-const val plus6 = twoVal.plus(longVal)
+const val plus6 = twoVal.<!EVALUATED("4")!>plus(longVal)<!>
-const val plus7 = twoVal.plus(floatVal)
+const val plus7 = twoVal.<!EVALUATED("4.0")!>plus(floatVal)<!>
-const val plus8 = twoVal.plus(doubleVal)
+const val plus8 = twoVal.<!EVALUATED("4.0")!>plus(doubleVal)<!>
 
-const val minus1 = oneVal.minus(twoVal)
+const val minus1 = oneVal.<!EVALUATED("-1")!>minus(twoVal)<!>
-const val minus2 = twoVal.minus(twoVal)
+const val minus2 = twoVal.<!EVALUATED("0")!>minus(twoVal)<!>
-const val minus3 = threeVal.minus(twoVal)
+const val minus3 = threeVal.<!EVALUATED("1")!>minus(twoVal)<!>
-const val minus4 = twoVal.minus(shortVal)
+const val minus4 = twoVal.<!EVALUATED("0")!>minus(shortVal)<!>
-const val minus5 = twoVal.minus(intVal)
+const val minus5 = twoVal.<!EVALUATED("0")!>minus(intVal)<!>
-const val minus6 = twoVal.minus(longVal)
+const val minus6 = twoVal.<!EVALUATED("0")!>minus(longVal)<!>
-const val minus7 = twoVal.minus(floatVal)
+const val minus7 = twoVal.<!EVALUATED("0.0")!>minus(floatVal)<!>
-const val minus8 = twoVal.minus(doubleVal)
+const val minus8 = twoVal.<!EVALUATED("0.0")!>minus(doubleVal)<!>
 
-const val times1 = oneVal.times(twoVal)
+const val times1 = oneVal.<!EVALUATED("2")!>times(twoVal)<!>
-const val times2 = twoVal.times(twoVal)
+const val times2 = twoVal.<!EVALUATED("4")!>times(twoVal)<!>
-const val times3 = threeVal.times(twoVal)
+const val times3 = threeVal.<!EVALUATED("6")!>times(twoVal)<!>
-const val times4 = twoVal.times(shortVal)
+const val times4 = twoVal.<!EVALUATED("4")!>times(shortVal)<!>
-const val times5 = twoVal.times(intVal)
+const val times5 = twoVal.<!EVALUATED("4")!>times(intVal)<!>
-const val times6 = twoVal.times(longVal)
+const val times6 = twoVal.<!EVALUATED("4")!>times(longVal)<!>
-const val times7 = twoVal.times(floatVal)
+const val times7 = twoVal.<!EVALUATED("4.0")!>times(floatVal)<!>
-const val times8 = twoVal.times(doubleVal)
+const val times8 = twoVal.<!EVALUATED("4.0")!>times(doubleVal)<!>
 
-const val div1 = oneVal.div(twoVal)
+const val div1 = oneVal.<!EVALUATED("0")!>div(twoVal)<!>
-const val div2 = twoVal.div(twoVal)
+const val div2 = twoVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div3 = threeVal.div(twoVal)
+const val div3 = threeVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div4 = twoVal.div(shortVal)
+const val div4 = twoVal.<!EVALUATED("1")!>div(shortVal)<!>
-const val div5 = twoVal.div(intVal)
+const val div5 = twoVal.<!EVALUATED("1")!>div(intVal)<!>
-const val div6 = twoVal.div(longVal)
+const val div6 = twoVal.<!EVALUATED("1")!>div(longVal)<!>
-const val div7 = twoVal.div(floatVal)
+const val div7 = twoVal.<!EVALUATED("1.0")!>div(floatVal)<!>
-const val div8 = twoVal.div(doubleVal)
+const val div8 = twoVal.<!EVALUATED("1.0")!>div(doubleVal)<!>
 
-const val rem1 = oneVal.rem(twoVal)
+const val rem1 = oneVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem2 = twoVal.rem(twoVal)
+const val rem2 = twoVal.<!EVALUATED("0")!>rem(twoVal)<!>
-const val rem3 = threeVal.rem(twoVal)
+const val rem3 = threeVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem4 = twoVal.rem(shortVal)
+const val rem4 = twoVal.<!EVALUATED("0")!>rem(shortVal)<!>
-const val rem5 = twoVal.rem(intVal)
+const val rem5 = twoVal.<!EVALUATED("0")!>rem(intVal)<!>
-const val rem6 = twoVal.rem(longVal)
+const val rem6 = twoVal.<!EVALUATED("0")!>rem(longVal)<!>
-const val rem7 = twoVal.rem(floatVal)
+const val rem7 = twoVal.<!EVALUATED("0.0")!>rem(floatVal)<!>
-const val rem8 = twoVal.rem(doubleVal)
+const val rem8 = twoVal.<!EVALUATED("0.0")!>rem(doubleVal)<!>
 
-const val unaryPlus1 = oneVal.unaryPlus()
+const val unaryPlus1 = oneVal.<!EVALUATED("1")!>unaryPlus()<!>
-const val unaryPlus2 = minusOneVal.unaryPlus()
+const val unaryPlus2 = minusOneVal.<!EVALUATED("-1")!>unaryPlus()<!>
-const val unaryMinus1 = oneVal.unaryMinus()
+const val unaryMinus1 = oneVal.<!EVALUATED("-1")!>unaryMinus()<!>
-const val unaryMinus2 = minusOneVal.unaryMinus()
+const val unaryMinus2 = minusOneVal.<!EVALUATED("1")!>unaryMinus()<!>
 
-const val convert1 = oneVal.toByte()
+const val convert1 = oneVal.<!EVALUATED("1")!>toByte()<!>
-const val convert2 = oneVal.toChar()
+const val convert2 = oneVal.<!EVALUATED("
")!>toChar()<!>
-const val convert3 = oneVal.toShort()
+const val convert3 = oneVal.<!EVALUATED("1")!>toShort()<!>
-const val convert4 = oneVal.toInt()
+const val convert4 = oneVal.<!EVALUATED("1")!>toInt()<!>
-const val convert5 = oneVal.toLong()
+const val convert5 = oneVal.<!EVALUATED("1")!>toLong()<!>
-const val convert6 = oneVal.toFloat()
+const val convert6 = oneVal.<!EVALUATED("1.0")!>toFloat()<!>
-const val convert7 = oneVal.toDouble()
+const val convert7 = oneVal.<!EVALUATED("1.0")!>toDouble()<!>
 
-const val equals1 = oneVal == twoVal
+const val equals1 = <!EVALUATED("false")!>oneVal == twoVal<!>
-const val equals2 = twoVal == twoVal
+const val equals2 = <!EVALUATED("true")!>twoVal == twoVal<!>
-const val equals3 = threeVal == twoVal
+const val equals3 = <!EVALUATED("false")!>threeVal == twoVal<!>
-const val equals4 = fourVal == twoVal
+const val equals4 = <!EVALUATED("false")!>fourVal == twoVal<!>
 
-const val toString1 = oneVal.toString()
+const val toString1 = oneVal.<!EVALUATED("1")!>toString()<!>
-const val toString2 = twoVal.toString()
+const val toString2 = twoVal.<!EVALUATED("2")!>toString()<!>
 
 fun box(): String {
-    if (compareTo1 != -1)   return "Fail 1.1"
+    if (<!EVALUATED("false")!>compareTo1 != -1<!>)   return "Fail 1.1"
-    if (compareTo2 != 0)    return "Fail 1.2"
+    if (<!EVALUATED("false")!>compareTo2 != 0<!>)    return "Fail 1.2"
-    if (compareTo3 != 1)    return "Fail 1.3"
+    if (<!EVALUATED("false")!>compareTo3 != 1<!>)    return "Fail 1.3"
-    if (compareTo4 != 0)    return "Fail 1.4"
+    if (<!EVALUATED("false")!>compareTo4 != 0<!>)    return "Fail 1.4"
-    if (compareTo5 != 0)    return "Fail 1.5"
+    if (<!EVALUATED("false")!>compareTo5 != 0<!>)    return "Fail 1.5"
-    if (compareTo6 != 0)    return "Fail 1.6"
+    if (<!EVALUATED("false")!>compareTo6 != 0<!>)    return "Fail 1.6"
-    if (compareTo7 != 0)    return "Fail 1.7"
+    if (<!EVALUATED("false")!>compareTo7 != 0<!>)    return "Fail 1.7"
-    if (compareTo8 != 0)    return "Fail 1.8"
+    if (<!EVALUATED("false")!>compareTo8 != 0<!>)    return "Fail 1.8"
 
-    if (plus1 != 3)     return "Fail 2.1"
+    if (<!EVALUATED("false")!>plus1 != 3<!>)     return "Fail 2.1"
-    if (plus2 != 4)     return "Fail 2.2"
+    if (<!EVALUATED("false")!>plus2 != 4<!>)     return "Fail 2.2"
-    if (plus3 != 5)     return "Fail 2.3"
+    if (<!EVALUATED("false")!>plus3 != 5<!>)     return "Fail 2.3"
-    if (plus4 != 4)     return "Fail 2.4"
+    if (<!EVALUATED("false")!>plus4 != 4<!>)     return "Fail 2.4"
-    if (plus5 != 4)     return "Fail 2.5"
+    if (<!EVALUATED("false")!>plus5 != 4<!>)     return "Fail 2.5"
-    if (plus6 != 4L)     return "Fail 2.6"
+    if (<!EVALUATED("false")!>plus6 != 4L<!>)     return "Fail 2.6"
-    if (plus7 != 4.0f)  return "Fail 2.7"
+    if (<!EVALUATED("false")!>plus7 != 4.0f<!>)  return "Fail 2.7"
-    if (plus8 != 4.0)  return "Fail 2.8"
+    if (<!EVALUATED("false")!>plus8 != 4.0<!>)  return "Fail 2.8"
 
-    if (minus1 != -1)       return "Fail 3.1"
+    if (<!EVALUATED("false")!>minus1 != -1<!>)       return "Fail 3.1"
-    if (minus2 != 0)        return "Fail 3.2"
+    if (<!EVALUATED("false")!>minus2 != 0<!>)        return "Fail 3.2"
-    if (minus3 != 1)        return "Fail 3.3"
+    if (<!EVALUATED("false")!>minus3 != 1<!>)        return "Fail 3.3"
-    if (minus4 != 0)        return "Fail 3.4"
+    if (<!EVALUATED("false")!>minus4 != 0<!>)        return "Fail 3.4"
-    if (minus5 != 0)        return "Fail 3.5"
+    if (<!EVALUATED("false")!>minus5 != 0<!>)        return "Fail 3.5"
-    if (minus6 != 0L)        return "Fail 3.6"
+    if (<!EVALUATED("false")!>minus6 != 0L<!>)        return "Fail 3.6"
-    if (minus7 != 0.0f)     return "Fail 3.7"
+    if (<!EVALUATED("false")!>minus7 != 0.0f<!>)     return "Fail 3.7"
-    if (minus8 != 0.0)      return "Fail 3.8"
+    if (<!EVALUATED("false")!>minus8 != 0.0<!>)      return "Fail 3.8"
 
-    if (times1 != 2)        return "Fail 4.1"
+    if (<!EVALUATED("false")!>times1 != 2<!>)        return "Fail 4.1"
-    if (times2 != 4)        return "Fail 4.2"
+    if (<!EVALUATED("false")!>times2 != 4<!>)        return "Fail 4.2"
-    if (times3 != 6)        return "Fail 4.3"
+    if (<!EVALUATED("false")!>times3 != 6<!>)        return "Fail 4.3"
-    if (times4 != 4)        return "Fail 4.4"
+    if (<!EVALUATED("false")!>times4 != 4<!>)        return "Fail 4.4"
-    if (times5 != 4)        return "Fail 4.5"
+    if (<!EVALUATED("false")!>times5 != 4<!>)        return "Fail 4.5"
-    if (times6 != 4L)        return "Fail 4.6"
+    if (<!EVALUATED("false")!>times6 != 4L<!>)        return "Fail 4.6"
-    if (times7 != 4.0f)     return "Fail 4.7"
+    if (<!EVALUATED("false")!>times7 != 4.0f<!>)     return "Fail 4.7"
-    if (times8 != 4.0)      return "Fail 4.8"
+    if (<!EVALUATED("false")!>times8 != 4.0<!>)      return "Fail 4.8"
 
-    if (div1 != 0)          return "Fail 5.1"
+    if (<!EVALUATED("false")!>div1 != 0<!>)          return "Fail 5.1"
-    if (div2 != 1)          return "Fail 5.2"
+    if (<!EVALUATED("false")!>div2 != 1<!>)          return "Fail 5.2"
-    if (div3 != 1)          return "Fail 5.3"
+    if (<!EVALUATED("false")!>div3 != 1<!>)          return "Fail 5.3"
-    if (div4 != 1)          return "Fail 5.4"
+    if (<!EVALUATED("false")!>div4 != 1<!>)          return "Fail 5.4"
-    if (div5 != 1)          return "Fail 5.5"
+    if (<!EVALUATED("false")!>div5 != 1<!>)          return "Fail 5.5"
-    if (div6 != 1L)          return "Fail 5.6"
+    if (<!EVALUATED("false")!>div6 != 1L<!>)          return "Fail 5.6"
-    if (div7 != 1.0f)       return "Fail 5.7"
+    if (<!EVALUATED("false")!>div7 != 1.0f<!>)       return "Fail 5.7"
-    if (div8 != 1.0)        return "Fail 5.8"
+    if (<!EVALUATED("false")!>div8 != 1.0<!>)        return "Fail 5.8"
 
-    if (rem1 != 1)      return "Fail 6.1"
+    if (<!EVALUATED("false")!>rem1 != 1<!>)      return "Fail 6.1"
-    if (rem2 != 0)      return "Fail 6.2"
+    if (<!EVALUATED("false")!>rem2 != 0<!>)      return "Fail 6.2"
-    if (rem3 != 1)      return "Fail 6.3"
+    if (<!EVALUATED("false")!>rem3 != 1<!>)      return "Fail 6.3"
-    if (rem4 != 0)      return "Fail 6.4"
+    if (<!EVALUATED("false")!>rem4 != 0<!>)      return "Fail 6.4"
-    if (rem5 != 0)      return "Fail 6.5"
+    if (<!EVALUATED("false")!>rem5 != 0<!>)      return "Fail 6.5"
-    if (rem6 != 0L)      return "Fail 6.6"
+    if (<!EVALUATED("false")!>rem6 != 0L<!>)      return "Fail 6.6"
-    if (rem7 != 0.0f)   return "Fail 6.7"
+    if (<!EVALUATED("false")!>rem7 != 0.0f<!>)   return "Fail 6.7"
-    if (rem8 != 0.0)    return "Fail 6.8"
+    if (<!EVALUATED("false")!>rem8 != 0.0<!>)    return "Fail 6.8"
 
-    if (unaryPlus1 != 1)    return "Fail 7.1"
+    if (<!EVALUATED("false")!>unaryPlus1 != 1<!>)    return "Fail 7.1"
-    if (unaryPlus2 != -1)   return "Fail 7.2"
+    if (<!EVALUATED("false")!>unaryPlus2 != -1<!>)   return "Fail 7.2"
-    if (unaryMinus1 != -1)  return "Fail 7.3"
+    if (<!EVALUATED("false")!>unaryMinus1 != -1<!>)  return "Fail 7.3"
-    if (unaryMinus2 != 1)   return "Fail 7.4"
+    if (<!EVALUATED("false")!>unaryMinus2 != 1<!>)   return "Fail 7.4"
 
-    if (convert1 != 1.toByte())      return "Fail 8.1"
+    if (<!EVALUATED("false")!>convert1 != 1.toByte()<!>)      return "Fail 8.1"
-    if (convert2 != '
')  return "Fail 8.2"
+    if (<!EVALUATED("false")!>convert2 != '
'<!>)  return "Fail 8.2"
-    if (convert3 != 1.toShort())      return "Fail 8.3"
+    if (<!EVALUATED("false")!>convert3 != 1.toShort()<!>)      return "Fail 8.3"
-    if (convert4 != 1)      return "Fail 8.4"
+    if (<!EVALUATED("false")!>convert4 != 1<!>)      return "Fail 8.4"
-    if (convert5 != 1L)      return "Fail 8.5"
+    if (<!EVALUATED("false")!>convert5 != 1L<!>)      return "Fail 8.5"
-    if (convert6 != 1.0f)   return "Fail 8.6"
+    if (<!EVALUATED("false")!>convert6 != 1.0f<!>)   return "Fail 8.6"
-    if (convert7 != 1.0)    return "Fail 8.7"
+    if (<!EVALUATED("false")!>convert7 != 1.0<!>)    return "Fail 8.7"
 
-    if (equals1 != false)   return "Fail 9.1"
+    if (<!EVALUATED("false")!>equals1 != false<!>)   return "Fail 9.1"
-    if (equals2 != true)    return "Fail 9.2"
+    if (<!EVALUATED("false")!>equals2 != true<!>)    return "Fail 9.2"
-    if (equals3 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 9.3"
-    if (equals4 != false)   return "Fail 9.4"
+    if (<!EVALUATED("false")!>equals4 != false<!>)   return "Fail 9.4"
 
-    if (toString1 != "1")   return "Fail 10.1"
+    if (<!EVALUATED("false")!>toString1 != "1"<!>)   return "Fail 10.1"
-    if (toString2 != "2")   return "Fail 10.2"
+    if (<!EVALUATED("false")!>toString2 != "2"<!>)   return "Fail 10.2"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/charOperations.kt

@@ -5,94 +5,94 @@
 // IGNORE_BACKEND_K1: NATIVE
 // WITH_STDLIB
 
-const val oneVal = '1'
+const val oneVal = <!EVALUATED("1")!>'1'<!>
-const val twoVal = '2'
+const val twoVal = <!EVALUATED("2")!>'2'<!>
-const val threeVal = '3'
+const val threeVal = <!EVALUATED("3")!>'3'<!>
-const val fourVal = '4'
+const val fourVal = <!EVALUATED("4")!>'4'<!>
 
-const val intVal = 5
+const val intVal = <!EVALUATED("5")!>5<!>
 
-const val compareTo1 = oneVal.compareTo(twoVal)
+const val compareTo1 = oneVal.<!EVALUATED("-1")!>compareTo(twoVal)<!>
-const val compareTo2 = twoVal.compareTo(twoVal)
+const val compareTo2 = twoVal.<!EVALUATED("0")!>compareTo(twoVal)<!>
-const val compareTo3 = threeVal.compareTo(twoVal)
+const val compareTo3 = threeVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
-const val compareTo4 = fourVal.compareTo(twoVal)
+const val compareTo4 = fourVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
 
-const val plus1 = oneVal.plus(intVal)
+const val plus1 = oneVal.<!EVALUATED("6")!>plus(intVal)<!>
-const val plus2 = twoVal.plus(intVal)
+const val plus2 = twoVal.<!EVALUATED("7")!>plus(intVal)<!>
-const val plus3 = threeVal.plus(intVal)
+const val plus3 = threeVal.<!EVALUATED("8")!>plus(intVal)<!>
-const val plus4 = fourVal.plus(intVal)
+const val plus4 = fourVal.<!EVALUATED("9")!>plus(intVal)<!>
 
-const val minusChar1 = oneVal.minus(twoVal)
+const val minusChar1 = oneVal.<!EVALUATED("-1")!>minus(twoVal)<!>
-const val minusChar2 = twoVal.minus(twoVal)
+const val minusChar2 = twoVal.<!EVALUATED("0")!>minus(twoVal)<!>
-const val minusChar3 = threeVal.minus(twoVal)
+const val minusChar3 = threeVal.<!EVALUATED("1")!>minus(twoVal)<!>
-const val minusChar4 = fourVal.minus(twoVal)
+const val minusChar4 = fourVal.<!EVALUATED("2")!>minus(twoVal)<!>
 
-const val minusInt1 = oneVal.minus(intVal)
+const val minusInt1 = oneVal.<!EVALUATED(",")!>minus(intVal)<!>
-const val minusInt2 = twoVal.minus(intVal)
+const val minusInt2 = twoVal.<!EVALUATED("-")!>minus(intVal)<!>
-const val minusInt3 = threeVal.minus(intVal)
+const val minusInt3 = threeVal.<!EVALUATED(".")!>minus(intVal)<!>
-const val minusInt4 = fourVal.minus(intVal)
+const val minusInt4 = fourVal.<!EVALUATED("/")!>minus(intVal)<!>
 
-const val convert1 = oneVal.toByte()
+const val convert1 = oneVal.<!EVALUATED("49")!>toByte()<!>
-const val convert2 = oneVal.toChar()
+const val convert2 = oneVal.<!EVALUATED("1")!>toChar()<!>
-const val convert3 = oneVal.toShort()
+const val convert3 = oneVal.<!EVALUATED("49")!>toShort()<!>
-const val convert4 = oneVal.toInt()
+const val convert4 = oneVal.<!EVALUATED("49")!>toInt()<!>
-const val convert5 = oneVal.toLong()
+const val convert5 = oneVal.<!EVALUATED("49")!>toLong()<!>
-const val convert6 = oneVal.toFloat()
+const val convert6 = oneVal.<!EVALUATED("49.0")!>toFloat()<!>
-const val convert7 = oneVal.toDouble()
+const val convert7 = oneVal.<!EVALUATED("49.0")!>toDouble()<!>
 
-const val equals1 = oneVal == twoVal
+const val equals1 = <!EVALUATED("false")!>oneVal == twoVal<!>
-const val equals2 = twoVal == twoVal
+const val equals2 = <!EVALUATED("true")!>twoVal == twoVal<!>
-const val equals3 = threeVal == twoVal
+const val equals3 = <!EVALUATED("false")!>threeVal == twoVal<!>
-const val equals4 = fourVal == twoVal
+const val equals4 = <!EVALUATED("false")!>fourVal == twoVal<!>
 
-const val toString1 = oneVal.toString()
+const val toString1 = oneVal.<!EVALUATED("1")!>toString()<!>
-const val toString2 = twoVal.toString()
+const val toString2 = twoVal.<!EVALUATED("2")!>toString()<!>
 
-const val code1 = oneVal.code
+const val code1 = oneVal.<!EVALUATED("49")!>code<!>
-const val code2 = twoVal.code
+const val code2 = twoVal.<!EVALUATED("50")!>code<!>
-const val code3 = threeVal.code
+const val code3 = threeVal.<!EVALUATED("51")!>code<!>
-const val code4 = fourVal.code
+const val code4 = fourVal.<!EVALUATED("52")!>code<!>
 
 fun box(): String {
-    if (compareTo1 != -1)   return "Fail 1.1"
+    if (<!EVALUATED("false")!>compareTo1 != -1<!>)   return "Fail 1.1"
-    if (compareTo2 != 0)    return "Fail 1.2"
+    if (<!EVALUATED("false")!>compareTo2 != 0<!>)    return "Fail 1.2"
-    if (compareTo3 != 1)    return "Fail 1.3"
+    if (<!EVALUATED("false")!>compareTo3 != 1<!>)    return "Fail 1.3"
-    if (compareTo4 != 1)    return "Fail 1.4"
+    if (<!EVALUATED("false")!>compareTo4 != 1<!>)    return "Fail 1.4"
 
-    if (plus1 != '6')   return "Fail 2.1"
+    if (<!EVALUATED("false")!>plus1 != '6'<!>)   return "Fail 2.1"
-    if (plus2 != '7')   return "Fail 2.2"
+    if (<!EVALUATED("false")!>plus2 != '7'<!>)   return "Fail 2.2"
-    if (plus3 != '8')   return "Fail 2.3"
+    if (<!EVALUATED("false")!>plus3 != '8'<!>)   return "Fail 2.3"
-    if (plus4 != '9')   return "Fail 2.4"
+    if (<!EVALUATED("false")!>plus4 != '9'<!>)   return "Fail 2.4"
 
-    if (minusChar1 != -1)   return "Fail 3.1"
+    if (<!EVALUATED("false")!>minusChar1 != -1<!>)   return "Fail 3.1"
-    if (minusChar2 != 0)    return "Fail 3.2"
+    if (<!EVALUATED("false")!>minusChar2 != 0<!>)    return "Fail 3.2"
-    if (minusChar3 != 1)    return "Fail 3.3"
+    if (<!EVALUATED("false")!>minusChar3 != 1<!>)    return "Fail 3.3"
-    if (minusChar4 != 2)    return "Fail 3.4"
+    if (<!EVALUATED("false")!>minusChar4 != 2<!>)    return "Fail 3.4"
 
-    if (minusInt1 != ',')   return "Fail 4.1"
+    if (<!EVALUATED("false")!>minusInt1 != ','<!>)   return "Fail 4.1"
-    if (minusInt2 != '-')   return "Fail 4.2"
+    if (<!EVALUATED("false")!>minusInt2 != '-'<!>)   return "Fail 4.2"
-    if (minusInt3 != '.')   return "Fail 4.3"
+    if (<!EVALUATED("false")!>minusInt3 != '.'<!>)   return "Fail 4.3"
-    if (minusInt4 != '/')   return "Fail 4.4"
+    if (<!EVALUATED("false")!>minusInt4 != '/'<!>)   return "Fail 4.4"
 
-    if (convert1 != 49.toByte())    return "Fail 5.1"
+    if (<!EVALUATED("false")!>convert1 != 49.toByte()<!>)    return "Fail 5.1"
-    if (convert2 != '1')            return "Fail 5.2"
+    if (<!EVALUATED("false")!>convert2 != '1'<!>)            return "Fail 5.2"
-    if (convert3 != 49.toShort())   return "Fail 5.3"
+    if (<!EVALUATED("false")!>convert3 != 49.toShort()<!>)   return "Fail 5.3"
-    if (convert4 != 49)             return "Fail 5.4"
+    if (<!EVALUATED("false")!>convert4 != 49<!>)             return "Fail 5.4"
-    if (convert5 != 49L)            return "Fail 5.5"
+    if (<!EVALUATED("false")!>convert5 != 49L<!>)            return "Fail 5.5"
-    if (convert6 != 49.0f)          return "Fail 5.6"
+    if (<!EVALUATED("false")!>convert6 != 49.0f<!>)          return "Fail 5.6"
-    if (convert7 != 49.0)           return "Fail 5.7"
+    if (<!EVALUATED("false")!>convert7 != 49.0<!>)           return "Fail 5.7"
 
-    if (equals1 != false)   return "Fail 6.1"
+    if (<!EVALUATED("false")!>equals1 != false<!>)   return "Fail 6.1"
-    if (equals2 != true)    return "Fail 6.2"
+    if (<!EVALUATED("false")!>equals2 != true<!>)    return "Fail 6.2"
-    if (equals3 != false)   return "Fail 6.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 6.3"
-    if (equals4 != false)   return "Fail 6.4"
+    if (<!EVALUATED("false")!>equals4 != false<!>)   return "Fail 6.4"
 
-    if (toString1 != "1")   return "Fail 7.1"
+    if (<!EVALUATED("false")!>toString1 != "1"<!>)   return "Fail 7.1"
-    if (toString2 != "2")   return "Fail 7.2"
+    if (<!EVALUATED("false")!>toString2 != "2"<!>)   return "Fail 7.2"
 
-    if (code1 != 49)   return "Fail 8.1"
+    if (<!EVALUATED("false")!>code1 != 49<!>)   return "Fail 8.1"
-    if (code2 != 50)   return "Fail 8.2"
+    if (<!EVALUATED("false")!>code2 != 50<!>)   return "Fail 8.2"
-    if (code3 != 51)   return "Fail 8.3"
+    if (<!EVALUATED("false")!>code3 != 51<!>)   return "Fail 8.3"
-    if (code4 != 52)   return "Fail 8.4"
+    if (<!EVALUATED("false")!>code4 != 52<!>)   return "Fail 8.4"
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/constTrimIndent.kt

@@ -3,16 +3,16 @@
 // IGNORE_BACKEND_K1: JVM_IR
 // WITH_STDLIB
 
-const val trimIndent = "123".trimIndent()
+const val trimIndent = "123".<!EVALUATED("123")!>trimIndent()<!>
 const val complexTrimIndent =
     """
             ABC
             123
             456
-        """.trimIndent()
+        """.<!EVALUATED("ABC\n123\n456")!>trimIndent()<!>
 
 fun box(): String {
-    if (trimIndent != "123") return "Fail 1"
+    if (<!EVALUATED("false")!>trimIndent != "123"<!>) return "Fail 1"
-    if (complexTrimIndent != "ABC\n123\n456") return "Fail 2"
+    if (<!EVALUATED("false")!>complexTrimIndent != "ABC\n123\n456"<!>) return "Fail 2"
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/constTrimMargin.kt

@@ -3,21 +3,21 @@
 // IGNORE_BACKEND_K1: JVM_IR
 // WITH_STDLIB
 
-const val trimMargin = "123".trimMargin()
+const val trimMargin = "123".<!EVALUATED("123")!>trimMargin()<!>
 
 const val trimMarginDefault = """ABC
                 |123
-                |456""".trimMargin()
+                |456""".<!EVALUATED("ABC\n123\n456")!>trimMargin()<!>
 
 const val withoutMargin = """
     #XYZ
     #foo
     #bar
-""".trimMargin("#")
+""".<!EVALUATED("XYZ\nfoo\nbar")!>trimMargin("#")<!>
 
 fun box(): String {
-    if (trimMargin != "123") return "Fail 1"
+    if (<!EVALUATED("false")!>trimMargin != "123"<!>) return "Fail 1"
-    if (trimMarginDefault != "ABC\n123\n456") return "Fail 2"
+    if (<!EVALUATED("false")!>trimMarginDefault != "ABC\n123\n456"<!>) return "Fail 2"
-    if (withoutMargin != "XYZ\nfoo\nbar") return "Fail 3"
+    if (<!EVALUATED("false")!>withoutMargin != "XYZ\nfoo\nbar"<!>) return "Fail 3"
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/doubleOperations.kt

@@ -3,168 +3,171 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: NATIVE
 
-const val minusOneVal = -1.0
+const val minusOneVal = <!EVALUATED("-1.0")!>-1.0<!>
-const val oneVal = 1.0
+const val oneVal = <!EVALUATED("1.0")!>1.0<!>
-const val twoVal = 2.0
+const val twoVal = <!EVALUATED("2.0")!>2.0<!>
-const val threeVal = 3.0
+const val threeVal = <!EVALUATED("3.0")!>3.0<!>
-const val fourVal = 4.0
+const val fourVal = <!EVALUATED("4.0")!>4.0<!>
-const val oneAndAHalf = 1.5
+const val oneAndAHalf = <!EVALUATED("1.5")!>1.5<!>
 
-const val byteVal = 2.toByte()
+const val byteVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val shortVal = 2.toShort()
+const val shortVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val intVal = 2
+const val intVal = <!EVALUATED("2")!>2<!>
-const val longVal = 2L
+const val longVal = <!EVALUATED("2")!>2L<!>
-const val floatVal = 2.0f
+const val floatVal = <!EVALUATED("2.0")!>2.0f<!>
-const val doubleVal = 2.0
+const val doubleVal = <!EVALUATED("2.0")!>2.0<!>
 
-const val compareTo1 = oneVal.compareTo(twoVal)
+const val compareTo1 = oneVal.<!EVALUATED("-1")!>compareTo(twoVal)<!>
-const val compareTo2 = twoVal.compareTo(twoVal)
+const val compareTo2 = twoVal.<!EVALUATED("0")!>compareTo(twoVal)<!>
-const val compareTo3 = threeVal.compareTo(twoVal)
+const val compareTo3 = threeVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
-const val compareTo4 = twoVal.compareTo(byteVal)
+const val compareTo4 = twoVal.<!EVALUATED("0")!>compareTo(byteVal)<!>
-const val compareTo5 = twoVal.compareTo(shortVal)
+const val compareTo5 = twoVal.<!EVALUATED("0")!>compareTo(shortVal)<!>
-const val compareTo6 = twoVal.compareTo(intVal)
+const val compareTo6 = twoVal.<!EVALUATED("0")!>compareTo(intVal)<!>
-const val compareTo7 = twoVal.compareTo(longVal)
+const val compareTo7 = twoVal.<!EVALUATED("0")!>compareTo(longVal)<!>
-const val compareTo8 = twoVal.compareTo(floatVal)
+const val compareTo8 = twoVal.<!EVALUATED("0")!>compareTo(floatVal)<!>
 
-const val plus1 = oneVal.plus(twoVal)
+const val plus1 = oneVal.<!EVALUATED("3.0")!>plus(twoVal)<!>
-const val plus2 = twoVal.plus(twoVal)
+const val plus2 = twoVal.<!EVALUATED("4.0")!>plus(twoVal)<!>
-const val plus3 = threeVal.plus(twoVal)
+const val plus3 = threeVal.<!EVALUATED("5.0")!>plus(twoVal)<!>
-const val plus4 = twoVal.plus(byteVal)
+const val plus4 = twoVal.<!EVALUATED("4.0")!>plus(byteVal)<!>
-const val plus5 = twoVal.plus(shortVal)
+const val plus5 = twoVal.<!EVALUATED("4.0")!>plus(shortVal)<!>
-const val plus6 = twoVal.plus(intVal)
+const val plus6 = twoVal.<!EVALUATED("4.0")!>plus(intVal)<!>
-const val plus7 = twoVal.plus(longVal)
+const val plus7 = twoVal.<!EVALUATED("4.0")!>plus(longVal)<!>
-const val plus8 = twoVal.plus(floatVal)
+const val plus8 = twoVal.<!EVALUATED("4.0")!>plus(floatVal)<!>
 
-const val minus1 = oneVal.minus(twoVal)
+const val minus1 = oneVal.<!EVALUATED("-1.0")!>minus(twoVal)<!>
-const val minus2 = twoVal.minus(twoVal)
+const val minus2 = twoVal.<!EVALUATED("0.0")!>minus(twoVal)<!>
-const val minus3 = threeVal.minus(twoVal)
+const val minus3 = threeVal.<!EVALUATED("1.0")!>minus(twoVal)<!>
-const val minus4 = twoVal.minus(byteVal)
+const val minus4 = twoVal.<!EVALUATED("0.0")!>minus(byteVal)<!>
-const val minus5 = twoVal.minus(shortVal)
+const val minus5 = twoVal.<!EVALUATED("0.0")!>minus(shortVal)<!>
-const val minus6 = twoVal.minus(intVal)
+const val minus6 = twoVal.<!EVALUATED("0.0")!>minus(intVal)<!>
-const val minus7 = twoVal.minus(longVal)
+const val minus7 = twoVal.<!EVALUATED("0.0")!>minus(longVal)<!>
-const val minus8 = twoVal.minus(floatVal)
+const val minus8 = twoVal.<!EVALUATED("0.0")!>minus(floatVal)<!>
 
-const val times1 = oneVal.times(twoVal)
+const val times1 = oneVal.<!EVALUATED("2.0")!>times(twoVal)<!>
-const val times2 = twoVal.times(twoVal)
+const val times2 = twoVal.<!EVALUATED("4.0")!>times(twoVal)<!>
-const val times3 = threeVal.times(twoVal)
+const val times3 = threeVal.<!EVALUATED("6.0")!>times(twoVal)<!>
-const val times4 = twoVal.times(byteVal)
+const val times4 = twoVal.<!EVALUATED("4.0")!>times(byteVal)<!>
-const val times5 = twoVal.times(shortVal)
+const val times5 = twoVal.<!EVALUATED("4.0")!>times(shortVal)<!>
-const val times6 = twoVal.times(intVal)
+const val times6 = twoVal.<!EVALUATED("4.0")!>times(intVal)<!>
-const val times7 = twoVal.times(longVal)
+const val times7 = twoVal.<!EVALUATED("4.0")!>times(longVal)<!>
-const val times8 = twoVal.times(floatVal)
+const val times8 = twoVal.<!EVALUATED("4.0")!>times(floatVal)<!>
 
-const val div1 = oneVal.div(twoVal)
+const val div1 = oneVal.<!EVALUATED("0.5")!>div(twoVal)<!>
-const val div2 = twoVal.div(twoVal)
+const val div2 = twoVal.<!EVALUATED("1.0")!>div(twoVal)<!>
-const val div3 = threeVal.div(twoVal)
+const val div3 = threeVal.<!EVALUATED("1.5")!>div(twoVal)<!>
-const val div4 = twoVal.div(byteVal)
+const val div4 = twoVal.<!EVALUATED("1.0")!>div(byteVal)<!>
-const val div5 = twoVal.div(shortVal)
+const val div5 = twoVal.<!EVALUATED("1.0")!>div(shortVal)<!>
-const val div6 = twoVal.div(intVal)
+const val div6 = twoVal.<!EVALUATED("1.0")!>div(intVal)<!>
-const val div7 = twoVal.div(longVal)
+const val div7 = twoVal.<!EVALUATED("1.0")!>div(longVal)<!>
-const val div8 = twoVal.div(floatVal)
+const val div8 = twoVal.<!EVALUATED("1.0")!>div(floatVal)<!>
 
-const val rem1 = oneVal.rem(twoVal)
+const val rem1 = oneVal.<!EVALUATED("1.0")!>rem(twoVal)<!>
-const val rem2 = twoVal.rem(twoVal)
+const val rem2 = twoVal.<!EVALUATED("0.0")!>rem(twoVal)<!>
-const val rem3 = threeVal.rem(twoVal)
+const val rem3 = threeVal.<!EVALUATED("1.0")!>rem(twoVal)<!>
-const val rem4 = twoVal.rem(byteVal)
+const val rem4 = twoVal.<!EVALUATED("0.0")!>rem(byteVal)<!>
-const val rem5 = twoVal.rem(shortVal)
+const val rem5 = twoVal.<!EVALUATED("0.0")!>rem(shortVal)<!>
-const val rem6 = twoVal.rem(intVal)
+const val rem6 = twoVal.<!EVALUATED("0.0")!>rem(intVal)<!>
-const val rem7 = twoVal.rem(longVal)
+const val rem7 = twoVal.<!EVALUATED("0.0")!>rem(longVal)<!>
-const val rem8 = twoVal.rem(floatVal)
+const val rem8 = twoVal.<!EVALUATED("0.0")!>rem(floatVal)<!>
 
-const val unaryPlus1 = oneVal.unaryPlus()
+const val unaryPlus1 = oneVal.<!EVALUATED("1.0")!>unaryPlus()<!>
-const val unaryPlus2 = minusOneVal.unaryPlus()
+const val unaryPlus2 = minusOneVal.<!EVALUATED("-1.0")!>unaryPlus()<!>
-const val unaryMinus1 = oneVal.unaryMinus()
+const val unaryMinus1 = oneVal.<!EVALUATED("-1.0")!>unaryMinus()<!>
-const val unaryMinus2 = minusOneVal.unaryMinus()
+const val unaryMinus2 = minusOneVal.<!EVALUATED("1.0")!>unaryMinus()<!>
 
-const val convert1 = oneVal.toChar()
+const val convert1 = oneVal.<!EVALUATED("
")!>toChar()<!>
-const val convert2 = oneVal.toInt()
+const val convert2 = oneVal.<!EVALUATED("1")!>toInt()<!>
-const val convert3 = oneVal.toLong()
+const val convert3 = oneVal.<!EVALUATED("1")!>toLong()<!>
-const val convert4 = oneVal.toFloat()
+const val convert4 = oneVal.<!EVALUATED("1.0")!>toFloat()<!>
-const val convert5 = oneVal.toDouble()
+const val convert5 = oneVal.<!EVALUATED("1.0")!>toDouble()<!>
 
-const val equals1 = oneVal == twoVal
+const val equals1 = <!EVALUATED("false")!>oneVal == twoVal<!>
-const val equals2 = twoVal == twoVal
+const val equals2 = <!EVALUATED("true")!>twoVal == twoVal<!>
-const val equals3 = threeVal == twoVal
+const val equals3 = <!EVALUATED("false")!>threeVal == twoVal<!>
-const val equals4 = fourVal == twoVal
+const val equals4 = <!EVALUATED("false")!>fourVal == twoVal<!>
 
-const val toString1 = oneVal.toString()
+const val toString1 = oneVal.<!EVALUATED("1.0")!>toString()<!>
-const val toString2 = twoVal.toString()
+const val toString2 = twoVal.<!EVALUATED("2.0")!>toString()<!>
-const val toString3 = oneAndAHalf.toString()
+const val toString3 = oneAndAHalf.<!EVALUATED("1.5")!>toString()<!>
+
+fun <T> T.id(): T = this
 
 fun box(): String {
-    if (compareTo1 != -1)   return "Fail 1.1"
+    if (<!EVALUATED("false")!>compareTo1 != -1<!>)   return "Fail 1.1"
-    if (compareTo2 != 0)    return "Fail 1.2"
+    if (<!EVALUATED("false")!>compareTo2 != 0<!>)    return "Fail 1.2"
-    if (compareTo3 != 1)    return "Fail 1.3"
+    if (<!EVALUATED("false")!>compareTo3 != 1<!>)    return "Fail 1.3"
-    if (compareTo4 != 0)    return "Fail 1.4"
+    if (<!EVALUATED("false")!>compareTo4 != 0<!>)    return "Fail 1.4"
-    if (compareTo5 != 0)    return "Fail 1.5"
+    if (<!EVALUATED("false")!>compareTo5 != 0<!>)    return "Fail 1.5"
-    if (compareTo6 != 0)    return "Fail 1.6"
+    if (<!EVALUATED("false")!>compareTo6 != 0<!>)    return "Fail 1.6"
-    if (compareTo7 != 0)    return "Fail 1.7"
+    if (<!EVALUATED("false")!>compareTo7 != 0<!>)    return "Fail 1.7"
-    if (compareTo8 != 0)    return "Fail 1.8"
+    if (<!EVALUATED("false")!>compareTo8 != 0<!>)    return "Fail 1.8"
 
-    if (plus1 != 3.0)     return "Fail 2.1"
+    if (<!EVALUATED("false")!>plus1 != 3.0<!>)     return "Fail 2.1"
-    if (plus2 != 4.0)     return "Fail 2.2"
+    if (<!EVALUATED("false")!>plus2 != 4.0<!>)     return "Fail 2.2"
-    if (plus3 != 5.0)     return "Fail 2.3"
+    if (<!EVALUATED("false")!>plus3 != 5.0<!>)     return "Fail 2.3"
-    if (plus4 != 4.0)     return "Fail 2.4"
+    if (<!EVALUATED("false")!>plus4 != 4.0<!>)     return "Fail 2.4"
-    if (plus5 != 4.0)     return "Fail 2.5"
+    if (<!EVALUATED("false")!>plus5 != 4.0<!>)     return "Fail 2.5"
-    if (plus6 != 4.0)     return "Fail 2.6"
+    if (<!EVALUATED("false")!>plus6 != 4.0<!>)     return "Fail 2.6"
-    if (plus7 != 4.0)  return "Fail 2.7"
+    if (<!EVALUATED("false")!>plus7 != 4.0<!>)  return "Fail 2.7"
-    if (plus8 != 4.0)   return "Fail 2.8"
+    if (<!EVALUATED("false")!>plus8 != 4.0<!>)   return "Fail 2.8"
 
-    if (minus1 != -1.0)       return "Fail 3.1"
+    if (<!EVALUATED("false")!>minus1 != -1.0<!>)       return "Fail 3.1"
-    if (minus2 != 0.0)        return "Fail 3.2"
+    if (<!EVALUATED("false")!>minus2 != 0.0<!>)        return "Fail 3.2"
-    if (minus3 != 1.0)        return "Fail 3.3"
+    if (<!EVALUATED("false")!>minus3 != 1.0<!>)        return "Fail 3.3"
-    if (minus4 != 0.0)        return "Fail 3.4"
+    if (<!EVALUATED("false")!>minus4 != 0.0<!>)        return "Fail 3.4"
-    if (minus5 != 0.0)        return "Fail 3.5"
+    if (<!EVALUATED("false")!>minus5 != 0.0<!>)        return "Fail 3.5"
-    if (minus6 != 0.0)        return "Fail 3.6"
+    if (<!EVALUATED("false")!>minus6 != 0.0<!>)        return "Fail 3.6"
-    if (minus7 != 0.0)     return "Fail 3.7"
+    if (<!EVALUATED("false")!>minus7 != 0.0<!>)     return "Fail 3.7"
-    if (minus8 != 0.0)      return "Fail 3.8"
+    if (<!EVALUATED("false")!>minus8 != 0.0<!>)      return "Fail 3.8"
 
-    if (times1 != 2.0)        return "Fail 4.1"
+    if (<!EVALUATED("false")!>times1 != 2.0<!>)        return "Fail 4.1"
-    if (times2 != 4.0)        return "Fail 4.2"
+    if (<!EVALUATED("false")!>times2 != 4.0<!>)        return "Fail 4.2"
-    if (times3 != 6.0)        return "Fail 4.3"
+    if (<!EVALUATED("false")!>times3 != 6.0<!>)        return "Fail 4.3"
-    if (times4 != 4.0)        return "Fail 4.4"
+    if (<!EVALUATED("false")!>times4 != 4.0<!>)        return "Fail 4.4"
-    if (times5 != 4.0)        return "Fail 4.5"
+    if (<!EVALUATED("false")!>times5 != 4.0<!>)        return "Fail 4.5"
-    if (times6 != 4.0)        return "Fail 4.6"
+    if (<!EVALUATED("false")!>times6 != 4.0<!>)        return "Fail 4.6"
-    if (times7 != 4.0)     return "Fail 4.7"
+    if (<!EVALUATED("false")!>times7 != 4.0<!>)     return "Fail 4.7"
-    if (times8 != 4.0)      return "Fail 4.8"
+    if (<!EVALUATED("false")!>times8 != 4.0<!>)      return "Fail 4.8"
 
-    if (div1 != 0.5)        return "Fail 5.1"
+    if (<!EVALUATED("false")!>div1 != 0.5<!>)        return "Fail 5.1"
-    if (div2 != 1.0)        return "Fail 5.2"
+    if (<!EVALUATED("false")!>div2 != 1.0<!>)        return "Fail 5.2"
-    if (div3 != 1.5)        return "Fail 5.3"
+    if (<!EVALUATED("false")!>div3 != 1.5<!>)        return "Fail 5.3"
-    if (div4 != 1.0)          return "Fail 5.4"
+    if (<!EVALUATED("false")!>div4 != 1.0<!>)          return "Fail 5.4"
-    if (div5 != 1.0)          return "Fail 5.5"
+    if (<!EVALUATED("false")!>div5 != 1.0<!>)          return "Fail 5.5"
-    if (div6 != 1.0)          return "Fail 5.6"
+    if (<!EVALUATED("false")!>div6 != 1.0<!>)          return "Fail 5.6"
-    if (div7 != 1.0)       return "Fail 5.7"
+    if (<!EVALUATED("false")!>div7 != 1.0<!>)       return "Fail 5.7"
-    if (div8 != 1.0)        return "Fail 5.8"
+    if (<!EVALUATED("false")!>div8 != 1.0<!>)        return "Fail 5.8"
 
-    if (rem1 != 1.0)      return "Fail 6.1"
+    if (<!EVALUATED("false")!>rem1 != 1.0<!>)      return "Fail 6.1"
-    if (rem2 != 0.0)      return "Fail 6.2"
+    if (<!EVALUATED("false")!>rem2 != 0.0<!>)      return "Fail 6.2"
-    if (rem3 != 1.0)      return "Fail 6.3"
+    if (<!EVALUATED("false")!>rem3 != 1.0<!>)      return "Fail 6.3"
-    if (rem4 != 0.0)      return "Fail 6.4"
+    if (<!EVALUATED("false")!>rem4 != 0.0<!>)      return "Fail 6.4"
-    if (rem5 != 0.0)      return "Fail 6.5"
+    if (<!EVALUATED("false")!>rem5 != 0.0<!>)      return "Fail 6.5"
-    if (rem6 != 0.0)      return "Fail 6.6"
+    if (<!EVALUATED("false")!>rem6 != 0.0<!>)      return "Fail 6.6"
-    if (rem7 != 0.0)   return "Fail 6.7"
+    if (<!EVALUATED("false")!>rem7 != 0.0<!>)   return "Fail 6.7"
-    if (rem8 != 0.0)    return "Fail 6.8"
+    if (<!EVALUATED("false")!>rem8 != 0.0<!>)    return "Fail 6.8"
 
-    if (unaryPlus1 != 1.0)    return "Fail 7.1"
+    if (<!EVALUATED("false")!>unaryPlus1 != 1.0<!>)    return "Fail 7.1"
-    if (unaryPlus2 != -1.0)   return "Fail 7.2"
+    if (<!EVALUATED("false")!>unaryPlus2 != -1.0<!>)   return "Fail 7.2"
-    if (unaryMinus1 != -1.0)  return "Fail 7.3"
+    if (<!EVALUATED("false")!>unaryMinus1 != -1.0<!>)  return "Fail 7.3"
-    if (unaryMinus2 != 1.0)   return "Fail 7.4"
+    if (<!EVALUATED("false")!>unaryMinus2 != 1.0<!>)   return "Fail 7.4"
 
-    if (convert1 != '
')  return "Fail 8.1"
+    if (<!EVALUATED("false")!>convert1 != '
'<!>)  return "Fail 8.1"
-    if (convert2 != 1)      return "Fail 8.2"
+    if (<!EVALUATED("false")!>convert2 != 1<!>)      return "Fail 8.2"
-    if (convert3 != 1L)      return "Fail 8.3"
+    if (<!EVALUATED("false")!>convert3 != 1L<!>)      return "Fail 8.3"
-    if (convert4 != 1.0f)   return "Fail 8.4"
+    if (<!EVALUATED("false")!>convert4 != 1.0f<!>)   return "Fail 8.4"
-    if (convert5 != 1.0)    return "Fail 8.5"
+    if (<!EVALUATED("false")!>convert5 != 1.0<!>)    return "Fail 8.5"
 
-    if (equals1 != false)   return "Fail 9.1"
+    if (<!EVALUATED("false")!>equals1 != false<!>)   return "Fail 9.1"
-    if (equals2 != true)    return "Fail 9.2"
+    if (<!EVALUATED("false")!>equals2 != true<!>)    return "Fail 9.2"
-    if (equals3 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 9.3"
-    if (equals4 != false)   return "Fail 9.4"
+    if (<!EVALUATED("false")!>equals4 != false<!>)   return "Fail 9.4"
 
-    if (toString1 != "1.0" && toString1 != "1" /* JS */)    return "Fail 10.1"
+    // id is needed to avoid evaluation and so match different cases for JVM and JS
-    if (toString2 != "2.0" && toString2 != "2" /* JS */)    return "Fail 10.2"
+    if (<!EVALUATED("1.0")!>toString1<!>.id() != "1.0" && <!EVALUATED("1.0")!>toString1<!>.id() != "1" /* JS */)    return "Fail 10.1"
-    if (toString3 != "1.5")                                 return "Fail 10.3"
+    if (<!EVALUATED("2.0")!>toString2<!>.id() != "2.0" && <!EVALUATED("2.0")!>toString2<!>.id() != "2" /* JS */)    return "Fail 10.2"
+    if (<!EVALUATED("1.5")!>toString3<!>.id() != "1.5")                                      return "Fail 10.3"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/enumName.kt

@@ -6,15 +6,15 @@ enum class EnumClass {
     OK, VALUE, anotherValue, WITH_UNDERSCORE
 }
 
-const val name1 = EnumClass.OK.name
+const val name1 = EnumClass.OK.<!EVALUATED("OK")!>name<!>
-const val name2 = EnumClass.VALUE.name
+const val name2 = EnumClass.VALUE.<!EVALUATED("VALUE")!>name<!>
-const val name3 = EnumClass.anotherValue.name
+const val name3 = EnumClass.anotherValue.<!EVALUATED("anotherValue")!>name<!>
-const val name4 = EnumClass.WITH_UNDERSCORE.name
+const val name4 = EnumClass.WITH_UNDERSCORE.<!EVALUATED("WITH_UNDERSCORE")!>name<!>
 
 fun box(): String {
-    if (EnumClass.OK.name != "OK") return "Fail 1"
+    if (<!EVALUATED("false")!>EnumClass.OK.name != "OK"<!>) return "Fail 1"
-    if (name2 != "VALUE") return "Fail 2"
+    if (<!EVALUATED("false")!>name2 != "VALUE"<!>) return "Fail 2"
-    if (name3 != "anotherValue") return "Fail 3"
+    if (<!EVALUATED("false")!>name3 != "anotherValue"<!>) return "Fail 3"
-    if (name4 != "WITH_UNDERSCORE") return "Fail 4"
+    if (<!EVALUATED("false")!>name4 != "WITH_UNDERSCORE"<!>) return "Fail 4"
-    return name1
+    return <!EVALUATED("OK")!>name1<!>
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/enumRecursiveName.kt

@@ -1,14 +1,11 @@
 // TARGET_BACKEND: JVM_IR
-// IGNORE_FIR_DIAGNOSTICS
+// IGNORE_BACKEND_K2: JVM_IR
-// IGNORE_BACKEND_K1: JVM_IR
-// !DIAGNOSTICS: -UNINITIALIZED_ENUM_ENTRY
 
 enum class TestEnum(val testNaming: String) {
-    OK(OK.name),
+    OK(OK.<!EVALUATED("OK")!>name<!>),
 }
 
-const val name = TestEnum.OK.name
-
 fun box(): String {
+    val name = TestEnum.OK.<!EVALUATED("OK")!>name<!>
     return name
 }

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/equals_after.kt

@@ -1,141 +1,141 @@
 // !LANGUAGE: +IntrinsicConstEvaluation
 // TARGET_BACKEND: JVM_IR
 
-const val trueVal = true
+const val trueVal = <!EVALUATED("true")!>true<!>
-const val falseVal = false
+const val falseVal = <!EVALUATED("false")!>false<!>
 
-const val charOneVal = '1'
+const val charOneVal = <!EVALUATED("1")!>'1'<!>
-const val charTwoVal = '2'
+const val charTwoVal = <!EVALUATED("2")!>'2'<!>
-const val charThreeVal = '3'
+const val charThreeVal = <!EVALUATED("3")!>'3'<!>
-const val charFourVal = '4'
+const val charFourVal = <!EVALUATED("4")!>'4'<!>
 
-const val byteMinusOneVal = (-1).toByte()
+const val byteMinusOneVal = (-1).<!EVALUATED("-1")!>toByte()<!>
-const val byteOneVal = 1.toByte()
+const val byteOneVal = 1.<!EVALUATED("1")!>toByte()<!>
-const val byteTwoVal = 2.toByte()
+const val byteTwoVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val byteThreeVal = 3.toByte()
+const val byteThreeVal = 3.<!EVALUATED("3")!>toByte()<!>
-const val byteFourVal = 4.toByte()
+const val byteFourVal = 4.<!EVALUATED("4")!>toByte()<!>
 
-const val shortMinusOneVal = (-1).toShort()
+const val shortMinusOneVal = (-1).<!EVALUATED("-1")!>toShort()<!>
-const val shortOneVal = 1.toShort()
+const val shortOneVal = 1.<!EVALUATED("1")!>toShort()<!>
-const val shortTwoVal = 2.toShort()
+const val shortTwoVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val shortThreeVal = 3.toShort()
+const val shortThreeVal = 3.<!EVALUATED("3")!>toShort()<!>
-const val shortFourVal = 4.toShort()
+const val shortFourVal = 4.<!EVALUATED("4")!>toShort()<!>
 
-const val intMinusOneVal = -1
+const val intMinusOneVal = <!EVALUATED("-1")!>-1<!>
-const val intOneVal = 1
+const val intOneVal = <!EVALUATED("1")!>1<!>
-const val intTwoVal = 2
+const val intTwoVal = <!EVALUATED("2")!>2<!>
-const val intThreeVal = 3
+const val intThreeVal = <!EVALUATED("3")!>3<!>
-const val intFourVal = 4
+const val intFourVal = <!EVALUATED("4")!>4<!>
 
-const val longMinusOneVal = -1L
+const val longMinusOneVal = <!EVALUATED("-1")!>-1L<!>
-const val longOneVal = 1L
+const val longOneVal = <!EVALUATED("1")!>1L<!>
-const val longTwoVal = 2L
+const val longTwoVal = <!EVALUATED("2")!>2L<!>
-const val longThreeVal = 3L
+const val longThreeVal = <!EVALUATED("3")!>3L<!>
-const val longFourVal = 4L
+const val longFourVal = <!EVALUATED("4")!>4L<!>
 
-const val floatMinusOneVal = -1.0f
+const val floatMinusOneVal = <!EVALUATED("-1.0")!>-1.0f<!>
-const val floatOneVal = 1.0f
+const val floatOneVal = <!EVALUATED("1.0")!>1.0f<!>
-const val floatTwoVal = 2.0f
+const val floatTwoVal = <!EVALUATED("2.0")!>2.0f<!>
-const val floatThreeVal = 3.0f
+const val floatThreeVal = <!EVALUATED("3.0")!>3.0f<!>
-const val floatFourVal = 4.0f
+const val floatFourVal = <!EVALUATED("4.0")!>4.0f<!>
 
-const val doubleMinusOneVal = -1.0
+const val doubleMinusOneVal = <!EVALUATED("-1.0")!>-1.0<!>
-const val doubleOneVal = 1.0
+const val doubleOneVal = <!EVALUATED("1.0")!>1.0<!>
-const val doubleTwoVal = 2.0
+const val doubleTwoVal = <!EVALUATED("2.0")!>2.0<!>
-const val doubleThreeVal = 3.0
+const val doubleThreeVal = <!EVALUATED("3.0")!>3.0<!>
-const val doubleFourVal = 4.0
+const val doubleFourVal = <!EVALUATED("4.0")!>4.0<!>
 
-const val someStr = "123"
+const val someStr = <!EVALUATED("123")!>"123"<!>
-const val otherStr = "other"
+const val otherStr = <!EVALUATED("other")!>"other"<!>
 
-const val equalsBoolean1 = trueVal.equals(trueVal)
+const val equalsBoolean1 = trueVal.<!EVALUATED("true")!>equals(trueVal)<!>
-const val equalsBoolean2 = trueVal == falseVal
+const val equalsBoolean2 = <!EVALUATED("false")!>trueVal == falseVal<!>
-const val equalsBoolean3 = falseVal.equals(1)
+const val equalsBoolean3 = falseVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsChar1 = charOneVal.equals(charTwoVal)
+const val equalsChar1 = charOneVal.<!EVALUATED("false")!>equals(charTwoVal)<!>
-const val equalsChar2 = charTwoVal.equals(charTwoVal)
+const val equalsChar2 = charTwoVal.<!EVALUATED("true")!>equals(charTwoVal)<!>
-const val equalsChar3 = charThreeVal == charTwoVal
+const val equalsChar3 = <!EVALUATED("false")!>charThreeVal == charTwoVal<!>
-const val equalsChar4 = charFourVal.equals(1)
+const val equalsChar4 = charFourVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsByte1 = byteOneVal.equals(byteTwoVal)
+const val equalsByte1 = byteOneVal.<!EVALUATED("false")!>equals(byteTwoVal)<!>
-const val equalsByte2 = byteTwoVal.equals(byteTwoVal)
+const val equalsByte2 = byteTwoVal.<!EVALUATED("true")!>equals(byteTwoVal)<!>
-const val equalsByte3 = byteThreeVal == byteTwoVal
+const val equalsByte3 = <!EVALUATED("false")!>byteThreeVal == byteTwoVal<!>
-const val equalsByte4 = byteFourVal.equals(1)
+const val equalsByte4 = byteFourVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsShort1 = shortOneVal.equals(shortTwoVal)
+const val equalsShort1 = shortOneVal.<!EVALUATED("false")!>equals(shortTwoVal)<!>
-const val equalsShort2 = shortTwoVal.equals(shortTwoVal)
+const val equalsShort2 = shortTwoVal.<!EVALUATED("true")!>equals(shortTwoVal)<!>
-const val equalsShort3 = shortThreeVal == shortTwoVal
+const val equalsShort3 = <!EVALUATED("false")!>shortThreeVal == shortTwoVal<!>
-const val equalsShort4 = shortFourVal.equals(1)
+const val equalsShort4 = shortFourVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsInt1 = intOneVal.equals(intTwoVal)
+const val equalsInt1 = intOneVal.<!EVALUATED("false")!>equals(intTwoVal)<!>
-const val equalsInt2 = intTwoVal.equals(intTwoVal)
+const val equalsInt2 = intTwoVal.<!EVALUATED("true")!>equals(intTwoVal)<!>
-const val equalsInt3 = intThreeVal == intTwoVal
+const val equalsInt3 = <!EVALUATED("false")!>intThreeVal == intTwoVal<!>
-const val equalsInt4 = intFourVal.equals(1)
+const val equalsInt4 = intFourVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsLong1 = longOneVal.equals(longTwoVal)
+const val equalsLong1 = longOneVal.<!EVALUATED("false")!>equals(longTwoVal)<!>
-const val equalsLong2 = longTwoVal.equals(longTwoVal)
+const val equalsLong2 = longTwoVal.<!EVALUATED("true")!>equals(longTwoVal)<!>
-const val equalsLong3 = longThreeVal == longTwoVal
+const val equalsLong3 = <!EVALUATED("false")!>longThreeVal == longTwoVal<!>
-const val equalsLong4 = longFourVal.equals(1)
+const val equalsLong4 = longFourVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsFloat1 = floatOneVal.equals(floatTwoVal)
+const val equalsFloat1 = floatOneVal.<!EVALUATED("false")!>equals(floatTwoVal)<!>
-const val equalsFloat2 = floatTwoVal.equals(floatTwoVal)
+const val equalsFloat2 = floatTwoVal.<!EVALUATED("true")!>equals(floatTwoVal)<!>
-const val equalsFloat3 = floatThreeVal == floatTwoVal
+const val equalsFloat3 = <!EVALUATED("false")!>floatThreeVal == floatTwoVal<!>
-const val equalsFloat4 = floatFourVal.equals(1)
+const val equalsFloat4 = floatFourVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsDouble1 = doubleOneVal.equals(doubleTwoVal)
+const val equalsDouble1 = doubleOneVal.<!EVALUATED("false")!>equals(doubleTwoVal)<!>
-const val equalsDouble2 = doubleTwoVal.equals(doubleTwoVal)
+const val equalsDouble2 = doubleTwoVal.<!EVALUATED("true")!>equals(doubleTwoVal)<!>
-const val equalsDouble3 = doubleThreeVal == doubleTwoVal
+const val equalsDouble3 = <!EVALUATED("false")!>doubleThreeVal == doubleTwoVal<!>
-const val equalsDouble4 = doubleFourVal.equals(1)
+const val equalsDouble4 = doubleFourVal.<!EVALUATED("false")!>equals(1)<!>
 
-const val equalsString1 = someStr.equals(otherStr)
+const val equalsString1 = someStr.<!EVALUATED("false")!>equals(otherStr)<!>
-const val equalsString2 = someStr.equals("123")
+const val equalsString2 = someStr.<!EVALUATED("true")!>equals("123")<!>
-const val equalsString3 = otherStr == someStr
+const val equalsString3 = <!EVALUATED("false")!>otherStr == someStr<!>
-const val equalsString4 = someStr.equals(1)
+const val equalsString4 = someStr.<!EVALUATED("false")!>equals(1)<!>
 
 fun box(): String {
-    if (equalsBoolean1 != true)    return "Fail 1.1"
+    if (<!EVALUATED("false")!>equalsBoolean1 != true<!>)    return "Fail 1.1"
-    if (equalsBoolean2 != false)   return "Fail 1.2"
+    if (<!EVALUATED("false")!>equalsBoolean2 != false<!>)   return "Fail 1.2"
-    if (equalsBoolean3 != false)   return "Fail 1.3"
+    if (<!EVALUATED("false")!>equalsBoolean3 != false<!>)   return "Fail 1.3"
 
-    if (equalsChar1 != false)   return "Fail 2.1"
+    if (<!EVALUATED("false")!>equalsChar1 != false<!>)   return "Fail 2.1"
-    if (equalsChar2 != true)    return "Fail 2.2"
+    if (<!EVALUATED("false")!>equalsChar2 != true<!>)    return "Fail 2.2"
-    if (equalsChar3 != false)   return "Fail 2.3"
+    if (<!EVALUATED("false")!>equalsChar3 != false<!>)   return "Fail 2.3"
-    if (equalsChar4 != false)   return "Fail 2.3"
+    if (<!EVALUATED("false")!>equalsChar4 != false<!>)   return "Fail 2.3"
 
-    if (equalsByte1 != false)   return "Fail 3.1"
+    if (<!EVALUATED("false")!>equalsByte1 != false<!>)   return "Fail 3.1"
-    if (equalsByte2 != true)    return "Fail 3.2"
+    if (<!EVALUATED("false")!>equalsByte2 != true<!>)    return "Fail 3.2"
-    if (equalsByte3 != false)   return "Fail 3.3"
+    if (<!EVALUATED("false")!>equalsByte3 != false<!>)   return "Fail 3.3"
-    if (equalsByte4 != false)   return "Fail 3.3"
+    if (<!EVALUATED("false")!>equalsByte4 != false<!>)   return "Fail 3.3"
 
-    if (equalsShort1 != false)   return "Fail 4.1"
+    if (<!EVALUATED("false")!>equalsShort1 != false<!>)   return "Fail 4.1"
-    if (equalsShort2 != true)    return "Fail 4.2"
+    if (<!EVALUATED("false")!>equalsShort2 != true<!>)    return "Fail 4.2"
-    if (equalsShort3 != false)   return "Fail 4.3"
+    if (<!EVALUATED("false")!>equalsShort3 != false<!>)   return "Fail 4.3"
-    if (equalsShort4 != false)   return "Fail 4.3"
+    if (<!EVALUATED("false")!>equalsShort4 != false<!>)   return "Fail 4.3"
 
-    if (equalsInt1 != false)   return "Fail 5.1"
+    if (<!EVALUATED("false")!>equalsInt1 != false<!>)   return "Fail 5.1"
-    if (equalsInt2 != true)    return "Fail 5.2"
+    if (<!EVALUATED("false")!>equalsInt2 != true<!>)    return "Fail 5.2"
-    if (equalsInt3 != false)   return "Fail 5.3"
+    if (<!EVALUATED("false")!>equalsInt3 != false<!>)   return "Fail 5.3"
-    if (equalsInt4 != false)   return "Fail 5.3"
+    if (<!EVALUATED("false")!>equalsInt4 != false<!>)   return "Fail 5.3"
 
-    if (equalsLong1 != false)   return "Fail 6.1"
+    if (<!EVALUATED("false")!>equalsLong1 != false<!>)   return "Fail 6.1"
-    if (equalsLong2 != true)    return "Fail 6.2"
+    if (<!EVALUATED("false")!>equalsLong2 != true<!>)    return "Fail 6.2"
-    if (equalsLong3 != false)   return "Fail 6.3"
+    if (<!EVALUATED("false")!>equalsLong3 != false<!>)   return "Fail 6.3"
-    if (equalsLong4 != false)   return "Fail 6.3"
+    if (<!EVALUATED("false")!>equalsLong4 != false<!>)   return "Fail 6.3"
 
-    if (equalsFloat1 != false)   return "Fail 7.1"
+    if (<!EVALUATED("false")!>equalsFloat1 != false<!>)   return "Fail 7.1"
-    if (equalsFloat2 != true)    return "Fail 7.2"
+    if (<!EVALUATED("false")!>equalsFloat2 != true<!>)    return "Fail 7.2"
-    if (equalsFloat3 != false)   return "Fail 7.3"
+    if (<!EVALUATED("false")!>equalsFloat3 != false<!>)   return "Fail 7.3"
-    if (equalsFloat4 != false)   return "Fail 7.3"
+    if (<!EVALUATED("false")!>equalsFloat4 != false<!>)   return "Fail 7.3"
 
-    if (equalsDouble1 != false)   return "Fail 8.1"
+    if (<!EVALUATED("false")!>equalsDouble1 != false<!>)   return "Fail 8.1"
-    if (equalsDouble2 != true)    return "Fail 8.2"
+    if (<!EVALUATED("false")!>equalsDouble2 != true<!>)    return "Fail 8.2"
-    if (equalsDouble3 != false)   return "Fail 8.3"
+    if (<!EVALUATED("false")!>equalsDouble3 != false<!>)   return "Fail 8.3"
-    if (equalsDouble4 != false)   return "Fail 8.3"
+    if (<!EVALUATED("false")!>equalsDouble4 != false<!>)   return "Fail 8.3"
 
-    if (equalsString1 != false)   return "Fail 9.1"
+    if (<!EVALUATED("false")!>equalsString1 != false<!>)   return "Fail 9.1"
-    if (equalsString2 != true)    return "Fail 9.2"
+    if (<!EVALUATED("false")!>equalsString2 != true<!>)    return "Fail 9.2"
-    if (equalsString3 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equalsString3 != false<!>)   return "Fail 9.3"
-    if (equalsString4 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equalsString4 != false<!>)   return "Fail 9.3"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/floatOperations.kt

@@ -3,168 +3,171 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: NATIVE
 
-const val minusOneVal = -1.0f
+const val minusOneVal = <!EVALUATED("-1.0")!>-1.0f<!>
-const val oneVal = 1.0f
+const val oneVal = <!EVALUATED("1.0")!>1.0f<!>
-const val twoVal = 2.0f
+const val twoVal = <!EVALUATED("2.0")!>2.0f<!>
-const val threeVal = 3.0f
+const val threeVal = <!EVALUATED("3.0")!>3.0f<!>
-const val fourVal = 4.0f
+const val fourVal = <!EVALUATED("4.0")!>4.0f<!>
-const val oneAndAHalf = 1.5f
+const val oneAndAHalf = <!EVALUATED("1.5")!>1.5f<!>
 
-const val byteVal = 2.toByte()
+const val byteVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val shortVal = 2.toShort()
+const val shortVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val intVal = 2
+const val intVal = <!EVALUATED("2")!>2<!>
-const val longVal = 2L
+const val longVal = <!EVALUATED("2")!>2L<!>
-const val floatVal = 2.0f
+const val floatVal = <!EVALUATED("2.0")!>2.0f<!>
-const val doubleVal = 2.0
+const val doubleVal = <!EVALUATED("2.0")!>2.0<!>
 
-const val compareTo1 = oneVal.compareTo(twoVal)
+const val compareTo1 = oneVal.<!EVALUATED("-1")!>compareTo(twoVal)<!>
-const val compareTo2 = twoVal.compareTo(twoVal)
+const val compareTo2 = twoVal.<!EVALUATED("0")!>compareTo(twoVal)<!>
-const val compareTo3 = threeVal.compareTo(twoVal)
+const val compareTo3 = threeVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
-const val compareTo4 = twoVal.compareTo(byteVal)
+const val compareTo4 = twoVal.<!EVALUATED("0")!>compareTo(byteVal)<!>
-const val compareTo5 = twoVal.compareTo(shortVal)
+const val compareTo5 = twoVal.<!EVALUATED("0")!>compareTo(shortVal)<!>
-const val compareTo6 = twoVal.compareTo(intVal)
+const val compareTo6 = twoVal.<!EVALUATED("0")!>compareTo(intVal)<!>
-const val compareTo7 = twoVal.compareTo(longVal)
+const val compareTo7 = twoVal.<!EVALUATED("0")!>compareTo(longVal)<!>
-const val compareTo8 = twoVal.compareTo(doubleVal)
+const val compareTo8 = twoVal.<!EVALUATED("0")!>compareTo(doubleVal)<!>
 
-const val plus1 = oneVal.plus(twoVal)
+const val plus1 = oneVal.<!EVALUATED("3.0")!>plus(twoVal)<!>
-const val plus2 = twoVal.plus(twoVal)
+const val plus2 = twoVal.<!EVALUATED("4.0")!>plus(twoVal)<!>
-const val plus3 = threeVal.plus(twoVal)
+const val plus3 = threeVal.<!EVALUATED("5.0")!>plus(twoVal)<!>
-const val plus4 = twoVal.plus(byteVal)
+const val plus4 = twoVal.<!EVALUATED("4.0")!>plus(byteVal)<!>
-const val plus5 = twoVal.plus(shortVal)
+const val plus5 = twoVal.<!EVALUATED("4.0")!>plus(shortVal)<!>
-const val plus6 = twoVal.plus(intVal)
+const val plus6 = twoVal.<!EVALUATED("4.0")!>plus(intVal)<!>
-const val plus7 = twoVal.plus(longVal)
+const val plus7 = twoVal.<!EVALUATED("4.0")!>plus(longVal)<!>
-const val plus8 = twoVal.plus(doubleVal)
+const val plus8 = twoVal.<!EVALUATED("4.0")!>plus(doubleVal)<!>
 
-const val minus1 = oneVal.minus(twoVal)
+const val minus1 = oneVal.<!EVALUATED("-1.0")!>minus(twoVal)<!>
-const val minus2 = twoVal.minus(twoVal)
+const val minus2 = twoVal.<!EVALUATED("0.0")!>minus(twoVal)<!>
-const val minus3 = threeVal.minus(twoVal)
+const val minus3 = threeVal.<!EVALUATED("1.0")!>minus(twoVal)<!>
-const val minus4 = twoVal.minus(byteVal)
+const val minus4 = twoVal.<!EVALUATED("0.0")!>minus(byteVal)<!>
-const val minus5 = twoVal.minus(shortVal)
+const val minus5 = twoVal.<!EVALUATED("0.0")!>minus(shortVal)<!>
-const val minus6 = twoVal.minus(intVal)
+const val minus6 = twoVal.<!EVALUATED("0.0")!>minus(intVal)<!>
-const val minus7 = twoVal.minus(longVal)
+const val minus7 = twoVal.<!EVALUATED("0.0")!>minus(longVal)<!>
-const val minus8 = twoVal.minus(doubleVal)
+const val minus8 = twoVal.<!EVALUATED("0.0")!>minus(doubleVal)<!>
 
-const val times1 = oneVal.times(twoVal)
+const val times1 = oneVal.<!EVALUATED("2.0")!>times(twoVal)<!>
-const val times2 = twoVal.times(twoVal)
+const val times2 = twoVal.<!EVALUATED("4.0")!>times(twoVal)<!>
-const val times3 = threeVal.times(twoVal)
+const val times3 = threeVal.<!EVALUATED("6.0")!>times(twoVal)<!>
-const val times4 = twoVal.times(byteVal)
+const val times4 = twoVal.<!EVALUATED("4.0")!>times(byteVal)<!>
-const val times5 = twoVal.times(shortVal)
+const val times5 = twoVal.<!EVALUATED("4.0")!>times(shortVal)<!>
-const val times6 = twoVal.times(intVal)
+const val times6 = twoVal.<!EVALUATED("4.0")!>times(intVal)<!>
-const val times7 = twoVal.times(longVal)
+const val times7 = twoVal.<!EVALUATED("4.0")!>times(longVal)<!>
-const val times8 = twoVal.times(doubleVal)
+const val times8 = twoVal.<!EVALUATED("4.0")!>times(doubleVal)<!>
 
-const val div1 = oneVal.div(twoVal)
+const val div1 = oneVal.<!EVALUATED("0.5")!>div(twoVal)<!>
-const val div2 = twoVal.div(twoVal)
+const val div2 = twoVal.<!EVALUATED("1.0")!>div(twoVal)<!>
-const val div3 = threeVal.div(twoVal)
+const val div3 = threeVal.<!EVALUATED("1.5")!>div(twoVal)<!>
-const val div4 = twoVal.div(byteVal)
+const val div4 = twoVal.<!EVALUATED("1.0")!>div(byteVal)<!>
-const val div5 = twoVal.div(shortVal)
+const val div5 = twoVal.<!EVALUATED("1.0")!>div(shortVal)<!>
-const val div6 = twoVal.div(intVal)
+const val div6 = twoVal.<!EVALUATED("1.0")!>div(intVal)<!>
-const val div7 = twoVal.div(longVal)
+const val div7 = twoVal.<!EVALUATED("1.0")!>div(longVal)<!>
-const val div8 = twoVal.div(doubleVal)
+const val div8 = twoVal.<!EVALUATED("1.0")!>div(doubleVal)<!>
 
-const val rem1 = oneVal.rem(twoVal)
+const val rem1 = oneVal.<!EVALUATED("1.0")!>rem(twoVal)<!>
-const val rem2 = twoVal.rem(twoVal)
+const val rem2 = twoVal.<!EVALUATED("0.0")!>rem(twoVal)<!>
-const val rem3 = threeVal.rem(twoVal)
+const val rem3 = threeVal.<!EVALUATED("1.0")!>rem(twoVal)<!>
-const val rem4 = twoVal.rem(byteVal)
+const val rem4 = twoVal.<!EVALUATED("0.0")!>rem(byteVal)<!>
-const val rem5 = twoVal.rem(shortVal)
+const val rem5 = twoVal.<!EVALUATED("0.0")!>rem(shortVal)<!>
-const val rem6 = twoVal.rem(intVal)
+const val rem6 = twoVal.<!EVALUATED("0.0")!>rem(intVal)<!>
-const val rem7 = twoVal.rem(longVal)
+const val rem7 = twoVal.<!EVALUATED("0.0")!>rem(longVal)<!>
-const val rem8 = twoVal.rem(doubleVal)
+const val rem8 = twoVal.<!EVALUATED("0.0")!>rem(doubleVal)<!>
 
-const val unaryPlus1 = oneVal.unaryPlus()
+const val unaryPlus1 = oneVal.<!EVALUATED("1.0")!>unaryPlus()<!>
-const val unaryPlus2 = minusOneVal.unaryPlus()
+const val unaryPlus2 = minusOneVal.<!EVALUATED("-1.0")!>unaryPlus()<!>
-const val unaryMinus1 = oneVal.unaryMinus()
+const val unaryMinus1 = oneVal.<!EVALUATED("-1.0")!>unaryMinus()<!>
-const val unaryMinus2 = minusOneVal.unaryMinus()
+const val unaryMinus2 = minusOneVal.<!EVALUATED("1.0")!>unaryMinus()<!>
 
-const val convert1 = oneVal.toChar()
+const val convert1 = oneVal.<!EVALUATED("
")!>toChar()<!>
-const val convert2 = oneVal.toInt()
+const val convert2 = oneVal.<!EVALUATED("1")!>toInt()<!>
-const val convert3 = oneVal.toLong()
+const val convert3 = oneVal.<!EVALUATED("1")!>toLong()<!>
-const val convert4 = oneVal.toFloat()
+const val convert4 = oneVal.<!EVALUATED("1.0")!>toFloat()<!>
-const val convert5 = oneVal.toDouble()
+const val convert5 = oneVal.<!EVALUATED("1.0")!>toDouble()<!>
 
-const val equals1 = oneVal == twoVal
+const val equals1 = <!EVALUATED("false")!>oneVal == twoVal<!>
-const val equals2 = twoVal == twoVal
+const val equals2 = <!EVALUATED("true")!>twoVal == twoVal<!>
-const val equals3 = threeVal == twoVal
+const val equals3 = <!EVALUATED("false")!>threeVal == twoVal<!>
-const val equals4 = fourVal == twoVal
+const val equals4 = <!EVALUATED("false")!>fourVal == twoVal<!>
 
-const val toString1 = oneVal.toString()
+const val toString1 = oneVal.<!EVALUATED("1.0")!>toString()<!>
-const val toString2 = twoVal.toString()
+const val toString2 = twoVal.<!EVALUATED("2.0")!>toString()<!>
-const val toString3 = oneAndAHalf.toString()
+const val toString3 = oneAndAHalf.<!EVALUATED("1.5")!>toString()<!>
+
+fun <T> T.id(): T = this
 
 fun box(): String {
-    if (compareTo1 != -1)   return "Fail 1.1"
+    if (<!EVALUATED("false")!>compareTo1 != -1<!>)   return "Fail 1.1"
-    if (compareTo2 != 0)    return "Fail 1.2"
+    if (<!EVALUATED("false")!>compareTo2 != 0<!>)    return "Fail 1.2"
-    if (compareTo3 != 1)    return "Fail 1.3"
+    if (<!EVALUATED("false")!>compareTo3 != 1<!>)    return "Fail 1.3"
-    if (compareTo4 != 0)    return "Fail 1.4"
+    if (<!EVALUATED("false")!>compareTo4 != 0<!>)    return "Fail 1.4"
-    if (compareTo5 != 0)    return "Fail 1.5"
+    if (<!EVALUATED("false")!>compareTo5 != 0<!>)    return "Fail 1.5"
-    if (compareTo6 != 0)    return "Fail 1.6"
+    if (<!EVALUATED("false")!>compareTo6 != 0<!>)    return "Fail 1.6"
-    if (compareTo7 != 0)    return "Fail 1.7"
+    if (<!EVALUATED("false")!>compareTo7 != 0<!>)    return "Fail 1.7"
-    if (compareTo8 != 0)    return "Fail 1.8"
+    if (<!EVALUATED("false")!>compareTo8 != 0<!>)    return "Fail 1.8"
 
-    if (plus1 != 3f)     return "Fail 2.1"
+    if (<!EVALUATED("false")!>plus1 != 3f<!>)     return "Fail 2.1"
-    if (plus2 != 4f)     return "Fail 2.2"
+    if (<!EVALUATED("false")!>plus2 != 4f<!>)     return "Fail 2.2"
-    if (plus3 != 5f)     return "Fail 2.3"
+    if (<!EVALUATED("false")!>plus3 != 5f<!>)     return "Fail 2.3"
-    if (plus4 != 4f)     return "Fail 2.4"
+    if (<!EVALUATED("false")!>plus4 != 4f<!>)     return "Fail 2.4"
-    if (plus5 != 4f)     return "Fail 2.5"
+    if (<!EVALUATED("false")!>plus5 != 4f<!>)     return "Fail 2.5"
-    if (plus6 != 4f)     return "Fail 2.6"
+    if (<!EVALUATED("false")!>plus6 != 4f<!>)     return "Fail 2.6"
-    if (plus7 != 4.0f)  return "Fail 2.7"
+    if (<!EVALUATED("false")!>plus7 != 4.0f<!>)  return "Fail 2.7"
-    if (plus8 != 4.0)   return "Fail 2.8"
+    if (<!EVALUATED("false")!>plus8 != 4.0<!>)   return "Fail 2.8"
 
-    if (minus1 != -1f)       return "Fail 3.1"
+    if (<!EVALUATED("false")!>minus1 != -1f<!>)       return "Fail 3.1"
-    if (minus2 != 0f)        return "Fail 3.2"
+    if (<!EVALUATED("false")!>minus2 != 0f<!>)        return "Fail 3.2"
-    if (minus3 != 1f)        return "Fail 3.3"
+    if (<!EVALUATED("false")!>minus3 != 1f<!>)        return "Fail 3.3"
-    if (minus4 != 0f)        return "Fail 3.4"
+    if (<!EVALUATED("false")!>minus4 != 0f<!>)        return "Fail 3.4"
-    if (minus5 != 0f)        return "Fail 3.5"
+    if (<!EVALUATED("false")!>minus5 != 0f<!>)        return "Fail 3.5"
-    if (minus6 != 0f)        return "Fail 3.6"
+    if (<!EVALUATED("false")!>minus6 != 0f<!>)        return "Fail 3.6"
-    if (minus7 != 0.0f)     return "Fail 3.7"
+    if (<!EVALUATED("false")!>minus7 != 0.0f<!>)     return "Fail 3.7"
-    if (minus8 != 0.0)      return "Fail 3.8"
+    if (<!EVALUATED("false")!>minus8 != 0.0<!>)      return "Fail 3.8"
 
-    if (times1 != 2f)        return "Fail 4.1"
+    if (<!EVALUATED("false")!>times1 != 2f<!>)        return "Fail 4.1"
-    if (times2 != 4f)        return "Fail 4.2"
+    if (<!EVALUATED("false")!>times2 != 4f<!>)        return "Fail 4.2"
-    if (times3 != 6f)        return "Fail 4.3"
+    if (<!EVALUATED("false")!>times3 != 6f<!>)        return "Fail 4.3"
-    if (times4 != 4f)        return "Fail 4.4"
+    if (<!EVALUATED("false")!>times4 != 4f<!>)        return "Fail 4.4"
-    if (times5 != 4f)        return "Fail 4.5"
+    if (<!EVALUATED("false")!>times5 != 4f<!>)        return "Fail 4.5"
-    if (times6 != 4f)        return "Fail 4.6"
+    if (<!EVALUATED("false")!>times6 != 4f<!>)        return "Fail 4.6"
-    if (times7 != 4.0f)     return "Fail 4.7"
+    if (<!EVALUATED("false")!>times7 != 4.0f<!>)     return "Fail 4.7"
-    if (times8 != 4.0)      return "Fail 4.8"
+    if (<!EVALUATED("false")!>times8 != 4.0<!>)      return "Fail 4.8"
 
-    if (div1 != 0.5f)       return "Fail 5.1"
+    if (<!EVALUATED("false")!>div1 != 0.5f<!>)       return "Fail 5.1"
-    if (div2 != 1.0f)       return "Fail 5.2"
+    if (<!EVALUATED("false")!>div2 != 1.0f<!>)       return "Fail 5.2"
-    if (div3 != 1.5f)       return "Fail 5.3"
+    if (<!EVALUATED("false")!>div3 != 1.5f<!>)       return "Fail 5.3"
-    if (div4 != 1f)          return "Fail 5.4"
+    if (<!EVALUATED("false")!>div4 != 1f<!>)          return "Fail 5.4"
-    if (div5 != 1f)          return "Fail 5.5"
+    if (<!EVALUATED("false")!>div5 != 1f<!>)          return "Fail 5.5"
-    if (div6 != 1f)          return "Fail 5.6"
+    if (<!EVALUATED("false")!>div6 != 1f<!>)          return "Fail 5.6"
-    if (div7 != 1.0f)       return "Fail 5.7"
+    if (<!EVALUATED("false")!>div7 != 1.0f<!>)       return "Fail 5.7"
-    if (div8 != 1.0)        return "Fail 5.8"
+    if (<!EVALUATED("false")!>div8 != 1.0<!>)        return "Fail 5.8"
 
-    if (rem1 != 1f)      return "Fail 6.1"
+    if (<!EVALUATED("false")!>rem1 != 1f<!>)      return "Fail 6.1"
-    if (rem2 != 0f)      return "Fail 6.2"
+    if (<!EVALUATED("false")!>rem2 != 0f<!>)      return "Fail 6.2"
-    if (rem3 != 1f)      return "Fail 6.3"
+    if (<!EVALUATED("false")!>rem3 != 1f<!>)      return "Fail 6.3"
-    if (rem4 != 0f)      return "Fail 6.4"
+    if (<!EVALUATED("false")!>rem4 != 0f<!>)      return "Fail 6.4"
-    if (rem5 != 0f)      return "Fail 6.5"
+    if (<!EVALUATED("false")!>rem5 != 0f<!>)      return "Fail 6.5"
-    if (rem6 != 0f)      return "Fail 6.6"
+    if (<!EVALUATED("false")!>rem6 != 0f<!>)      return "Fail 6.6"
-    if (rem7 != 0.0f)   return "Fail 6.7"
+    if (<!EVALUATED("false")!>rem7 != 0.0f<!>)   return "Fail 6.7"
-    if (rem8 != 0.0)    return "Fail 6.8"
+    if (<!EVALUATED("false")!>rem8 != 0.0<!>)    return "Fail 6.8"
 
-    if (unaryPlus1 != 1f)    return "Fail 7.1"
+    if (<!EVALUATED("false")!>unaryPlus1 != 1f<!>)    return "Fail 7.1"
-    if (unaryPlus2 != -1f)   return "Fail 7.2"
+    if (<!EVALUATED("false")!>unaryPlus2 != -1f<!>)   return "Fail 7.2"
-    if (unaryMinus1 != -1f)  return "Fail 7.3"
+    if (<!EVALUATED("false")!>unaryMinus1 != -1f<!>)  return "Fail 7.3"
-    if (unaryMinus2 != 1f)   return "Fail 7.4"
+    if (<!EVALUATED("false")!>unaryMinus2 != 1f<!>)   return "Fail 7.4"
 
-    if (convert1 != '
')  return "Fail 8.1"
+    if (<!EVALUATED("false")!>convert1 != '
'<!>)  return "Fail 8.1"
-    if (convert2 != 1)      return "Fail 8.2"
+    if (<!EVALUATED("false")!>convert2 != 1<!>)      return "Fail 8.2"
-    if (convert3 != 1L)      return "Fail 8.3"
+    if (<!EVALUATED("false")!>convert3 != 1L<!>)      return "Fail 8.3"
-    if (convert4 != 1.0f)   return "Fail 8.4"
+    if (<!EVALUATED("false")!>convert4 != 1.0f<!>)   return "Fail 8.4"
-    if (convert5 != 1.0)    return "Fail 8.5"
+    if (<!EVALUATED("false")!>convert5 != 1.0<!>)    return "Fail 8.5"
 
-    if (equals1 != false)   return "Fail 9.1"
+    if (<!EVALUATED("false")!>equals1 != false<!>)   return "Fail 9.1"
-    if (equals2 != true)    return "Fail 9.2"
+    if (<!EVALUATED("false")!>equals2 != true<!>)    return "Fail 9.2"
-    if (equals3 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 9.3"
-    if (equals4 != false)   return "Fail 9.4"
+    if (<!EVALUATED("false")!>equals4 != false<!>)   return "Fail 9.4"
 
-    if (toString1 != "1.0" && toString1 != "1" /* JS */)    return "Fail 10.1"
+    // id is needed to avoid evaluation and so match different cases for JVM and JS
-    if (toString2 != "2.0" && toString2 != "2" /* JS */)    return "Fail 10.2"
+    if (<!EVALUATED("1.0")!>toString1<!>.id() != "1.0" && <!EVALUATED("1.0")!>toString1<!>.id() != "1" /* JS */)    return "Fail 10.1"
-    if (toString3 != "1.5")                                 return "Fail 10.3"
+    if (<!EVALUATED("2.0")!>toString2<!>.id() != "2.0" && <!EVALUATED("2.0")!>toString2<!>.id() != "2" /* JS */)    return "Fail 10.2"
+    if (<!EVALUATED("1.5")!>toString3<!>.id() != "1.5")                                      return "Fail 10.3"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/ifConstVal.kt

@@ -4,29 +4,19 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: JVM_IR, NATIVE, JS_IR, JS_IR_ES6
 
-const val flag = true
+const val flag = <!EVALUATED("true")!>true<!>
-const val value = 10
+const val value = <!EVALUATED("10")!>10<!>
-const val condition = if (flag) "True" else "Error"
+const val condition = <!EVALUATED("True")!>if (flag) "True" else "Error"<!>
-const val withWhen = when (flag) {
+const val withWhen = <!EVALUATED("True")!>when (flag) { true -> "True"; else -> "Error" }<!>
-    true -> "True"
+const val withWhen2 = <!EVALUATED("True")!>when { flag == true -> "True"; else -> "Error" }<!>
-    else -> "Error"
+const val withWhen3 = <!EVALUATED("1")!>when(value) { 10 -> "1"; 100 -> "2"; else -> "3" }<!>
-}
+const val multibranchIf = <!EVALUATED("3")!>if (value == 100) 1 else if (value == 1000) 2 else 3<!>
-const val withWhen2 = when {
-    flag == true -> "True"
-    else -> "Error"
-}
-const val withWhen3 = when(value) {
-    10 -> "1"
-    100 -> "2"
-    else -> "3"
-}
-const val multibranchIf = if (value == 100) 1 else if (value == 1000) 2 else 3
 
 fun box(): String {
-    if (condition != "True") return "Fail 1"
+    if (<!EVALUATED("false")!>condition != "True"<!>) return "Fail 1"
-    if (withWhen != "True") return "Fail 2"
+    if (<!EVALUATED("false")!>withWhen != "True"<!>) return "Fail 2"
-    if (withWhen2 != "True") return "Fail 3"
+    if (<!EVALUATED("false")!>withWhen2 != "True"<!>) return "Fail 3"
-    if (withWhen3 != "1") return "Fail 4"
+    if (<!EVALUATED("false")!>withWhen3 != "1"<!>) return "Fail 4"
-    if (multibranchIf != 3) return "Fail 5"
+    if (<!EVALUATED("false")!>multibranchIf != 3<!>) return "Fail 5"
     return "OK"
 }

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/intOperations.kt

@@ -3,169 +3,169 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: NATIVE
 
-const val minusOneVal = -1
+const val minusOneVal = <!EVALUATED("-1")!>-1<!>
-const val oneVal = 1
+const val oneVal = <!EVALUATED("1")!>1<!>
-const val twoVal = 2
+const val twoVal = <!EVALUATED("2")!>2<!>
-const val threeVal = 3
+const val threeVal = <!EVALUATED("3")!>3<!>
-const val fourVal = 4
+const val fourVal = <!EVALUATED("4")!>4<!>
 
-const val byteVal = 2.toByte()
+const val byteVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val shortVal = 2.toShort()
+const val shortVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val intVal = 2
+const val intVal = <!EVALUATED("2")!>2<!>
-const val longVal = 2L
+const val longVal = <!EVALUATED("2")!>2L<!>
-const val floatVal = 2.0f
+const val floatVal = <!EVALUATED("2.0")!>2.0f<!>
-const val doubleVal = 2.0
+const val doubleVal = <!EVALUATED("2.0")!>2.0<!>
 
-const val compareTo1 = oneVal.compareTo(twoVal)
+const val compareTo1 = oneVal.<!EVALUATED("-1")!>compareTo(twoVal)<!>
-const val compareTo2 = twoVal.compareTo(twoVal)
+const val compareTo2 = twoVal.<!EVALUATED("0")!>compareTo(twoVal)<!>
-const val compareTo3 = threeVal.compareTo(twoVal)
+const val compareTo3 = threeVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
-const val compareTo4 = twoVal.compareTo(byteVal)
+const val compareTo4 = twoVal.<!EVALUATED("0")!>compareTo(byteVal)<!>
-const val compareTo5 = twoVal.compareTo(shortVal)
+const val compareTo5 = twoVal.<!EVALUATED("0")!>compareTo(shortVal)<!>
-const val compareTo6 = twoVal.compareTo(longVal)
+const val compareTo6 = twoVal.<!EVALUATED("0")!>compareTo(longVal)<!>
-const val compareTo7 = twoVal.compareTo(floatVal)
+const val compareTo7 = twoVal.<!EVALUATED("0")!>compareTo(floatVal)<!>
-const val compareTo8 = twoVal.compareTo(doubleVal)
+const val compareTo8 = twoVal.<!EVALUATED("0")!>compareTo(doubleVal)<!>
 
-const val plus1 = oneVal.plus(twoVal)
+const val plus1 = oneVal.<!EVALUATED("3")!>plus(twoVal)<!>
-const val plus2 = twoVal.plus(twoVal)
+const val plus2 = twoVal.<!EVALUATED("4")!>plus(twoVal)<!>
-const val plus3 = threeVal.plus(twoVal)
+const val plus3 = threeVal.<!EVALUATED("5")!>plus(twoVal)<!>
-const val plus4 = twoVal.plus(byteVal)
+const val plus4 = twoVal.<!EVALUATED("4")!>plus(byteVal)<!>
-const val plus5 = twoVal.plus(shortVal)
+const val plus5 = twoVal.<!EVALUATED("4")!>plus(shortVal)<!>
-const val plus6 = twoVal.plus(longVal)
+const val plus6 = twoVal.<!EVALUATED("4")!>plus(longVal)<!>
-const val plus7 = twoVal.plus(floatVal)
+const val plus7 = twoVal.<!EVALUATED("4.0")!>plus(floatVal)<!>
-const val plus8 = twoVal.plus(doubleVal)
+const val plus8 = twoVal.<!EVALUATED("4.0")!>plus(doubleVal)<!>
 
-const val minus1 = oneVal.minus(twoVal)
+const val minus1 = oneVal.<!EVALUATED("-1")!>minus(twoVal)<!>
-const val minus2 = twoVal.minus(twoVal)
+const val minus2 = twoVal.<!EVALUATED("0")!>minus(twoVal)<!>
-const val minus3 = threeVal.minus(twoVal)
+const val minus3 = threeVal.<!EVALUATED("1")!>minus(twoVal)<!>
-const val minus4 = twoVal.minus(byteVal)
+const val minus4 = twoVal.<!EVALUATED("0")!>minus(byteVal)<!>
-const val minus5 = twoVal.minus(shortVal)
+const val minus5 = twoVal.<!EVALUATED("0")!>minus(shortVal)<!>
-const val minus6 = twoVal.minus(longVal)
+const val minus6 = twoVal.<!EVALUATED("0")!>minus(longVal)<!>
-const val minus7 = twoVal.minus(floatVal)
+const val minus7 = twoVal.<!EVALUATED("0.0")!>minus(floatVal)<!>
-const val minus8 = twoVal.minus(doubleVal)
+const val minus8 = twoVal.<!EVALUATED("0.0")!>minus(doubleVal)<!>
 
-const val times1 = oneVal.times(twoVal)
+const val times1 = oneVal.<!EVALUATED("2")!>times(twoVal)<!>
-const val times2 = twoVal.times(twoVal)
+const val times2 = twoVal.<!EVALUATED("4")!>times(twoVal)<!>
-const val times3 = threeVal.times(twoVal)
+const val times3 = threeVal.<!EVALUATED("6")!>times(twoVal)<!>
-const val times4 = twoVal.times(byteVal)
+const val times4 = twoVal.<!EVALUATED("4")!>times(byteVal)<!>
-const val times5 = twoVal.times(shortVal)
+const val times5 = twoVal.<!EVALUATED("4")!>times(shortVal)<!>
-const val times6 = twoVal.times(longVal)
+const val times6 = twoVal.<!EVALUATED("4")!>times(longVal)<!>
-const val times7 = twoVal.times(floatVal)
+const val times7 = twoVal.<!EVALUATED("4.0")!>times(floatVal)<!>
-const val times8 = twoVal.times(doubleVal)
+const val times8 = twoVal.<!EVALUATED("4.0")!>times(doubleVal)<!>
 
-const val div1 = oneVal.div(twoVal)
+const val div1 = oneVal.<!EVALUATED("0")!>div(twoVal)<!>
-const val div2 = twoVal.div(twoVal)
+const val div2 = twoVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div3 = threeVal.div(twoVal)
+const val div3 = threeVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div4 = twoVal.div(byteVal)
+const val div4 = twoVal.<!EVALUATED("1")!>div(byteVal)<!>
-const val div5 = twoVal.div(shortVal)
+const val div5 = twoVal.<!EVALUATED("1")!>div(shortVal)<!>
-const val div6 = twoVal.div(longVal)
+const val div6 = twoVal.<!EVALUATED("1")!>div(longVal)<!>
-const val div7 = twoVal.div(floatVal)
+const val div7 = twoVal.<!EVALUATED("1.0")!>div(floatVal)<!>
-const val div8 = twoVal.div(doubleVal)
+const val div8 = twoVal.<!EVALUATED("1.0")!>div(doubleVal)<!>
 
-const val rem1 = oneVal.rem(twoVal)
+const val rem1 = oneVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem2 = twoVal.rem(twoVal)
+const val rem2 = twoVal.<!EVALUATED("0")!>rem(twoVal)<!>
-const val rem3 = threeVal.rem(twoVal)
+const val rem3 = threeVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem4 = twoVal.rem(byteVal)
+const val rem4 = twoVal.<!EVALUATED("0")!>rem(byteVal)<!>
-const val rem5 = twoVal.rem(shortVal)
+const val rem5 = twoVal.<!EVALUATED("0")!>rem(shortVal)<!>
-const val rem6 = twoVal.rem(longVal)
+const val rem6 = twoVal.<!EVALUATED("0")!>rem(longVal)<!>
-const val rem7 = twoVal.rem(floatVal)
+const val rem7 = twoVal.<!EVALUATED("0.0")!>rem(floatVal)<!>
-const val rem8 = twoVal.rem(doubleVal)
+const val rem8 = twoVal.<!EVALUATED("0.0")!>rem(doubleVal)<!>
 
-const val unaryPlus1 = oneVal.unaryPlus()
+const val unaryPlus1 = oneVal.<!EVALUATED("1")!>unaryPlus()<!>
-const val unaryPlus2 = minusOneVal.unaryPlus()
+const val unaryPlus2 = minusOneVal.<!EVALUATED("-1")!>unaryPlus()<!>
-const val unaryMinus1 = oneVal.unaryMinus()
+const val unaryMinus1 = oneVal.<!EVALUATED("-1")!>unaryMinus()<!>
-const val unaryMinus2 = minusOneVal.unaryMinus()
+const val unaryMinus2 = minusOneVal.<!EVALUATED("1")!>unaryMinus()<!>
 
-const val convert1 = oneVal.toByte()
+const val convert1 = oneVal.<!EVALUATED("1")!>toByte()<!>
-const val convert2 = oneVal.toChar()
+const val convert2 = oneVal.<!EVALUATED("
")!>toChar()<!>
-const val convert3 = oneVal.toShort()
+const val convert3 = oneVal.<!EVALUATED("1")!>toShort()<!>
-const val convert4 = oneVal.toInt()
+const val convert4 = oneVal.<!EVALUATED("1")!>toInt()<!>
-const val convert5 = oneVal.toLong()
+const val convert5 = oneVal.<!EVALUATED("1")!>toLong()<!>
-const val convert6 = oneVal.toFloat()
+const val convert6 = oneVal.<!EVALUATED("1.0")!>toFloat()<!>
-const val convert7 = oneVal.toDouble()
+const val convert7 = oneVal.<!EVALUATED("1.0")!>toDouble()<!>
 
-const val equals1 = oneVal == twoVal
+const val equals1 = <!EVALUATED("false")!>oneVal == twoVal<!>
-const val equals2 = twoVal == twoVal
+const val equals2 = <!EVALUATED("true")!>twoVal == twoVal<!>
-const val equals3 = threeVal == twoVal
+const val equals3 = <!EVALUATED("false")!>threeVal == twoVal<!>
-const val equals4 = fourVal == twoVal
+const val equals4 = <!EVALUATED("false")!>fourVal == twoVal<!>
 
-const val toString1 = oneVal.toString()
+const val toString1 = oneVal.<!EVALUATED("1")!>toString()<!>
-const val toString2 = twoVal.toString()
+const val toString2 = twoVal.<!EVALUATED("2")!>toString()<!>
 
 fun box(): String {
-    if (compareTo1 != -1)   return "Fail 1.1"
+    if (<!EVALUATED("false")!>compareTo1 != -1<!>)   return "Fail 1.1"
-    if (compareTo2 != 0)    return "Fail 1.2"
+    if (<!EVALUATED("false")!>compareTo2 != 0<!>)    return "Fail 1.2"
-    if (compareTo3 != 1)    return "Fail 1.3"
+    if (<!EVALUATED("false")!>compareTo3 != 1<!>)    return "Fail 1.3"
-    if (compareTo4 != 0)    return "Fail 1.4"
+    if (<!EVALUATED("false")!>compareTo4 != 0<!>)    return "Fail 1.4"
-    if (compareTo5 != 0)    return "Fail 1.5"
+    if (<!EVALUATED("false")!>compareTo5 != 0<!>)    return "Fail 1.5"
-    if (compareTo6 != 0)    return "Fail 1.6"
+    if (<!EVALUATED("false")!>compareTo6 != 0<!>)    return "Fail 1.6"
-    if (compareTo7 != 0)    return "Fail 1.7"
+    if (<!EVALUATED("false")!>compareTo7 != 0<!>)    return "Fail 1.7"
-    if (compareTo8 != 0)    return "Fail 1.8"
+    if (<!EVALUATED("false")!>compareTo8 != 0<!>)    return "Fail 1.8"
 
-    if (plus1 != 3)     return "Fail 2.1"
+    if (<!EVALUATED("false")!>plus1 != 3<!>)     return "Fail 2.1"
-    if (plus2 != 4)     return "Fail 2.2"
+    if (<!EVALUATED("false")!>plus2 != 4<!>)     return "Fail 2.2"
-    if (plus3 != 5)     return "Fail 2.3"
+    if (<!EVALUATED("false")!>plus3 != 5<!>)     return "Fail 2.3"
-    if (plus4 != 4)     return "Fail 2.4"
+    if (<!EVALUATED("false")!>plus4 != 4<!>)     return "Fail 2.4"
-    if (plus5 != 4)     return "Fail 2.5"
+    if (<!EVALUATED("false")!>plus5 != 4<!>)     return "Fail 2.5"
-    if (plus6 != 4L)     return "Fail 2.6"
+    if (<!EVALUATED("false")!>plus6 != 4L<!>)     return "Fail 2.6"
-    if (plus7 != 4.0f)  return "Fail 2.7"
+    if (<!EVALUATED("false")!>plus7 != 4.0f<!>)  return "Fail 2.7"
-    if (plus8 != 4.0)   return "Fail 2.8"
+    if (<!EVALUATED("false")!>plus8 != 4.0<!>)   return "Fail 2.8"
 
-    if (minus1 != -1)       return "Fail 3.1"
+    if (<!EVALUATED("false")!>minus1 != -1<!>)       return "Fail 3.1"
-    if (minus2 != 0)        return "Fail 3.2"
+    if (<!EVALUATED("false")!>minus2 != 0<!>)        return "Fail 3.2"
-    if (minus3 != 1)        return "Fail 3.3"
+    if (<!EVALUATED("false")!>minus3 != 1<!>)        return "Fail 3.3"
-    if (minus4 != 0)        return "Fail 3.4"
+    if (<!EVALUATED("false")!>minus4 != 0<!>)        return "Fail 3.4"
-    if (minus5 != 0)        return "Fail 3.5"
+    if (<!EVALUATED("false")!>minus5 != 0<!>)        return "Fail 3.5"
-    if (minus6 != 0L)        return "Fail 3.6"
+    if (<!EVALUATED("false")!>minus6 != 0L<!>)        return "Fail 3.6"
-    if (minus7 != 0.0f)     return "Fail 3.7"
+    if (<!EVALUATED("false")!>minus7 != 0.0f<!>)     return "Fail 3.7"
-    if (minus8 != 0.0)      return "Fail 3.8"
+    if (<!EVALUATED("false")!>minus8 != 0.0<!>)      return "Fail 3.8"
 
-    if (times1 != 2)        return "Fail 4.1"
+    if (<!EVALUATED("false")!>times1 != 2<!>)        return "Fail 4.1"
-    if (times2 != 4)        return "Fail 4.2"
+    if (<!EVALUATED("false")!>times2 != 4<!>)        return "Fail 4.2"
-    if (times3 != 6)        return "Fail 4.3"
+    if (<!EVALUATED("false")!>times3 != 6<!>)        return "Fail 4.3"
-    if (times4 != 4)        return "Fail 4.4"
+    if (<!EVALUATED("false")!>times4 != 4<!>)        return "Fail 4.4"
-    if (times5 != 4)        return "Fail 4.5"
+    if (<!EVALUATED("false")!>times5 != 4<!>)        return "Fail 4.5"
-    if (times6 != 4L)        return "Fail 4.6"
+    if (<!EVALUATED("false")!>times6 != 4L<!>)        return "Fail 4.6"
-    if (times7 != 4.0f)     return "Fail 4.7"
+    if (<!EVALUATED("false")!>times7 != 4.0f<!>)     return "Fail 4.7"
-    if (times8 != 4.0)      return "Fail 4.8"
+    if (<!EVALUATED("false")!>times8 != 4.0<!>)      return "Fail 4.8"
 
-    if (div1 != 0)          return "Fail 5.1"
+    if (<!EVALUATED("false")!>div1 != 0<!>)          return "Fail 5.1"
-    if (div2 != 1)          return "Fail 5.2"
+    if (<!EVALUATED("false")!>div2 != 1<!>)          return "Fail 5.2"
-    if (div3 != 1)          return "Fail 5.3"
+    if (<!EVALUATED("false")!>div3 != 1<!>)          return "Fail 5.3"
-    if (div4 != 1)          return "Fail 5.4"
+    if (<!EVALUATED("false")!>div4 != 1<!>)          return "Fail 5.4"
-    if (div5 != 1)          return "Fail 5.5"
+    if (<!EVALUATED("false")!>div5 != 1<!>)          return "Fail 5.5"
-    if (div6 != 1L)          return "Fail 5.6"
+    if (<!EVALUATED("false")!>div6 != 1L<!>)          return "Fail 5.6"
-    if (div7 != 1.0f)       return "Fail 5.7"
+    if (<!EVALUATED("false")!>div7 != 1.0f<!>)       return "Fail 5.7"
-    if (div8 != 1.0)        return "Fail 5.8"
+    if (<!EVALUATED("false")!>div8 != 1.0<!>)        return "Fail 5.8"
 
-    if (rem1 != 1)      return "Fail 6.1"
+    if (<!EVALUATED("false")!>rem1 != 1<!>)      return "Fail 6.1"
-    if (rem2 != 0)      return "Fail 6.2"
+    if (<!EVALUATED("false")!>rem2 != 0<!>)      return "Fail 6.2"
-    if (rem3 != 1)      return "Fail 6.3"
+    if (<!EVALUATED("false")!>rem3 != 1<!>)      return "Fail 6.3"
-    if (rem4 != 0)      return "Fail 6.4"
+    if (<!EVALUATED("false")!>rem4 != 0<!>)      return "Fail 6.4"
-    if (rem5 != 0)      return "Fail 6.5"
+    if (<!EVALUATED("false")!>rem5 != 0<!>)      return "Fail 6.5"
-    if (rem6 != 0L)      return "Fail 6.6"
+    if (<!EVALUATED("false")!>rem6 != 0L<!>)      return "Fail 6.6"
-    if (rem7 != 0.0f)   return "Fail 6.7"
+    if (<!EVALUATED("false")!>rem7 != 0.0f<!>)   return "Fail 6.7"
-    if (rem8 != 0.0)    return "Fail 6.8"
+    if (<!EVALUATED("false")!>rem8 != 0.0<!>)    return "Fail 6.8"
 
-    if (unaryPlus1 != 1)    return "Fail 7.1"
+    if (<!EVALUATED("false")!>unaryPlus1 != 1<!>)    return "Fail 7.1"
-    if (unaryPlus2 != -1)   return "Fail 7.2"
+    if (<!EVALUATED("false")!>unaryPlus2 != -1<!>)   return "Fail 7.2"
-    if (unaryMinus1 != -1)  return "Fail 7.3"
+    if (<!EVALUATED("false")!>unaryMinus1 != -1<!>)  return "Fail 7.3"
-    if (unaryMinus2 != 1)   return "Fail 7.4"
+    if (<!EVALUATED("false")!>unaryMinus2 != 1<!>)   return "Fail 7.4"
 
-    if (convert1 != 1.toByte())      return "Fail 8.1"
+    if (<!EVALUATED("false")!>convert1 != 1.toByte()<!>)      return "Fail 8.1"
-    if (convert2 != '
')  return "Fail 8.2"
+    if (<!EVALUATED("false")!>convert2 != '
'<!>)  return "Fail 8.2"
-    if (convert3 != 1.toShort())      return "Fail 8.3"
+    if (<!EVALUATED("false")!>convert3 != 1.toShort()<!>)      return "Fail 8.3"
-    if (convert4 != 1)      return "Fail 8.4"
+    if (<!EVALUATED("false")!>convert4 != 1<!>)      return "Fail 8.4"
-    if (convert5 != 1L)      return "Fail 8.5"
+    if (<!EVALUATED("false")!>convert5 != 1L<!>)      return "Fail 8.5"
-    if (convert6 != 1.0f)   return "Fail 8.6"
+    if (<!EVALUATED("false")!>convert6 != 1.0f<!>)   return "Fail 8.6"
-    if (convert7 != 1.0)    return "Fail 8.7"
+    if (<!EVALUATED("false")!>convert7 != 1.0<!>)    return "Fail 8.7"
 
-    if (equals1 != false)   return "Fail 9.1"
+    if (<!EVALUATED("false")!>equals1 != false<!>)   return "Fail 9.1"
-    if (equals2 != true)    return "Fail 9.2"
+    if (<!EVALUATED("false")!>equals2 != true<!>)    return "Fail 9.2"
-    if (equals3 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 9.3"
-    if (equals4 != false)   return "Fail 9.4"
+    if (<!EVALUATED("false")!>equals4 != false<!>)   return "Fail 9.4"
 
-    if (toString1 != "1")   return "Fail 10.1"
+    if (<!EVALUATED("false")!>toString1 != "1"<!>)   return "Fail 10.1"
-    if (toString2 != "2")   return "Fail 10.2"
+    if (<!EVALUATED("false")!>toString2 != "2"<!>)   return "Fail 10.2"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/kCallableName.kt

@@ -8,19 +8,19 @@ class A(val OK: Int, val somePropertyWithLongName: String) {
 }
 val topLevelProp = 1
 
-const val propertyName1 = A::OK.name
+const val propertyName1 = A::OK.<!EVALUATED("OK")!>name<!>
-const val propertyName2 = A::somePropertyWithLongName.name
+const val propertyName2 = A::somePropertyWithLongName.<!EVALUATED("somePropertyWithLongName")!>name<!>
-const val methodName = A::foo.name
+const val methodName = A::foo.<!EVALUATED("foo")!>name<!>
-const val suspendMethodName = A::bar.name
+const val suspendMethodName = A::bar.<!EVALUATED("bar")!>name<!>
-const val className = ::A.name
+const val className = ::A.<!EVALUATED("<init>")!>name<!>
-const val topLevelPropName = ::topLevelProp.name
+const val topLevelPropName = ::topLevelProp.<!EVALUATED("topLevelProp")!>name<!>
 
 fun box(): String {
-    if (propertyName1 != "OK") return "Fail 1"
+    if (<!EVALUATED("false")!>propertyName1 != "OK"<!>) return "Fail 1"
-    if (propertyName2 != "somePropertyWithLongName") return "Fail 2"
+    if (<!EVALUATED("false")!>propertyName2 != "somePropertyWithLongName"<!>) return "Fail 2"
-    if (methodName != "foo") return "Fail 3.1"
+    if (<!EVALUATED("false")!>methodName != "foo"<!>) return "Fail 3.1"
-    if (suspendMethodName != "bar") return "Fail 3.2"
+    if (<!EVALUATED("false")!>suspendMethodName != "bar"<!>) return "Fail 3.2"
-    if (className != "<init>") return "Fail 4"
+    if (<!EVALUATED("false")!>className != "<init>"<!>) return "Fail 4"
-    if (topLevelPropName != "topLevelProp") return "Fail 5"
+    if (<!EVALUATED("false")!>topLevelPropName != "topLevelProp"<!>) return "Fail 5"
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/kt53272.kt

@@ -4,12 +4,12 @@
 
 // FILE: 1.kt
 
-const val name = E.OK.name
+const val name = E.OK.<!EVALUATED("OK")!>name<!>
-fun box(): String = name
+fun box(): String = <!EVALUATED("OK")!>name<!>
 
 // FILE: 2.kt
 
 enum class E(val parent: E?) {
     X(null),
     OK(X),
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/longOperations.kt

@@ -3,169 +3,169 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: NATIVE
 
-const val minusOneVal = -1L
+const val minusOneVal = <!EVALUATED("-1")!>-1L<!>
-const val oneVal = 1L
+const val oneVal = <!EVALUATED("1")!>1L<!>
-const val twoVal = 2L
+const val twoVal = <!EVALUATED("2")!>2L<!>
-const val threeVal = 3L
+const val threeVal = <!EVALUATED("3")!>3L<!>
-const val fourVal = 4L
+const val fourVal = <!EVALUATED("4")!>4L<!>
 
-const val byteVal = 2.toByte()
+const val byteVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val shortVal = 2.toShort()
+const val shortVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val intVal = 2
+const val intVal = <!EVALUATED("2")!>2<!>
-const val longVal = 2L
+const val longVal = <!EVALUATED("2")!>2L<!>
-const val floatVal = 2.0f
+const val floatVal = <!EVALUATED("2.0")!>2.0f<!>
-const val doubleVal = 2.0
+const val doubleVal = <!EVALUATED("2.0")!>2.0<!>
 
-const val compareTo1 = oneVal.compareTo(twoVal)
+const val compareTo1 = oneVal.<!EVALUATED("-1")!>compareTo(twoVal)<!>
-const val compareTo2 = twoVal.compareTo(twoVal)
+const val compareTo2 = twoVal.<!EVALUATED("0")!>compareTo(twoVal)<!>
-const val compareTo3 = threeVal.compareTo(twoVal)
+const val compareTo3 = threeVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
-const val compareTo4 = twoVal.compareTo(byteVal)
+const val compareTo4 = twoVal.<!EVALUATED("0")!>compareTo(byteVal)<!>
-const val compareTo5 = twoVal.compareTo(shortVal)
+const val compareTo5 = twoVal.<!EVALUATED("0")!>compareTo(shortVal)<!>
-const val compareTo6 = twoVal.compareTo(intVal)
+const val compareTo6 = twoVal.<!EVALUATED("0")!>compareTo(intVal)<!>
-const val compareTo7 = twoVal.compareTo(floatVal)
+const val compareTo7 = twoVal.<!EVALUATED("0")!>compareTo(floatVal)<!>
-const val compareTo8 = twoVal.compareTo(doubleVal)
+const val compareTo8 = twoVal.<!EVALUATED("0")!>compareTo(doubleVal)<!>
 
-const val plus1 = oneVal.plus(twoVal)
+const val plus1 = oneVal.<!EVALUATED("3")!>plus(twoVal)<!>
-const val plus2 = twoVal.plus(twoVal)
+const val plus2 = twoVal.<!EVALUATED("4")!>plus(twoVal)<!>
-const val plus3 = threeVal.plus(twoVal)
+const val plus3 = threeVal.<!EVALUATED("5")!>plus(twoVal)<!>
-const val plus4 = twoVal.plus(byteVal)
+const val plus4 = twoVal.<!EVALUATED("4")!>plus(byteVal)<!>
-const val plus5 = twoVal.plus(shortVal)
+const val plus5 = twoVal.<!EVALUATED("4")!>plus(shortVal)<!>
-const val plus6 = twoVal.plus(intVal)
+const val plus6 = twoVal.<!EVALUATED("4")!>plus(intVal)<!>
-const val plus7 = twoVal.plus(floatVal)
+const val plus7 = twoVal.<!EVALUATED("4.0")!>plus(floatVal)<!>
-const val plus8 = twoVal.plus(doubleVal)
+const val plus8 = twoVal.<!EVALUATED("4.0")!>plus(doubleVal)<!>
 
-const val minus1 = oneVal.minus(twoVal)
+const val minus1 = oneVal.<!EVALUATED("-1")!>minus(twoVal)<!>
-const val minus2 = twoVal.minus(twoVal)
+const val minus2 = twoVal.<!EVALUATED("0")!>minus(twoVal)<!>
-const val minus3 = threeVal.minus(twoVal)
+const val minus3 = threeVal.<!EVALUATED("1")!>minus(twoVal)<!>
-const val minus4 = twoVal.minus(byteVal)
+const val minus4 = twoVal.<!EVALUATED("0")!>minus(byteVal)<!>
-const val minus5 = twoVal.minus(shortVal)
+const val minus5 = twoVal.<!EVALUATED("0")!>minus(shortVal)<!>
-const val minus6 = twoVal.minus(intVal)
+const val minus6 = twoVal.<!EVALUATED("0")!>minus(intVal)<!>
-const val minus7 = twoVal.minus(floatVal)
+const val minus7 = twoVal.<!EVALUATED("0.0")!>minus(floatVal)<!>
-const val minus8 = twoVal.minus(doubleVal)
+const val minus8 = twoVal.<!EVALUATED("0.0")!>minus(doubleVal)<!>
 
-const val times1 = oneVal.times(twoVal)
+const val times1 = oneVal.<!EVALUATED("2")!>times(twoVal)<!>
-const val times2 = twoVal.times(twoVal)
+const val times2 = twoVal.<!EVALUATED("4")!>times(twoVal)<!>
-const val times3 = threeVal.times(twoVal)
+const val times3 = threeVal.<!EVALUATED("6")!>times(twoVal)<!>
-const val times4 = twoVal.times(byteVal)
+const val times4 = twoVal.<!EVALUATED("4")!>times(byteVal)<!>
-const val times5 = twoVal.times(shortVal)
+const val times5 = twoVal.<!EVALUATED("4")!>times(shortVal)<!>
-const val times6 = twoVal.times(intVal)
+const val times6 = twoVal.<!EVALUATED("4")!>times(intVal)<!>
-const val times7 = twoVal.times(floatVal)
+const val times7 = twoVal.<!EVALUATED("4.0")!>times(floatVal)<!>
-const val times8 = twoVal.times(doubleVal)
+const val times8 = twoVal.<!EVALUATED("4.0")!>times(doubleVal)<!>
 
-const val div1 = oneVal.div(twoVal)
+const val div1 = oneVal.<!EVALUATED("0")!>div(twoVal)<!>
-const val div2 = twoVal.div(twoVal)
+const val div2 = twoVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div3 = threeVal.div(twoVal)
+const val div3 = threeVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div4 = twoVal.div(byteVal)
+const val div4 = twoVal.<!EVALUATED("1")!>div(byteVal)<!>
-const val div5 = twoVal.div(shortVal)
+const val div5 = twoVal.<!EVALUATED("1")!>div(shortVal)<!>
-const val div6 = twoVal.div(intVal)
+const val div6 = twoVal.<!EVALUATED("1")!>div(intVal)<!>
-const val div7 = twoVal.div(floatVal)
+const val div7 = twoVal.<!EVALUATED("1.0")!>div(floatVal)<!>
-const val div8 = twoVal.div(doubleVal)
+const val div8 = twoVal.<!EVALUATED("1.0")!>div(doubleVal)<!>
 
-const val rem1 = oneVal.rem(twoVal)
+const val rem1 = oneVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem2 = twoVal.rem(twoVal)
+const val rem2 = twoVal.<!EVALUATED("0")!>rem(twoVal)<!>
-const val rem3 = threeVal.rem(twoVal)
+const val rem3 = threeVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem4 = twoVal.rem(byteVal)
+const val rem4 = twoVal.<!EVALUATED("0")!>rem(byteVal)<!>
-const val rem5 = twoVal.rem(shortVal)
+const val rem5 = twoVal.<!EVALUATED("0")!>rem(shortVal)<!>
-const val rem6 = twoVal.rem(intVal)
+const val rem6 = twoVal.<!EVALUATED("0")!>rem(intVal)<!>
-const val rem7 = twoVal.rem(floatVal)
+const val rem7 = twoVal.<!EVALUATED("0.0")!>rem(floatVal)<!>
-const val rem8 = twoVal.rem(doubleVal)
+const val rem8 = twoVal.<!EVALUATED("0.0")!>rem(doubleVal)<!>
 
-const val unaryPlus1 = oneVal.unaryPlus()
+const val unaryPlus1 = oneVal.<!EVALUATED("1")!>unaryPlus()<!>
-const val unaryPlus2 = minusOneVal.unaryPlus()
+const val unaryPlus2 = minusOneVal.<!EVALUATED("-1")!>unaryPlus()<!>
-const val unaryMinus1 = oneVal.unaryMinus()
+const val unaryMinus1 = oneVal.<!EVALUATED("-1")!>unaryMinus()<!>
-const val unaryMinus2 = minusOneVal.unaryMinus()
+const val unaryMinus2 = minusOneVal.<!EVALUATED("1")!>unaryMinus()<!>
 
-const val convert1 = oneVal.toByte()
+const val convert1 = oneVal.<!EVALUATED("1")!>toByte()<!>
-const val convert2 = oneVal.toChar()
+const val convert2 = oneVal.<!EVALUATED("
")!>toChar()<!>
-const val convert3 = oneVal.toShort()
+const val convert3 = oneVal.<!EVALUATED("1")!>toShort()<!>
-const val convert4 = oneVal.toInt()
+const val convert4 = oneVal.<!EVALUATED("1")!>toInt()<!>
-const val convert5 = oneVal.toLong()
+const val convert5 = oneVal.<!EVALUATED("1")!>toLong()<!>
-const val convert6 = oneVal.toFloat()
+const val convert6 = oneVal.<!EVALUATED("1.0")!>toFloat()<!>
-const val convert7 = oneVal.toDouble()
+const val convert7 = oneVal.<!EVALUATED("1.0")!>toDouble()<!>
 
-const val equals1 = oneVal == twoVal
+const val equals1 = <!EVALUATED("false")!>oneVal == twoVal<!>
-const val equals2 = twoVal == twoVal
+const val equals2 = <!EVALUATED("true")!>twoVal == twoVal<!>
-const val equals3 = threeVal == twoVal
+const val equals3 = <!EVALUATED("false")!>threeVal == twoVal<!>
-const val equals4 = fourVal == twoVal
+const val equals4 = <!EVALUATED("false")!>fourVal == twoVal<!>
 
-const val toString1 = oneVal.toString()
+const val toString1 = oneVal.<!EVALUATED("1")!>toString()<!>
-const val toString2 = twoVal.toString()
+const val toString2 = twoVal.<!EVALUATED("2")!>toString()<!>
 
 fun box(): String {
-    if (compareTo1 != -1)   return "Fail 1.1"
+    if (<!EVALUATED("false")!>compareTo1 != -1<!>)   return "Fail 1.1"
-    if (compareTo2 != 0)    return "Fail 1.2"
+    if (<!EVALUATED("false")!>compareTo2 != 0<!>)    return "Fail 1.2"
-    if (compareTo3 != 1)    return "Fail 1.3"
+    if (<!EVALUATED("false")!>compareTo3 != 1<!>)    return "Fail 1.3"
-    if (compareTo4 != 0)    return "Fail 1.4"
+    if (<!EVALUATED("false")!>compareTo4 != 0<!>)    return "Fail 1.4"
-    if (compareTo5 != 0)    return "Fail 1.5"
+    if (<!EVALUATED("false")!>compareTo5 != 0<!>)    return "Fail 1.5"
-    if (compareTo6 != 0)    return "Fail 1.6"
+    if (<!EVALUATED("false")!>compareTo6 != 0<!>)    return "Fail 1.6"
-    if (compareTo7 != 0)    return "Fail 1.7"
+    if (<!EVALUATED("false")!>compareTo7 != 0<!>)    return "Fail 1.7"
-    if (compareTo8 != 0)    return "Fail 1.8"
+    if (<!EVALUATED("false")!>compareTo8 != 0<!>)    return "Fail 1.8"
 
-    if (plus1 != 3L)     return "Fail 2.1"
+    if (<!EVALUATED("false")!>plus1 != 3L<!>)     return "Fail 2.1"
-    if (plus2 != 4L)     return "Fail 2.2"
+    if (<!EVALUATED("false")!>plus2 != 4L<!>)     return "Fail 2.2"
-    if (plus3 != 5L)     return "Fail 2.3"
+    if (<!EVALUATED("false")!>plus3 != 5L<!>)     return "Fail 2.3"
-    if (plus4 != 4L)     return "Fail 2.4"
+    if (<!EVALUATED("false")!>plus4 != 4L<!>)     return "Fail 2.4"
-    if (plus5 != 4L)     return "Fail 2.5"
+    if (<!EVALUATED("false")!>plus5 != 4L<!>)     return "Fail 2.5"
-    if (plus6 != 4L)     return "Fail 2.6"
+    if (<!EVALUATED("false")!>plus6 != 4L<!>)     return "Fail 2.6"
-    if (plus7 != 4.0f)  return "Fail 2.7"
+    if (<!EVALUATED("false")!>plus7 != 4.0f<!>)  return "Fail 2.7"
-    if (plus8 != 4.0)   return "Fail 2.8"
+    if (<!EVALUATED("false")!>plus8 != 4.0<!>)   return "Fail 2.8"
 
-    if (minus1 != -1L)       return "Fail 3.1"
+    if (<!EVALUATED("false")!>minus1 != -1L<!>)       return "Fail 3.1"
-    if (minus2 != 0L)        return "Fail 3.2"
+    if (<!EVALUATED("false")!>minus2 != 0L<!>)        return "Fail 3.2"
-    if (minus3 != 1L)        return "Fail 3.3"
+    if (<!EVALUATED("false")!>minus3 != 1L<!>)        return "Fail 3.3"
-    if (minus4 != 0L)        return "Fail 3.4"
+    if (<!EVALUATED("false")!>minus4 != 0L<!>)        return "Fail 3.4"
-    if (minus5 != 0L)        return "Fail 3.5"
+    if (<!EVALUATED("false")!>minus5 != 0L<!>)        return "Fail 3.5"
-    if (minus6 != 0L)        return "Fail 3.6"
+    if (<!EVALUATED("false")!>minus6 != 0L<!>)        return "Fail 3.6"
-    if (minus7 != 0.0f)     return "Fail 3.7"
+    if (<!EVALUATED("false")!>minus7 != 0.0f<!>)     return "Fail 3.7"
-    if (minus8 != 0.0)      return "Fail 3.8"
+    if (<!EVALUATED("false")!>minus8 != 0.0<!>)      return "Fail 3.8"
 
-    if (times1 != 2L)        return "Fail 4.1"
+    if (<!EVALUATED("false")!>times1 != 2L<!>)        return "Fail 4.1"
-    if (times2 != 4L)        return "Fail 4.2"
+    if (<!EVALUATED("false")!>times2 != 4L<!>)        return "Fail 4.2"
-    if (times3 != 6L)        return "Fail 4.3"
+    if (<!EVALUATED("false")!>times3 != 6L<!>)        return "Fail 4.3"
-    if (times4 != 4L)        return "Fail 4.4"
+    if (<!EVALUATED("false")!>times4 != 4L<!>)        return "Fail 4.4"
-    if (times5 != 4L)        return "Fail 4.5"
+    if (<!EVALUATED("false")!>times5 != 4L<!>)        return "Fail 4.5"
-    if (times6 != 4L)        return "Fail 4.6"
+    if (<!EVALUATED("false")!>times6 != 4L<!>)        return "Fail 4.6"
-    if (times7 != 4.0f)     return "Fail 4.7"
+    if (<!EVALUATED("false")!>times7 != 4.0f<!>)     return "Fail 4.7"
-    if (times8 != 4.0)      return "Fail 4.8"
+    if (<!EVALUATED("false")!>times8 != 4.0<!>)      return "Fail 4.8"
 
-    if (div1 != 0L)          return "Fail 5.1"
+    if (<!EVALUATED("false")!>div1 != 0L<!>)          return "Fail 5.1"
-    if (div2 != 1L)          return "Fail 5.2"
+    if (<!EVALUATED("false")!>div2 != 1L<!>)          return "Fail 5.2"
-    if (div3 != 1L)          return "Fail 5.3"
+    if (<!EVALUATED("false")!>div3 != 1L<!>)          return "Fail 5.3"
-    if (div4 != 1L)          return "Fail 5.4"
+    if (<!EVALUATED("false")!>div4 != 1L<!>)          return "Fail 5.4"
-    if (div5 != 1L)          return "Fail 5.5"
+    if (<!EVALUATED("false")!>div5 != 1L<!>)          return "Fail 5.5"
-    if (div6 != 1L)          return "Fail 5.6"
+    if (<!EVALUATED("false")!>div6 != 1L<!>)          return "Fail 5.6"
-    if (div7 != 1.0f)       return "Fail 5.7"
+    if (<!EVALUATED("false")!>div7 != 1.0f<!>)       return "Fail 5.7"
-    if (div8 != 1.0)        return "Fail 5.8"
+    if (<!EVALUATED("false")!>div8 != 1.0<!>)        return "Fail 5.8"
 
-    if (rem1 != 1L)      return "Fail 6.1"
+    if (<!EVALUATED("false")!>rem1 != 1L<!>)      return "Fail 6.1"
-    if (rem2 != 0L)      return "Fail 6.2"
+    if (<!EVALUATED("false")!>rem2 != 0L<!>)      return "Fail 6.2"
-    if (rem3 != 1L)      return "Fail 6.3"
+    if (<!EVALUATED("false")!>rem3 != 1L<!>)      return "Fail 6.3"
-    if (rem4 != 0L)      return "Fail 6.4"
+    if (<!EVALUATED("false")!>rem4 != 0L<!>)      return "Fail 6.4"
-    if (rem5 != 0L)      return "Fail 6.5"
+    if (<!EVALUATED("false")!>rem5 != 0L<!>)      return "Fail 6.5"
-    if (rem6 != 0L)      return "Fail 6.6"
+    if (<!EVALUATED("false")!>rem6 != 0L<!>)      return "Fail 6.6"
-    if (rem7 != 0.0f)   return "Fail 6.7"
+    if (<!EVALUATED("false")!>rem7 != 0.0f<!>)   return "Fail 6.7"
-    if (rem8 != 0.0)    return "Fail 6.8"
+    if (<!EVALUATED("false")!>rem8 != 0.0<!>)    return "Fail 6.8"
 
-    if (unaryPlus1 != 1L)    return "Fail 7.1"
+    if (<!EVALUATED("false")!>unaryPlus1 != 1L<!>)    return "Fail 7.1"
-    if (unaryPlus2 != -1L)   return "Fail 7.2"
+    if (<!EVALUATED("false")!>unaryPlus2 != -1L<!>)   return "Fail 7.2"
-    if (unaryMinus1 != -1L)  return "Fail 7.3"
+    if (<!EVALUATED("false")!>unaryMinus1 != -1L<!>)  return "Fail 7.3"
-    if (unaryMinus2 != 1L)   return "Fail 7.4"
+    if (<!EVALUATED("false")!>unaryMinus2 != 1L<!>)   return "Fail 7.4"
 
-    if (convert1 != 1.toByte())      return "Fail 8.1"
+    if (<!EVALUATED("false")!>convert1 != 1.toByte()<!>)      return "Fail 8.1"
-    if (convert2 != '
')  return "Fail 8.2"
+    if (<!EVALUATED("false")!>convert2 != '
'<!>)  return "Fail 8.2"
-    if (convert3 != 1.toShort())      return "Fail 8.3"
+    if (<!EVALUATED("false")!>convert3 != 1.toShort()<!>)      return "Fail 8.3"
-    if (convert4 != 1)      return "Fail 8.4"
+    if (<!EVALUATED("false")!>convert4 != 1<!>)      return "Fail 8.4"
-    if (convert5 != 1L)      return "Fail 8.5"
+    if (<!EVALUATED("false")!>convert5 != 1L<!>)      return "Fail 8.5"
-    if (convert6 != 1.0f)   return "Fail 8.6"
+    if (<!EVALUATED("false")!>convert6 != 1.0f<!>)   return "Fail 8.6"
-    if (convert7 != 1.0)    return "Fail 8.7"
+    if (<!EVALUATED("false")!>convert7 != 1.0<!>)    return "Fail 8.7"
 
-    if (equals1 != false)   return "Fail 9.1"
+    if (<!EVALUATED("false")!>equals1 != false<!>)   return "Fail 9.1"
-    if (equals2 != true)    return "Fail 9.2"
+    if (<!EVALUATED("false")!>equals2 != true<!>)    return "Fail 9.2"
-    if (equals3 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 9.3"
-    if (equals4 != false)   return "Fail 9.4"
+    if (<!EVALUATED("false")!>equals4 != false<!>)   return "Fail 9.4"
 
-    if (toString1 != "1")   return "Fail 10.1"
+    if (<!EVALUATED("false")!>toString1 != "1"<!>)   return "Fail 10.1"
-    if (toString2 != "2")   return "Fail 10.2"
+    if (<!EVALUATED("false")!>toString2 != "2"<!>)   return "Fail 10.2"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/objectConstValInAnnotationArgument.kt

@@ -0,0 +1,15 @@
+// TARGET_BACKEND: JVM_IR
+annotation class Key(val value: String)
+
+object Messanger {
+    const val DEFAULT_TEXT = <!EVALUATED("OK")!>"OK"<!>
+
+    // Note: second `EVALUATED` from `message$default`
+    fun message(@Key(value = <!EVALUATED("OK"), EVALUATED("OK")!>DEFAULT_TEXT<!>) text: String = <!EVALUATED("OK")!>DEFAULT_TEXT<!>): String {
+        return text
+    }
+}
+
+fun box(): String {
+    return Messanger.message()
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/shortOperations.kt

@@ -3,169 +3,169 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: NATIVE
 
-const val minusOneVal = (-1).toShort()
+const val minusOneVal = (-1).<!EVALUATED("-1")!>toShort()<!>
-const val oneVal = 1.toShort()
+const val oneVal = 1.<!EVALUATED("1")!>toShort()<!>
-const val twoVal = 2.toShort()
+const val twoVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val threeVal = 3.toShort()
+const val threeVal = 3.<!EVALUATED("3")!>toShort()<!>
-const val fourVal = 4.toShort()
+const val fourVal = 4.<!EVALUATED("4")!>toShort()<!>
 
-const val byteVal = 2.toByte()
+const val byteVal = 2.<!EVALUATED("2")!>toByte()<!>
-const val shortVal = 2.toShort()
+const val shortVal = 2.<!EVALUATED("2")!>toShort()<!>
-const val intVal = 2
+const val intVal = <!EVALUATED("2")!>2<!>
-const val longVal = 2L
+const val longVal = <!EVALUATED("2")!>2L<!>
-const val floatVal = 2.0f
+const val floatVal = <!EVALUATED("2.0")!>2.0f<!>
-const val doubleVal = 2.0
+const val doubleVal = <!EVALUATED("2.0")!>2.0<!>
 
-const val compareTo1 = oneVal.compareTo(twoVal)
+const val compareTo1 = oneVal.<!EVALUATED("-1")!>compareTo(twoVal)<!>
-const val compareTo2 = twoVal.compareTo(twoVal)
+const val compareTo2 = twoVal.<!EVALUATED("0")!>compareTo(twoVal)<!>
-const val compareTo3 = threeVal.compareTo(twoVal)
+const val compareTo3 = threeVal.<!EVALUATED("1")!>compareTo(twoVal)<!>
-const val compareTo4 = twoVal.compareTo(byteVal)
+const val compareTo4 = twoVal.<!EVALUATED("0")!>compareTo(byteVal)<!>
-const val compareTo5 = twoVal.compareTo(intVal)
+const val compareTo5 = twoVal.<!EVALUATED("0")!>compareTo(intVal)<!>
-const val compareTo6 = twoVal.compareTo(longVal)
+const val compareTo6 = twoVal.<!EVALUATED("0")!>compareTo(longVal)<!>
-const val compareTo7 = twoVal.compareTo(floatVal)
+const val compareTo7 = twoVal.<!EVALUATED("0")!>compareTo(floatVal)<!>
-const val compareTo8 = twoVal.compareTo(doubleVal)
+const val compareTo8 = twoVal.<!EVALUATED("0")!>compareTo(doubleVal)<!>
 
-const val plus1 = oneVal.plus(twoVal)
+const val plus1 = oneVal.<!EVALUATED("3")!>plus(twoVal)<!>
-const val plus2 = twoVal.plus(twoVal)
+const val plus2 = twoVal.<!EVALUATED("4")!>plus(twoVal)<!>
-const val plus3 = threeVal.plus(twoVal)
+const val plus3 = threeVal.<!EVALUATED("5")!>plus(twoVal)<!>
-const val plus4 = twoVal.plus(byteVal)
+const val plus4 = twoVal.<!EVALUATED("4")!>plus(byteVal)<!>
-const val plus5 = twoVal.plus(intVal)
+const val plus5 = twoVal.<!EVALUATED("4")!>plus(intVal)<!>
-const val plus6 = twoVal.plus(longVal)
+const val plus6 = twoVal.<!EVALUATED("4")!>plus(longVal)<!>
-const val plus7 = twoVal.plus(floatVal)
+const val plus7 = twoVal.<!EVALUATED("4.0")!>plus(floatVal)<!>
-const val plus8 = twoVal.plus(doubleVal)
+const val plus8 = twoVal.<!EVALUATED("4.0")!>plus(doubleVal)<!>
 
-const val minus1 = oneVal.minus(twoVal)
+const val minus1 = oneVal.<!EVALUATED("-1")!>minus(twoVal)<!>
-const val minus2 = twoVal.minus(twoVal)
+const val minus2 = twoVal.<!EVALUATED("0")!>minus(twoVal)<!>
-const val minus3 = threeVal.minus(twoVal)
+const val minus3 = threeVal.<!EVALUATED("1")!>minus(twoVal)<!>
-const val minus4 = twoVal.minus(byteVal)
+const val minus4 = twoVal.<!EVALUATED("0")!>minus(byteVal)<!>
-const val minus5 = twoVal.minus(intVal)
+const val minus5 = twoVal.<!EVALUATED("0")!>minus(intVal)<!>
-const val minus6 = twoVal.minus(longVal)
+const val minus6 = twoVal.<!EVALUATED("0")!>minus(longVal)<!>
-const val minus7 = twoVal.minus(floatVal)
+const val minus7 = twoVal.<!EVALUATED("0.0")!>minus(floatVal)<!>
-const val minus8 = twoVal.minus(doubleVal)
+const val minus8 = twoVal.<!EVALUATED("0.0")!>minus(doubleVal)<!>
 
-const val times1 = oneVal.times(twoVal)
+const val times1 = oneVal.<!EVALUATED("2")!>times(twoVal)<!>
-const val times2 = twoVal.times(twoVal)
+const val times2 = twoVal.<!EVALUATED("4")!>times(twoVal)<!>
-const val times3 = threeVal.times(twoVal)
+const val times3 = threeVal.<!EVALUATED("6")!>times(twoVal)<!>
-const val times4 = twoVal.times(byteVal)
+const val times4 = twoVal.<!EVALUATED("4")!>times(byteVal)<!>
-const val times5 = twoVal.times(intVal)
+const val times5 = twoVal.<!EVALUATED("4")!>times(intVal)<!>
-const val times6 = twoVal.times(longVal)
+const val times6 = twoVal.<!EVALUATED("4")!>times(longVal)<!>
-const val times7 = twoVal.times(floatVal)
+const val times7 = twoVal.<!EVALUATED("4.0")!>times(floatVal)<!>
-const val times8 = twoVal.times(doubleVal)
+const val times8 = twoVal.<!EVALUATED("4.0")!>times(doubleVal)<!>
 
-const val div1 = oneVal.div(twoVal)
+const val div1 = oneVal.<!EVALUATED("0")!>div(twoVal)<!>
-const val div2 = twoVal.div(twoVal)
+const val div2 = twoVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div3 = threeVal.div(twoVal)
+const val div3 = threeVal.<!EVALUATED("1")!>div(twoVal)<!>
-const val div4 = twoVal.div(byteVal)
+const val div4 = twoVal.<!EVALUATED("1")!>div(byteVal)<!>
-const val div5 = twoVal.div(intVal)
+const val div5 = twoVal.<!EVALUATED("1")!>div(intVal)<!>
-const val div6 = twoVal.div(longVal)
+const val div6 = twoVal.<!EVALUATED("1")!>div(longVal)<!>
-const val div7 = twoVal.div(floatVal)
+const val div7 = twoVal.<!EVALUATED("1.0")!>div(floatVal)<!>
-const val div8 = twoVal.div(doubleVal)
+const val div8 = twoVal.<!EVALUATED("1.0")!>div(doubleVal)<!>
 
-const val rem1 = oneVal.rem(twoVal)
+const val rem1 = oneVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem2 = twoVal.rem(twoVal)
+const val rem2 = twoVal.<!EVALUATED("0")!>rem(twoVal)<!>
-const val rem3 = threeVal.rem(twoVal)
+const val rem3 = threeVal.<!EVALUATED("1")!>rem(twoVal)<!>
-const val rem4 = twoVal.rem(byteVal)
+const val rem4 = twoVal.<!EVALUATED("0")!>rem(byteVal)<!>
-const val rem5 = twoVal.rem(intVal)
+const val rem5 = twoVal.<!EVALUATED("0")!>rem(intVal)<!>
-const val rem6 = twoVal.rem(longVal)
+const val rem6 = twoVal.<!EVALUATED("0")!>rem(longVal)<!>
-const val rem7 = twoVal.rem(floatVal)
+const val rem7 = twoVal.<!EVALUATED("0.0")!>rem(floatVal)<!>
-const val rem8 = twoVal.rem(doubleVal)
+const val rem8 = twoVal.<!EVALUATED("0.0")!>rem(doubleVal)<!>
 
-const val unaryPlus1 = oneVal.unaryPlus()
+const val unaryPlus1 = oneVal.<!EVALUATED("1")!>unaryPlus()<!>
-const val unaryPlus2 = minusOneVal.unaryPlus()
+const val unaryPlus2 = minusOneVal.<!EVALUATED("-1")!>unaryPlus()<!>
-const val unaryMinus1 = oneVal.unaryMinus()
+const val unaryMinus1 = oneVal.<!EVALUATED("-1")!>unaryMinus()<!>
-const val unaryMinus2 = minusOneVal.unaryMinus()
+const val unaryMinus2 = minusOneVal.<!EVALUATED("1")!>unaryMinus()<!>
 
-const val convert1 = oneVal.toByte()
+const val convert1 = oneVal.<!EVALUATED("1")!>toByte()<!>
-const val convert2 = oneVal.toChar()
+const val convert2 = oneVal.<!EVALUATED("
")!>toChar()<!>
-const val convert3 = oneVal.toShort()
+const val convert3 = oneVal.<!EVALUATED("1")!>toShort()<!>
-const val convert4 = oneVal.toInt()
+const val convert4 = oneVal.<!EVALUATED("1")!>toInt()<!>
-const val convert5 = oneVal.toLong()
+const val convert5 = oneVal.<!EVALUATED("1")!>toLong()<!>
-const val convert6 = oneVal.toFloat()
+const val convert6 = oneVal.<!EVALUATED("1.0")!>toFloat()<!>
-const val convert7 = oneVal.toDouble()
+const val convert7 = oneVal.<!EVALUATED("1.0")!>toDouble()<!>
 
-const val equals1 = oneVal == twoVal
+const val equals1 = <!EVALUATED("false")!>oneVal == twoVal<!>
-const val equals2 = twoVal == twoVal
+const val equals2 = <!EVALUATED("true")!>twoVal == twoVal<!>
-const val equals3 = threeVal == twoVal
+const val equals3 = <!EVALUATED("false")!>threeVal == twoVal<!>
-const val equals4 = fourVal == twoVal
+const val equals4 = <!EVALUATED("false")!>fourVal == twoVal<!>
 
-const val toString1 = oneVal.toString()
+const val toString1 = oneVal.<!EVALUATED("1")!>toString()<!>
-const val toString2 = twoVal.toString()
+const val toString2 = twoVal.<!EVALUATED("2")!>toString()<!>
 
 fun box(): String {
-    if (compareTo1 != -1)   return "Fail 1.1"
+    if (<!EVALUATED("false")!>compareTo1 != -1<!>)   return "Fail 1.1"
-    if (compareTo2 != 0)    return "Fail 1.2"
+    if (<!EVALUATED("false")!>compareTo2 != 0<!>)    return "Fail 1.2"
-    if (compareTo3 != 1)    return "Fail 1.3"
+    if (<!EVALUATED("false")!>compareTo3 != 1<!>)    return "Fail 1.3"
-    if (compareTo4 != 0)    return "Fail 1.4"
+    if (<!EVALUATED("false")!>compareTo4 != 0<!>)    return "Fail 1.4"
-    if (compareTo5 != 0)    return "Fail 1.5"
+    if (<!EVALUATED("false")!>compareTo5 != 0<!>)    return "Fail 1.5"
-    if (compareTo6 != 0)    return "Fail 1.6"
+    if (<!EVALUATED("false")!>compareTo6 != 0<!>)    return "Fail 1.6"
-    if (compareTo7 != 0)    return "Fail 1.7"
+    if (<!EVALUATED("false")!>compareTo7 != 0<!>)    return "Fail 1.7"
-    if (compareTo8 != 0)    return "Fail 1.8"
+    if (<!EVALUATED("false")!>compareTo8 != 0<!>)    return "Fail 1.8"
 
-    if (plus1 != 3)     return "Fail 2.1"
+    if (<!EVALUATED("false")!>plus1 != 3<!>)     return "Fail 2.1"
-    if (plus2 != 4)     return "Fail 2.2"
+    if (<!EVALUATED("false")!>plus2 != 4<!>)     return "Fail 2.2"
-    if (plus3 != 5)     return "Fail 2.3"
+    if (<!EVALUATED("false")!>plus3 != 5<!>)     return "Fail 2.3"
-    if (plus4 != 4)     return "Fail 2.4"
+    if (<!EVALUATED("false")!>plus4 != 4<!>)     return "Fail 2.4"
-    if (plus5 != 4)     return "Fail 2.5"
+    if (<!EVALUATED("false")!>plus5 != 4<!>)     return "Fail 2.5"
-    if (plus6 != 4L)     return "Fail 2.6"
+    if (<!EVALUATED("false")!>plus6 != 4L<!>)     return "Fail 2.6"
-    if (plus7 != 4.0f)  return "Fail 2.7"
+    if (<!EVALUATED("false")!>plus7 != 4.0f<!>)  return "Fail 2.7"
-    if (plus8 != 4.0)   return "Fail 2.8"
+    if (<!EVALUATED("false")!>plus8 != 4.0<!>)   return "Fail 2.8"
 
-    if (minus1 != -1)       return "Fail 3.1"
+    if (<!EVALUATED("false")!>minus1 != -1<!>)       return "Fail 3.1"
-    if (minus2 != 0)        return "Fail 3.2"
+    if (<!EVALUATED("false")!>minus2 != 0<!>)        return "Fail 3.2"
-    if (minus3 != 1)        return "Fail 3.3"
+    if (<!EVALUATED("false")!>minus3 != 1<!>)        return "Fail 3.3"
-    if (minus4 != 0)        return "Fail 3.4"
+    if (<!EVALUATED("false")!>minus4 != 0<!>)        return "Fail 3.4"
-    if (minus5 != 0)        return "Fail 3.5"
+    if (<!EVALUATED("false")!>minus5 != 0<!>)        return "Fail 3.5"
-    if (minus6 != 0L)        return "Fail 3.6"
+    if (<!EVALUATED("false")!>minus6 != 0L<!>)        return "Fail 3.6"
-    if (minus7 != 0.0f)     return "Fail 3.7"
+    if (<!EVALUATED("false")!>minus7 != 0.0f<!>)     return "Fail 3.7"
-    if (minus8 != 0.0)      return "Fail 3.8"
+    if (<!EVALUATED("false")!>minus8 != 0.0<!>)      return "Fail 3.8"
 
-    if (times1 != 2)        return "Fail 4.1"
+    if (<!EVALUATED("false")!>times1 != 2<!>)        return "Fail 4.1"
-    if (times2 != 4)        return "Fail 4.2"
+    if (<!EVALUATED("false")!>times2 != 4<!>)        return "Fail 4.2"
-    if (times3 != 6)        return "Fail 4.3"
+    if (<!EVALUATED("false")!>times3 != 6<!>)        return "Fail 4.3"
-    if (times4 != 4)        return "Fail 4.4"
+    if (<!EVALUATED("false")!>times4 != 4<!>)        return "Fail 4.4"
-    if (times5 != 4)        return "Fail 4.5"
+    if (<!EVALUATED("false")!>times5 != 4<!>)        return "Fail 4.5"
-    if (times6 != 4L)        return "Fail 4.6"
+    if (<!EVALUATED("false")!>times6 != 4L<!>)        return "Fail 4.6"
-    if (times7 != 4.0f)     return "Fail 4.7"
+    if (<!EVALUATED("false")!>times7 != 4.0f<!>)     return "Fail 4.7"
-    if (times8 != 4.0)      return "Fail 4.8"
+    if (<!EVALUATED("false")!>times8 != 4.0<!>)      return "Fail 4.8"
 
-    if (div1 != 0)          return "Fail 5.1"
+    if (<!EVALUATED("false")!>div1 != 0<!>)          return "Fail 5.1"
-    if (div2 != 1)          return "Fail 5.2"
+    if (<!EVALUATED("false")!>div2 != 1<!>)          return "Fail 5.2"
-    if (div3 != 1)          return "Fail 5.3"
+    if (<!EVALUATED("false")!>div3 != 1<!>)          return "Fail 5.3"
-    if (div4 != 1)          return "Fail 5.4"
+    if (<!EVALUATED("false")!>div4 != 1<!>)          return "Fail 5.4"
-    if (div5 != 1)          return "Fail 5.5"
+    if (<!EVALUATED("false")!>div5 != 1<!>)          return "Fail 5.5"
-    if (div6 != 1L)          return "Fail 5.6"
+    if (<!EVALUATED("false")!>div6 != 1L<!>)          return "Fail 5.6"
-    if (div7 != 1.0f)       return "Fail 5.7"
+    if (<!EVALUATED("false")!>div7 != 1.0f<!>)       return "Fail 5.7"
-    if (div8 != 1.0)        return "Fail 5.8"
+    if (<!EVALUATED("false")!>div8 != 1.0<!>)        return "Fail 5.8"
 
-    if (rem1 != 1)      return "Fail 6.1"
+    if (<!EVALUATED("false")!>rem1 != 1<!>)      return "Fail 6.1"
-    if (rem2 != 0)      return "Fail 6.2"
+    if (<!EVALUATED("false")!>rem2 != 0<!>)      return "Fail 6.2"
-    if (rem3 != 1)      return "Fail 6.3"
+    if (<!EVALUATED("false")!>rem3 != 1<!>)      return "Fail 6.3"
-    if (rem4 != 0)      return "Fail 6.4"
+    if (<!EVALUATED("false")!>rem4 != 0<!>)      return "Fail 6.4"
-    if (rem5 != 0)      return "Fail 6.5"
+    if (<!EVALUATED("false")!>rem5 != 0<!>)      return "Fail 6.5"
-    if (rem6 != 0L)      return "Fail 6.6"
+    if (<!EVALUATED("false")!>rem6 != 0L<!>)      return "Fail 6.6"
-    if (rem7 != 0.0f)   return "Fail 6.7"
+    if (<!EVALUATED("false")!>rem7 != 0.0f<!>)   return "Fail 6.7"
-    if (rem8 != 0.0)    return "Fail 6.8"
+    if (<!EVALUATED("false")!>rem8 != 0.0<!>)    return "Fail 6.8"
 
-    if (unaryPlus1 != 1)    return "Fail 7.1"
+    if (<!EVALUATED("false")!>unaryPlus1 != 1<!>)    return "Fail 7.1"
-    if (unaryPlus2 != -1)   return "Fail 7.2"
+    if (<!EVALUATED("false")!>unaryPlus2 != -1<!>)   return "Fail 7.2"
-    if (unaryMinus1 != -1)  return "Fail 7.3"
+    if (<!EVALUATED("false")!>unaryMinus1 != -1<!>)  return "Fail 7.3"
-    if (unaryMinus2 != 1)   return "Fail 7.4"
+    if (<!EVALUATED("false")!>unaryMinus2 != 1<!>)   return "Fail 7.4"
 
-    if (convert1 != 1.toByte())      return "Fail 8.1"
+    if (<!EVALUATED("false")!>convert1 != 1.toByte()<!>)      return "Fail 8.1"
-    if (convert2 != '
')  return "Fail 8.2"
+    if (<!EVALUATED("false")!>convert2 != '
'<!>)  return "Fail 8.2"
-    if (convert3 != 1.toShort())      return "Fail 8.3"
+    if (<!EVALUATED("false")!>convert3 != 1.toShort()<!>)      return "Fail 8.3"
-    if (convert4 != 1)      return "Fail 8.4"
+    if (<!EVALUATED("false")!>convert4 != 1<!>)      return "Fail 8.4"
-    if (convert5 != 1L)      return "Fail 8.5"
+    if (<!EVALUATED("false")!>convert5 != 1L<!>)      return "Fail 8.5"
-    if (convert6 != 1.0f)   return "Fail 8.6"
+    if (<!EVALUATED("false")!>convert6 != 1.0f<!>)   return "Fail 8.6"
-    if (convert7 != 1.0)    return "Fail 8.7"
+    if (<!EVALUATED("false")!>convert7 != 1.0<!>)    return "Fail 8.7"
 
-    if (equals1 != false)   return "Fail 9.1"
+    if (<!EVALUATED("false")!>equals1 != false<!>)   return "Fail 9.1"
-    if (equals2 != true)    return "Fail 9.2"
+    if (<!EVALUATED("false")!>equals2 != true<!>)    return "Fail 9.2"
-    if (equals3 != false)   return "Fail 9.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 9.3"
-    if (equals4 != false)   return "Fail 9.4"
+    if (<!EVALUATED("false")!>equals4 != false<!>)   return "Fail 9.4"
 
-    if (toString1 != "1")   return "Fail 10.1"
+    if (<!EVALUATED("false")!>toString1 != "1"<!>)   return "Fail 10.1"
-    if (toString2 != "2")   return "Fail 10.2"
+    if (<!EVALUATED("false")!>toString2 != "2"<!>)   return "Fail 10.2"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/stdlibConst.kt

@@ -3,14 +3,14 @@
 // TARGET_BACKEND: JS_IR
 // WITH_STDLIB
 
-const val code = '1'.code
+const val code = '1'.<!EVALUATED("49")!>code<!>
-const val floorDiv = 10.floorDiv(2)
+const val floorDiv = 10.<!EVALUATED("5")!>floorDiv(2)<!>
-const val mod = 5.mod(3)
+const val mod = 5.<!EVALUATED("2")!>mod(3)<!>
 
 fun box(): String {
-    if (code != 49) return "Fail 1"
+    if (<!EVALUATED("false")!>code != 49<!>) return "Fail 1"
-    if (floorDiv != 5) return "Fail 2"
+    if (<!EVALUATED("false")!>floorDiv != 5<!>) return "Fail 2"
-    if (mod != 2) return "Fail 3"
+    if (<!EVALUATED("false")!>mod != 2<!>) return "Fail 3"
 
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/stringConcatenation.kt

@@ -3,14 +3,14 @@
 // TARGET_BACKEND: JS_IR
 // WITH_STDLIB
 
-const val simple = "O${'K'} ${1.toLong() + 2.5}"
+const val simple = <!EVALUATED("OK 3.5")!>"O${'K'} ${1.toLong() + 2.5}"<!>
-const val withInnerConcatenation = "1 ${"2 ${3} ${4} 5"} 6"
+const val withInnerConcatenation = <!EVALUATED("1 2 3 4 5 6")!>"1 ${"2 ${3} ${4} 5"} 6"<!>
-const val withNull = "1 ${null}" // but `"1" + null` is invalid
+const val withNull = <!EVALUATED("1 null")!>"1 ${null}"<!> // but `"1" + null` is invalid
 
 fun box(): String {
-    if (simple != "OK 3.5") return "Fail 1"
+    if (<!EVALUATED("false")!>simple != "OK 3.5"<!>) return "Fail 1"
-    if (withInnerConcatenation != "1 2 3 4 5 6") return "Fail 2"
+    if (<!EVALUATED("false")!>withInnerConcatenation != "1 2 3 4 5 6"<!>) return "Fail 2"
-    if (withNull != "1 null") return "Fail 3"
+    if (<!EVALUATED("false")!>withNull != "1 null"<!>) return "Fail 3"
 
     return "OK"
 }

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/stringOperations.kt

@@ -2,48 +2,48 @@
 // TARGET_BACKEND: NATIVE
 // TARGET_BACKEND: JS_IR
 
-const val someStr = "123"
+const val someStr = <!EVALUATED("123")!>"123"<!>
-const val otherStr = "other"
+const val otherStr = <!EVALUATED("other")!>"other"<!>
 
-const val oneVal = 1
+const val oneVal = <!EVALUATED("1")!>1<!>
 
-const val plus1 = someStr.plus(otherStr)
+const val plus1 = someStr.<!EVALUATED("123other")!>plus(otherStr)<!>
-const val plus2 = someStr.plus(oneVal)
+const val plus2 = someStr.<!EVALUATED("1231")!>plus(oneVal)<!>
 
-const val length1 = someStr.length
+const val length1 = someStr.<!EVALUATED("3")!>length<!>
-const val length2 = otherStr.length
+const val length2 = otherStr.<!EVALUATED("5")!>length<!>
 
-const val get1 = someStr.get(0)
+const val get1 = someStr.<!EVALUATED("1")!>get(0)<!>
-const val get2 = otherStr.get(oneVal)
+const val get2 = otherStr.<!EVALUATED("t")!>get(oneVal)<!>
 
-const val compareTo1 = someStr.compareTo("123")
+const val compareTo1 = someStr.<!EVALUATED("0")!>compareTo("123")<!>
-const val compareTo2 = someStr.compareTo(otherStr)
+const val compareTo2 = someStr.<!EVALUATED("-62")!>compareTo(otherStr)<!>
-const val compareTo3 = otherStr.compareTo(someStr)
+const val compareTo3 = otherStr.<!EVALUATED("62")!>compareTo(someStr)<!>
 
-const val equals1 = someStr == "123"
+const val equals1 = <!EVALUATED("true")!>someStr == "123"<!>
-const val equals2 = someStr == otherStr
+const val equals2 = <!EVALUATED("false")!>someStr == otherStr<!>
-const val equals3 = otherStr == someStr
+const val equals3 = <!EVALUATED("false")!>otherStr == someStr<!>
 
-const val toString1 = someStr.toString()
+const val toString1 = someStr.<!EVALUATED("123")!>toString()<!>
 
 fun box(): String {
-    if (plus1 != "123other")    return "Fail 1.1"
+    if (<!EVALUATED("false")!>plus1 != "123other"<!>)    return "Fail 1.1"
-    if (plus2 != "1231")        return "Fail 1.2"
+    if (<!EVALUATED("false")!>plus2 != "1231"<!>)        return "Fail 1.2"
 
-    if (length1 != 3)   return "Fail 2.1"
+    if (<!EVALUATED("false")!>length1 != 3<!>)   return "Fail 2.1"
-    if (length2 != 5)   return "Fail 2.2"
+    if (<!EVALUATED("false")!>length2 != 5<!>)   return "Fail 2.2"
 
-    if (get1 != '1')    return "Fail 3.1"
+    if (<!EVALUATED("false")!>get1 != '1'<!>)    return "Fail 3.1"
-    if (get2 != 't')    return "Fail 3.2"
+    if (<!EVALUATED("false")!>get2 != 't'<!>)    return "Fail 3.2"
 
-    if (compareTo1 != 0)    return "Fail 4.1"
+    if (<!EVALUATED("false")!>compareTo1 != 0<!>)    return "Fail 4.1"
-    if (compareTo2 >= 0)    return "Fail 4.2"
+    if (<!EVALUATED("false")!>compareTo2 >= 0<!>)    return "Fail 4.2"
-    if (compareTo3 <= 0)    return "Fail 4.3"
+    if (<!EVALUATED("false")!>compareTo3 <= 0<!>)    return "Fail 4.3"
 
-    if (equals1 != true)    return "Fail 5.1"
+    if (<!EVALUATED("false")!>equals1 != true<!>)    return "Fail 5.1"
-    if (equals2 != false)   return "Fail 5.2"
+    if (<!EVALUATED("false")!>equals2 != false<!>)   return "Fail 5.2"
-    if (equals3 != false)   return "Fail 5.3"
+    if (<!EVALUATED("false")!>equals3 != false<!>)   return "Fail 5.3"
 
-    if (toString1 != "123") return "Fail 6.1"
+    if (<!EVALUATED("false")!>toString1 != "123"<!>) return "Fail 6.1"
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/unsignedConst.kt

@@ -3,15 +3,15 @@
 // TARGET_BACKEND: JS_IR
 // WITH_STDLIB
 
-const val byteVal: UByte = 1u
+const val byteVal: UByte = <!EVALUATED("1")!>1u<!>
-const val shortVal: UShort = 2u
+const val shortVal: UShort = <!EVALUATED("2")!>2u<!>
-const val intVal: UInt = 3u
+const val intVal: UInt = <!EVALUATED("3")!>3u<!>
-const val longVal: ULong = 4uL
+const val longVal: ULong = <!EVALUATED("4")!>4uL<!>
 
 fun box(): String {
-    if (byteVal != 1u.toUByte())    return "Fail 1"
+    if (<!EVALUATED("1")!>byteVal<!> != 1u.toUByte())    return "Fail 1"
-    if (shortVal != 2u.toUShort())  return "Fail 2"
+    if (<!EVALUATED("2")!>shortVal<!> != 2u.toUShort())  return "Fail 2"
-    if (intVal != 3u.toUInt())      return "Fail 3"
+    if (<!EVALUATED("3")!>intVal<!> != 3u.toUInt())      return "Fail 3"
-    if (longVal != 4u.toULong())    return "Fail 4"
+    if (<!EVALUATED("4")!>longVal<!> != 4u.toULong())    return "Fail 4"
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/jsIrToConst.kt

@@ -1,10 +1,10 @@
 // TARGET_BACKEND: JS_IR
 // IGNORE_BACKEND_K1: JS_IR, JS_IR_ES6
 
-const val toStringInConst = 1.0.toString()
+const val toStringInConst = 1.0.<!EVALUATED("1")!>toString()<!>
 
 fun box(): String {
-    if (toStringInConst != "1") return "Fail 1"
+    if (<!EVALUATED("false")!>toStringInConst != "1"<!>) return "Fail 1"
-    if (1.0.toString() != toStringInConst) return "Fail 2"
+    if (<!EVALUATED("false")!>1.0.toString() != toStringInConst<!>) return "Fail 2"
     return "OK"
 }

compiler/testData/codegen/box/involvesIrInterpreter/kt53480.kt

@@ -11,5 +11,5 @@ enum class A {
 }
 
 fun box(): String {
-    return A.OK.name
+    return A.OK.<!EVALUATED("OK")!>name<!>
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/kt55108.kt

@@ -3,19 +3,19 @@
 
 annotation class A(vararg val strings: String)
 
-@A(*arrayOf("foo", "bar"), "baz")
+@A(*arrayOf(<!EVALUATED("foo")!>"foo"<!>, <!EVALUATED("bar")!>"bar"<!>), <!EVALUATED("baz")!>"baz"<!>)
 class B
 
-@A("baz", *arrayOf("foo", "bar"), "xyz")
+@A(<!EVALUATED("baz")!>"baz"<!>, *arrayOf(<!EVALUATED("foo")!>"foo"<!>, <!EVALUATED("bar")!>"bar"<!>), <!EVALUATED("xyz")!>"xyz"<!>)
 class C
 
-@A(*arrayOf("foo", "bar", "xyz"))
+@A(*arrayOf(<!EVALUATED("foo")!>"foo"<!>, <!EVALUATED("bar")!>"bar"<!>, <!EVALUATED("xyz")!>"xyz"<!>))
 class D
 
-@A("foo", "baz", "bar")
+@A(<!EVALUATED("foo")!>"foo"<!>, <!EVALUATED("baz")!>"baz"<!>, <!EVALUATED("bar")!>"bar"<!>)
 class E
 
-@A(*arrayOf("foo", "bar"), *arrayOf("baz", "xyz"))
+@A(*arrayOf(<!EVALUATED("foo")!>"foo"<!>, <!EVALUATED("bar")!>"bar"<!>), *arrayOf(<!EVALUATED("baz")!>"baz"<!>, <!EVALUATED("xyz")!>"xyz"<!>))
 class F
 
 fun box(): String {

compiler/testData/codegen/box/involvesIrInterpreter/kt55912.kt

@@ -1,8 +1,11 @@
+// IGNORE_BACKEND: WASM
+// WASM test infra can't handle `EVALUATED` diagnostic
+
 public annotation class Entity(val foreignKeys: Array<String>)
 
-@Entity(foreignKeys = kotlin.arrayOf("id")) // works without "kotlin."
+@Entity(foreignKeys = kotlin.arrayOf(<!EVALUATED("id")!>"id"<!>)) // works without "kotlin."
 class Record
 
 fun box(): String {
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/kt56215.kt

@@ -7,7 +7,7 @@ fun ObjectWithExtension?.nullableExtensionFun(): String =
         "Not null"
 
 fun ObjectWithExtension.extensionFun(): String =
-    if(this == null)
+    if(<!EVALUATED("false")!>this == null<!>)
         "Null" // unreachable branch, will be optimized by interpreter
     else
         "Not null"

compiler/testData/codegen/box/involvesIrInterpreter/kt57313.kt

@@ -15,7 +15,7 @@ class OrgBootstrapTriggerJob(val orgId: Long, val bootstrap: OrgBootstrapRequest
     }
 }
 
-val name = "${OrgBootstrapTriggerJob::class.simpleName}.${OrgBootstrapTriggerJob::execute.name}"
+val name = "${OrgBootstrapTriggerJob::class.simpleName}<!EVALUATED(".")!>.<!>${OrgBootstrapTriggerJob::execute.<!EVALUATED("execute")!>name<!>}"
 
 fun box(): String {
     return "OK"

compiler/testData/codegen/box/involvesIrInterpreter/referenceNameFromStaticInDifferentModule.kt

@@ -27,9 +27,14 @@ class B {
 
 fun box(): String {
     // `name` call must be optimized with `ConstEvaluationLowering`
-    if (A::somePropertyFromObject.name != "somePropertyFromObject") return "Fail 1"
+    val somePropertyFromObjectName = A::somePropertyFromObject.<!EVALUATED("somePropertyFromObject")!>name<!>
-    if (A::someFunctionFromObject.name != "someFunctionFromObject") return "Fail 2"
+    val someFunctionFromObjectName = A::someFunctionFromObject.<!EVALUATED("someFunctionFromObject")!>name<!>
-    if (B.Companion::somePropertyFromCompanionObject.name != "somePropertyFromCompanionObject") return "Fail 3"
+    val somePropertyFromCompanionObjectName = B.Companion::somePropertyFromCompanionObject.<!EVALUATED("somePropertyFromCompanionObject")!>name<!>
-    if (B.Companion::someFunctionFromCompanionObject.name != "someFunctionFromCompanionObject") return "Fail 4"
+    val someFunctionFromCompanionObjectName = B.Companion::someFunctionFromCompanionObject.<!EVALUATED("someFunctionFromCompanionObject")!>name<!>
+
+    if (somePropertyFromObjectName != "somePropertyFromObject") return "Fail 1"
+    if (someFunctionFromObjectName != "someFunctionFromObject") return "Fail 2"
+    if (somePropertyFromCompanionObjectName != "somePropertyFromCompanionObject") return "Fail 3"
+    if (someFunctionFromCompanionObjectName != "someFunctionFromCompanionObject") return "Fail 4"
     return "OK"
 }

compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt

@@ -17,10 +17,10 @@ annotation class AnnotationWithAnnotation(val anno: Annotation)
 @Retention(AnnotationRetention.BINARY)
 annotation class AnnotationWithAnnotationWithAnnotation(val anno: AnnotationWithAnnotation)
 
-@AnnotationWithAnnotation(Annotation("Str" + "ing"))
+@AnnotationWithAnnotation(Annotation("Str" <!EVALUATED("String")!>+ "ing"<!>))
 class A
 
-@AnnotationWithAnnotationWithAnnotation(AnnotationWithAnnotation(Annotation("Str" + "ing")))
+@AnnotationWithAnnotationWithAnnotation(AnnotationWithAnnotation(Annotation("Str" <!EVALUATED("String")!>+ "ing"<!>)))
 class B
 
 // MODULE: main
@@ -28,4 +28,4 @@ class B
 
 fun box(): String {
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt

@@ -28,25 +28,25 @@ annotation class BinaryAnnotation(val str: String)
 
 // 1. CLASS
 // 8. CONSTRUCTOR
-@BinaryAnnotation("Str" + "ing")
+@BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>)
-class A @BinaryAnnotation("Str" + "ing") constructor(val i: Int) {
+class A @BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) constructor(val i: Int) {
-    @BinaryAnnotation("Str" + "ing") constructor() : this(0)
+    @BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) constructor() : this(0)
 }
 
 // 2. ANNOTATION_CLASS
-@BinaryAnnotation("Str" + "ing")
+@BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>)
 annotation class Anno
 
 // 3. TYPE_PARAMETER
-fun <@BinaryAnnotation("Str" + "ing") T, U> fooWithTypeParam(a: T, b: U) {}
+fun <@BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) T, U> fooWithTypeParam(a: T, b: U) {}
 
 // 4. PROPERTY
-@BinaryAnnotation("Str" + "ing")
+@BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>)
 val prop: Int = 0
 
 // 5. FIELD
 enum class SomeEnum {
-    @BinaryAnnotation("Str" + "ing") A,
+    @BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) A,
     B;
 }
 
@@ -64,24 +64,24 @@ enum class SomeEnum {
 
 
 // 7. VALUE_PARAMETER
-fun @receiver:BinaryAnnotation("Str" + "ing") String.myExtension() {  }
+fun @receiver:BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) String.myExtension() {  }
-fun foo(@BinaryAnnotation("Str" + "ing") a: Int) {  }
+fun foo(@BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) a: Int) {  }
 
-val @receiver:BinaryAnnotation("Str" + "ing") String.a: Int
+val @receiver:BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) String.a: Int
     get() = 0
 
 // 9. FUNCTION
-@BinaryAnnotation("Str" + "ing")
+@BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>)
 fun bar() {}
 
 // 10. PROPERTY_GETTER
 // 11. PROPERTY_SETTER
 var b: Int
-    @BinaryAnnotation("Str" + "ing") get() = 0
+    @BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) get() = 0
-    @BinaryAnnotation("Str" + "ing") set(value) {}
+    @BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>) set(value) {}
 
 // 15. TYPEALIAS
-@BinaryAnnotation("Str" + "ing")
+@BinaryAnnotation("Str" <!EVALUATED("String")!>+ "ing"<!>)
 typealias C = Int
 
 // MODULE: main
@@ -89,4 +89,4 @@ typealias C = Int
 
 fun box(): String {
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt

@@ -13,10 +13,10 @@ annotation class AnnotationWithVararg(vararg val array: String)
 @Retention(AnnotationRetention.BINARY)
 annotation class AnnotationWithArray(val array: Array<String>)
 
-@AnnotationWithVararg("Str" + "ing", "String2", "String${3}")
+@AnnotationWithVararg("Str" <!EVALUATED("String")!>+ "ing"<!>, <!EVALUATED("String2")!>"String2"<!>, <!EVALUATED("String3")!>"String${3}"<!>)
 class A
 
-@AnnotationWithArray(["Str" + "ing", "String2", "String${3}"])
+@AnnotationWithArray(["Str" <!EVALUATED("String")!>+ "ing"<!>, <!EVALUATED("String2")!>"String2"<!>, <!EVALUATED("String3")!>"String${3}"<!>])
 class B
 
 // MODULE: main
@@ -24,4 +24,4 @@ class B
 
 fun box(): String {
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt

@@ -12,7 +12,7 @@ annotation class AnnotationWithDefault(val str: String = "Str" + "ing")
 @AnnotationWithDefault()
 class A
 
-@AnnotationWithDefault("Other")
+@AnnotationWithDefault(<!EVALUATED("Other")!>"Other"<!>)
 class B
 
 // MODULE: main
@@ -20,4 +20,4 @@ class B
 
 fun box(): String {
     return "OK"
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/stringConcatenationWithObject.kt

@@ -14,4 +14,4 @@ class O {
 
 fun box(): String {
     return "$O" + "$K" // must not be evaluated during compile time
-}
+}

compiler/testData/codegen/box/involvesIrInterpreter/thisPlusString.kt

@@ -12,8 +12,8 @@ object Test {
 }
 
 fun box(): String {
-    if (!Test.foo().startsWith("foo ")) return "Fail ${Test.foo()}"
+    if (!Test.foo().startsWith("foo ")) return "<!EVALUATED("Fail ")!>Fail <!>${Test.foo()}"
-    if (!Test.bar().startsWith("bar ")) return "Fail ${Test.bar()}"
+    if (!Test.bar().startsWith("bar ")) return "<!EVALUATED("Fail ")!>Fail <!>${Test.bar()}"
-    if (!Test.baz().startsWith("baz ")) return "Fail ${Test.baz()}"
+    if (!Test.baz().startsWith("baz ")) return "<!EVALUATED("Fail ")!>Fail <!>${Test.baz()}"
     return "OK"
 }

compiler/testData/ir/interpreter/kt53480.kt

@@ -1,12 +0,0 @@
-// FILE: J.java
-public class J {
-    public static int f() { return 0; }
-}
-
-// FILE: Main.kt
-enum class A {
-    E;
-    val x = J.f()
-}
-
-const val name = A.E.name

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -329,12 +329,6 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTest("compiler/testData/codegen/box/annotations/noTypeUseIfFlagIsSpecified.kt");
         }
 
-        @Test
-        @TestMetadata("objectConstValInAnnotationArgument.kt")
-        public void testObjectConstValInAnnotationArgument() throws Exception {
-            runTest("compiler/testData/codegen/box/annotations/objectConstValInAnnotationArgument.kt");
-        }
-
         @Test
         @TestMetadata("parameterAnnotationInDefaultImpls.kt")
         public void testParameterAnnotationInDefaultImpls() throws Exception {
@@ -28454,6 +28448,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                 runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/longOperations.kt");
             }
 
+            @Test
+            @TestMetadata("objectConstValInAnnotationArgument.kt")
+            public void testObjectConstValInAnnotationArgument() throws Exception {
+                runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/objectConstValInAnnotationArgument.kt");
+            }
+
             @Test
             @TestMetadata("shortOperations.kt")
             public void testShortOperations() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java

@@ -329,12 +329,6 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack
             runTest("compiler/testData/codegen/box/annotations/noTypeUseIfFlagIsSpecified.kt");
         }
 
-        @Test
-        @TestMetadata("objectConstValInAnnotationArgument.kt")
-        public void testObjectConstValInAnnotationArgument() throws Exception {
-            runTest("compiler/testData/codegen/box/annotations/objectConstValInAnnotationArgument.kt");
-        }
-
         @Test
         @TestMetadata("parameterAnnotationInDefaultImpls.kt")
         public void testParameterAnnotationInDefaultImpls() throws Exception {
@@ -28454,6 +28448,12 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack
                 runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/longOperations.kt");
             }
 
+            @Test
+            @TestMetadata("objectConstValInAnnotationArgument.kt")
+            public void testObjectConstValInAnnotationArgument() throws Exception {
+                runTest("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/objectConstValInAnnotationArgument.kt");
+            }
+
             @Test
             @TestMetadata("shortOperations.kt")
             public void testShortOperations() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/ir/interpreter/JvmIrInterpreterAfterFirPsi2IrTestGenerated.java

@@ -205,12 +205,6 @@ public class JvmIrInterpreterAfterFirPsi2IrTestGenerated extends AbstractJvmIrIn
         runTest("compiler/testData/ir/interpreter/interfaceDefault.kt");
     }
 
-    @Test
-    @TestMetadata("kt53480.kt")
-    public void testKt53480() throws Exception {
-        runTest("compiler/testData/ir/interpreter/kt53480.kt");
-    }
-
     @Test
     @TestMetadata("lambda.kt")
     public void testLambda() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/ir/interpreter/JvmIrInterpreterAfterPsi2IrTestGenerated.java

@@ -205,12 +205,6 @@ public class JvmIrInterpreterAfterPsi2IrTestGenerated extends AbstractJvmIrInter
         runTest("compiler/testData/ir/interpreter/interfaceDefault.kt");
     }
 
-    @Test
-    @TestMetadata("kt53480.kt")
-    public void testKt53480() throws Exception {
-        runTest("compiler/testData/ir/interpreter/kt53480.kt");
-    }
-
     @Test
     @TestMetadata("lambda.kt")
     public void testLambda() throws Exception {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt

@@ -31,6 +31,17 @@ abstract class JsBinaryArtifactHandler(
     doNotRunIfThereWerePreviousFailures
 )
 
+abstract class KlibArtifactHandler(
+    testServices: TestServices,
+    failureDisablesNextSteps: Boolean = false,
+    doNotRunIfThereWerePreviousFailures: Boolean = false
+) : BinaryArtifactHandler<BinaryArtifacts.KLib>(
+    testServices,
+    ArtifactKinds.KLib,
+    failureDisablesNextSteps,
+    doNotRunIfThereWerePreviousFailures
+)
+
 abstract class NativeBinaryArtifactHandler(
     testServices: TestServices,
     failureDisablesNextSteps: Boolean = false,

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInterpreterBackendHandler.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.test.backend.handlers
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.interpreter.IrInterpreter
@@ -21,6 +22,15 @@ import org.jetbrains.kotlin.test.services.GlobalMetadataInfoHandler
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.globalMetadataInfoHandler
 
+fun matchIrFileWithTestFile(irModuleFragment: IrModuleFragment, module: TestModule): List<Pair<IrFile, TestFile>> {
+    val irFileWithTestFile = irModuleFragment.files.map { irFile ->
+        irFile to module.files.firstOrNull { testFile -> testFile.relativePath == irFile.fileEntry.name.drop(1) }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    return irFileWithTestFile.filterNot { (_, testFile) -> testFile == null || testFile.isAdditional } as List<Pair<IrFile, TestFile>>
+}
+
 open class IrInterpreterBackendHandler(testServices: TestServices) : AbstractIrHandler(testServices) {
     private val globalMetadataInfoHandler = testServices.globalMetadataInfoHandler
 
@@ -29,8 +39,7 @@ open class IrInterpreterBackendHandler(testServices: TestServices) : AbstractIrH
     override fun processModule(module: TestModule, info: IrBackendInput) {
         val moduleFragment = info.irModuleFragment
         val evaluator = Evaluator(IrInterpreter(moduleFragment.irBuiltins), globalMetadataInfoHandler)
-        for ((irFile, testFile) in moduleFragment.files.zip(module.files)) {
+        for ((irFile, testFile) in matchIrFileWithTestFile(moduleFragment, module)) {
-            if (testFile.isAdditional) continue
             evaluator.evaluate(irFile, testFile)
         }
     }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInterpreterDumpHandler.kt

@@ -5,54 +5,118 @@
 
 package org.jetbrains.kotlin.test.backend.handlers
 
-import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
+import com.intellij.openapi.util.text.StringUtil
-import org.jetbrains.kotlin.test.model.BinaryArtifacts
+import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
-import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo
-import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.constant.ErrorValue
-import org.jetbrains.kotlin.test.services.getOrCreateTempDirectory
+import org.jetbrains.kotlin.constant.EvaluatedConstTracker
-import java.io.File
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.declarations.IrAnnotationContainer
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase
+import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.expressions.IrConst
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
+import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
+import org.jetbrains.kotlin.ir.visitors.acceptVoid
+import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.IGNORE_BACKEND_K2
+import org.jetbrains.kotlin.test.model.*
+import org.jetbrains.kotlin.test.services.*
+import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator
 
-class IrInterpreterDumpHandler(testServices: TestServices) : JvmBinaryArtifactHandler(testServices) {
+interface IrInterpreterDumpHandler {
-    private fun getDump(module: TestModule): Pair<File, File>? {
+    val testServices: TestServices
-        val dumpDirectory = testServices.getOrCreateTempDirectory(PhasedIrDumpHandler.DUMPED_IR_FOLDER_NAME)
+    private val globalMetadataInfoHandler
-        val dumpFiles = dumpDirectory.resolve(module.name).listFiles()
+        get() = testServices.globalMetadataInfoHandler
-        val before = dumpFiles?.single { it.name.contains(PhasedIrDumpHandler.BEFORE_PREFIX) } ?: return null
-        val after = dumpFiles.single { it.name.contains(PhasedIrDumpHandler.AFTER_PREFIX) } ?: return null
-        return Pair(before, after)
-    }
 
-    private fun findConstProperties(text: String): List<Int> {
+    fun processModule(module: TestModule) {
-        return text.split("\n")
+        if (!module.isSuppressedForK2() && testServices.defaultsProvider.defaultFrontend == FrontendKinds.ClassicFrontend) {
-            .mapIndexed { index: Int, line: String -> Pair(index, line) }
+            module.files.forEach { testFile ->
-            .filter { it.second.trim().startsWith("PROPERTY") && it.second.contains("[const,val]") }
+                val expected = globalMetadataInfoHandler.getExistingMetaInfosForFile(testFile)
-            .map { it.first }
+                globalMetadataInfoHandler.addMetadataInfosForFile(testFile, expected)
-    }
-
-    private fun checkInitializersAreConst(text: String, propertiesStart: List<Int>) {
-        val lines = text.split("\n")
-        for (index in propertiesStart) {
-            testServices.assertions.assertTrue(lines[index + 3].trim().startsWith("CONST")) {
-                "Property at $index wasn't converted to const"
             }
+            return
+        }
+
+        val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module)
+        val evaluatedConstTracker = configuration.get(CommonConfigurationKeys.EVALUATED_CONST_TRACKER) ?: return
+        val irModule = testServices.dependencyProvider.getArtifact(module, BackendKinds.IrBackend).irModuleFragment
+        for ((irFile, testFile) in matchIrFileWithTestFile(irModule, module)) {
+            evaluatedConstTracker.processFile(testFile, irFile, testServices.defaultsProvider.defaultTargetBackend ?: module.targetBackend)
         }
     }
 
+    fun TestModule.isSuppressedForK2(): Boolean {
+        val ignoredBackends = this.directives[IGNORE_BACKEND_K2]
+        val targetBackend = testServices.defaultsProvider.defaultTargetBackend ?: this.targetBackend
+        return targetBackend in ignoredBackends || TargetBackend.ANY in ignoredBackends
+    }
+
+    private fun EvaluatedConstTracker.processFile(testFile: TestFile, irFile: IrFile, targetBackend: TargetBackend?) {
+        irFile.accept(object : IrElementVisitorVoid {
+            override fun visitElement(element: IrElement) {
+                element.acceptChildrenVoid(this)
+            }
+
+            override fun visitDeclaration(declaration: IrDeclarationBase) {
+                if (declaration.origin == JvmLoweredDeclarationOrigin.SYNTHETIC_METHOD_FOR_PROPERTY_OR_TYPEALIAS_ANNOTATIONS) return
+                visitAnnotations(declaration)
+                super.visitDeclaration(declaration)
+            }
+
+            // TODO can be dropped if we are going to draw one info per line segment
+            override fun visitField(declaration: IrField) {
+                if (targetBackend == TargetBackend.JVM_IR) {
+                    declaration.correspondingPropertySymbol?.owner?.let { visitAnnotations(it) }
+                }
+                super.visitField(declaration)
+            }
+
+            private fun visitAnnotations(annotationContainer: IrAnnotationContainer) {
+                annotationContainer.annotations.forEach { annotation ->
+                    annotation.acceptVoid(this)
+                }
+            }
+
+            override fun visitConst(expression: IrConst<*>) {
+                val constantValue = this@processFile.load(expression.startOffset, expression.endOffset) ?: return
+                val message = constantValue.stringTemplateValue()
+                val metaInfo = ParsedCodeMetaInfo(
+                    expression.startOffset, expression.endOffset,
+                    attributes = mutableListOf(),
+                    tag = if (constantValue is ErrorValue) "WAS_NOT_EVALUATED" else "EVALUATED",
+                    description = StringUtil.escapeLineBreak(message)
+                )
+                globalMetadataInfoHandler.addMetadataInfosForFile(testFile, listOf(metaInfo))
+            }
+        }, null)
+    }
+}
+
+class JvmIrInterpreterDumpHandler(testServices: TestServices) : IrInterpreterDumpHandler, JvmBinaryArtifactHandler(testServices) {
     override fun processModule(module: TestModule, info: BinaryArtifacts.Jvm) {
-        if (CodegenTestDirectives.DUMP_IR_FOR_GIVEN_PHASES !in module.directives) return
+        processModule(module)
-        val (before, after) = getDump(module) ?: testServices.assertions.fail { "Cannot find BEFORE and AFTER lowering files" }
-
-        val beforeText = before.readText()
-        val afterText = after.readText()
-        val propertiesBefore = findConstProperties(beforeText)
-        val propertiesAfter = findConstProperties(afterText)
-        testServices.assertions.assertTrue(propertiesBefore.isNotEmpty()) { "Test file doesn't contain const properties" }
-        testServices.assertions.assertEquals(propertiesBefore.size, propertiesAfter.size) {
-            "After lowering some properties are missing"
-        }
-
-        checkInitializersAreConst(afterText, propertiesAfter)
     }
 
     override fun processAfterAllModules(someAssertionWasFailed: Boolean) {}
 }
+
+class JsIrInterpreterDumpHandler(testServices: TestServices) : IrInterpreterDumpHandler, JsBinaryArtifactHandler(testServices) {
+    override fun processModule(module: TestModule, info: BinaryArtifacts.Js) {
+        processModule(module)
+    }
+
+    override fun processAfterAllModules(someAssertionWasFailed: Boolean) {}
+}
+
+class KlibInterpreterDumpHandler(testServices: TestServices) : IrInterpreterDumpHandler, KlibArtifactHandler(testServices) {
+    override fun processModule(module: TestModule, info: BinaryArtifacts.KLib) {
+        if (JsEnvironmentConfigurator.isMainModule(module, testServices)) return
+        processModule(module)
+    }
+
+    override fun processAfterAllModules(someAssertionWasFailed: Boolean) {}
+}
+

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.test.builders.CompilerStepsNames.CLASSIC_FRONTEND_HA
 import org.jetbrains.kotlin.test.builders.CompilerStepsNames.FIR_HANDLERS_STEP_NAME
 import org.jetbrains.kotlin.test.builders.CompilerStepsNames.JS_ARTIFACTS_HANDLERS_STEP_NAME
 import org.jetbrains.kotlin.test.builders.CompilerStepsNames.JVM_ARTIFACTS_HANDLERS_STEP_NAME
+import org.jetbrains.kotlin.test.builders.CompilerStepsNames.KLIB_ARTIFACTS_HANDLERS_STEP_NAME
 import org.jetbrains.kotlin.test.builders.CompilerStepsNames.RAW_IR_HANDLERS_STEP_NAME
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter
 import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter
@@ -37,6 +38,7 @@ object CompilerStepsNames {
     const val JVM_BACKEND_STEP_NAME = "jvm backend"
     const val JVM_ARTIFACTS_HANDLERS_STEP_NAME = "jvm artifacts handlers"
     const val JS_ARTIFACTS_HANDLERS_STEP_NAME = "js artifacts handlers"
+    const val KLIB_ARTIFACTS_HANDLERS_STEP_NAME = "klib artifacts handlers"
 
 }
 
@@ -103,6 +105,12 @@ inline fun TestConfigurationBuilder.jsArtifactsHandlersStep(
     namedHandlersStep(JS_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Js, init)
 }
 
+inline fun TestConfigurationBuilder.klibArtifactsHandlersStep(
+    init: HandlersStepBuilder<BinaryArtifacts.KLib>.() -> Unit = {}
+) {
+    namedHandlersStep(KLIB_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.KLib, init)
+}
+
 // and those ones to configure already defined step
 inline fun TestConfigurationBuilder.configureClassicFrontendHandlersStep(
     init: HandlersStepBuilder<ClassicFrontendOutputArtifact>.() -> Unit = {}
@@ -133,3 +141,9 @@ inline fun TestConfigurationBuilder.configureJsArtifactsHandlersStep(
 ) {
     configureNamedHandlersStep(JS_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Js, init)
 }
+
+inline fun TestConfigurationBuilder.configureKlibArtifactsHandlersStep(
+    init: HandlersStepBuilder<BinaryArtifacts.KLib>.() -> Unit = {}
+) {
+    configureNamedHandlersStep(KLIB_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.KLib, init)
+}

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/codegen/AbstractJvmBlackBoxCodegenTestBase.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.test.runners.codegen
 
-import org.jetbrains.kotlin.backend.jvm.constEvaluationPhase
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.test.Constructor
 import org.jetbrains.kotlin.test.TargetBackend
@@ -14,13 +13,12 @@ import org.jetbrains.kotlin.test.backend.BlackBoxCodegenSuppressor
 import org.jetbrains.kotlin.test.backend.BlackBoxInlinerCodegenSuppressor
 import org.jetbrains.kotlin.test.backend.handlers.BytecodeListingHandler
 import org.jetbrains.kotlin.test.backend.handlers.BytecodeTextHandler
-import org.jetbrains.kotlin.test.backend.handlers.IrInterpreterDumpHandler
+import org.jetbrains.kotlin.test.backend.handlers.JvmIrInterpreterDumpHandler
 import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.configureClassicFrontendHandlersStep
 import org.jetbrains.kotlin.test.builders.configureFirHandlersStep
 import org.jetbrains.kotlin.test.builders.configureJvmArtifactsHandlersStep
-import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.IGNORE_DEXING
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.USE_JAVAC_BASED_ON_JVM_TARGET
 import org.jetbrains.kotlin.test.directives.ConfigurationDirectives.WITH_STDLIB
@@ -105,12 +103,9 @@ abstract class AbstractJvmBlackBoxCodegenTestBase<R : ResultingArtifact.Frontend
             useConfigurators(::JvmForeignAnnotationsConfigurator)
         }
 
-        forTestsMatching("compiler/testData/codegen/box/involvesIrInterpreter/dumpIrAndCheck/*") {
+        forTestsMatching("compiler/testData/codegen/box/involvesIrInterpreter/*") {
-            defaultDirectives {
-                CodegenTestDirectives.DUMP_IR_FOR_GIVEN_PHASES with constEvaluationPhase
-            }
             configureJvmArtifactsHandlersStep {
-                useHandlers(::IrInterpreterDumpHandler)
+                useHandlers(::JvmIrInterpreterDumpHandler)
             }
         }
 

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/ir/interpreter/AbstractIrInterpreterTest.kt

@@ -97,9 +97,4 @@ class IrInterpreterEnvironmentConfigurator(testServices: TestServices) : Environ
     ): Map<AnalysisFlag<*>, Any?> {
         return mapOf(AnalysisFlags.builtInsFromSources to true)
     }
-
-    override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) {
-        super.configureCompilerConfiguration(configuration, module)
-        configuration.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create())
-    }
 }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt

@@ -14,10 +14,8 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.jvm.addModularRootIfNotNull
 import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.config.CompilerConfigurationKey
+import org.jetbrains.kotlin.constant.EvaluatedConstTracker
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.MockLibraryUtil
@@ -223,6 +221,7 @@ class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfig
 
         val isIr = module.targetBackend?.isIR == true
         configuration.put(JVMConfigurationKeys.IR, isIr)
+        configuration.putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create())
 
         val javaSourceFiles = module.javaFiles.filter { INCLUDE_JAVA_AS_BINARY !in it.directives }
 

core/compiler.common/src/org/jetbrains/kotlin/constant/EvaluatedConstTracker.kt

@@ -15,7 +15,7 @@ abstract class EvaluatedConstTracker {
         /**
          * Right now there are two places where we want to create this tracker.
          * 1. Right before `fir2ir` phase. We need to store evaluated values to use them later in const value serialization.
-         * 2. In interpreter's tests for all IR backends. This is needed ONLY for tests and cover case when we run K1 IR compiler.
+         * 2. In tests for K1 IR. This is needed ONLY for tests to log results of interpretation on lowering level.
          */
         fun create(): EvaluatedConstTracker {
             return DefaultEvaluatedConstTracker()

js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsBlackBoxCodegenTestBase.kt

@@ -12,6 +12,8 @@ import org.jetbrains.kotlin.platform.js.JsPlatforms
 import org.jetbrains.kotlin.test.Constructor
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.backend.BlackBoxCodegenSuppressor
+import org.jetbrains.kotlin.test.backend.handlers.JsIrInterpreterDumpHandler
+import org.jetbrains.kotlin.test.backend.handlers.KlibInterpreterDumpHandler
 import org.jetbrains.kotlin.test.builders.*
 import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives
 import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives.DIAGNOSTICS
@@ -113,10 +115,21 @@ abstract class AbstractJsBlackBoxCodegenTestBase<R : ResultingArtifact.FrontendO
         irHandlersStep()
 
         facadeStep(backendFacade)
+        klibArtifactsHandlersStep()
         afterBackendFacade?.let { facadeStep(it) }
         facadeStep(recompileFacade)
         jsArtifactsHandlersStep {
             useHandlers(::JsSourceMapPathRewriter)
         }
+
+        forTestsMatching("compiler/testData/codegen/box/involvesIrInterpreter/*") {
+            enableMetaInfoHandler()
+            configureKlibArtifactsHandlersStep {
+                useHandlers(::KlibInterpreterDumpHandler)
+            }
+            configureJsArtifactsHandlersStep {
+                useHandlers(::JsIrInterpreterDumpHandler)
+            }
+        }
     }
 }