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

Fix interpreter tests after changing offset calculation

Browse Source
This commit is contained in:
Ilya Chernikov
2022-03-14 15:43:37 +01:00
committed by teamcity
parent 738c1f34df
commit 53bc593062
71 changed files with 359 additions and 355 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/ir/interpreter/abstract1.kt
Vendored
+5 -5
View File
@@ -42,10 +42,10 @@ fun getClassCAsC(num: Int): C {
return C(num)
}
const val num1 = getAClassImplementation(1).<!EVALUATED: `1`!>getIntNum()<!>
const val num2 = getBClassImplementation(2).<!EVALUATED: `2`!>getIntNum()<!>
const val num1 = <!EVALUATED: `1`!>getAClassImplementation(1).getIntNum()<!>
const val num2 = <!EVALUATED: `2`!>getBClassImplementation(2).getIntNum()<!>
// all `getIntNum` methods are from class C
const val num3 = getClassCAsA(3).<!EVALUATED: `3`!>getIntNum()<!>
const val num4 = getClassCAsB(4).<!EVALUATED: `4`!>getIntNum()<!>
const val num5 = getClassCAsC(5).<!EVALUATED: `5`!>getIntNum()<!>
const val num3 = <!EVALUATED: `3`!>getClassCAsA(3).getIntNum()<!>
const val num4 = <!EVALUATED: `4`!>getClassCAsB(4).getIntNum()<!>
const val num5 = <!EVALUATED: `5`!>getClassCAsC(5).getIntNum()<!>
compiler/testData/ir/interpreter/abstract2.kt
Vendored
+4 -4
View File
@@ -36,8 +36,8 @@ fun getClassCAsB(num: Int): B {
}
// all methods call from C
const val num1 = getClassCAsA(1).<!EVALUATED: `1`!>getIntNum()<!>
const val num2 = getClassCAsB(2).<!EVALUATED: `2`!>getIntNum()<!>
const val num1 = <!EVALUATED: `1`!>getClassCAsA(1).getIntNum()<!>
const val num2 = <!EVALUATED: `2`!>getClassCAsB(2).getIntNum()<!>
const val num3 = getClassCAsA(3).<!EVALUATED: `-3`!>getIntNumInverse()<!>
const val num4 = getClassCAsB(4).<!EVALUATED: `-4`!>getIntNumInverse()<!>
const val num3 = <!EVALUATED: `-3`!>getClassCAsA(3).getIntNumInverse()<!>
const val num4 = <!EVALUATED: `-4`!>getClassCAsB(4).getIntNumInverse()<!>
compiler/testData/ir/interpreter/abstract3.kt
Vendored
+6 -6
View File
@@ -41,9 +41,9 @@ fun getClassDAsD(num: Int): D {
return D(num)
}
const val numA1 = getClassDAsA(1).<!EVALUATED: `3`!>getInt()<!>
const val numB1 = getClassDAsB(1).<!EVALUATED: `3`!>getInt()<!>
const val numC1 = getClassDAsC(1).<!EVALUATED: `3`!>getInt()<!>
const val numC2 = getClassDAsC(1).<!EVALUATED: `1`!>getString()<!>
const val numD1 = getClassDAsD(1).<!EVALUATED: `3`!>getInt()<!>
const val numD2 = getClassDAsD(1).<!EVALUATED: `1`!>getString()<!>
const val numA1 = <!EVALUATED: `3`!>getClassDAsA(1).getInt()<!>
const val numB1 = <!EVALUATED: `3`!>getClassDAsB(1).getInt()<!>
const val numC1 = <!EVALUATED: `3`!>getClassDAsC(1).getInt()<!>
const val numC2 = <!EVALUATED: `1`!>getClassDAsC(1).getString()<!>
const val numD1 = <!EVALUATED: `3`!>getClassDAsD(1).getInt()<!>
const val numD2 = <!EVALUATED: `1`!>getClassDAsD(1).getString()<!>
compiler/testData/ir/interpreter/abstract4.kt
Vendored
+1 -1
View File
@@ -34,4 +34,4 @@ class ImplementIterator constructor(val i: Int) : ComplexIterator(i) {
@CompileTimeCalculation
fun getIterator(i: Int): ComplexIterator = ImplementIterator(i)
const val next = getIterator(10).<!EVALUATED: `31`!>complexNext()<!>
const val next = <!EVALUATED: `31`!>getIterator(10).complexNext()<!>
compiler/testData/ir/interpreter/collections/arrayConstructor.kt
Vendored
BIN
View File
Binary file not shown.
compiler/testData/ir/interpreter/collections/arrayOf.kt
Vendored
+2 -2
View File
@@ -17,7 +17,7 @@ fun changeAndReturnSumForObject(array: Array<A>, index: Int, newValue: A): Int {
return sum
}
const val a = arrayOf(1, 2, 3).<!EVALUATED: `3`!>size<!>
const val a = <!EVALUATED: `3`!>arrayOf(1, 2, 3).size<!>
const val b = <!EVALUATED: `15`!>changeAndReturnSum(intArrayOf(1, 2, 3), 0, 10)<!>
const val c = emptyArray<Int>().<!EVALUATED: `0`!>size<!>
const val c = <!EVALUATED: `0`!>emptyArray<Int>().size<!>
const val d = <!EVALUATED: `15`!>changeAndReturnSumForObject(arrayOf(A(1), A(2), A(3)), 0, A(10))<!>
compiler/testData/ir/interpreter/collections/doubleArrayOf.kt
Vendored
+4 -4
View File
@@ -1,13 +1,13 @@
import kotlin.collections.*
const val doubleArray = arrayOf(
const val doubleArray = <!EVALUATED: `1, 2, 3; 4, 5; 6`!>arrayOf(
arrayOf(1, 2, 3),
arrayOf(4, 5),
arrayOf(6)
).<!EVALUATED: `1, 2, 3; 4, 5; 6`!>joinToString(separator = "; ") { it.joinToString() }<!>
).joinToString(separator = "; ") { it.joinToString() }<!>
const val doubleUintArray = arrayOf(
const val doubleUintArray = <!EVALUATED: `1, 2, 3; 4, 5; 6`!>arrayOf(
arrayOf(1u, 2u, 3u),
arrayOf(4u, 5u),
arrayOf(6u)
).<!EVALUATED: `1, 2, 3; 4, 5; 6`!>joinToString(separator = "; ") { it.joinToString() }<!>
).joinToString(separator = "; ") { it.joinToString() }<!>
compiler/testData/ir/interpreter/collections/doubleList.kt
Vendored
+6 -6
View File
@@ -1,16 +1,16 @@
import kotlin.collections.*
const val doubleListSize = listOf(
const val doubleListSize = <!EVALUATED: `3`!>listOf(
listOf("1", "2", "3"),
listOf("4", "5", "6"),
listOf("7", "8", "9")
).<!EVALUATED: `3`!>size<!>
).size<!>
const val doubleListSizeOfList = listOf(
const val doubleListSizeOfList = <!EVALUATED: `3`!>listOf(
listOf("1"),
listOf("4", "5"),
listOf("7", "8", "9")
)[2].<!EVALUATED: `3`!>size<!>
)[2].size<!>
const val doubleListGetSingleElement = <!EVALUATED: `9`!>listOf(
listOf("1"),
@@ -18,8 +18,8 @@ const val doubleListGetSingleElement = <!EVALUATED: `9`!>listOf(
listOf("7", "8", "9")
)[2][2]<!>
const val doubleListElements = listOf(
const val doubleListElements = <!EVALUATED: `1; 4, 5; 7, 8, 9`!>listOf(
listOf("1"),
listOf("4", "5"),
listOf("7", "8", "9")
).<!EVALUATED: `1; 4, 5; 7, 8, 9`!>joinToString(separator = "; ") { it.joinToString() }<!>
).joinToString(separator = "; ") { it.joinToString() }<!>
compiler/testData/ir/interpreter/collections/listOf.kt
Vendored
+3 -3
View File
@@ -1,8 +1,8 @@
import kotlin.collections.*
const val a = listOf(1, 2, 3).<!EVALUATED: `3`!>size<!>
const val b = emptyList<Int>().<!EVALUATED: `0`!>size<!>
const val c = listOf<Int>().<!EVALUATED: `1`!>hashCode()<!>
const val a = <!EVALUATED: `3`!>listOf(1, 2, 3).size<!>
const val b = <!EVALUATED: `0`!>emptyList<Int>().size<!>
const val c = <!EVALUATED: `1`!>listOf<Int>().hashCode()<!>
@CompileTimeCalculation
fun getSum(list: List<Int>): Int {
compiler/testData/ir/interpreter/collections/mapOf.kt
Vendored
+12 -12
View File
@@ -1,18 +1,18 @@
import kotlin.*
import kotlin.collections.*
const val a = mapOf(1 to "1", 2 to "2", 3 to "3").<!EVALUATED: `3`!>size<!>
const val b = emptyMap<Any, Any>().<!EVALUATED: `0`!>size<!>
const val a = <!EVALUATED: `3`!>mapOf(1 to "1", 2 to "2", 3 to "3").size<!>
const val b = <!EVALUATED: `0`!>emptyMap<Any, Any>().size<!>
const val contains1 = mapOf(1 to "1", 2 to "2", 3 to "3").<!EVALUATED: `true`!>containsKey(1)<!>
const val contains2 = mapOf(1 to "1", 2 to "2", 3 to "3").<!EVALUATED: `true`!>contains(1)<!>
const val contains3 = mapOf(1 to "1", 2 to "2", 3 to "3").<!EVALUATED: `false`!>contains<Any, String>("1")<!>
const val contains4 = mapOf(1 to "1", 2 to "2", 3 to "3").<!EVALUATED: `true`!>containsValue("1")<!>
const val contains1 = <!EVALUATED: `true`!>mapOf(1 to "1", 2 to "2", 3 to "3").containsKey(1)<!>
const val contains2 = <!EVALUATED: `true`!>mapOf(1 to "1", 2 to "2", 3 to "3").contains(1)<!>
const val contains3 = <!EVALUATED: `false`!>mapOf(1 to "1", 2 to "2", 3 to "3").contains<Any, String>("1")<!>
const val contains4 = <!EVALUATED: `true`!>mapOf(1 to "1", 2 to "2", 3 to "3").containsValue("1")<!>
const val get1 = mapOf(1 to "1", 2 to "2", 3 to "3").get(1)<!EVALUATED: `1`!>!!<!>
const val get2 = mapOf(1 to "1", 2 to "2", 3 to "3")[2]<!EVALUATED: `2`!>!!<!>
const val get3 = mapOf(1 to "1", 2 to "2", 3 to "3")[0].<!EVALUATED: `null`!>toString()<!>
const val get1 = <!EVALUATED: `1`!>mapOf(1 to "1", 2 to "2", 3 to "3").get(1)!!<!>
const val get2 = <!EVALUATED: `2`!>mapOf(1 to "1", 2 to "2", 3 to "3")[2]!!<!>
const val get3 = <!EVALUATED: `null`!>mapOf(1 to "1", 2 to "2", 3 to "3")[0].toString()<!>
const val keys = mapOf(1 to "1", 2 to "2", 3 to "3").keys.<!EVALUATED: `3`!>size<!>
const val values = mapOf(1 to "1", 2 to "2", 3 to "3").values.<!EVALUATED: `3`!>size<!>
const val entries = mapOf(1 to "1", 2 to "2", 3 to "3").entries.<!EVALUATED: `3`!>size<!>
const val keys = <!EVALUATED: `3`!>mapOf(1 to "1", 2 to "2", 3 to "3").keys.size<!>
const val values = <!EVALUATED: `3`!>mapOf(1 to "1", 2 to "2", 3 to "3").values.size<!>
const val entries = <!EVALUATED: `3`!>mapOf(1 to "1", 2 to "2", 3 to "3").entries.size<!>
compiler/testData/ir/interpreter/collections/mutableListOf.kt
Vendored
+3 -3
View File
@@ -27,11 +27,11 @@ fun testIterator(mutableList: MutableList<Byte>): String {
return "Sum = " + sum
}
const val emptyMutableListSize = mutableListOf<Any>().<!EVALUATED: `0`!>size<!>
const val mutableListSize = mutableListOf(1, 2, 3).<!EVALUATED: `3`!>size<!>
const val emptyMutableListSize = <!EVALUATED: `0`!>mutableListOf<Any>().size<!>
const val mutableListSize = <!EVALUATED: `3`!>mutableListOf(1, 2, 3).size<!>
const val mutableListAdd = <!EVALUATED: `After add new size is 4`!>testAdd(mutableListOf(1, 2, 3), 4)<!>
const val mutableListRemove1 = <!EVALUATED: `After remove new size is 2`!>testRemove(mutableListOf("1", "2", "3"), "1")<!>
const val mutableListRemove2 = <!EVALUATED: `After remove new size is 3`!>testRemove(mutableListOf("1", "2", "3"), "4")<!>
const val mutableListAddAll = <!EVALUATED: `After addAll new size is 5`!>testAddAll(mutableListOf(1.0, 2.0, 3.0), listOf(4.333, -5.5))<!>
const val mutableListSum = <!EVALUATED: `Sum = 136`!>testIterator(mutableListOf<Byte>(1, (-2).toByte(), 127, 10, 0))<!>
const val mutableListSubList = mutableListOf(1, 2, 3, 4).subList(0, 2).<!EVALUATED: `2`!>size<!>
const val mutableListSubList = <!EVALUATED: `2`!>mutableListOf(1, 2, 3, 4).subList(0, 2).size<!>
compiler/testData/ir/interpreter/collections/mutableMapOf.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
import kotlin.*
import kotlin.collections.*
const val a1 = mutableMapOf(1 to "1", 2 to "2", 3 to "3").<!EVALUATED: `3`!>size<!>
const val a2 = mutableMapOf(1 to "1", 2 to "2", 3 to "3").apply { remove(1) }.<!EVALUATED: `2`!>size<!>
const val a1 = <!EVALUATED: `3`!>mutableMapOf(1 to "1", 2 to "2", 3 to "3").size<!>
const val a2 = <!EVALUATED: `2`!>mutableMapOf(1 to "1", 2 to "2", 3 to "3").apply { remove(1) }.size<!>
compiler/testData/ir/interpreter/collections/mutableSetOf.kt
Vendored
+2 -2
View File
@@ -27,8 +27,8 @@ fun testIterator(mutableSet: MutableSet<Byte>): String {
return "Sum = " + sum
}
const val emptyMutableSetSize = mutableSetOf<Any>().<!EVALUATED: `0`!>size<!>
const val mutableSetSize = mutableSetOf(1, 2, 3).<!EVALUATED: `3`!>size<!>
const val emptyMutableSetSize = <!EVALUATED: `0`!>mutableSetOf<Any>().size<!>
const val mutableSetSize = <!EVALUATED: `3`!>mutableSetOf(1, 2, 3).size<!>
const val mutableSetAdd = <!EVALUATED: `After add new size is 4`!>testAdd(mutableSetOf(1, 2, 3), 4)<!>
const val mutableSetRemove1 = <!EVALUATED: `After remove new size is 2`!>testRemove(mutableSetOf("1", "2", "3"), "1")<!>
const val mutableSetRemove2 = <!EVALUATED: `After remove new size is 3`!>testRemove(mutableSetOf("1", "2", "3"), "4")<!>
compiler/testData/ir/interpreter/collections/sequenceOf.kt
Vendored
+4 -4
View File
@@ -1,6 +1,6 @@
import kotlin.sequences.*
const val a = sequenceOf(1, 2, 3).iterator().<!EVALUATED: `1`!>next()<!>
const val b = sequenceOf(2, 3).iterator().<!EVALUATED: `2`!>next()<!>
const val c = sequenceOf<Int>().iterator().<!EVALUATED: `false`!>hasNext()<!>
const val d = generateSequence() { 42 }.iterator().<!EVALUATED: `42`!>next()<!>
const val a = <!EVALUATED: `1`!>sequenceOf(1, 2, 3).iterator().next()<!>
const val b = <!EVALUATED: `2`!>sequenceOf(2, 3).iterator().next()<!>
const val c = <!EVALUATED: `false`!>sequenceOf<Int>().iterator().hasNext()<!>
const val d = <!EVALUATED: `42`!>generateSequence() { 42 }.iterator().next()<!>
compiler/testData/ir/interpreter/collections/setOf.kt
Vendored
+4 -4
View File
@@ -1,9 +1,9 @@
import kotlin.collections.*
const val a1 = setOf(1, 2, 3).<!EVALUATED: `3`!>size<!>
const val a2 = setOf(1, 2, 3, 3, 2, 1).<!EVALUATED: `3`!>size<!>
const val b = emptySet<Int>().<!EVALUATED: `0`!>size<!>
const val c = setOf<Int>().<!EVALUATED: `0`!>hashCode()<!>
const val a1 = <!EVALUATED: `3`!>setOf(1, 2, 3).size<!>
const val a2 = <!EVALUATED: `3`!>setOf(1, 2, 3, 3, 2, 1).size<!>
const val b = <!EVALUATED: `0`!>emptySet<Int>().size<!>
const val c = <!EVALUATED: `0`!>setOf<Int>().hashCode()<!>
@CompileTimeCalculation
fun getSum(set: Set<Int>): Int {
compiler/testData/ir/interpreter/companionOverride.kt
Vendored
+3 -3
View File
@@ -27,6 +27,6 @@ class C {
}
}
const val a = A.<!EVALUATED: `A`!>get()<!>
const val c1 = C.<!EVALUATED: `Object`!>defaultGet()<!>
const val c2 = C.<!EVALUATED: `Default: Object; from super B: B; from current: companion C`!>get()<!>
const val a = <!EVALUATED: `A`!>A.get()<!>
const val c1 = <!EVALUATED: `Object`!>C.defaultGet()<!>
const val c2 = <!EVALUATED: `Default: Object; from super B: B; from current: companion C`!>C.get()<!>
compiler/testData/ir/interpreter/composition.kt
Vendored
+17 -17
View File
@@ -50,22 +50,22 @@ open class C @CompileTimeCalculation constructor(@CompileTimeCalculation val c:
}
}
const val a1 = A(1).<!EVALUATED: `1`!>get()<!>
const val a2 = A(1).setA(2).<!EVALUATED: `2`!>get()<!>
const val a3 = A(1).<!EVALUATED: `1`!>openGet()<!>
const val a1 = <!EVALUATED: `1`!>A(1).get()<!>
const val a2 = <!EVALUATED: `2`!>A(1).setA(2).get()<!>
const val a3 = <!EVALUATED: `1`!>A(1).openGet()<!>
const val b1 = B(1).<!EVALUATED: `2`!>getAFromB()<!>
const val b2 = B(1).<!EVALUATED: `2`!>getFromProperty()<!>
const val b3 = B(1).aObj.<!EVALUATED: `2`!>get()<!>
const val b4 = B(1).aObj.setA(-1).<!EVALUATED: `-1`!>get()<!>
const val b5 = B(1).aObj.<!EVALUATED: `2`!>a<!>
const val b1 = <!EVALUATED: `2`!>B(1).getAFromB()<!>
const val b2 = <!EVALUATED: `2`!>B(1).getFromProperty()<!>
const val b3 = <!EVALUATED: `2`!>B(1).aObj.get()<!>
const val b4 = <!EVALUATED: `-1`!>B(1).aObj.setA(-1).get()<!>
const val b5 = <!EVALUATED: `2`!>B(1).aObj.a<!>
const val c1 = C(1).<!EVALUATED: `3`!>getAFromC()<!>
const val c2 = C(1).<!EVALUATED: `2`!>getBFromC()<!>
const val c3 = C(1).aObj.<!EVALUATED: `3`!>get()<!>
const val c4 = C(1).<!EVALUATED: `3`!>openGet()<!>
const val c5 = C(1).bObj.<!EVALUATED: `3`!>getAFromB()<!>
const val c6 = C(1).bObj.<!EVALUATED: `3`!>getFromProperty()<!>
const val c7 = C(1).bObj.aObj.setA(-2).<!EVALUATED: `-2`!>get()<!>
const val c8 = C(1).bObj.<!EVALUATED: `2`!>b<!>
const val c9 = C(1).aObj.<!EVALUATED: `3`!>a<!>
const val c1 = <!EVALUATED: `3`!>C(1).getAFromC()<!>
const val c2 = <!EVALUATED: `2`!>C(1).getBFromC()<!>
const val c3 = <!EVALUATED: `3`!>C(1).aObj.get()<!>
const val c4 = <!EVALUATED: `3`!>C(1).openGet()<!>
const val c5 = <!EVALUATED: `3`!>C(1).bObj.getAFromB()<!>
const val c6 = <!EVALUATED: `3`!>C(1).bObj.getFromProperty()<!>
const val c7 = <!EVALUATED: `-2`!>C(1).bObj.aObj.setA(-2).get()<!>
const val c8 = <!EVALUATED: `2`!>C(1).bObj.b<!>
const val c9 = <!EVALUATED: `3`!>C(1).aObj.a<!>
compiler/testData/ir/interpreter/copyReceivedValue.kt
Vendored
+1 -1
View File
@@ -5,4 +5,4 @@ fun Int.minusOne(): Int {
return this
}
const val a = 5.<!EVALUATED: `5`!>minusOne()<!>
const val a = <!EVALUATED: `5`!>5.minusOne()<!>
compiler/testData/ir/interpreter/dataClass.kt
Vendored
+12 -12
View File
@@ -7,21 +7,21 @@ fun Person.getAsString(): String {
return "Person name is $name and his phone is $phone"
}
const val a1 = Person("John", 123456).<!EVALUATED: `John`!>name<!>
const val a2 = Person("John", 123456).<!EVALUATED: `John`!>component1()<!>
const val a3 = Person("John", 123456).<!EVALUATED: `123456`!>phone<!>
const val a4 = Person("John", 123456).<!EVALUATED: `123456`!>component2()<!>
const val a1 = <!EVALUATED: `John`!>Person("John", 123456).name<!>
const val a2 = <!EVALUATED: `John`!>Person("John", 123456).component1()<!>
const val a3 = <!EVALUATED: `123456`!>Person("John", 123456).phone<!>
const val a4 = <!EVALUATED: `123456`!>Person("John", 123456).component2()<!>
const val b1 = Person("John", 789).copy("Adam").<!EVALUATED: `Person(name=Adam, phone=789)`!>toString()<!>
const val b2 = Person("John", 789).copy("Adam", 123).<!EVALUATED: `Person(name=Adam, phone=123)`!>toString()<!>
const val b1 = <!EVALUATED: `Person(name=Adam, phone=789)`!>Person("John", 789).copy("Adam").toString()<!>
const val b2 = <!EVALUATED: `Person(name=Adam, phone=123)`!>Person("John", 789).copy("Adam", 123).toString()<!>
const val c = Person("John", 123456).<!EVALUATED: `true`!>equals(Person("John", 123456))<!>
const val d = Person("John", 123456).<!EVALUATED: `Person name is John and his phone is 123456`!>getAsString()<!>
const val c = <!EVALUATED: `true`!>Person("John", 123456).equals(Person("John", 123456))<!>
const val d = <!EVALUATED: `Person name is John and his phone is 123456`!>Person("John", 123456).getAsString()<!>
@CompileTimeCalculation
data class WithArray(val array: Array<*>?, val intArray: IntArray?)
const val e1 = WithArray(arrayOf(1, 2.0), intArrayOf(1, 2, 3)).<!EVALUATED: `WithArray(array=[1, 2.0], intArray=[1, 2, 3])`!>toString()<!>
const val e2 = WithArray(null, intArrayOf(1, 2, 3)).<!EVALUATED: `WithArray(array=null, intArray=[1, 2, 3])`!>toString()<!>
const val e3 = WithArray(arrayOf("1", false), null).<!EVALUATED: `WithArray(array=[1, false], intArray=null)`!>toString()<!>
const val e4 = WithArray(null, null).<!EVALUATED: `WithArray(array=null, intArray=null)`!>toString()<!>
const val e1 = <!EVALUATED: `WithArray(array=[1, 2.0], intArray=[1, 2, 3])`!>WithArray(arrayOf(1, 2.0), intArrayOf(1, 2, 3)).toString()<!>
const val e2 = <!EVALUATED: `WithArray(array=null, intArray=[1, 2, 3])`!>WithArray(null, intArrayOf(1, 2, 3)).toString()<!>
const val e3 = <!EVALUATED: `WithArray(array=[1, false], intArray=null)`!>WithArray(arrayOf("1", false), null).toString()<!>
const val e4 = <!EVALUATED: `WithArray(array=null, intArray=null)`!>WithArray(null, null).toString()<!>
compiler/testData/ir/interpreter/defaultArgs.kt
Vendored
+11 -11
View File
@@ -20,9 +20,9 @@ const val sumBasedOnPrevious1 = <!EVALUATED: `11`!>sumBasedOnPrevious()<!>
const val sumBasedOnPrevious2 = <!EVALUATED: `5`!>sumBasedOnPrevious(b = 1, c = 1)<!>
const val sumBasedOnPrevious3 = <!EVALUATED: `8`!>sumBasedOnPrevious(a = 1, c = 1)<!>
const val sumInInterfaceDefault1 = B().<!EVALUATED: `42`!>foo(1)<!>
const val sumInInterfaceDefault2 = B().<!EVALUATED: `4`!>foo(x = 1, y = 2)<!>
const val sumInInterfaceDefault3 = B().<!EVALUATED: `-1`!>foo(x = 1, y = 2, z = -1)<!>
const val sumInInterfaceDefault1 = <!EVALUATED: `42`!>B().foo(1)<!>
const val sumInInterfaceDefault2 = <!EVALUATED: `4`!>B().foo(x = 1, y = 2)<!>
const val sumInInterfaceDefault3 = <!EVALUATED: `-1`!>B().foo(x = 1, y = 2, z = -1)<!>
const val someConstProp = 0
@CompileTimeCalculation
@@ -38,12 +38,12 @@ class Outer {
}
}
const val inner1 = Outer().Inner().<!EVALUATED: `100`!>withInner(100)<!>
const val inner2 = Outer().Inner().<!EVALUATED: `-1`!>withInner()<!>
const val inner3 = Outer().Inner().<!EVALUATED: `100`!>withOuter(100)<!>
const val inner4 = Outer().Inner().<!EVALUATED: `-2`!>withOuter()<!>
const val inner5 = Outer().Inner().<!EVALUATED: `100`!>withGlobal(100)<!>
const val inner6 = Outer().Inner().<!EVALUATED: `0`!>withGlobal()<!>
const val inner1 = <!EVALUATED: `100`!>Outer().Inner().withInner(100)<!>
const val inner2 = <!EVALUATED: `-1`!>Outer().Inner().withInner()<!>
const val inner3 = <!EVALUATED: `100`!>Outer().Inner().withOuter(100)<!>
const val inner4 = <!EVALUATED: `-2`!>Outer().Inner().withOuter()<!>
const val inner5 = <!EVALUATED: `100`!>Outer().Inner().withGlobal(100)<!>
const val inner6 = <!EVALUATED: `0`!>Outer().Inner().withGlobal()<!>
@CompileTimeCalculation
interface I<T> {
@@ -59,5 +59,5 @@ open class C<T> {
@CompileTimeCalculation
class D(override val prop: Int): C<Int>(), I<Int> {}
const val fooB1 = D(10).<!EVALUATED: `10`!>foo()<!>
const val fooB2 = D(10).<!EVALUATED: `-1`!>foo(-1)<!>
const val fooB1 = <!EVALUATED: `10`!>D(10).foo()<!>
const val fooB2 = <!EVALUATED: `-1`!>D(10).foo(-1)<!>
compiler/testData/ir/interpreter/defaultEquals.kt
Vendored
+1 -1
View File
@@ -9,5 +9,5 @@ fun theSameObjectEquals(value: Any): Boolean {
return value == getTheSameValue(value) && value === getTheSameValue(value)
}
const val equals1 = A().<!EVALUATED: `false`!>equals(A())<!>
const val equals1 = <!EVALUATED: `false`!>A().equals(A())<!>
const val equals2 = <!EVALUATED: `true`!>theSameObjectEquals(A())<!>
compiler/testData/ir/interpreter/enums1.kt
Vendored
+10 -10
View File
@@ -6,20 +6,20 @@ enum class EnumClass {
VALUE1, VALUE2
}
const val a = EnumClass.VALUE1.<!EVALUATED: `VALUE1`!>name<!>
const val b = EnumClass.values().<!EVALUATED: `2`!>size<!>
const val c = EnumClass.valueOf("VALUE1").<!EVALUATED: `0`!>ordinal<!>
const val d = EnumClass.valueOf("VALUE3").<!WAS_NOT_EVALUATED: `
const val a = <!EVALUATED: `VALUE1`!>EnumClass.VALUE1.name<!>
const val b = <!EVALUATED: `2`!>EnumClass.values().size<!>
const val c = <!EVALUATED: `0`!>EnumClass.valueOf("VALUE1").ordinal<!>
const val d = <!WAS_NOT_EVALUATED: `
Exception java.lang.IllegalArgumentException: No enum constant EnumClass.VALUE3
at Enums1Kt.EnumClass.valueOf(enums1.kt)
at Enums1Kt.<clinit>(enums1.kt:12)`!>ordinal<!>
at Enums1Kt.<clinit>(enums1.kt:12)`!>EnumClass.valueOf("VALUE3").ordinal<!>
const val e1 = EnumClass.VALUE1.hashCode().<!EVALUATED: `true`!>let { it is Int && it > 0 && it == EnumClass.VALUE1.hashCode() }<!>
const val e2 = EnumClass.VALUE1.<!EVALUATED: `VALUE1`!>toString()<!>
const val e1 = <!EVALUATED: `true`!>EnumClass.VALUE1.hashCode().let { it is Int && it > 0 && it == EnumClass.VALUE1.hashCode() }<!>
const val e2 = <!EVALUATED: `VALUE1`!>EnumClass.VALUE1.toString()<!>
const val e3 = <!EVALUATED: `true`!>EnumClass.VALUE1 == EnumClass.VALUE1<!>
const val e4 = <!EVALUATED: `false`!>EnumClass.VALUE1 == EnumClass.VALUE2<!>
const val f1 = enumValues<EnumClass>().<!EVALUATED: `2`!>size<!>
const val f2 = enumValueOf<EnumClass>("VALUE1").<!EVALUATED: `VALUE1`!>name<!>
const val f1 = <!EVALUATED: `2`!>enumValues<EnumClass>().size<!>
const val f2 = <!EVALUATED: `VALUE1`!>enumValueOf<EnumClass>("VALUE1").name<!>
const val j1 = enumValues<EnumClass>().<!EVALUATED: `VALUE1, VALUE2`!>joinToString { it.name }<!>
const val j1 = <!EVALUATED: `VALUE1, VALUE2`!>enumValues<EnumClass>().joinToString { it.name }<!>
compiler/testData/ir/interpreter/enums2.kt
Vendored
+9 -9
View File
@@ -15,15 +15,15 @@ enum class Color(val rgb: Int) {
fun getColorAsInt(): Int = rgb
}
const val a1 = Empty.values().<!EVALUATED: `0`!>size<!>
const val a2 = enumValues<Empty>().<!EVALUATED: `0`!>size<!>
const val a1 = <!EVALUATED: `0`!>Empty.values().size<!>
const val a2 = <!EVALUATED: `0`!>enumValues<Empty>().size<!>
const val b1 = Color.BLACK.<!EVALUATED: `BLACK`!>name<!>
const val b2 = Color.BLACK.<!EVALUATED: `0x000000`!>getColorAsString()<!>
const val b3 = Color.RED.<!EVALUATED: `0xFF0000`!>getColorAsString()<!>
const val b1 = <!EVALUATED: `BLACK`!>Color.BLACK.name<!>
const val b2 = <!EVALUATED: `0x000000`!>Color.BLACK.getColorAsString()<!>
const val b3 = <!EVALUATED: `0xFF0000`!>Color.RED.getColorAsString()<!>
const val c1 = Color.BLACK.<!EVALUATED: `0`!>getColorAsInt()<!>
const val c2 = Color.RED.<!EVALUATED: `16711680`!>getColorAsInt()<!>
const val c1 = <!EVALUATED: `0`!>Color.BLACK.getColorAsInt()<!>
const val c2 = <!EVALUATED: `16711680`!>Color.RED.getColorAsInt()<!>
@CompileTimeCalculation
enum class EnumWithoutPrimary {
@@ -37,5 +37,5 @@ enum class EnumWithoutPrimary {
}
}
const val d1 = EnumWithoutPrimary.X.<!EVALUATED: `0`!>someProp<!>
const val d2 = EnumWithoutPrimary.Y.<!EVALUATED: `10`!>someProp<!>
const val d1 = <!EVALUATED: `0`!>EnumWithoutPrimary.X.someProp<!>
const val d2 = <!EVALUATED: `10`!>EnumWithoutPrimary.Y.someProp<!>
compiler/testData/ir/interpreter/enums3.kt
Vendored
+5 -5
View File
@@ -1,9 +1,9 @@
import kotlin.text.*
const val a = RegexOption.IGNORE_CASE.<!EVALUATED: `IGNORE_CASE`!>name<!>
const val b = RegexOption.IGNORE_CASE.<!EVALUATED: `0`!>ordinal<!>
const val c = RegexOption.MULTILINE.<!EVALUATED: `MULTILINE`!>name<!>
const val d = RegexOption.MULTILINE.<!EVALUATED: `1`!>ordinal<!>
const val a = <!EVALUATED: `IGNORE_CASE`!>RegexOption.IGNORE_CASE.name<!>
const val b = <!EVALUATED: `0`!>RegexOption.IGNORE_CASE.ordinal<!>
const val c = <!EVALUATED: `MULTILINE`!>RegexOption.MULTILINE.name<!>
const val d = <!EVALUATED: `1`!>RegexOption.MULTILINE.ordinal<!>
const val e = <!EVALUATED: `true`!>RegexOption.IGNORE_CASE == RegexOption.IGNORE_CASE<!>
const val f = <!EVALUATED: `true`!>RegexOption.IGNORE_CASE != RegexOption.MULTILINE<!>
const val g = RegexOption.IGNORE_CASE.<!EVALUATED: `IGNORE_CASE`!>toString()<!>
const val g = <!EVALUATED: `IGNORE_CASE`!>RegexOption.IGNORE_CASE.toString()<!>
compiler/testData/ir/interpreter/exceptions/classCastException.kt
Vendored
+7 -7
View File
@@ -49,25 +49,25 @@ const val c2 = <!WAS_NOT_EVALUATED: `
Exception java.lang.ClassCastException: kotlin.Int cannot be cast to kotlin.String
at ClassCastExceptionKt.<clinit>(classCastException.kt:48)`!>unsafeClassCast<String>()<!>
const val d1 = A<Int>().<!EVALUATED: `1`!>unsafeCast()<!>
const val d2 = A<String>().<!WAS_NOT_EVALUATED: `
const val d1 = <!EVALUATED: `1`!>A<Int>().unsafeCast()<!>
const val d2 = <!WAS_NOT_EVALUATED: `
Exception java.lang.ClassCastException: kotlin.Int cannot be cast to kotlin.String
at ClassCastExceptionKt.<clinit>(classCastException.kt:51)`!>unsafeCast()<!>
at ClassCastExceptionKt.<clinit>(classCastException.kt:51)`!>A<String>().unsafeCast()<!>
const val stringList = getIntList<List<String>>().<!WAS_NOT_EVALUATED: `
const val stringList = <!WAS_NOT_EVALUATED: `
Exception java.lang.ClassCastException: kotlin.Int cannot be cast to kotlin.String
at ClassCastExceptionKt.stringList.<anonymous>(classCastException.kt:54)
at ClassCastExceptionKt.stringList.Function$0.invoke(classCastException.kt:0)
at StandardKt.kotlin.let(Standard.kt:32)
at ClassCastExceptionKt.<clinit>(classCastException.kt:53)`!>let {
at ClassCastExceptionKt.<clinit>(classCastException.kt:53)`!>getIntList<List<String>>().let {
it[0].length
}<!>
const val nullableStringList = getStringNullableList<List<String>>().<!WAS_NOT_EVALUATED: `
const val nullableStringList = <!WAS_NOT_EVALUATED: `
Exception java.lang.NullPointerException
at ClassCastExceptionKt.nullableStringList.<anonymous>(classCastException.kt)
at ClassCastExceptionKt.nullableStringList.Function$0.invoke(classCastException.kt:0)
at StandardKt.kotlin.let(Standard.kt:32)
at ClassCastExceptionKt.<clinit>(classCastException.kt:56)`!>let { it[0].length }<!>
at ClassCastExceptionKt.<clinit>(classCastException.kt:56)`!>getStringNullableList<List<String>>().let { it[0].length }<!>
const val nullableStringLength = <!WAS_NOT_EVALUATED: `
Exception java.lang.IllegalArgumentException: Parameter specified as non-null is null: method ClassCastExceptionKt.getLength, parameter str
at ClassCastExceptionKt.<clinit>(classCastException.kt:31)`!>getLength(getStringNullableList<List<String>>()[0])<!>
compiler/testData/ir/interpreter/exceptions/exceptionWithCause.kt
Vendored
+2 -2
View File
@@ -31,7 +31,7 @@ class Junk {
private fun e(): Nothing = throw LowLevelException()
}
const val exceptionWithCause = Junk().a().<!WAS_NOT_EVALUATED: `
const val exceptionWithCause = <!WAS_NOT_EVALUATED: `
Exception HighLevelException: MidLevelException: LowLevelException
at ExceptionWithCauseKt.Junk.a(exceptionWithCause.kt:15)
at ExceptionWithCauseKt.<clinit>(exceptionWithCause.kt:34)
@@ -46,4 +46,4 @@ Caused by: LowLevelException
at ExceptionWithCauseKt.Junk.c(exceptionWithCause.kt:23)
at ExceptionWithCauseKt.Junk.b(exceptionWithCause.kt:19)
at ExceptionWithCauseKt.Junk.a(exceptionWithCause.kt:13)
at ExceptionWithCauseKt.<clinit>(exceptionWithCause.kt:34)`!>toString()<!>
at ExceptionWithCauseKt.<clinit>(exceptionWithCause.kt:34)`!>Junk().a().toString()<!>
compiler/testData/ir/interpreter/extensionReceiver.kt
Vendored
+3 -3
View File
@@ -14,6 +14,6 @@ class A(val length: Int) {
}
}
const val simple = 1.<!EVALUATED: `1`!>get()<!>
const val right = A(3).<!EVALUATED: `true`!>check("123")<!>
const val wrong = A(2).<!EVALUATED: `false`!>check("123")<!>
const val simple = <!EVALUATED: `1`!>1.get()<!>
const val right = <!EVALUATED: `true`!>A(3).check("123")<!>
const val wrong = <!EVALUATED: `false`!>A(2).check("123")<!>
compiler/testData/ir/interpreter/generatedStdlib/contains.kt
Vendored
+4 -4
View File
@@ -1,7 +1,7 @@
import kotlin.collections.*
import kotlin.sequences.*
const val a = intArrayOf(1, 2, 3).<!EVALUATED: `true`!>contains(1)<!>
const val b = intArrayOf(1, 2, 3).<!EVALUATED: `false`!>contains(4)<!>
const val c = arrayOf(1, "2", 3.0).<!EVALUATED: `true`!>contains("2")<!>
const val d = sequenceOf(1, 2, 3).<!EVALUATED: `true`!>contains(2)<!>
const val a = <!EVALUATED: `true`!>intArrayOf(1, 2, 3).contains(1)<!>
const val b = <!EVALUATED: `false`!>intArrayOf(1, 2, 3).contains(4)<!>
const val c = <!EVALUATED: `true`!>arrayOf(1, "2", 3.0).contains("2")<!>
const val d = <!EVALUATED: `true`!>sequenceOf(1, 2, 3).contains(2)<!>
compiler/testData/ir/interpreter/generatedStdlib/elementAtOrElse.kt
Vendored
+5 -5
View File
@@ -2,8 +2,8 @@ import kotlin.*
import kotlin.collections.*
import kotlin.text.*
const val a = listOf(1, 2, 3).<!EVALUATED: `2`!>elementAtOrElse(1) { -1 }<!>
const val b = listOf(1, 2, 3).<!EVALUATED: `-1`!>elementAtOrElse(4) { -1 }<!>
const val c = uintArrayOf(1u, 2u, 3u, 4u).<!EVALUATED: `3`!>elementAtOrElse(2) { 0u }<!>
const val d = "abcd".<!EVALUATED: `c`!>elementAtOrElse(2) { '0' }<!>
const val e = "abcd".<!EVALUATED: `0`!>elementAtOrElse(4) { '0' }<!>
const val a = <!EVALUATED: `2`!>listOf(1, 2, 3).elementAtOrElse(1) { -1 }<!>
const val b = <!EVALUATED: `-1`!>listOf(1, 2, 3).elementAtOrElse(4) { -1 }<!>
const val c = <!EVALUATED: `3`!>uintArrayOf(1u, 2u, 3u, 4u).elementAtOrElse(2) { 0u }<!>
const val d = <!EVALUATED: `c`!>"abcd".elementAtOrElse(2) { '0' }<!>
const val e = <!EVALUATED: `0`!>"abcd".elementAtOrElse(4) { '0' }<!>
compiler/testData/ir/interpreter/generatedStdlib/first.kt
Vendored
+4 -4
View File
@@ -2,10 +2,10 @@ import kotlin.*
import kotlin.collections.*
import kotlin.text.*
const val a = "abcs".<!EVALUATED: `a`!>first()<!>
const val b = UIntArray(3) { it.toUInt() }.<!EVALUATED: `0`!>first()<!>
const val a = <!EVALUATED: `a`!>"abcs".first()<!>
const val b = <!EVALUATED: `0`!>UIntArray(3) { it.toUInt() }.first()<!>
const val c = <!EVALUATED: `1`!>listOf(1, "2", 3.0).first() as Int<!>
const val d = listOf<Int>().<!WAS_NOT_EVALUATED: `
const val d = <!WAS_NOT_EVALUATED: `
Exception java.util.NoSuchElementException: List is empty.
at CollectionsKt.kotlin.collections.first(Collections.kt:88)
at FirstKt.<clinit>(first.kt:8)`!>first()<!>
at FirstKt.<clinit>(first.kt:8)`!>listOf<Int>().first()<!>
compiler/testData/ir/interpreter/generatedStdlib/joinToString.kt
Vendored
+2 -2
View File
@@ -1,5 +1,5 @@
import kotlin.collections.*
import kotlin.sequences.*
const val a = listOf(1, 2, 3).<!EVALUATED: `1, 2, 3`!>joinToString()<!>
const val b = sequenceOf(-1, -2, -3).<!EVALUATED: `-1.-2.-3`!>joinToString(separator = ".")<!>
const val a = <!EVALUATED: `1, 2, 3`!>listOf(1, 2, 3).joinToString()<!>
const val b = <!EVALUATED: `-1.-2.-3`!>sequenceOf(-1, -2, -3).joinToString(separator = ".")<!>
compiler/testData/ir/interpreter/generatedStdlib/toList.kt
Vendored
+7 -7
View File
@@ -3,14 +3,14 @@ import kotlin.collections.*
import kotlin.text.*
import kotlin.sequences.*
const val zeroElementIntArrayToList = intArrayOf().toList().<!EVALUATED: `0`!>size<!>
const val singleElementIntArrayToList = intArrayOf(1).toList().<!EVALUATED: `1`!>size<!>
const val intArrayToList = intArrayOf(1, 2, 3).toList().<!EVALUATED: `3`!>size<!>
const val zeroElementIntArrayToList = <!EVALUATED: `0`!>intArrayOf().toList().size<!>
const val singleElementIntArrayToList = <!EVALUATED: `1`!>intArrayOf(1).toList().size<!>
const val intArrayToList = <!EVALUATED: `3`!>intArrayOf(1, 2, 3).toList().size<!>
const val customArrayToList = <!EVALUATED: `Some other value`!>arrayOf(1, "2", 3.0, "Some other value").toList()[3] as String<!>
const val listFromSet = setOf(1, 2, 2, 3, 3).toList().<!EVALUATED: `1, 2, 3`!>joinToString()<!>
const val listFromIterable = mapOf(1 to "One", 2 to "Two", 3 to "Three").entries.toList().<!EVALUATED: `1=One, 2=Two, 3=Three`!>joinToString()<!>
const val listFromSet = <!EVALUATED: `1, 2, 3`!>setOf(1, 2, 2, 3, 3).toList().joinToString()<!>
const val listFromIterable = <!EVALUATED: `1=One, 2=Two, 3=Three`!>mapOf(1 to "One", 2 to "Two", 3 to "Three").entries.toList().joinToString()<!>
const val stringToList = "String".toList().<!EVALUATED: `S, t, r, i, n, g`!>joinToString()<!>
const val stringToList = <!EVALUATED: `S, t, r, i, n, g`!>"String".toList().joinToString()<!>
const val sequenceToList = sequenceOf(3, 2, 1).toList().<!EVALUATED: `3, 2, 1`!>joinToString()<!>
const val sequenceToList = <!EVALUATED: `3, 2, 1`!>sequenceOf(3, 2, 1).toList().joinToString()<!>
compiler/testData/ir/interpreter/generatedStdlib/trim.kt
Vendored
+3 -3
View File
@@ -1,5 +1,5 @@
import kotlin.text.*
const val trimmed = " 1 ".<!EVALUATED: `1`!>trim()<!>
const val trimmedWithPredicate = (" 2 " as CharSequence).trim { it.isWhitespace() }.<!EVALUATED: `2`!>toString()<!>
const val charSequenceTrim = (" 3 " as CharSequence).trim().<!EVALUATED: `3`!>toString()<!>
const val trimmed = <!EVALUATED: `1`!>" 1 ".trim()<!>
const val trimmedWithPredicate = <!EVALUATED: `2`!>(" 2 " as CharSequence).trim { it.isWhitespace() }.toString()<!>
const val charSequenceTrim = <!EVALUATED: `3`!>(" 3 " as CharSequence).trim().toString()<!>
compiler/testData/ir/interpreter/innerClass.kt
Vendored
+5 -5
View File
@@ -20,11 +20,11 @@ class Outer {
}
}
const val a1 = Outer().<!EVALUATED: `outer foo`!>foo()<!>
const val a2 = Outer().Middle().<!EVALUATED: `middle foo`!>foo()<!>
const val a3 = Outer().Middle().Inner().<!EVALUATED: `inner foo with outer bar = "bar"`!>foo()<!>
const val a1 = <!EVALUATED: `outer foo`!>Outer().foo()<!>
const val a2 = <!EVALUATED: `middle foo`!>Outer().Middle().foo()<!>
const val a3 = <!EVALUATED: `inner foo with outer bar = "bar"`!>Outer().Middle().Inner().foo()<!>
const val b = Outer().Middle().Inner().<!EVALUATED: `From inner: 3; from middle: 2; from outer: 1`!>getAllNums()<!>
const val b = <!EVALUATED: `From inner: 3; from middle: 2; from outer: 1`!>Outer().Middle().Inner().getAllNums()<!>
open class A(val s: String) {
val z = s
@@ -45,4 +45,4 @@ open class A(val s: String) {
}
}
const val c = A("Fail").B("OK").<!EVALUATED: `OK`!>testB()<!>
const val c = <!EVALUATED: `OK`!>A("Fail").B("OK").testB()<!>
compiler/testData/ir/interpreter/instanceOf.kt
Vendored
+6 -6
View File
@@ -27,9 +27,9 @@ fun foo(): Unit {}
@CompileTimeCalculation
fun bar(p1: Int): Unit {}
const val d1 =<!EVALUATED: `true`!>::foo is kotlin.reflect.KFunction<*><!>
const val d2 =<!EVALUATED: `true`!>::foo is Function0<*><!>
const val d3 =<!EVALUATED: `false`!>::foo is Function1<*, *><!>
const val d4 =<!EVALUATED: `true`!>::bar is kotlin.reflect.KFunction<*><!>
const val d5 =<!EVALUATED: `false`!>::bar is Function0<*><!>
const val d6 =<!EVALUATED: `true`!>::bar is Function1<*, *><!>
const val d1 = <!EVALUATED: `true`!>::foo is kotlin.reflect.KFunction<*><!>
const val d2 = <!EVALUATED: `true`!>::foo is Function0<*><!>
const val d3 = <!EVALUATED: `false`!>::foo is Function1<*, *><!>
const val d4 = <!EVALUATED: `true`!>::bar is kotlin.reflect.KFunction<*><!>
const val d5 = <!EVALUATED: `false`!>::bar is Function0<*><!>
const val d6 = <!EVALUATED: `true`!>::bar is Function1<*, *><!>
compiler/testData/ir/interpreter/instanceOfWithTypeParameters.kt
Vendored
+1 -1
View File
@@ -135,4 +135,4 @@ fun <T> checkForArray(value: T): String {
if (value !is ArrayList<*>?) sb.append("fail 4; ")
return if (sb.isEmpty()) "OK" else sb.toString()
}
}
compiler/testData/ir/interpreter/interface.kt
Vendored
+5 -5
View File
@@ -35,8 +35,8 @@ fun getClassAsC(num: Int): C {
return C(num)
}
const val num1 = getClassAsA(1).<!EVALUATED: `1`!>getStr()<!>
const val num2 = getClassAsB(2).<!EVALUATED: `2`!>getStr()<!>
const val num3 = getClassAsB(3).<!EVALUATED: `3`!>getInt()<!>
const val num4 = getClassAsC(4).<!EVALUATED: `4`!>getStr()<!>
const val num5 = getClassAsC(5).<!EVALUATED: `5`!>getInt()<!>
const val num1 = <!EVALUATED: `1`!>getClassAsA(1).getStr()<!>
const val num2 = <!EVALUATED: `2`!>getClassAsB(2).getStr()<!>
const val num3 = <!EVALUATED: `3`!>getClassAsB(3).getInt()<!>
const val num4 = <!EVALUATED: `4`!>getClassAsC(4).getStr()<!>
const val num5 = <!EVALUATED: `5`!>getClassAsC(5).getInt()<!>
compiler/testData/ir/interpreter/interfaceDefault.kt
Vendored
+4 -4
View File
@@ -12,8 +12,8 @@ class B(val b: Int) : A {
fun getStrFromB() = "B " + super.getStr()
}
const val str1 = B(5).<!EVALUATED: `Number is 5`!>getStr()<!>
const val str2 = B(5).<!EVALUATED: `B Number is 5`!>getStrFromB()<!>
const val str1 = <!EVALUATED: `Number is 5`!>B(5).getStr()<!>
const val str2 = <!EVALUATED: `B Number is 5`!>B(5).getStrFromB()<!>
@CompileTimeCalculation
interface C {
@@ -26,5 +26,5 @@ class D(override val num: Int) : C {
fun getStr() = "D num = " + super.getInt()
}
const val num1 = D(10).<!EVALUATED: `10`!>getInt()<!>
const val num2 = D(10).<!EVALUATED: `D num = 10`!>getStr()<!>
const val num1 = <!EVALUATED: `10`!>D(10).getInt()<!>
const val num2 = <!EVALUATED: `D num = 10`!>D(10).getStr()<!>
compiler/testData/ir/interpreter/jvm/classReference.kt
Vendored
+15 -15
View File
@@ -12,12 +12,12 @@ class A(val a: Int, val b: String) {
fun Int.funWithExtension(other: Int) = this + other
}
const val aSimpleName = A::class.simpleName<!EVALUATED: `A`!>!!<!>
const val aQualifiedName = A::class.qualifiedName<!EVALUATED: `test.A`!>!!<!>
const val aMembers = A::class.members.<!EVALUATED: `val test.A.a: kotlin.Int, val test.A.b: kotlin.String, val test.A.(kotlin.String.)propertyWithExtension: kotlin.Int, fun test.A.(kotlin.Int.)funWithExtension(kotlin.Int): kotlin.Int, fun test.A.equals(kotlin.Any?): kotlin.Boolean, fun test.A.hashCode(): kotlin.Int, fun test.A.toString(): kotlin.String`!>joinToString()<!>
const val aConstructors = A::class.constructors.<!EVALUATED: `fun <init>(kotlin.Int, kotlin.String): test.A`!>joinToString()<!>
const val aVisibility = A::class.visibility.<!EVALUATED: `PUBLIC`!>toString()<!>
const val aSupertypes = A::class.supertypes.<!EVALUATED: `kotlin.Any`!>joinToString()<!>
const val aSimpleName = <!EVALUATED: `A`!>A::class.simpleName!!<!>
const val aQualifiedName = <!EVALUATED: `test.A`!>A::class.qualifiedName!!<!>
const val aMembers = <!EVALUATED: `val test.A.a: kotlin.Int, val test.A.b: kotlin.String, val test.A.(kotlin.String.)propertyWithExtension: kotlin.Int, fun test.A.(kotlin.Int.)funWithExtension(kotlin.Int): kotlin.Int, fun test.A.equals(kotlin.Any?): kotlin.Boolean, fun test.A.hashCode(): kotlin.Int, fun test.A.toString(): kotlin.String`!>A::class.members.joinToString()<!>
const val aConstructors = <!EVALUATED: `fun <init>(kotlin.Int, kotlin.String): test.A`!>A::class.constructors.joinToString()<!>
const val aVisibility = <!EVALUATED: `PUBLIC`!>A::class.visibility.toString()<!>
const val aSupertypes = <!EVALUATED: `kotlin.Any`!>A::class.supertypes.joinToString()<!>
@CompileTimeCalculation
interface Base<T>
@@ -31,14 +31,14 @@ class B<T, E : T, D : Any>(val prop: T) : Base<T> {
fun <E : Number> withTypeParameter(num: E) = num.toString()
}
const val bMembers = B::class.members.<!EVALUATED: `val test.B<T, E, D>.prop: T, fun test.B<T, E, D>.get(): T, fun test.B<T, E, D>.getThis(): test.B<T, out E, in D>, fun test.B<T, E, D>.withTypeParameter(E): kotlin.String, fun test.B<T, E, D>.equals(kotlin.Any?): kotlin.Boolean, fun test.B<T, E, D>.hashCode(): kotlin.Int, fun test.B<T, E, D>.toString(): kotlin.String`!>joinToString()<!>
const val bTypeParameters = B::class.typeParameters.<!EVALUATED: `T, E, D`!>joinToString()<!>
const val bSupertypes = B::class.supertypes.<!EVALUATED: `test.Base<T>, kotlin.Any`!>joinToString()<!>
const val bReturnType1 = B::class.members.toList()[1].returnType.<!EVALUATED: `T`!>toString()<!>
const val bReturnType2 = B::class.members.toList()[3].returnType.<!EVALUATED: `kotlin.String`!>toString()<!>
const val bMembers = <!EVALUATED: `val test.B<T, E, D>.prop: T, fun test.B<T, E, D>.get(): T, fun test.B<T, E, D>.getThis(): test.B<T, out E, in D>, fun test.B<T, E, D>.withTypeParameter(E): kotlin.String, fun test.B<T, E, D>.equals(kotlin.Any?): kotlin.Boolean, fun test.B<T, E, D>.hashCode(): kotlin.Int, fun test.B<T, E, D>.toString(): kotlin.String`!>B::class.members.joinToString()<!>
const val bTypeParameters = <!EVALUATED: `T, E, D`!>B::class.typeParameters.joinToString()<!>
const val bSupertypes = <!EVALUATED: `test.Base<T>, kotlin.Any`!>B::class.supertypes.joinToString()<!>
const val bReturnType1 = <!EVALUATED: `T`!>B::class.members.toList()[1].returnType.toString()<!>
const val bReturnType2 = <!EVALUATED: `kotlin.String`!>B::class.members.toList()[3].returnType.toString()<!>
const val arguments1 = (B<Number, Double, Int>(1)::getThis as KFunction<*>).returnType.arguments.<!EVALUATED: `T, out E, in D`!>joinToString()<!>
const val arguments2 = (arrayOf(1)::iterator as KFunction<*>).returnType.arguments.<!EVALUATED: `T`!>joinToString()<!>
const val arguments1 = <!EVALUATED: `T, out E, in D`!>(B<Number, Double, Int>(1)::getThis as KFunction<*>).returnType.arguments.joinToString()<!>
const val arguments2 = <!EVALUATED: `T`!>(arrayOf(1)::iterator as KFunction<*>).returnType.arguments.joinToString()<!>
@CompileTimeCalculation
class C {
@@ -46,5 +46,5 @@ class C {
get() = this.length
}
const val cMember = C::class.members.toList()[0].<!EVALUATED: `val test.C.(kotlin.String.)getLength: kotlin.Int`!>toString()<!>
const val cMemberReturnType = C::class.members.toList()[0].returnType.classifier.<!EVALUATED: `class kotlin.Int`!>toString()<!>
const val cMember = <!EVALUATED: `val test.C.(kotlin.String.)getLength: kotlin.Int`!>C::class.members.toList()[0].toString()<!>
const val cMemberReturnType = <!EVALUATED: `class kotlin.Int`!>C::class.members.toList()[0].returnType.classifier.toString()<!>
compiler/testData/ir/interpreter/jvm/javaStatic.kt
Vendored
+4 -4
View File
@@ -17,10 +17,10 @@ const val floatMinExponent = <!EVALUATED: `-126`!>{ java.lang.Float.MIN_EXPONENT
const val floatNegInfinity = <!EVALUATED: `-Infinity`!>{ java.lang.Float.NEGATIVE_INFINITY }()<!>
const val floatPosInfinity = <!EVALUATED: `Infinity`!>{ java.lang.Float.POSITIVE_INFINITY }()<!>
const val booleanFalse = { java.lang.Boolean.FALSE }().<!EVALUATED: `false`!>toString()<!>
const val booleanTrue = { java.lang.Boolean.TRUE }().<!EVALUATED: `true`!>toString()<!>
const val booleanFalse = <!EVALUATED: `false`!>{ java.lang.Boolean.FALSE }().toString()<!>
const val booleanTrue = <!EVALUATED: `true`!>{ java.lang.Boolean.TRUE }().toString()<!>
const val charMax = { java.lang.Character.MAX_VALUE }().<!EVALUATED: `65535`!>toInt()<!>
const val charMin = { java.lang.Character.MIN_VALUE }().<!EVALUATED: `0`!>toInt()<!>
const val charMax = <!EVALUATED: `65535`!>{ java.lang.Character.MAX_VALUE }().toInt()<!>
const val charMin = <!EVALUATED: `0`!>{ java.lang.Character.MIN_VALUE }().toInt()<!>
const val charSize = <!EVALUATED: `16`!>{ java.lang.Character.SIZE }()<!>
const val charBytes = <!EVALUATED: `2`!>{ java.lang.Character.BYTES }()<!>
compiler/testData/ir/interpreter/jvm/kProperty2.kt
Vendored
+1 -1
View File
@@ -8,4 +8,4 @@ class A(val a: Int) {
get() = this.length * a
}
const val kproperty2Get = A::class.members.toList()[1].call(A(2), "123").<!EVALUATED: `6`!>toString()<!>
const val kproperty2Get = <!EVALUATED: `6`!>A::class.members.toList()[1].call(A(2), "123").toString()<!>
compiler/testData/ir/interpreter/jvm/parameterReference.kt
Vendored
+6 -6
View File
@@ -14,9 +14,9 @@ class A {
fun String.get(a: Int) = this
}
const val parameters1 = (::withParameters as KFunction<*>).parameters.<!EVALUATED: `parameter #0 a of fun withParameters(kotlin.Int, kotlin.Double): kotlin.Int, parameter #1 b of fun withParameters(kotlin.Int, kotlin.Double): kotlin.Int`!>joinToString()<!>
const val parameters2 = (String::withExtension as KFunction<*>).parameters.<!EVALUATED: `extension receiver parameter of fun kotlin.String.withExtension(kotlin.Int): kotlin.Int, parameter #1 a of fun kotlin.String.withExtension(kotlin.Int): kotlin.Int`!>joinToString()<!>
const val parameters3 = A::class.members.toList()[0].parameters.<!EVALUATED: `instance parameter of fun test.A.(kotlin.String.)get(kotlin.Int): kotlin.String, extension receiver parameter of fun test.A.(kotlin.String.)get(kotlin.Int): kotlin.String, parameter #2 a of fun test.A.(kotlin.String.)get(kotlin.Int): kotlin.String`!>joinToString()<!>
const val parameters1 = <!EVALUATED: `parameter #0 a of fun withParameters(kotlin.Int, kotlin.Double): kotlin.Int, parameter #1 b of fun withParameters(kotlin.Int, kotlin.Double): kotlin.Int`!>(::withParameters as KFunction<*>).parameters.joinToString()<!>
const val parameters2 = <!EVALUATED: `extension receiver parameter of fun kotlin.String.withExtension(kotlin.Int): kotlin.Int, parameter #1 a of fun kotlin.String.withExtension(kotlin.Int): kotlin.Int`!>(String::withExtension as KFunction<*>).parameters.joinToString()<!>
const val parameters3 = <!EVALUATED: `instance parameter of fun test.A.(kotlin.String.)get(kotlin.Int): kotlin.String, extension receiver parameter of fun test.A.(kotlin.String.)get(kotlin.Int): kotlin.String, parameter #2 a of fun test.A.(kotlin.String.)get(kotlin.Int): kotlin.String`!>A::class.members.toList()[0].parameters.joinToString()<!>
// properties
@CompileTimeCalculation
@@ -25,6 +25,6 @@ class B(val b: Int) {
get() = this.length
}
const val property0Parameters = B(1)::b.parameters.<!EVALUATED: `[]`!>toString()<!>
const val property1Parameters = B::b.parameters.<!EVALUATED: `[instance parameter of val test.B.b: kotlin.Int]`!>toString()<!>
const val property2Parameters = B::class.members.toList()[1].parameters.<!EVALUATED: `[instance parameter of val test.B.(kotlin.String.)size: kotlin.Int, extension receiver parameter of val test.B.(kotlin.String.)size: kotlin.Int]`!>toString()<!>
const val property0Parameters = <!EVALUATED: `[]`!>B(1)::b.parameters.toString()<!>
const val property1Parameters = <!EVALUATED: `[instance parameter of val test.B.b: kotlin.Int]`!>B::b.parameters.toString()<!>
const val property2Parameters = <!EVALUATED: `[instance parameter of val test.B.(kotlin.String.)size: kotlin.Int, extension receiver parameter of val test.B.(kotlin.String.)size: kotlin.Int]`!>B::class.members.toList()[1].parameters.toString()<!>
compiler/testData/ir/interpreter/localFunction.kt
Vendored
+2 -2
View File
@@ -47,8 +47,8 @@ fun getNumAfterLocalInvoke(): Int {
return a
}
const val a = returnTheSameValueFun(2).<!EVALUATED: `2`!>invoke()<!>
const val b = multiplyByTwo(1).<!EVALUATED: `2`!>invoke()<!>
const val a = <!EVALUATED: `2`!>returnTheSameValueFun(2).invoke()<!>
const val b = <!EVALUATED: `2`!>multiplyByTwo(1).invoke()<!>
const val c = <!EVALUATED: `5`!>checkStackCorrectness()<!>
const val d = <!EVALUATED: `previous = 10; multiplied by two = 20; b = 0`!>checkLaterInvoke()<!>
const val e = <!EVALUATED: `result = 8; (a, b) = (10, 20)`!>localInline()<!>
compiler/testData/ir/interpreter/localObject.kt
Vendored
+2 -2
View File
@@ -15,5 +15,5 @@ class A(val a: Int) {
}
}
const val a = getLocalObject(10).<!EVALUATED: `10`!>getNum()<!>
const val b = A(2).localObject.<!EVALUATED: `2`!>getNum()<!>
const val a = <!EVALUATED: `10`!>getLocalObject(10).getNum()<!>
const val b = <!EVALUATED: `2`!>A(2).localObject.getNum()<!>
compiler/testData/ir/interpreter/logIntrinsic.kt
Vendored
+1 -1
View File
@@ -32,4 +32,4 @@ fun getSomeInfo(): String {
@CompileTimeCalculation
inline fun log(info: String, fileNameAndLine: String = sourceLocation()): String {
return info + " at " + fileNameAndLine
}
}
compiler/testData/ir/interpreter/multipleOverridden.kt
Vendored
+1 -1
View File
@@ -20,4 +20,4 @@ class D : A(), B, C {
}
}
const val a = D().<!EVALUATED: `6`!>get()<!>
const val a = <!EVALUATED: `6`!>D().get()<!>
compiler/testData/ir/interpreter/object.kt
Vendored
+5 -5
View File
@@ -21,8 +21,8 @@ object ObjectWithConst {
fun concat(first: String, second: Any) = "$first$second"
}
const val num = A().<!EVALUATED: `10`!>a<!>
const val numStatic = A.<!EVALUATED: `-10`!>static<!>
const val numStaticFromFun = A.<!EVALUATED: `2147483647`!>getStaticNumber()<!>
const val valFromObject = ObjectWithConst.<!EVALUATED: `Value in a: 100`!>b<!>
const val valFnonConstFromObject = ObjectWithConst.<!EVALUATED: `Not const field in compile time object`!>nonConst<!>
const val num = <!EVALUATED: `10`!>A().a<!>
const val numStatic = <!EVALUATED: `-10`!>A.static<!>
const val numStaticFromFun = <!EVALUATED: `2147483647`!>A.getStaticNumber()<!>
const val valFromObject = <!EVALUATED: `Value in a: 100`!>ObjectWithConst.b<!>
const val valFnonConstFromObject = <!EVALUATED: `Not const field in compile time object`!>ObjectWithConst.nonConst<!>
compiler/testData/ir/interpreter/objectOverride.kt
Vendored
+4 -4
View File
@@ -21,7 +21,7 @@ object C : B() {
override fun get() = "Default: " + super.defaultGet() + "; from super B: " + super.get() + "; from current: " + "companion C"
}
const val a1 = A.<!EVALUATED: `Object`!>defaultGet()<!>
const val a2 = A.<!EVALUATED: `A`!>get()<!>
const val c1 = C.<!EVALUATED: `Object`!>defaultGet()<!>
const val c2 = C.<!EVALUATED: `Default: Object; from super B: B; from current: companion C`!>get()<!>
const val a1 = <!EVALUATED: `Object`!>A.defaultGet()<!>
const val a2 = <!EVALUATED: `A`!>A.get()<!>
const val c1 = <!EVALUATED: `Object`!>C.defaultGet()<!>
const val c2 = <!EVALUATED: `Default: Object; from super B: B; from current: companion C`!>C.get()<!>
compiler/testData/ir/interpreter/overrideDifferentName.kt
Vendored
+2 -2
View File
@@ -10,5 +10,5 @@ class B(val b: Int) : A() {
}
}
const val a = A().<!EVALUATED: `11`!>inc(10)<!>
const val b = B(10).<!EVALUATED: `21`!>inc(11)<!>
const val a = <!EVALUATED: `11`!>A().inc(10)<!>
const val b = <!EVALUATED: `21`!>B(10).inc(11)<!>
compiler/testData/ir/interpreter/overrideExtension.kt
Vendored
+2 -2
View File
@@ -10,5 +10,5 @@ class B : A() {
override fun String.getSize() = -1
}
const val a = A().<!EVALUATED: `4`!>returnSizeOf("1234")<!>
const val b = B().<!EVALUATED: `-1`!>returnSizeOf("1234")<!>
const val a = <!EVALUATED: `4`!>A().returnSizeOf("1234")<!>
const val b = <!EVALUATED: `-1`!>B().returnSizeOf("1234")<!>
compiler/testData/ir/interpreter/primitives/charMethods.kt
Vendored
+1 -1
View File
@@ -32,7 +32,7 @@ const val a3 = <!EVALUATED: `8`!>minus('9', '1')<!>
const val a4 = <!EVALUATED: `8`!>minus('9', 1)<!>
const val a5 = <!EVALUATED: `2`!>inc('1')<!>
const val a6 = <!EVALUATED: `0`!>dec('1')<!>
const val a7 = rangeTo('9', '1').<!EVALUATED: `1`!>last<!>
const val a7 = <!EVALUATED: `1`!>rangeTo('9', '1').last<!>
const val b1 = <!EVALUATED: `49`!>toByte('1')<!>
const val b2 = <!EVALUATED: `2`!>toChar('2')<!>
compiler/testData/ir/interpreter/primitives/intMethods.kt
Vendored
+4 -4
View File
@@ -133,10 +133,10 @@ const val decrement = <!EVALUATED: `2`!>dec(3)<!>
const val unaryPlus = <!EVALUATED: `3`!>unaryPlus(3)<!>
const val unaryMinus = <!EVALUATED: `-3`!>unaryMinus(3)<!>
const val rangeTo1 = rangeTo(5, 1.toByte()).<!EVALUATED: `1`!>last<!>
const val rangeTo2 = rangeTo(5, 2.toShort()).<!EVALUATED: `2`!>last<!>
const val rangeTo3 = rangeTo(5, 3).<!EVALUATED: `3`!>last<!>
const val rangeTo4 = rangeTo(5, 4L).<!EVALUATED: `4`!>last<!>
const val rangeTo1 = <!EVALUATED: `1`!>rangeTo(5, 1.toByte()).last<!>
const val rangeTo2 = <!EVALUATED: `2`!>rangeTo(5, 2.toShort()).last<!>
const val rangeTo3 = <!EVALUATED: `3`!>rangeTo(5, 3).last<!>
const val rangeTo4 = <!EVALUATED: `4`!>rangeTo(5, 4L).last<!>
const val shiftLeft = <!EVALUATED: `16`!>shl(8, 1)<!>
const val shiftRight = <!EVALUATED: `2`!>shr(8, 2)<!>
compiler/testData/ir/interpreter/primitives/longMethods.kt
Vendored
+4 -4
View File
@@ -131,10 +131,10 @@ const val decrement = <!EVALUATED: `2`!>dec(3L)<!>
const val unaryPlus = <!EVALUATED: `3`!>unaryPlus(3L)<!>
const val unaryMinus = <!EVALUATED: `-3`!>unaryMinus(3L)<!>
const val rangeTo1 = rangeTo(5L, 1.toByte()).<!EVALUATED: `1`!>last<!>
const val rangeTo2 = rangeTo(5L, 2.toShort()).<!EVALUATED: `2`!>last<!>
const val rangeTo3 = rangeTo(5L, 3).<!EVALUATED: `3`!>last<!>
const val rangeTo4 = rangeTo(5L, 4L).<!EVALUATED: `4`!>last<!>
const val rangeTo1 = <!EVALUATED: `1`!>rangeTo(5L, 1.toByte()).last<!>
const val rangeTo2 = <!EVALUATED: `2`!>rangeTo(5L, 2.toShort()).last<!>
const val rangeTo3 = <!EVALUATED: `3`!>rangeTo(5L, 3).last<!>
const val rangeTo4 = <!EVALUATED: `4`!>rangeTo(5L, 4L).last<!>
const val shiftLeft = <!EVALUATED: `16`!>shl(8L, 1)<!>
const val shiftRight = <!EVALUATED: `2`!>shr(8L, 2)<!>
compiler/testData/ir/interpreter/primitives/uInt.kt
Vendored
+1 -1
View File
@@ -103,7 +103,7 @@ const val rem4 = <!EVALUATED: `2`!>rem(2u, uLong)<!>
const val inc = <!EVALUATED: `4`!>inc(3u)<!>
const val dec = <!EVALUATED: `2`!>dec(3u)<!>
const val rangeTo = rangeTo(0u, 10u).<!EVALUATED: `10`!>last<!>
const val rangeTo = <!EVALUATED: `10`!>rangeTo(0u, 10u).last<!>
const val shiftLeft = <!EVALUATED: `16`!>shl(8u, 1)<!>
const val shiftRight = <!EVALUATED: `2`!>shr(8u, 2)<!>
compiler/testData/ir/interpreter/progressionFromClosedRange.kt
Vendored
+3 -3
View File
@@ -1,3 +1,3 @@
const val a = IntProgression.fromClosedRange(0, 10, 1).<!EVALUATED: `0`!>first<!>
const val b = LongProgression.fromClosedRange(0L, 10L, 1L).<!EVALUATED: `10`!>last<!>
const val c = CharProgression.fromClosedRange('0', '9', 1).<!EVALUATED: `1`!>step<!>
const val a = <!EVALUATED: `0`!>IntProgression.fromClosedRange(0, 10, 1).first<!>
const val b = <!EVALUATED: `10`!>LongProgression.fromClosedRange(0L, 10L, 1L).last<!>
const val c = <!EVALUATED: `1`!>CharProgression.fromClosedRange('0', '9', 1).step<!>
compiler/testData/ir/interpreter/proxy/customCharSequence.kt
Vendored
+3 -3
View File
@@ -7,6 +7,6 @@ class MyCharSequence(val str: String): CharSequence {
override fun subSequence(startIndex: Int, endIndex: Int) = str.subSequence(startIndex, endIndex)
}
const val sbSize = StringBuilder(MyCharSequence("MyString")).<!EVALUATED: `8`!>length<!>
const val appendSize = StringBuilder().append(MyCharSequence("MyString")).<!EVALUATED: `8`!>length<!>
const val subSequenceSize = StringBuilder(StringBuilder(MyCharSequence("MyString")).subSequence(0, 4)).<!EVALUATED: `4`!>length<!>
const val sbSize = <!EVALUATED: `8`!>StringBuilder(MyCharSequence("MyString")).length<!>
const val appendSize = <!EVALUATED: `8`!>StringBuilder().append(MyCharSequence("MyString")).length<!>
const val subSequenceSize = <!EVALUATED: `4`!>StringBuilder(StringBuilder(MyCharSequence("MyString")).subSequence(0, 4)).length<!>
compiler/testData/ir/interpreter/proxy/customEquals.kt
Vendored
+1 -1
View File
@@ -23,4 +23,4 @@ class B(val b: Int) {
override fun toString(): String = "B($b)"
}
const val areEquals = <!EVALUATED: `true`!>listOf(B(1), B(2)) == listOf(B(1), B(2))<!>
const val asString = listOf(B(1), B(2)).<!EVALUATED: `[B(1), B(2)]`!>toString()<!>
const val asString = <!EVALUATED: `[B(1), B(2)]`!>listOf(B(1), B(2)).toString()<!>
compiler/testData/ir/interpreter/proxy/proxyPair.kt
Vendored
+3 -3
View File
@@ -3,6 +3,6 @@ import kotlin.collections.*
@CompileTimeCalculation
class A(val a: Int)
const val size = mapOf(1 to "A(1)").<!EVALUATED: `1`!>size<!>
const val first = mapOf(1 to "A(1)").entries.single().<!EVALUATED: `1`!>key<!>
const val second = mapOf(1 to "A(1)").values.<!EVALUATED: `A(1)`!>single()<!>
const val size = <!EVALUATED: `1`!>mapOf(1 to "A(1)").size<!>
const val first = <!EVALUATED: `1`!>mapOf(1 to "A(1)").entries.single().key<!>
const val second = <!EVALUATED: `A(1)`!>mapOf(1 to "A(1)").values.single()<!>
compiler/testData/ir/interpreter/rangeTo.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
@CompileTimeCalculation internal class IntProgressionIterator(first: Int, last: Int, val step: Int) : IntIterator()
@CompileTimeCalculation public class IntRange(start: Int, endInclusive: Int) : IntProgression(start, endInclusive, 1), ClosedRange<Int>
const val range = (1..10).<!EVALUATED: `1`!>first<!>
const val range = <!EVALUATED: `1`!>(1..10).first<!>
@CompileTimeCalculation
fun getIterator(first: Int, last: Int): Int {
compiler/testData/ir/interpreter/reference/propertyReference.kt
Vendored
+15 -15
View File
@@ -3,30 +3,30 @@ import kotlin.*
@CompileTimeCalculation
class A(val a: Int)
const val propertyName = A::a.<!EVALUATED: `a`!>name<!>
const val propertyGet = A::a.<!EVALUATED: `1`!>get(A(1))<!>
const val propertyInvoke = A::a.<!EVALUATED: `2`!>invoke(A(2))<!>
const val propertyName = <!EVALUATED: `a`!>A::a.name<!>
const val propertyGet = <!EVALUATED: `1`!>A::a.get(A(1))<!>
const val propertyInvoke = <!EVALUATED: `2`!>A::a.invoke(A(2))<!>
const val propertyWithReceiverName = A(10)::a.<!EVALUATED: `a`!>name<!>
const val propertyWithReceiverGet = A(11)::a.<!EVALUATED: `11`!>get()<!>
const val propertyWithReceiverInvoke = A(12)::a.<!EVALUATED: `12`!>invoke()<!>
const val propertyWithReceiverName = <!EVALUATED: `a`!>A(10)::a.name<!>
const val propertyWithReceiverGet = <!EVALUATED: `11`!>A(11)::a.get()<!>
const val propertyWithReceiverInvoke = <!EVALUATED: `12`!>A(12)::a.invoke()<!>
@CompileTimeCalculation
class B(var b: Int)
const val mutablePropertyName = B::b.<!EVALUATED: `b`!>name<!>
const val mutablePropertyGet = B::b.<!EVALUATED: `1`!>get(B(1))<!>
const val mutablePropertySet = B(2).apply { B::b.set(this, 3) }.<!EVALUATED: `3`!>b<!>
const val mutablePropertyInvoke = B::b.<!EVALUATED: `4`!>invoke(B(4))<!>
const val mutablePropertyName = <!EVALUATED: `b`!>B::b.name<!>
const val mutablePropertyGet = <!EVALUATED: `1`!>B::b.get(B(1))<!>
const val mutablePropertySet = <!EVALUATED: `3`!>B(2).apply { B::b.set(this, 3) }.b<!>
const val mutablePropertyInvoke = <!EVALUATED: `4`!>B::b.invoke(B(4))<!>
const val mutablePropertyWithReceiverName = B(10)::b.<!EVALUATED: `b`!>name<!>
const val mutablePropertyWithReceiverGet = B(11)::b.<!EVALUATED: `11`!>get()<!>
const val mutablePropertyWithReceiverSet = B(12).apply { this::b.set(13) }.<!EVALUATED: `13`!>b<!>
const val mutablePropertyWithReceiverInvoke = B(14)::b.<!EVALUATED: `14`!>invoke()<!>
const val mutablePropertyWithReceiverName = <!EVALUATED: `b`!>B(10)::b.name<!>
const val mutablePropertyWithReceiverGet = <!EVALUATED: `11`!>B(11)::b.get()<!>
const val mutablePropertyWithReceiverSet = <!EVALUATED: `13`!>B(12).apply { this::b.set(13) }.b<!>
const val mutablePropertyWithReceiverInvoke = <!EVALUATED: `14`!>B(14)::b.invoke()<!>
@CompileTimeCalculation
var <T> T.bar : T
get() = this
set(value) { }
const val barToString = String::bar.<!EVALUATED: `var T.bar: T`!>toString()<!>
const val barToString = <!EVALUATED: `var T.bar: T`!>String::bar.toString()<!>
compiler/testData/ir/interpreter/regex.kt
Vendored
+25 -25
View File
@@ -1,35 +1,35 @@
import kotlin.text.*
import kotlin.collections.*
const val regConstructor1 = Regex("pattern").<!EVALUATED: `pattern`!>pattern<!>
const val regConstructor2 = Regex("pattern", RegexOption.IGNORE_CASE).options.iterator().next().<!EVALUATED: `IGNORE_CASE`!>name<!>
const val regConstructor3 = Regex("pattern", setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE)).options.<!EVALUATED: `2`!>size<!>
const val regConstructor1 = <!EVALUATED: `pattern`!>Regex("pattern").pattern<!>
const val regConstructor2 = <!EVALUATED: `IGNORE_CASE`!>Regex("pattern", RegexOption.IGNORE_CASE).options.iterator().next().name<!>
const val regConstructor3 = <!EVALUATED: `2`!>Regex("pattern", setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE)).options.size<!>
const val matchEntire1 = Regex("pat").matchEntire("pat")?.value.<!EVALUATED: `pat`!>toString()<!>
const val matchEntire2 = Regex("[abc]").matchEntire("a")?.range?.last.<!EVALUATED: `0`!>toString()<!>
const val matches1 = Regex("str(1)?").<!EVALUATED: `true`!>matches("str1")<!>
const val matches2 = Regex("str(1)?").<!EVALUATED: `false`!>matches("str2")<!>
const val containsMatchIn1 = Regex("[0-9]").<!EVALUATED: `true`!>containsMatchIn("0")<!>
const val containsMatchIn2 = Regex("[0-9]").<!EVALUATED: `true`!>containsMatchIn("!!0!!")<!>
const val containsMatchIn3 = Regex("[0-9]").<!EVALUATED: `false`!>containsMatchIn("!!p!!")<!>
const val matchEntire1 = <!EVALUATED: `pat`!>Regex("pat").matchEntire("pat")?.value.toString()<!>
const val matchEntire2 = <!EVALUATED: `0`!>Regex("[abc]").matchEntire("a")?.range?.last.toString()<!>
const val matches1 = <!EVALUATED: `true`!>Regex("str(1)?").matches("str1")<!>
const val matches2 = <!EVALUATED: `false`!>Regex("str(1)?").matches("str2")<!>
const val containsMatchIn1 = <!EVALUATED: `true`!>Regex("[0-9]").containsMatchIn("0")<!>
const val containsMatchIn2 = <!EVALUATED: `true`!>Regex("[0-9]").containsMatchIn("!!0!!")<!>
const val containsMatchIn3 = <!EVALUATED: `false`!>Regex("[0-9]").containsMatchIn("!!p!!")<!>
//replace
const val replace1 = Regex("0").<!EVALUATED: `There are n apples`!>replace("There are 0 apples", "n")<!>
const val replace2 = Regex("(red|green|blue)").<!EVALUATED: `Roses are red!, Violets are blue!`!>replace("Roses are red, Violets are blue") { it.value + "!" }<!>
const val replace3 = Regex("(red|green|blue)").<!EVALUATED: `Roses are REPLACED, Violets are blue`!>replaceFirst("Roses are red, Violets are blue", "REPLACED")<!>
const val split = Regex("\\W+").split("Roses are red, Violets are blue").<!EVALUATED: `6`!>size<!>
const val replace1 = <!EVALUATED: `There are n apples`!>Regex("0").replace("There are 0 apples", "n")<!>
const val replace2 = <!EVALUATED: `Roses are red!, Violets are blue!`!>Regex("(red|green|blue)").replace("Roses are red, Violets are blue") { it.value + "!" }<!>
const val replace3 = <!EVALUATED: `Roses are REPLACED, Violets are blue`!>Regex("(red|green|blue)").replaceFirst("Roses are red, Violets are blue", "REPLACED")<!>
const val split = <!EVALUATED: `6`!>Regex("\\W+").split("Roses are red, Violets are blue").size<!>
//find
const val find1 = Regex("p").find("p")?.value.<!EVALUATED: `p`!>toString()<!>
const val find2 = Regex("(red|green|blue)").find("Roses are red, Violets are blue")?.groups?.size.<!EVALUATED: `2`!>toString()<!>
const val find3 = Regex("(red|green|blue)").find("Roses are red, Violets are blue")?.destructured?.component1().<!EVALUATED: `red`!>toString()<!>
const val find4 = Regex("(red|green|blue)").find("Roses are red, Violets are blue")?.next()?.value.<!EVALUATED: `blue`!>toString()<!>
const val find5 = Regex("(red|green|blue)").find("Roses are red, Violets are blue", 15)?.value.<!EVALUATED: `blue`!>toString()<!>
const val find6 = Regex("(red|green|blue)").findAll("Roses are red, Violets are blue").iterator().next()?.value.<!EVALUATED: `red`!>toString()<!>
const val find7 = Regex("(red|green|blue)").findAll("Roses are red, Violets are blue").iterator().next()?.next()?.value.<!EVALUATED: `blue`!>toString()<!>
const val find8 = Regex("(red|green|blue)").findAll("Roses are red, Violets are blue").iterator().next()?.next()?.next()?.value.<!EVALUATED: `null`!>toString()<!>
const val find1 = <!EVALUATED: `p`!>Regex("p").find("p")?.value.toString()<!>
const val find2 = <!EVALUATED: `2`!>Regex("(red|green|blue)").find("Roses are red, Violets are blue")?.groups?.size.toString()<!>
const val find3 = <!EVALUATED: `red`!>Regex("(red|green|blue)").find("Roses are red, Violets are blue")?.destructured?.component1().toString()<!>
const val find4 = <!EVALUATED: `blue`!>Regex("(red|green|blue)").find("Roses are red, Violets are blue")?.next()?.value.toString()<!>
const val find5 = <!EVALUATED: `blue`!>Regex("(red|green|blue)").find("Roses are red, Violets are blue", 15)?.value.toString()<!>
const val find6 = <!EVALUATED: `red`!>Regex("(red|green|blue)").findAll("Roses are red, Violets are blue").iterator().next()?.value.toString()<!>
const val find7 = <!EVALUATED: `blue`!>Regex("(red|green|blue)").findAll("Roses are red, Violets are blue").iterator().next()?.next()?.value.toString()<!>
const val find8 = <!EVALUATED: `null`!>Regex("(red|green|blue)").findAll("Roses are red, Violets are blue").iterator().next()?.next()?.next()?.value.toString()<!>
//companion
const val fromLiteral = Regex.fromLiteral("[a-z0-9]+").<!EVALUATED: `[a-z0-9]+`!>pattern<!>
const val escape = Regex.<!EVALUATED: `\Q[a-z0-9]+\E`!>escape("[a-z0-9]+")<!>
const val escapeReplacement = Regex.<!EVALUATED: `[a-z0-9]+`!>escapeReplacement("[a-z0-9]+")<!>
const val fromLiteral = <!EVALUATED: `[a-z0-9]+`!>Regex.fromLiteral("[a-z0-9]+").pattern<!>
const val escape = <!EVALUATED: `\Q[a-z0-9]+\E`!>Regex.escape("[a-z0-9]+")<!>
const val escapeReplacement = <!EVALUATED: `[a-z0-9]+`!>Regex.escapeReplacement("[a-z0-9]+")<!>
compiler/testData/ir/interpreter/safeClassCast.kt
Vendored
+3 -3
View File
@@ -34,6 +34,6 @@ const val c6 = <!EVALUATED: `false`!>arrayOf<List<Int>>(listOf(1, 2), listOf(2,
const val c7 = <!EVALUATED: `false`!>Array<List<Int>>(3) { listOf(it, it + 1) } as? Array<List<String>?> == null<!>
const val c8 = <!EVALUATED: `true`!>Array<List<Int>>(3) { listOf(it, it + 1) } as? Array<Set<Int>> == null<!>
const val d1 = arrayCast(arrayOf<Int>(1, 2, 3)).<!EVALUATED: `1`!>size<!>
const val d2 = arrayCast(*arrayOf<Int>(1, 2, 3)).<!EVALUATED: `3`!>size<!>
const val d3 = arrayCast<Int>(1, 2, 3).<!EVALUATED: `3`!>size<!>
const val d1 = <!EVALUATED: `1`!>arrayCast(arrayOf<Int>(1, 2, 3)).size<!>
const val d2 = <!EVALUATED: `3`!>arrayCast(*arrayOf<Int>(1, 2, 3)).size<!>
const val d3 = <!EVALUATED: `3`!>arrayCast<Int>(1, 2, 3).size<!>
compiler/testData/ir/interpreter/samConversion.kt
Vendored
+6 -6
View File
@@ -8,12 +8,12 @@ fun interface IntPredicate {
fun defaultMethod() = 1
}
const val isEven = IntPredicate { it % 2 == 0 }
.<!EVALUATED: `false, true, false, true, false`!>let { predicate -> listOf(1, 2, 3, 4, 5).map { predicate.accept(it) }.joinToString() }<!>
const val isOdd = IntPredicate { it % 2 != 0 }
.<!EVALUATED: `true, false, true, false, true`!>let { predicate -> listOf(1, 2, 3, 4, 5).map { predicate.accept(it) }.joinToString() }<!>
const val callToDefault = IntPredicate { false }.<!EVALUATED: `1`!>defaultMethod()<!>
const val callToString = IntPredicate { false }.<!EVALUATED: `(kotlin.Int) -> kotlin.Boolean`!>toString()<!>
const val isEven = <!EVALUATED: `false, true, false, true, false`!>IntPredicate { it % 2 == 0 }
.let { predicate -> listOf(1, 2, 3, 4, 5).map { predicate.accept(it) }.joinToString() }<!>
const val isOdd = <!EVALUATED: `true, false, true, false, true`!>IntPredicate { it % 2 != 0 }
.let { predicate -> listOf(1, 2, 3, 4, 5).map { predicate.accept(it) }.joinToString() }<!>
const val callToDefault = <!EVALUATED: `1`!>IntPredicate { false }.defaultMethod()<!>
const val callToString = <!EVALUATED: `(kotlin.Int) -> kotlin.Boolean`!>IntPredicate { false }.toString()<!>
@CompileTimeCalculation
fun interface KRunnable {
compiler/testData/ir/interpreter/scopeFunctions.kt
Vendored
+9 -9
View File
@@ -13,23 +13,23 @@ fun <T> echo(value: T): T = value
const val a = <!EVALUATED: `Run block`!>run { echo("Run block") }<!>
const val b = A(0, "Run with receiver").<!EVALUATED: `Run with receiver0`!>run { this.str + this.num }<!>
const val b = <!EVALUATED: `Run with receiver0`!>A(0, "Run with receiver").run { this.str + this.num }<!>
const val c = <!EVALUATED: `New String`!>with (A(1, "String")) {
setNewStr("New String")
this.str
}<!>
const val d = A(2, "Apply test").apply { this.setNewStr("New apply str") }.<!EVALUATED: `New apply str`!>str<!>
const val d = <!EVALUATED: `New apply str`!>A(2, "Apply test").apply { this.setNewStr("New apply str") }.str<!>
const val e = mutableListOf("one", "two", "three").also { it.add("four") }.<!EVALUATED: `4`!>size<!>
const val f1 = mutableListOf("one", "two", "three").<!EVALUATED: `4`!>let {
const val e = <!EVALUATED: `4`!>mutableListOf("one", "two", "three").also { it.add("four") }.size<!>
const val f1 = <!EVALUATED: `4`!>mutableListOf("one", "two", "three").let {
it.add("four")
it.size
}<!>
const val f2 = 10.<!EVALUATED: `20`!>let { it + 10 }<!>
const val f2 = <!EVALUATED: `20`!>10.let { it + 10 }<!>
const val g1 = 1.takeIf { it % 2 == 0 }.<!EVALUATED: `null`!>toString()<!>
const val g2 = 2.takeIf { it % 2 == 0 }.<!EVALUATED: `2`!>toString()<!>
const val h1 = (-1).takeUnless { it > 0 }.<!EVALUATED: `-1`!>toString()<!>
const val h2 = 1.takeUnless { it > 0 }.<!EVALUATED: `null`!>toString()<!>
const val g1 = <!EVALUATED: `null`!>1.takeIf { it % 2 == 0 }.toString()<!>
const val g2 = <!EVALUATED: `2`!>2.takeIf { it % 2 == 0 }.toString()<!>
const val h1 = <!EVALUATED: `-1`!>(-1).takeUnless { it > 0 }.toString()<!>
const val h2 = <!EVALUATED: `null`!>1.takeUnless { it > 0 }.toString()<!>
compiler/testData/ir/interpreter/secondaryConstructor.kt
Vendored
+10 -10
View File
@@ -20,17 +20,17 @@ class Person(val name: String, val surname: String) {
}
}
const val a1 = Person("Ivan", "Ivanov").<!EVALUATED: `-1`!>age<!>
const val a2 = Person("Ivan", "Ivanov").<!EVALUATED: `Ivan Ivanov`!>wholeName<!>
const val a1 = <!EVALUATED: `-1`!>Person("Ivan", "Ivanov").age<!>
const val a2 = <!EVALUATED: `Ivan Ivanov`!>Person("Ivan", "Ivanov").wholeName<!>
const val b1 = Person("Ivan").<!EVALUATED: `-1`!>age<!>
const val b2 = Person("Ivan").<!EVALUATED: `Ivan <NULL>`!>wholeName<!>
const val b1 = <!EVALUATED: `-1`!>Person("Ivan").age<!>
const val b2 = <!EVALUATED: `Ivan <NULL>`!>Person("Ivan").wholeName<!>
const val c1 = Person().<!EVALUATED: `-1`!>age<!>
const val c2 = Person().<!EVALUATED: `<NOT_GIVEN> <NULL>`!>wholeName<!>
const val c1 = <!EVALUATED: `-1`!>Person().age<!>
const val c2 = <!EVALUATED: `<NOT_GIVEN> <NULL>`!>Person().wholeName<!>
const val d1 = Person("Ivan", 20).<!EVALUATED: `20`!>age<!>
const val d2 = Person("Ivan", 20).<!EVALUATED: `Ivan <NULL>`!>wholeName<!>
const val d1 = <!EVALUATED: `20`!>Person("Ivan", 20).age<!>
const val d2 = <!EVALUATED: `Ivan <NULL>`!>Person("Ivan", 20).wholeName<!>
@CompileTimeCalculation
class A {
@@ -44,5 +44,5 @@ class A {
}
}
const val e1 = A(true).<!EVALUATED: `1`!>prop<!>
const val e2 = A(false).<!EVALUATED: `2`!>prop<!>
const val e1 = <!EVALUATED: `1`!>A(true).prop<!>
const val e2 = <!EVALUATED: `2`!>A(false).prop<!>
compiler/testData/ir/interpreter/stringBuilder.kt
Vendored
+9 -9
View File
@@ -8,17 +8,17 @@ fun appendVararg(vararg strings: String): String {
}
const val simpleAppend = StringBuilder().append("str").<!EVALUATED: `str`!>toString()<!>
const val withCapacity = StringBuilder(7).append("example").<!EVALUATED: `example`!>toString()<!>
const val withContent = StringBuilder("first").append(" ").append("second").<!EVALUATED: `first second`!>toString()<!>
const val simpleAppend = <!EVALUATED: `str`!>StringBuilder().append("str").toString()<!>
const val withCapacity = <!EVALUATED: `example`!>StringBuilder(7).append("example").toString()<!>
const val withContent = <!EVALUATED: `first second`!>StringBuilder("first").append(" ").append("second").toString()<!>
const val appendInFun = <!EVALUATED: `1 2 3`!>appendVararg("1", " ", "2", " ", "3")<!>
const val length1 = StringBuilder(3).append("1").<!EVALUATED: `1`!>length<!>
const val length2 = StringBuilder().append("123456789").<!EVALUATED: `9`!>length<!>
const val get0 = StringBuilder().append("1234556789").<!EVALUATED: `1`!>get(0)<!>
const val get1 = StringBuilder().append("1234556789").<!EVALUATED: `2`!>get(1)<!>
const val length1 = <!EVALUATED: `1`!>StringBuilder(3).append("1").length<!>
const val length2 = <!EVALUATED: `9`!>StringBuilder().append("123456789").length<!>
const val get0 = <!EVALUATED: `1`!>StringBuilder().append("1234556789").get(0)<!>
const val get1 = <!EVALUATED: `2`!>StringBuilder().append("1234556789").get(1)<!>
const val subSequence1 = <!EVALUATED: `12`!>StringBuilder().append("123456789").subSequence(0, 2) as String<!>
const val subSequence2 = <!EVALUATED: `345678`!>StringBuilder().append("123456789").subSequence(2, 8) as String<!>
const val appendPart = StringBuilder().append("123456789", 1, 3).<!EVALUATED: `23`!>toString()<!>
const val appendNull = StringBuilder().append(null as Any?).<!EVALUATED: `null`!>toString()<!>
const val appendPart = <!EVALUATED: `23`!>StringBuilder().append("123456789", 1, 3).toString()<!>
const val appendNull = <!EVALUATED: `null`!>StringBuilder().append(null as Any?).toString()<!>
compiler/testData/ir/interpreter/stringConcatenation.kt
Vendored
+1 -1
View File
@@ -56,7 +56,7 @@ const val concatLambda5 = <!EVALUATED: `(kotlin.Int?) -> kotlin.String?`!>"" + f
const val concatLambda6 = <!EVALUATED: `(kotlin.Int) -> kotlin.String`!>"" + { i: Int -> "" }<!>
const val concatLambda7 = <!EVALUATED: `() -> kotlin.Unit`!>"" + { }<!>
const val concatLambda8 = <!EVALUATED: `(kotlin.Int, kotlin.Double, kotlin.String) -> kotlin.Unit`!>"" + { i: Int, b: Double, c: String -> }<!>
const val concatLambda9 = "".<!EVALUATED: `kotlin.Double.(kotlin.Int) -> kotlin.String`!>let {
const val concatLambda9 = <!EVALUATED: `kotlin.Double.(kotlin.Int) -> kotlin.String`!>"".let {
val lambdaWith: Double.(Int) -> String = { "A" }
lambdaWith.toString()
}<!>
compiler/testData/ir/interpreter/superClass.kt
Vendored
+16 -16
View File
@@ -48,23 +48,23 @@ open class E @CompileTimeCalculation constructor(val e: Int) : D(e + 1) {
}
const val a1 = A(1).<!EVALUATED: `1`!>get()<!>
const val a2 = A(1).setA(2).<!EVALUATED: `2`!>get()<!>
const val a3 = A(1).<!EVALUATED: `1`!>openGet()<!>
const val a4 = A(1).<!EVALUATED: `1`!>a<!> // property inherits compile-time annotation from primary constructor
const val a1 = <!EVALUATED: `1`!>A(1).get()<!>
const val a2 = <!EVALUATED: `2`!>A(1).setA(2).get()<!>
const val a3 = <!EVALUATED: `1`!>A(1).openGet()<!>
const val a4 = <!EVALUATED: `1`!>A(1).a<!> // property inherits compile-time annotation from primary constructor
const val b1 = B(1).<!EVALUATED: `2`!>getAFromB()<!>
const val b2 = B(1).<!EVALUATED: `10`!>getFromValueParameter(A(10))<!>
const val b3 = B(1).<!EVALUATED: `2`!>get()<!> //fake overridden
const val b4 = B(1).setA(-1).<!EVALUATED: `-1`!>get()<!>
const val b1 = <!EVALUATED: `2`!>B(1).getAFromB()<!>
const val b2 = <!EVALUATED: `10`!>B(1).getFromValueParameter(A(10))<!>
const val b3 = <!EVALUATED: `2`!>B(1).get()<!> //fake overridden
const val b4 = <!EVALUATED: `-1`!>B(1).setA(-1).get()<!>
const val c1 = C(1).<!EVALUATED: `3`!>getAFromC()<!>
const val c2 = C(1).<!EVALUATED: `3`!>get()<!> //fake overridden
const val c3 = C(1).<!EVALUATED: `3`!>openGet()<!>
const val c4 = C(1).<!EVALUATED: `3`!>getAFromB()<!>
const val c5 = C(1).<!EVALUATED: `10`!>getFromValueParameter(A(10))<!> //method from B
const val c6 = C(1).setA(-2).<!EVALUATED: `-2`!>get()<!>
const val c1 = <!EVALUATED: `3`!>C(1).getAFromC()<!>
const val c2 = <!EVALUATED: `3`!>C(1).get()<!> //fake overridden
const val c3 = <!EVALUATED: `3`!>C(1).openGet()<!>
const val c4 = <!EVALUATED: `3`!>C(1).getAFromB()<!>
const val c5 = <!EVALUATED: `10`!>C(1).getFromValueParameter(A(10))<!> //method from B
const val c6 = <!EVALUATED: `-2`!>C(1).setA(-2).get()<!>
// test deep fake overridden
const val d1 = D(1).<!EVALUATED: `4`!>get()<!>
const val e1 = E(1).<!EVALUATED: `5`!>get()<!>
const val d1 = <!EVALUATED: `4`!>D(1).get()<!>
const val e1 = <!EVALUATED: `5`!>E(1).get()<!>
compiler/testData/ir/interpreter/unitResult.kt
Vendored
+6 -6
View File
@@ -4,9 +4,9 @@
@CompileTimeCalculation fun getUnitImplicitFromTry1(): Unit { try {} finally { 5 } }
@CompileTimeCalculation fun getUnitImplicitFromTry2(): Unit { try {} finally { } }
const val unit1 = Unit.<!EVALUATED: `kotlin.Unit`!>toString()<!>
const val unit2 = getUnitImplicit().<!EVALUATED: `kotlin.Unit`!>toString()<!>
const val unit3 = getUnitExplicit().<!EVALUATED: `kotlin.Unit`!>toString()<!>
const val unit4 = getUnitImplicitFromExpression().<!EVALUATED: `kotlin.Unit`!>toString()<!>
const val unit5 = getUnitImplicitFromTry1().<!EVALUATED: `kotlin.Unit`!>toString()<!>
const val unit6 = getUnitImplicitFromTry2().<!EVALUATED: `kotlin.Unit`!>toString()<!>
const val unit1 = <!EVALUATED: `kotlin.Unit`!>Unit.toString()<!>
const val unit2 = <!EVALUATED: `kotlin.Unit`!>getUnitImplicit().toString()<!>
const val unit3 = <!EVALUATED: `kotlin.Unit`!>getUnitExplicit().toString()<!>
const val unit4 = <!EVALUATED: `kotlin.Unit`!>getUnitImplicitFromExpression().toString()<!>
const val unit5 = <!EVALUATED: `kotlin.Unit`!>getUnitImplicitFromTry1().toString()<!>
const val unit6 = <!EVALUATED: `kotlin.Unit`!>getUnitImplicitFromTry2().toString()<!>
compiler/testData/ir/interpreter/withReceivers.kt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ fun <T : Number> plus(a: Temp<T>, b: Temp<T>): Double {
}
}
const val a1 = Temp<Int>(1).<!EVALUATED: `3.0`!>plus(Temp<Double>(2.0))<!>
const val a1 = <!EVALUATED: `3.0`!>Temp<Int>(1).plus(Temp<Double>(2.0))<!>
const val a2 = <!EVALUATED: `7.0`!>plus(Temp<Int>(3), Temp<Int>(4))<!>
compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInterpreterBackendHandler.kt
+7 -3
View File
@@ -39,7 +39,7 @@ open class IrInterpreterBackendHandler(testServices: TestServices) : AbstractIrH
private class Evaluator(private val interpreter: IrInterpreter, private val globalMetadataInfoHandler: GlobalMetadataInfoHandler) {
fun evaluate(irFile: IrFile, testFile: TestFile) {
object : IrElementTransformerVoid() {
private fun IrExpression.report(original: IrExpression): IrExpression {
private fun IrExpression.report(original: IrExpression, startOffsetForDiagnostic: Int? = null): IrExpression {
if (this == original) return this
val isError = this is IrErrorExpression
val message = when (this) {
@@ -48,9 +48,10 @@ private class Evaluator(private val interpreter: IrInterpreter, private val glob
else -> TODO("unsupported type ${this::class.java}")
}
val startOffset = when {
startOffsetForDiagnostic != null -> startOffsetForDiagnostic
// this additional check is needed to unify rendering from old and new frontends
original is IrCall && original.symbol.owner.fqNameWhenAvailable?.asString() == "kotlin.internal.ir.CHECK_NOT_NULL" -> endOffset - 2
else -> startOffset
else -> original.startOffset
}
val metaInfo = IrInterpreterCodeMetaInfo(startOffset, this.endOffset, message, isError)
globalMetadataInfoHandler.addMetadataInfosForFile(testFile, listOf(metaInfo))
@@ -82,7 +83,10 @@ private class Evaluator(private val interpreter: IrInterpreter, private val glob
if (expression is IrConst<*>) return declaration
val isConst = declaration.correspondingPropertySymbol?.owner?.isConst == true
if (isConst) initializer.expression = interpreter.interpret(expression, irFile).report(expression)
if (isConst) {
val startOffsetForDiagnostic = declaration.startOffset + "const val = ".length + declaration.name.asString().length
initializer.expression = interpreter.interpret(expression, irFile).report(expression, startOffsetForDiagnostic)
}
return declaration
}
}.visitFile(irFile)