review fix

compiler/tests-spec/build.gradle.kts

@@ -10,6 +10,7 @@ dependencies {
         testRuntimeOnly(intellijPluginDep("java"))
     }
     compile("org.jsoup:jsoup:1.10.3")
+    if (System.getProperty("idea.active") != null) testRuntimeOnly(files("${rootProject.projectDir}/dist/kotlinc/lib/kotlin-reflect.jar"))
 }
 
 sourceSets {

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.1.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +NewInference
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check kotlin.Nothing by throwing the exception
+ */
+
+fun foo(): Nothing {
+    throw Exception()
+}
+
+fun box(): String {
+    try {
+        foo()
+    } catch (e: Exception) {
+        return "OK"
+    }
+    return "NOK"
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.10.kt

@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 10
+ * DESCRIPTION: ckeck a common type of String and Nothing is String
+ */
+
+
+fun box(): String {
+    var name: Any? = null
+    val men = arrayListOf(Man("Phill"), Man())
+    loop@ for (i in men) {
+        name = i.name ?: break@loop
+    }
+    if (name is String?) return "OK"
+    return "NOK"
+}
+
+private class Man(var name: String? = null) {}

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.2.kt

@@ -0,0 +1,21 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION:
+ */
+
+fun box(): String {
+    try {
+        exit()
+    } catch (e: NullPointerException) {
+        return "OK"
+    }
+    return "NOK"
+}
+
+fun exit(): Nothing = null!!

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.3.kt

@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION:
+ */
+
+fun box(): String {
+    val bar = ::exit
+    try {
+        bar()
+    } catch (e: NotImplementedError) {
+        return "OK"
+    }
+    return "NOK"
+}
+
+
+private fun exit(): Nothing = TODO()

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.4.kt

@@ -0,0 +1,25 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 4
+ * DESCRIPTION:
+ */
+
+
+fun box(): String {
+    val bar = ::exit
+    try {
+        bar(enter())
+    } catch (e: NotImplementedError) {
+        return "OK"
+    }
+    return "NOK"
+}
+
+
+private fun exit(x: () -> Any?): Nothing = throw Exception(x().toString())
+private fun enter(): Nothing = TODO()

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.5.kt

@@ -0,0 +1,30 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 5
+ * DESCRIPTION:
+ */
+
+
+fun box(): String {
+    val person = Person("Elvis")
+    person.name
+    try {
+        person.name = null
+        person.name ?: throwException("Name is required")
+    } catch (e: IllegalArgumentException) {
+        return "OK"
+    }
+    return "NOK"
+}
+
+class Person(var name: String?) {}
+
+fun throwException(m: String): Nothing {
+    throw  IllegalArgumentException(m)
+}
+

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.6.kt

@@ -0,0 +1,36 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 6
+ * DESCRIPTION:
+ */
+
+
+fun box(): String {
+    val info = Info<String>()
+    info.getData { "text " }
+    val infoUseless = InfoUseless()
+    try {
+        infoUseless.getData { throw  IllegalArgumentException() }
+    } catch (e: IllegalArgumentException) {
+        return "OK"
+    }
+    return "NOK"
+}
+
+interface Infoable<T> {
+    fun getData(d: () -> T): T
+}
+
+open class Info<T : CharSequence> : Infoable<T> {
+    override fun getData(d: () -> T): T {
+        return d()
+    }
+}
+
+class InfoUseless : Info<Nothing>() {}
+

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.7.kt

@@ -0,0 +1,33 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 7
+ * DESCRIPTION:
+ */
+
+import java.util.*
+
+fun box() : String{
+    val deque1 = ArrayDeque<Any>()
+    val deque2 = ArrayDeque<Any>()
+    deque1.add { throw IllegalArgumentException() }
+    deque1.add { throw NullPointerException() }
+    deque1.add { TODO() }
+    move(deque1, deque2)
+    val v = deque2.first as () -> Nothing
+    try {
+        v.invoke()
+    } catch (e: NotImplementedError) {
+        return "OK"
+    }
+    return "NOK"
+}
+
+fun <T> move(from: ArrayDeque<out T>, to: ArrayDeque<in T>) {
+    to.add(from.last())
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.8.kt

@@ -0,0 +1,37 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 8
+ * DESCRIPTION:
+ */
+
+fun box(): String {
+    val c = Class()
+    try {
+        val a: () -> Nothing = c.data
+        a.invoke()
+    } catch (e: IllegalArgumentException) {
+        try {
+            val d: () -> Nothing = c.value
+            d()
+        } catch (e: NotImplementedError) {
+            return "OK"
+        }
+
+    }
+    return "NOK"
+}
+
+open class Class() {
+    var data: () -> Nothing = { throwException("data") as Nothing }
+    val value: () -> Nothing
+        get() = { TODO() as Nothing }
+}
+
+private fun throwException(m: String): Any {
+    throw  IllegalArgumentException(m)
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.9.kt

@@ -0,0 +1,52 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 9
+ * DESCRIPTION:
+ */
+
+fun box(): String {
+    try {
+        val city = City()
+    } catch (e: NotImplementedError) {
+        val city = City("", 1)
+
+        city.country
+        try {
+            city.lakeConsumer()
+        } catch (e: NotImplementedError) {
+            try {
+                city.streetsConsumer.stream().forEach { street -> street.invoke() }
+            } catch (e: IllegalArgumentException) {
+                try {
+                    val city = City("", 2) { "lake" }
+                    city.streetsConsumer[3].invoke()
+                } catch (e: UnsupportedOperationException) {
+                    return "OK"
+                }
+            }
+        }
+    }
+    return "NOK"
+}
+
+class City(val name: String = "", val index: Any = TODO()) {
+    var country: String = "Rus"
+    var lakeConsumer: () -> String
+    var streetsConsumer: MutableList<() -> String>
+
+    init {
+        lakeConsumer = { TODO() }
+        streetsConsumer = mutableListOf({ "x" }, { "y" }, { throw IllegalArgumentException() })
+    }
+
+    constructor(name: String, index: Any, lakeConsumer: () -> String) : this(name, index) {
+        this.lakeConsumer = lakeConsumer
+        this.streetsConsumer.add { throw UnsupportedOperationException() }
+    }
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/testsMap.json

@@ -0,0 +1,68 @@
+{
+  "1": {
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "ckeck a common type of String and Nothing is String",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check kotlin.Nothing by throwing the exception",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos/1.1.kt

@@ -0,0 +1,36 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * RELEVANT PLACES: expressions, equality-expressions, reference-equality-expressions -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: check  all values of type kotlin.Unit should reference the same underlying kotlin.Unit object.
+ */
+
+fun foo1() {
+    return Unit
+}
+
+fun foo2(): Unit {
+    return Unit
+}
+
+fun foo3(): Unit {
+}
+
+fun box(): String {
+    val u1 = foo1()
+    val u2 = foo2()
+    val u3 = foo3()
+    val u4 = Unit
+    if (u1 === u2 && u1 === u3 && u1 === u4
+        && u2 === u3 && u2 === u4
+        && u3 === u4
+    ) {
+        return ("OK")
+    }
+    return ("NOK")
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/testsMap.json

@@ -0,0 +1,56 @@
+{
+  "1": {
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if two values are equal (\u003d\u003d\u003d) by reference",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.1.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "two values are equal (\u003d\u003d\u003d) or non-equal (!\u003d\u003d) by reference",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.5.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if values are non-equal (!\u003d\u003d) by reference",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.4.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check equallity by refference via constructor",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/3.1.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if two values are non-equal (!\u003d\u003d) by reference",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.3.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if two values are equal (\u003d\u003d\u003d) by reference",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.2.kt",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check  all values of type kotlin.Unit should reference the same underlying kotlin.Unit object.",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1/pos/1.1.kt

@@ -0,0 +1,30 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, cast-expression -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check of the cast operators as or as?
+ */
+
+fun box(): String {
+    val c = Class()
+    if (c.data !is () -> Nothing) return "NOK"
+    val e1 : () -> Nothing = c.exception as () -> Nothing as? () -> Nothing ?: return "NOK"
+    val v = c.value as () -> Nothing as? () -> Nothing ?: return "NOK"
+
+    return "OK"
+}
+
+open class Class() {
+    var data: () -> Nothing = { throwException("boo") as Nothing }
+    var exception: () -> CharSequence = { throwException("foo") as String }
+    val value: () -> Any
+        get() = { TODO() as Nothing }
+}
+
+private fun throwException(m: String): Any {
+    throw  IllegalArgumentException(m)
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/testsMap.json

@@ -0,0 +1,14 @@
+{
+  "1": {
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": " check of the cast operators as or as?",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.1.kt

@@ -0,0 +1,28 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, equality-expressions, reference-equality-expressions -> paragraph 1 -> sentence 2
+ * RELEVANT PLACES:  expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check if two values are equal (===) by reference
+ */
+
+fun box(): String {
+    val u1 = foo1()
+    val u2 = foo2()
+    if (u1 === u2) {
+        return ("OK")
+    }
+    return ("NOK")
+}
+
+fun foo1() {
+    return Unit
+}
+
+fun foo2(): Unit {
+    return Unit
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.2.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, equality-expressions, reference-equality-expressions -> paragraph 1 -> sentence 2
+ * RELEVANT PLACES:  expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1,
+ * expressions, equality-expressions, reference-equality-expressions -> paragraph 3 -> sentence 3
+ * expressions, equality-expressions, reference-equality-expressions -> paragraph 2 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: check if two values are equal (===) by reference
+ */
+
+fun box(): String {
+    val u1 = "foo"
+    val u2 = "foo"
+    if (u1 === u2) {
+        return ("OK")
+    }
+    return ("NOK")
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.3.kt

@@ -0,0 +1,20 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, equality-expressions, reference-equality-expressions -> paragraph 1 -> sentence 2
+ * RELEVANT PLACES:  expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION: check if two values are non-equal (!==) by reference
+ */
+
+fun box(): String {
+    val u1 = "boo"
+    val u2 = "foo"
+    if (u1 !== u2) {
+        return ("OK")
+    }
+    return ("NOK")
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.4.kt

@@ -0,0 +1,24 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, equality-expressions, reference-equality-expressions -> paragraph 1 -> sentence 2
+ * RELEVANT PLACES: expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * NUMBER: 4
+ * DESCRIPTION: check if values are non-equal (!==) by reference
+ */
+
+fun box(): String {
+    val u1 = "foo"
+    val byteArray = "foo".toByteArray(Charsets.UTF_8)
+    val u2 = byteArray.toString()
+    val u3 = byteArray.toString()
+    if (u1 !== u2 && u1 !== u3 && u2 !== u3 &&
+        u2 !== u1 && u3 !== u1 && u3 !== u2
+    ) {
+        return ("OK")
+    }
+    return ("NOK")
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.5.kt

@@ -0,0 +1,29 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, equality-expressions, reference-equality-expressions -> paragraph 1 -> sentence 2
+ * RELEVANT PLACES:  expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * NUMBER: 5
+ * DESCRIPTION: two values are equal (===) or non-equal (!==) by reference
+ */
+
+fun box(): String {
+    val c1 = c
+    val c2 = c
+    val v1 = v
+    val v2 = v
+    if (c2 === c1 && c1 === c2 && c1 === c && c2 === c &&
+        v2 === v1 && v1 === v2 && v1 === v && v2 === v &&
+        v2 === c1 && v1 === c2 && v1 === c && v2 === c &&
+        c2 === v1 && c1 === v2 && c1 === v && c2 === v
+    ) {
+        return ("OK")
+    }
+    return ("NOK")
+}
+
+const val c = 1000
+const val v = 1000

compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/3.1.kt

@@ -0,0 +1,24 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, equality-expressions, reference-equality-expressions -> paragraph 1 -> sentence 3
+ * RELEVANT PLACES:  expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check equallity by refference via constructor
+ */
+
+fun box(): String {
+    val u2 = mutableListOf<Int>(1, 2, 3)
+    val u3 = u1
+    if (u1 !== u2 && u1 === u3
+    ) {
+        return ("OK")
+    }
+    return ("NOK")
+}
+
+val u1 = mutableListOf<Int>(1, 2, 3)
+

compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/testsMap.json

@@ -0,0 +1,53 @@
+{
+  "1": {
+    "pos": {
+      "2": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if two values are equal (\u003d\u003d\u003d) by reference",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "two values are equal (\u003d\u003d\u003d) or non-equal (!\u003d\u003d) by reference",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if values are non-equal (!\u003d\u003d) by reference",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if two values are non-equal (!\u003d\u003d) by reference",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check if two values are equal (\u003d\u003d\u003d) by reference",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check  all values of type kotlin.Unit should reference the same underlying kotlin.Unit object.",
+          "path": "compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos/1.1.kt",
+          "unexpectedBehaviour": false
+        }
+      ],
+      "3": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "check equallity by refference via constructor",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos/3.1.kt

@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, type-checking-and-containment-checking-expressions, type-checking-expression -> paragraph 1 -> sentence 3
+ * NUMBER: 1
+ * DESCRIPTION:checks whether the runtime type of E is not a subtype of T for !is operator.
+ */
+
+fun box(): String {
+    val bar = ::boo
+    val bar1 = ::exit
+    if (bar !is () -> Nothing && bar1 !is (Nothing) -> Nothing) return "NOK"
+
+    return "OK"
+}
+
+private fun boo(): Nothing = TODO()
+private fun exit(x: () -> Any?): Nothing = throw Exception(x().toString())
+private fun enter(): Nothing = TODO()
+

compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos/3.2.kt

@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, type-checking-and-containment-checking-expressions, type-checking-expression -> paragraph 1 -> sentence 3
+ * NUMBER: 2
+ * DESCRIPTION:checks whether the runtime type of EE is a subtype of TT for is operator
+ */
+
+fun box(): String {
+    val bar = ::boo
+    val bar1 = ::exit
+
+    if (bar is () -> Nothing && bar1 is (Nothing) -> Nothing) return "OK"
+
+    return "NOK"
+}
+
+private fun boo(): Nothing = TODO()
+private fun exit(x: () -> Any?): Nothing = throw Exception(x().toString())
+private fun enter(): Nothing = TODO()

compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/testsMap.json

@@ -0,0 +1,20 @@
+{
+  "1": {
+    "pos": {
+      "3": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "checks whether the runtime type of E is not a subtype of T for !is operator.",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "checks whether the runtime type of EE is a subtype of TT for is operator",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/1.1.kt

@@ -0,0 +1,20 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: type-system, type-kinds, built-in-types, kotlin.nothing -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: todo
+ */
+
+fun box(): String {
+    val b : Nothing?= null
+    try {
+        val a: Int = b!!
+    } catch (e: NullPointerException) {
+        return "OK"
+    }
+    return "NOK"
+}

compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/1.2.kt

@@ -0,0 +1,25 @@
+// WITH_RUNTIME
+
+/*
+ * KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: type-system, type-kinds, built-in-types, kotlin.nothing -> paragraph 1 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: check the allowance of returning Nothing where String is expected
+ */
+
+
+fun foo(s: String?): String {
+    return s ?: throw IllegalArgumentException("not null string is expected");
+}
+
+fun box(): String {
+    val b = foo("")
+    try {
+        val a = foo(null)
+    } catch (e: IllegalArgumentException) {
+        return "OK"
+    }
+    return "NOK"
+}

compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/testsMap.json

@@ -0,0 +1,20 @@
+{
+  "1": {
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "todo",
+          "unexpectedBehaviour": false
+        },
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 0,
+          "description": "todo",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.1.kt

@@ -0,0 +1,69 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check the type of jump expressions is Nothing and code placed on the left side of expression will never be executed
+ */
+
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    var name: Any? = null
+    val men = arrayListOf(Person("Phill"), Person(), Person("Bob"))
+    for (k in men) {
+        k.name
+        loop@ for (i in men) {
+            i.name
+            <!UNREACHABLE_CODE!>val valeua : Int =<!>     break@loop
+            <!UNREACHABLE_CODE!>i.name<!>
+        }
+        k.name
+        val s = k.name ?: break
+        k.name
+    }
+    val a = 1
+}
+
+class Person(var name: String? = null) {}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    var name: Any? = null
+    val men = arrayListOf(Person("Phill"), Person(), Person("Bob"))
+    for (k in men) {
+        loop@ for (i in men) {
+            i.name
+            <!UNREACHABLE_CODE!>val val1 =<!>    continue@loop
+            <!UNREACHABLE_CODE!>val1<!>
+            <!UNREACHABLE_CODE!>i.name<!>
+        }
+        val s = k.name ?: continue
+        k.name
+    }
+    val a = 1
+}
+
+// TESTCASE NUMBER: 3
+
+fun case3() {
+    listOf(1, 2, 3, 4, 5).forEach { x ->
+        val k = x
+
+        listOf(1, 2, 3, 4, 5).forEach lit@{
+            it
+            return@lit
+            <!UNREACHABLE_CODE!>print(it)<!>
+        }
+        val y = x
+        if (x == 3) return
+    }
+    val a = 1
+}

compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/testsMap.json

@@ -0,0 +1,14 @@
+{
+  "1": {
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 3,
+          "description": "check the type of jump expressions is Nothing and code placed on the left side of expression will never be executed",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/neg/1.1.kt

@@ -0,0 +1,44 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check kotlin.Unit is a unit type
+ * HELPERS: checkType
+ */
+
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    val unitInherited: UnitInherited = UnitInherited()
+}
+
+class UnitInherited : <!SINGLETON_IN_SUPERTYPE!>Unit<!> {}
+
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    val p2 = object : <!SINGLETON_IN_SUPERTYPE!>kotlin.Unit<!> {
+        override fun toString() = "inherited.Unit"
+    }
+}
+
+// TESTCASE NUMBER: 3
+
+fun case3() {
+    val aInherited: A<<!UPPER_BOUND_VIOLATED!>UnitInherited<!>> = A<<!UPPER_BOUND_VIOLATED!>UnitInherited<!>>()
+    val aOriginal: A<Unit> = A<Unit>()
+
+    val bInherited: B<<!UPPER_BOUND_VIOLATED!>UnitInherited<!>, UnitInherited> = B<<!UPPER_BOUND_VIOLATED!>UnitInherited<!>, UnitInherited>()
+    val bOriginal: B<Unit, Unit> = B<Unit, Unit>()
+}
+
+class A<T : <!FINAL_UPPER_BOUND!>Unit<!>> {}
+class B<T, K> where T : <!FINAL_UPPER_BOUND!>Unit<!>, K: Any{}

compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos/1.1.kt

@@ -0,0 +1,70 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, built-in-types-and-their-semantics, kotlin.unit -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: Check of Unit type
+ * HELPERS: checkType
+ */
+
+
+// TESTCASE NUMBER: 1
+
+fun foo() {}
+
+fun case1() {
+    foo() checkType { check<Unit>() }
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>foo()<!>
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2foo(m: String, bar: (m: String) -> Unit) {
+    bar(m)
+}
+
+
+class Case2Boo {
+    fun buz(m: String) {
+        val proc = m
+    }
+}
+
+
+fun case2() {
+    val boo = Case2Boo()
+    val res = case2foo("case 2", boo::buz)
+    res checkType { check<Unit>() }
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>res<!>
+}
+
+// TESTCASE NUMBER: 3
+interface Processable<T> {
+    fun process(): T
+}
+
+class Processor : Processable<Unit> {
+    override fun process() {}
+}
+
+fun case3() {
+    val p1 = Processor().process()
+    p1 checkType { check<Unit>() }
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>p1<!>
+}
+
+// TESTCASE NUMBER: 4
+
+fun case4() {
+    val p2 = object : Processable<Unit> {
+        override fun process() {}
+    }.process()
+    p2 checkType { check<Unit>() }
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>p2<!>
+}
+

compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/testsMap.json

@@ -0,0 +1,24 @@
+{
+  "1": {
+    "neg": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 3,
+          "description": "check kotlin.Unit is a unit type",
+          "unexpectedBehaviour": false
+        }
+      ]
+    },
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 4,
+          "description": "Check of Unit type",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos/1.1.kt

@@ -0,0 +1,57 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -UNREACHABLE_CODE
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: expressions, jump-expressions -> paragraph 2 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check he type of jump expressions is the kotlin.Nothing
+ */
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    var name: Any? = null
+    val men = arrayListOf(Person("Phill"), Person(), Person("Bob"))
+    for (k in men) {
+        k.name
+        loop@ for (i in men) {
+            val val1: Int = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>break@loop<!>
+            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>val1<!>
+        }
+        val s = k.name ?: <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>break<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String")!>s<!>
+    }
+}
+
+class Person(var name: String? = null) {}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    var name: Any? = null
+    val men = arrayListOf(Person("Phill"), Person(), Person("Bob"))
+    for (k in men) {
+        loop@ for (i in men) {
+            val val1 = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>continue@loop<!>
+            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>val1<!>
+        }
+        val s = k.name ?: <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>continue<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String")!>s<!>
+    }
+}
+
+// TESTCASE NUMBER: 3
+
+fun case3() {
+    listOf(1, 2, 3, 4, 5).forEach { x ->
+        listOf(1, 2, 3, 4, 5).forEach lit@{
+            val s = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>return@lit<!>
+            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>s<!>
+        }
+        if (x == 3) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>return<!>
+    }
+}

compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/testsMap.json

@@ -0,0 +1,14 @@
+{
+  "2": {
+    "pos": {
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 3,
+          "description": "check he type of jump expressions is the kotlin.Nothing",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/testsMap.json

@@ -6,12 +6,14 @@
           "specVersion": "0.1-100",
           "casesNumber": 11,
           "description": "The use of Boolean literals as the identifier (with backtick) in the class.",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos/1.2.kt",
           "unexpectedBehaviour": false
         },
         {
           "specVersion": "0.1-100",
           "casesNumber": 9,
           "description": "The use of Boolean literals as the identifier (with backtick) in the class.",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos/1.1.kt",
           "unexpectedBehaviour": false
         }
       ]

compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/testsMap.json

@@ -6,6 +6,7 @@
           "specVersion": "0.1-100",
           "casesNumber": 13,
           "description": "The use of Boolean literals as the identifier (with backtick) in the class.",
+          "path": "compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos/1.1.kt",
           "unexpectedBehaviour": false
         }
       ]

compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg/2.1.kt

@@ -0,0 +1,32 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -UNREACHABLE_CODE
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: type-system, type-kinds, built-in-types, kotlin.nothing -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Check of Nothing type
+ * HELPERS: checkType
+ */
+
+
+// TESTCASE NUMBER: 1
+class Case1(val nothing: Nothing)
+
+fun case1() {
+    val res = Case1(<!INVISIBLE_MEMBER!>Nothing<!>())
+}
+
+
+// TESTCASE NUMBER: 2
+class Case2 {
+    var data: String? = null
+}
+
+fun case2(c: Case2) {
+    val testValue = c.data ?: throw IllegalArgumentException("data required")
+    testValue checkType { <!NONE_APPLICABLE!>check<!><Nothing>() }
+}

compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/1.1.kt

@@ -0,0 +1,50 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -UNREACHABLE_CODE
+
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: type-system, type-kinds, built-in-types, kotlin.nothing -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: Check of Nothing type is a subtype of any types
+ * HELPERS: checkType, functions
+ */
+
+
+
+class NothingWrapper() {
+    val data: Nothing = TODO()
+}
+
+class CustomClass() {}
+
+// TESTCASE NUMBER: 1
+fun case1() {
+    val wrapper: NothingWrapper = NothingWrapper()
+    checkSubtype<Any>(wrapper.data)
+    checkSubtype<Any>(wrapper.data)
+
+    checkSubtype<Any>(wrapper.data)
+    checkSubtype<Function<Nothing>>(wrapper.data)
+    checkSubtype<Int>(wrapper.data)
+    checkSubtype<Short>(wrapper.data)
+    checkSubtype<Byte>(wrapper.data)
+    checkSubtype<Long>(wrapper.data)
+    checkSubtype<kotlin.Array<Any>>(wrapper.data)
+    checkSubtype<CustomClass>(wrapper.data)
+}
+
+// TESTCASE NUMBER: 2
+fun case2(wrapper: NothingWrapper) {
+    checkSubtype<MutableList<out Nothing>>(wrapper.data)
+    checkSubtype<MutableList<in String>>(wrapper.data)
+    checkSubtype<MutableList<out CustomClass>>(wrapper.data)
+    checkSubtype<MutableList<in CustomClass>>(wrapper.data)
+    checkSubtype<MutableList<Any?>>(wrapper.data)
+
+    checkSubtype<String>(wrapper.data)
+
+}

compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/2.1.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -UNREACHABLE_CODE
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * PLACE: type-system, type-kinds, built-in-types, kotlin.nothing -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Check of Nothing as a subtype of any type
+ * HELPERS: checkType, functions
+ */
+
+// TESTCASE NUMBER: 1
+class Case1 {
+    val data: Nothing = TODO()
+}
+
+fun case1(c: Case1) {
+    checkSubtype<Int>(c.data)
+    checkSubtype<Function<Nothing>>(c.data)
+}
+
+
+// TESTCASE NUMBER: 2
+class Case2 {
+    val dataFunction: Nothing = fail("fail msg")
+}
+
+fun fail(msg: String): Nothing {
+    throw Exception(msg)
+}
+
+fun case2(c: Case2) {
+    c.dataFunction checkType { check<Nothing>() }
+}

compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/testsMap.json

@@ -0,0 +1,32 @@
+{
+  "1": {
+    "neg": {
+      "2": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 2,
+          "description": "Check of Nothing type",
+          "unexpectedBehaviour": false
+        }
+      ]
+    },
+    "pos": {
+      "2": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 2,
+          "description": "Check of Nothing as a subtype of any type",
+          "unexpectedBehaviour": false
+        }
+      ],
+      "1": [
+        {
+          "specVersion": "0.1-213",
+          "casesNumber": 2,
+          "description": "Check of Nothing type is a subtype of any types",
+          "unexpectedBehaviour": false
+        }
+      ]
+    }
+  }
+}

compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.spec.codegen;
 import com.intellij.testFramework.TestDataPath;
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
-import org.jetbrains.kotlin.test.TargetBackend;
 import org.jetbrains.kotlin.test.TestMetadata;
 import org.junit.runner.RunWith;
 
@@ -22,11 +21,11 @@ import java.util.regex.Pattern;
 @RunWith(JUnit3RunnerWithInners.class)
 public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTestSpec {
     private void runTest(String testDataFilePath) throws Exception {
-        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
     }
 
     public void testAllFilesPresentInBox() throws Exception {
-        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true, "helpers", "templates");
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), true, "helpers", "templates");
     }
 
     @TestMetadata("compiler/tests-spec/testData/codegen/box/linked")
@@ -34,11 +33,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Linked extends AbstractBlackBoxCodegenTestSpec {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
         }
 
         public void testAllFilesPresentInLinked() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked"), Pattern.compile("^(.+)\\.kt$"), true);
         }
 
         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions")
@@ -46,11 +45,201 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Expressions extends AbstractBlackBoxCodegenTestSpec {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
             }
 
             public void testAllFilesPresentInExpressions() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+
+            @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Built_in_types_and_their_semantics extends AbstractBlackBoxCodegenTestSpec {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInBuilt_in_types_and_their_semantics() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class Kotlin_nothing_1 extends AbstractBlackBoxCodegenTestSpec {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInKotlin_nothing_1() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), true);
+                    }
+
+                    @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1")
+                    @TestDataPath("$PROJECT_ROOT")
+                    @RunWith(JUnit3RunnerWithInners.class)
+                    public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
+                        private void runTest(String testDataFilePath) throws Exception {
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                        }
+
+                        public void testAllFilesPresentInP_1() throws Exception {
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
+                        }
+
+                        @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos")
+                        @TestDataPath("$PROJECT_ROOT")
+                        @RunWith(JUnit3RunnerWithInners.class)
+                        public static class Pos extends AbstractBlackBoxCodegenTestSpec {
+                            private void runTest(String testDataFilePath) throws Exception {
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                            }
+
+                            @TestMetadata("1.1.kt")
+                            public void test1_1() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.1.kt");
+                            }
+
+                            @TestMetadata("1.10.kt")
+                            public void test1_10() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.10.kt");
+                            }
+
+                            @TestMetadata("1.2.kt")
+                            public void test1_2() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.2.kt");
+                            }
+
+                            @TestMetadata("1.3.kt")
+                            public void test1_3() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.3.kt");
+                            }
+
+                            @TestMetadata("1.4.kt")
+                            public void test1_4() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.4.kt");
+                            }
+
+                            @TestMetadata("1.5.kt")
+                            public void test1_5() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.5.kt");
+                            }
+
+                            @TestMetadata("1.6.kt")
+                            public void test1_6() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.6.kt");
+                            }
+
+                            @TestMetadata("1.7.kt")
+                            public void test1_7() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.7.kt");
+                            }
+
+                            @TestMetadata("1.8.kt")
+                            public void test1_8() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.8.kt");
+                            }
+
+                            @TestMetadata("1.9.kt")
+                            public void test1_9() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.9.kt");
+                            }
+
+                            public void testAllFilesPresentInPos() throws Exception {
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
+                            }
+                        }
+                    }
+                }
+
+                @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class Kotlin_unit extends AbstractBlackBoxCodegenTestSpec {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInKotlin_unit() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), true);
+                    }
+
+                    @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1")
+                    @TestDataPath("$PROJECT_ROOT")
+                    @RunWith(JUnit3RunnerWithInners.class)
+                    public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
+                        private void runTest(String testDataFilePath) throws Exception {
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                        }
+
+                        public void testAllFilesPresentInP_1() throws Exception {
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
+                        }
+
+                        @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos")
+                        @TestDataPath("$PROJECT_ROOT")
+                        @RunWith(JUnit3RunnerWithInners.class)
+                        public static class Pos extends AbstractBlackBoxCodegenTestSpec {
+                            private void runTest(String testDataFilePath) throws Exception {
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                            }
+
+                            @TestMetadata("1.1.kt")
+                            public void test1_1() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos/1.1.kt");
+                            }
+
+                            public void testAllFilesPresentInPos() throws Exception {
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
+                            }
+                        }
+                    }
+                }
+            }
+
+            @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Cast_expression extends AbstractBlackBoxCodegenTestSpec {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInCast_expression() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInP_1() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
+                    }
+
+                    @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1/pos")
+                    @TestDataPath("$PROJECT_ROOT")
+                    @RunWith(JUnit3RunnerWithInners.class)
+                    public static class Pos extends AbstractBlackBoxCodegenTestSpec {
+                        private void runTest(String testDataFilePath) throws Exception {
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                        }
+
+                        @TestMetadata("1.1.kt")
+                        public void test1_1() throws Exception {
+                            runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1/pos/1.1.kt");
+                        }
+
+                        public void testAllFilesPresentInPos() throws Exception {
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
+                        }
+                    }
+                }
             }
 
             @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals")
@@ -58,11 +247,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Constant_literals extends AbstractBlackBoxCodegenTestSpec {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInConstant_literals() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                 }
 
                 @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals")
@@ -70,11 +259,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Boolean_literals extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInBoolean_literals() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1")
@@ -82,11 +271,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_1() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1/pos")
@@ -94,7 +283,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("2.1.kt")
@@ -228,7 +417,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -239,11 +428,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Integer_literals extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInInteger_literals() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals")
@@ -251,11 +440,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Binary_integer_literals extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInBinary_integer_literals() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1")
@@ -263,11 +452,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             public void testAllFilesPresentInP_1() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
 
                             @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos")
@@ -275,7 +464,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -289,7 +478,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                                 }
 
                                 public void testAllFilesPresentInPos() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
                         }
@@ -300,11 +489,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Decimal_integer_literals extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInDecimal_integer_literals() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1")
@@ -312,11 +501,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             public void testAllFilesPresentInP_1() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
 
                             @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos")
@@ -324,7 +513,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -338,7 +527,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                                 }
 
                                 public void testAllFilesPresentInPos() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
                         }
@@ -349,11 +538,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Hexadecimal_integer_literals extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInHexadecimal_integer_literals() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1")
@@ -361,11 +550,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             public void testAllFilesPresentInP_1() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
 
                             @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos")
@@ -373,7 +562,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -387,7 +576,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                                 }
 
                                 public void testAllFilesPresentInPos() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
                         }
@@ -399,11 +588,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Real_literals extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInReal_literals() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1")
@@ -411,11 +600,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_1() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1/pos")
@@ -423,7 +612,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -437,7 +626,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -447,11 +636,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_2 extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_2() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2/pos")
@@ -459,7 +648,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -473,7 +662,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -483,11 +672,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_3 extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_3() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3/pos")
@@ -495,7 +684,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -534,7 +723,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -544,11 +733,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_4 extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_4() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4/pos")
@@ -556,7 +745,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -585,7 +774,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -596,11 +785,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class The_types_for_integer_literals extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInThe_types_for_integer_literals() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1")
@@ -608,11 +797,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_1() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos")
@@ -620,7 +809,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -639,7 +828,151 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
+                            }
+                        }
+                    }
+                }
+            }
+
+            @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Equality_expressions extends AbstractBlackBoxCodegenTestSpec {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInEquality_expressions() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class Reference_equality_expressions extends AbstractBlackBoxCodegenTestSpec {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInReference_equality_expressions() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), true);
+                    }
+
+                    @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1")
+                    @TestDataPath("$PROJECT_ROOT")
+                    @RunWith(JUnit3RunnerWithInners.class)
+                    public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
+                        private void runTest(String testDataFilePath) throws Exception {
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                        }
+
+                        public void testAllFilesPresentInP_1() throws Exception {
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
+                        }
+
+                        @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos")
+                        @TestDataPath("$PROJECT_ROOT")
+                        @RunWith(JUnit3RunnerWithInners.class)
+                        public static class Pos extends AbstractBlackBoxCodegenTestSpec {
+                            private void runTest(String testDataFilePath) throws Exception {
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                            }
+
+                            @TestMetadata("2.1.kt")
+                            public void test2_1() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.1.kt");
+                            }
+
+                            @TestMetadata("2.2.kt")
+                            public void test2_2() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.2.kt");
+                            }
+
+                            @TestMetadata("2.3.kt")
+                            public void test2_3() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.3.kt");
+                            }
+
+                            @TestMetadata("2.4.kt")
+                            public void test2_4() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.4.kt");
+                            }
+
+                            @TestMetadata("2.5.kt")
+                            public void test2_5() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/2.5.kt");
+                            }
+
+                            @TestMetadata("3.1.kt")
+                            public void test3_1() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos/3.1.kt");
+                            }
+
+                            public void testAllFilesPresentInPos() throws Exception {
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
+                            }
+                        }
+                    }
+                }
+            }
+
+            @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Type_checking_and_containment_checking_expressions extends AbstractBlackBoxCodegenTestSpec {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInType_checking_and_containment_checking_expressions() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class Type_checking_expression extends AbstractBlackBoxCodegenTestSpec {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInType_checking_expression() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), true);
+                    }
+
+                    @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1")
+                    @TestDataPath("$PROJECT_ROOT")
+                    @RunWith(JUnit3RunnerWithInners.class)
+                    public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
+                        private void runTest(String testDataFilePath) throws Exception {
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                        }
+
+                        public void testAllFilesPresentInP_1() throws Exception {
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
+                        }
+
+                        @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos")
+                        @TestDataPath("$PROJECT_ROOT")
+                        @RunWith(JUnit3RunnerWithInners.class)
+                        public static class Pos extends AbstractBlackBoxCodegenTestSpec {
+                            private void runTest(String testDataFilePath) throws Exception {
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                            }
+
+                            @TestMetadata("3.1.kt")
+                            public void test3_1() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos/3.1.kt");
+                            }
+
+                            @TestMetadata("3.2.kt")
+                            public void test3_2() throws Exception {
+                                runTest("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos/3.2.kt");
+                            }
+
+                            public void testAllFilesPresentInPos() throws Exception {
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -652,11 +985,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Type_system extends AbstractBlackBoxCodegenTestSpec {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
             }
 
             public void testAllFilesPresentInType_system() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
             @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1")
@@ -664,11 +997,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Introduction_1 extends AbstractBlackBoxCodegenTestSpec {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInIntroduction_1() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), true);
                 }
 
                 @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5")
@@ -676,11 +1009,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class P_5 extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInP_5() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5/pos")
@@ -688,7 +1021,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                         }
 
                         @TestMetadata("2.1.kt")
@@ -697,7 +1030,82 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                         }
 
                         public void testAllFilesPresentInPos() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), true);
+                        }
+                    }
+                }
+            }
+
+            @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Type_kinds extends AbstractBlackBoxCodegenTestSpec {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInType_kinds() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+
+                @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types")
+                @TestDataPath("$PROJECT_ROOT")
+                @RunWith(JUnit3RunnerWithInners.class)
+                public static class Built_in_types extends AbstractBlackBoxCodegenTestSpec {
+                    private void runTest(String testDataFilePath) throws Exception {
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                    }
+
+                    public void testAllFilesPresentInBuilt_in_types() throws Exception {
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), true);
+                    }
+
+                    @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing")
+                    @TestDataPath("$PROJECT_ROOT")
+                    @RunWith(JUnit3RunnerWithInners.class)
+                    public static class Kotlin_nothing extends AbstractBlackBoxCodegenTestSpec {
+                        private void runTest(String testDataFilePath) throws Exception {
+                            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                        }
+
+                        public void testAllFilesPresentInKotlin_nothing() throws Exception {
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), true);
+                        }
+
+                        @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1")
+                        @TestDataPath("$PROJECT_ROOT")
+                        @RunWith(JUnit3RunnerWithInners.class)
+                        public static class P_1 extends AbstractBlackBoxCodegenTestSpec {
+                            private void runTest(String testDataFilePath) throws Exception {
+                                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                            }
+
+                            public void testAllFilesPresentInP_1() throws Exception {
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
+                            }
+
+                            @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos")
+                            @TestDataPath("$PROJECT_ROOT")
+                            @RunWith(JUnit3RunnerWithInners.class)
+                            public static class Pos extends AbstractBlackBoxCodegenTestSpec {
+                                private void runTest(String testDataFilePath) throws Exception {
+                                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                                }
+
+                                @TestMetadata("1.1.kt")
+                                public void test1_1() throws Exception {
+                                    runTest("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/1.1.kt");
+                                }
+
+                                @TestMetadata("1.2.kt")
+                                public void test1_2() throws Exception {
+                                    runTest("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/1.2.kt");
+                                }
+
+                                public void testAllFilesPresentInPos() throws Exception {
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
+                                }
+                            }
                         }
                     }
                 }
@@ -710,11 +1118,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
     @RunWith(JUnit3RunnerWithInners.class)
     public static class NotLinked extends AbstractBlackBoxCodegenTestSpec {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
         }
 
         public void testAllFilesPresentInNotLinked() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked"), Pattern.compile("^(.+)\\.kt$"), true);
         }
 
         @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/annotations")
@@ -722,11 +1130,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Annotations extends AbstractBlackBoxCodegenTestSpec {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
             }
 
             public void testAllFilesPresentInAnnotations() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
             @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations")
@@ -734,11 +1142,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Type_annotations extends AbstractBlackBoxCodegenTestSpec {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInType_annotations() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), true);
                 }
 
                 @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations/neg")
@@ -746,7 +1154,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Neg extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     @TestMetadata("1.kt")
@@ -805,7 +1213,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     }
 
                     public void testAllFilesPresentInNeg() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
                 }
             }
@@ -816,11 +1224,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Objects extends AbstractBlackBoxCodegenTestSpec {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
             }
 
             public void testAllFilesPresentInObjects() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
             @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance")
@@ -828,11 +1236,11 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Inheritance extends AbstractBlackBoxCodegenTestSpec {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInInheritance() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance"), Pattern.compile("^(.+)\\.kt$"), true);
                 }
 
                 @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/neg")
@@ -840,7 +1248,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Neg extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     @TestMetadata("1.kt")
@@ -939,7 +1347,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     }
 
                     public void testAllFilesPresentInNeg() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
                 }
 
@@ -948,7 +1356,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Pos extends AbstractBlackBoxCodegenTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
                     }
 
                     @TestMetadata("1.kt")
@@ -962,7 +1370,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes
                     }
 
                     public void testAllFilesPresentInPos() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
                 }
             }

compiler/tests-spec/tests/org/jetbrains/kotlin/spec/parsing/ParsingTestSpecGenerated.java

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.spec.parsing;
 import com.intellij.testFramework.TestDataPath;
 import org.jetbrains.kotlin.test.JUnit3RunnerWithInners;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
-import org.jetbrains.kotlin.test.TargetBackend;
 import org.jetbrains.kotlin.test.TestMetadata;
 import org.junit.runner.RunWith;
 
@@ -22,11 +21,11 @@ import java.util.regex.Pattern;
 @RunWith(JUnit3RunnerWithInners.class)
 public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
     private void runTest(String testDataFilePath) throws Exception {
-        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
     }
 
     public void testAllFilesPresentInPsi() throws Exception {
-        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true, "helpers", "templates");
+        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi"), Pattern.compile("^(.+)\\.kt$"), true, "helpers", "templates");
     }
 
     @TestMetadata("compiler/tests-spec/testData/psi/linked")
@@ -34,11 +33,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Linked extends AbstractParsingTestSpec {
         private void runTest(String testDataFilePath) throws Exception {
-            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
         }
 
         public void testAllFilesPresentInLinked() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked"), Pattern.compile("^(.+)\\.kt$"), true);
         }
 
         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions")
@@ -46,11 +45,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Expressions extends AbstractParsingTestSpec {
             private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
             }
 
             public void testAllFilesPresentInExpressions() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), true);
             }
 
             @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals")
@@ -58,11 +57,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Constant_literals extends AbstractParsingTestSpec {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInConstant_literals() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                 }
 
                 @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals")
@@ -70,11 +69,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Integer_literals extends AbstractParsingTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInInteger_literals() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals")
@@ -82,11 +81,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Binary_integer_literals extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInBinary_integer_literals() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1")
@@ -94,11 +93,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class P_1 extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             public void testAllFilesPresentInP_1() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
 
                             @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg")
@@ -106,7 +105,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Neg extends AbstractParsingTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -125,7 +124,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                                 }
 
                                 public void testAllFilesPresentInNeg() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
 
@@ -134,7 +133,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Pos extends AbstractParsingTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -173,7 +172,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                                 }
 
                                 public void testAllFilesPresentInPos() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
                         }
@@ -184,11 +183,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Decimal_integer_literals extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInDecimal_integer_literals() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1")
@@ -196,11 +195,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class P_1 extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             public void testAllFilesPresentInP_1() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
 
                             @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg")
@@ -208,7 +207,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Neg extends AbstractParsingTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -217,7 +216,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                                 }
 
                                 public void testAllFilesPresentInNeg() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
 
@@ -226,7 +225,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Pos extends AbstractParsingTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -250,7 +249,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                                 }
 
                                 public void testAllFilesPresentInPos() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
                         }
@@ -260,11 +259,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class P_2 extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             public void testAllFilesPresentInP_2() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
 
                             @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2/neg")
@@ -272,11 +271,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Neg extends AbstractParsingTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                                 }
 
                                 public void testAllFilesPresentInNeg() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
                         }
@@ -287,11 +286,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Hexadecimal_integer_literals extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInHexadecimal_integer_literals() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1")
@@ -299,11 +298,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class P_1 extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             public void testAllFilesPresentInP_1() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
 
                             @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg")
@@ -311,7 +310,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Neg extends AbstractParsingTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -330,7 +329,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                                 }
 
                                 public void testAllFilesPresentInNeg() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
 
@@ -339,7 +338,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             @RunWith(JUnit3RunnerWithInners.class)
                             public static class Pos extends AbstractParsingTestSpec {
                                 private void runTest(String testDataFilePath) throws Exception {
-                                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                                 }
 
                                 @TestMetadata("1.1.kt")
@@ -373,7 +372,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                                 }
 
                                 public void testAllFilesPresentInPos() throws Exception {
-                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                                 }
                             }
                         }
@@ -385,11 +384,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class Real_literals extends AbstractParsingTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInReal_literals() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1")
@@ -397,11 +396,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_1 extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_1() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/neg")
@@ -409,7 +408,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Neg extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -458,7 +457,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInNeg() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
 
@@ -467,7 +466,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -491,7 +490,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -501,11 +500,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_2 extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_2() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/neg")
@@ -513,7 +512,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Neg extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -537,7 +536,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInNeg() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
 
@@ -546,7 +545,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -580,7 +579,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -590,11 +589,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_3 extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_3() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/neg")
@@ -602,7 +601,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Neg extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -641,7 +640,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInNeg() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
 
@@ -650,7 +649,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -704,7 +703,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -714,11 +713,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_4 extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_4() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/neg")
@@ -726,7 +725,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Neg extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -750,7 +749,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInNeg() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
 
@@ -759,7 +758,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -813,7 +812,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -823,11 +822,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_6 extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_6() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6/neg")
@@ -835,7 +834,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Neg extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -844,7 +843,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInNeg() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -855,11 +854,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class The_types_for_integer_literals extends AbstractParsingTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInThe_types_for_integer_literals() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1")
@@ -867,11 +866,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class P_1 extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         public void testAllFilesPresentInP_1() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
 
                         @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg")
@@ -879,7 +878,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Neg extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -903,7 +902,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInNeg() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
 
@@ -912,7 +911,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         @RunWith(JUnit3RunnerWithInners.class)
                         public static class Pos extends AbstractParsingTestSpec {
                             private void runTest(String testDataFilePath) throws Exception {
-                                KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                                KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                             }
 
                             @TestMetadata("1.1.kt")
@@ -966,7 +965,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                             }
 
                             public void testAllFilesPresentInPos() throws Exception {
-                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                             }
                         }
                     }
@@ -978,11 +977,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
             @RunWith(JUnit3RunnerWithInners.class)
             public static class When_expression extends AbstractParsingTestSpec {
                 private void runTest(String testDataFilePath) throws Exception {
-                    KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                    KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                 }
 
                 public void testAllFilesPresentInWhen_expression() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), true);
                 }
 
                 @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1")
@@ -990,11 +989,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class P_1 extends AbstractParsingTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInP_1() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/neg")
@@ -1002,7 +1001,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Neg extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         @TestMetadata("3.1.kt")
@@ -1016,7 +1015,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         }
 
                         public void testAllFilesPresentInNeg() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
                     }
 
@@ -1025,7 +1024,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Pos extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         @TestMetadata("3.1.kt")
@@ -1039,7 +1038,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         }
 
                         public void testAllFilesPresentInPos() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
                     }
                 }
@@ -1049,11 +1048,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class P_2 extends AbstractParsingTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInP_2() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2/neg")
@@ -1061,7 +1060,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Neg extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         @TestMetadata("1.1.kt")
@@ -1085,7 +1084,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         }
 
                         public void testAllFilesPresentInNeg() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
                     }
                 }
@@ -1095,11 +1094,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class P_5 extends AbstractParsingTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInP_5() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5/neg")
@@ -1107,7 +1106,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Neg extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         @TestMetadata("1.1.kt")
@@ -1126,7 +1125,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         }
 
                         public void testAllFilesPresentInNeg() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
                     }
                 }
@@ -1136,11 +1135,11 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                 @RunWith(JUnit3RunnerWithInners.class)
                 public static class P_6 extends AbstractParsingTestSpec {
                     private void runTest(String testDataFilePath) throws Exception {
-                        KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                        KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                     }
 
                     public void testAllFilesPresentInP_6() throws Exception {
-                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                        KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), true);
                     }
 
                     @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6/neg")
@@ -1148,7 +1147,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                     @RunWith(JUnit3RunnerWithInners.class)
                     public static class Neg extends AbstractParsingTestSpec {
                         private void runTest(String testDataFilePath) throws Exception {
-                            KotlinTestUtils.runTest(this::doParsingTest, TargetBackend.ANY, testDataFilePath);
+                            KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath);
                         }
 
                         @TestMetadata("11.1.kt")
@@ -1177,7 +1176,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec {
                         }
 
                         public void testAllFilesPresentInNeg() throws Exception {
-                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), true);
                         }
                     }
                 }