[TD] Update diagnostics test data due to new test runners

Update includes:
- Changing syntax of `OI/`NI` tags from `<!NI;TAG!>` to `<!TAG{NI}!>`
- Fix some incorrect directives
- Change order of diagnostics in some places
- Remove ignored diagnostics from FIR test data (previously `DIAGNOSTICS` didn't work)
- Update FIR dumps in some places and add `FIR_IDENTICAL` if needed
- Replace all JAVAC_SKIP with SKIP_JAVAC directive

compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt

@@ -13,4 +13,4 @@ fun test(c: Coll?) {
   if (c != null) {
     for(x in <!DEBUG_INFO_SMARTCAST!>c<!>) {}
   }
-}
+}

compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.fir.kt

@@ -52,4 +52,4 @@ fun bindNoGeneric(r: SimpleOption): SimpleOption {
         if (true) SimpleNone() else r
     }
     else r
-}
+}

compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt

@@ -9,7 +9,7 @@ class None<T> : Option<T>
 fun <T> bind(r: Option<T>): Option<T> {
     return if (r is Some) {
         // Ideally we should infer Option<T> here (see KT-10896)
-        (<!OI;TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT!>if<!> (true) <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>None()<!> else <!OI;DEBUG_INFO_SMARTCAST!>r<!>) checkType { <!OI;TYPE_MISMATCH!>_<!><Option<T>>() }
+        (<!TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT{OI}!>if<!> (true) <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>None()<!> else <!DEBUG_INFO_SMARTCAST{OI}!>r<!>) checkType { <!TYPE_MISMATCH{OI}!>_<!><Option<T>>() }
         // Works correctly
         if (true) None() else r
     }
@@ -25,9 +25,9 @@ fun <T> bind2(r: Option<T>): Option<T> {
 }
 
 fun <T, R> bind3(r: Option<T>): Option<T> {
-    return if (r is Some) <!NI;TYPE_MISMATCH!>{
+    return if (r is Some) <!TYPE_MISMATCH{NI}!>{
         // Diagnoses an error correctly
-        if (true) <!OI;TYPE_MISMATCH!>None<R>()<!> else r
+        if (true) <!TYPE_MISMATCH{OI}!>None<R>()<!> else r
     }<!>
     else r
 }
@@ -52,4 +52,4 @@ fun bindNoGeneric(r: SimpleOption): SimpleOption {
         if (true) SimpleNone() else r
     }
     else r
-}
+}

compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt

@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 
-val test1 = { if (true) <!OI;IMPLICIT_CAST_TO_ANY!>1<!> else <!OI;IMPLICIT_CAST_TO_ANY!>""<!> }
+val test1 = { if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>1<!> else <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> }
 
-val test2 = { { if (true) <!OI;IMPLICIT_CAST_TO_ANY!>1<!> else <!OI;IMPLICIT_CAST_TO_ANY!>""<!> } }
+val test2 = { { if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>1<!> else <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } }
 
 val test3: (Boolean) -> Any = { if (it) 1 else "" }
 

compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.fir.kt

@@ -59,4 +59,4 @@ val testUsage3 =
         else println()
 
 val testUsage4: Any get() =
-        if (true) 42 else println()
+        if (true) 42 else println()

compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt

@@ -17,8 +17,8 @@ fun testResultOfLambda2() =
 
 fun testResultOfAnonFun1() =
         run(fun () =
-                if (true) <!OI;IMPLICIT_CAST_TO_ANY!>42<!>
-                else <!OI;IMPLICIT_CAST_TO_ANY!>println()<!>
+                if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>42<!>
+                else <!IMPLICIT_CAST_TO_ANY{OI}!>println()<!>
         )
 
 fun testResultOfAnonFun2() =
@@ -28,7 +28,7 @@ fun testResultOfAnonFun2() =
 
 fun testReturnFromAnonFun() =
         run(fun () {
-            return <!NI;TYPE_MISMATCH!>if (true) <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> else println()<!>
+            return <!TYPE_MISMATCH{NI}!>if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> else println()<!>
         })
 
 fun <!IMPLICIT_NOTHING_RETURN_TYPE!>testReturn1<!>() =
@@ -59,4 +59,4 @@ val testUsage3 =
         else <!IMPLICIT_CAST_TO_ANY!>println()<!>
 
 val testUsage4: Any get() =
-        if (true) 42 else println()
+        if (true) 42 else println()

compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt

@@ -20,10 +20,10 @@ val xx6 = null ?: <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
 val xx7 = "" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
 
 val wxx1 = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
-val wxx2: Unit = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }<!>
+val wxx2: Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>
 val wxx3 = idAny(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
 val wxx4 = id(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
-val wxx5 = idUnit(<!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }<!>)
+val wxx5 = idUnit(<!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>)
 val wxx6 = null ?: <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
 val wxx7 = "" + <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
 
@@ -51,8 +51,8 @@ fun g1() = <!NO_ELSE_IN_WHEN!>when<!> { true -> work() }
 fun g2() = <!NO_ELSE_IN_WHEN!>when<!> { true -> mlist.add() }
 fun g3() = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
 fun g4(): Unit = <!NO_ELSE_IN_WHEN!>when<!> { true -> work() }
-fun g5(): Unit = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;TYPE_MISMATCH!>mlist.add()<!> }<!>
-fun g6(): Unit = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!> }<!>
+fun g5(): Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!TYPE_MISMATCH{OI}!>mlist.add()<!> }<!>
+fun g6(): Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>
 
 fun foo1(x: String?) {
     "" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42

compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.fir.kt

@@ -31,4 +31,4 @@ fun example() {
     }
 
     return if (true) true else {}
-}
+}

compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt

@@ -30,5 +30,5 @@ fun example() {
         return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (true) true<!>
     }
 
-    return <!NI;TYPE_MISMATCH!>if (true) <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!> else {}<!>
-}
+    return <!TYPE_MISMATCH{NI}!>if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>true<!> else {}<!>
+}

compiler/testData/diagnostics/tests/controlStructures/kt10717.kt

@@ -1,21 +1,21 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNREACHABLE_CODE -UNUSED_PARAMETER -RETURN_NOT_ALLOWED
 
 fun <!IMPLICIT_NOTHING_RETURN_TYPE!>test1<!>() = run {
-    return <!TYPE_MISMATCH("String", "Nothing")!>"OK"<!>
+    return <!TYPE_MISMATCH("String; Nothing")!>"OK"<!>
 }
 
 fun <!IMPLICIT_NOTHING_RETURN_TYPE!>test2<!>() = run {
     fun local(): String {
         return ""
     }
-    return <!TYPE_MISMATCH("String", "Nothing")!>""<!>
+    return <!TYPE_MISMATCH("String; Nothing")!>""<!>
 }
 
 inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> = null!!
 fun test3(a: List<String>, b: List<Int>) = a.map {
-    if (it.length == 3) return <!TYPE_MISMATCH("Nothing?", "List<Int>")!>null<!>
-    if (it.length == 4) return <!TYPE_MISMATCH("String", "List<Int>")!>""<!>
-    if (it.length == 4) return <!TYPE_MISMATCH("Int", "List<Int>")!>5<!>
+    if (it.length == 3) return <!TYPE_MISMATCH("Nothing?; List<Int>")!>null<!>
+    if (it.length == 4) return <!TYPE_MISMATCH("String; List<Int>")!>""<!>
+    if (it.length == 4) return <!TYPE_MISMATCH("Int; List<Int>")!>5<!>
     if (it.length == 4) return b
     1
 }

compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt

@@ -9,4 +9,4 @@ fun foo(b: String) {
         <!INAPPLICABLE_CANDIDATE!>in<!> 1..10 -> 1 //no type mismatch, but it should be here
         else -> 2
     }
-}
+}

compiler/testData/diagnostics/tests/controlStructures/kt1075.kt

@@ -5,8 +5,8 @@ package kt1075
 
 fun foo(b: String) {
     if (<!TYPE_MISMATCH!>b<!> in 1..10) {} //type mismatch
-    when (<!NI;TYPE_MISMATCH!>b<!>) {
+    when (<!TYPE_MISMATCH{NI}!>b<!>) {
         <!TYPE_MISMATCH_IN_RANGE!>in<!> 1..10 -> <!UNUSED_EXPRESSION!>1<!> //no type mismatch, but it should be here
         else -> <!UNUSED_EXPRESSION!>2<!>
     }
-}
+}

compiler/testData/diagnostics/tests/controlStructures/kt4310.fir.kt

@@ -9,4 +9,4 @@ fun test(a: Boolean, b: Boolean): Int {
             3
         }
     }
-}
+}

compiler/testData/diagnostics/tests/controlStructures/kt4310.kt

@@ -4,9 +4,9 @@ package f
 fun test(a: Boolean, b: Boolean): Int {
     return if(a) {
         1
-    } else <!NI;TYPE_MISMATCH!>{
-        <!OI;TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
+    } else <!TYPE_MISMATCH{NI}!>{
+        <!TYPE_MISMATCH{OI}!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
             3
         }<!>
     }<!>
-}
+}

compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt

@@ -0,0 +1,160 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNREACHABLE_CODE
+package kt770_351_735
+
+
+//KT-770 Reference is not resolved to anything, but is not marked unresolved
+fun main() {
+    var i = 0
+    when (i) {
+        1 -> i--
+        2 -> i = 2  // i is surrounded by a black border
+        else -> <!UNRESOLVED_REFERENCE!>j<!> = 2
+    }
+    System.out.println(i)
+}
+
+//KT-351 Distinguish statement and expression positions
+val w = <!EXPRESSION_REQUIRED!>while (true) {}<!>
+
+fun foo() {
+    var z = 2
+    val r = {  // type fun(): Any is inferred
+        if (true) {
+            2
+        }
+        else {
+            z = 34
+        }
+    }
+    val f: ()-> Int = r
+    val g: ()-> Any = r
+}
+
+//KT-735 Statements without braces are prohibited on the right side of when entries.
+fun box() : Int {
+    val d = 2
+    var z = 0
+    when(d) {
+        5, 3 -> z++
+        else -> z = -1000
+    }
+    return z
+}
+
+//More tests
+
+fun test1() { while(true) {} }
+fun test2(): Unit { while(true) {} }
+
+fun testCoercionToUnit() {
+    val simple: ()-> Unit = {
+        41
+    }
+    val withIf: ()-> Unit = {
+        if (true) {
+            3
+        } else {
+            45
+        }
+    }
+    val i = 34
+    val withWhen : () -> Unit = {
+        when(i) {
+            1 -> {
+                val d = 34
+                "1"
+                doSmth(d)
+
+            }
+            2 -> '4'
+            else -> true
+        }
+    }
+
+    var x = 43
+    val checkType = {
+        if (true) {
+            x = 4
+        } else {
+            45
+        }
+    }
+    val f : () -> String = checkType
+}
+
+fun doSmth(i: Int) {}
+
+fun testImplicitCoercion() {
+    val d = 21
+    var z = 0
+    var i = when(d) {
+        3 -> null
+        4 -> { val z = 23 }
+        else -> z = 20
+    }
+
+    var u = when(d) {
+        3 -> { z = 34 }
+        else -> z--
+    }
+
+    var iff = if (true) {
+        z = 34
+    }
+    val g = if (true) 4
+    val h = if (false) 4 else {}
+
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (true) {
+        4
+    } else {
+        z = 342
+    })
+}
+
+fun fooWithAnyArg(arg: Any) {}
+fun fooWithAnyNullableArg(arg: Any?) {}
+
+fun testCoercionToAny() {
+    val d = 21
+    val x1: Any = if (1>2) 1 else 2.0
+    val x2: Any? = if (1>2) 1 else 2.0
+    val x3: Any? = if (1>2) 1 else (if (1>2) null else 2.0)
+
+    fooWithAnyArg(if (1>2) 1 else 2.0)
+    fooWithAnyNullableArg(if (1>2) 1 else 2.0)
+    fooWithAnyNullableArg(if (1>2) 1 else (if (1>2) null else 2.0))
+
+    val y1: Any = when(d) { 1 -> 1.0 else -> 2.0 }
+    val y2: Any? = when(d) { 1 -> 1.0 else -> 2.0 }
+    val y3: Any? = when(d) { 1 -> 1.0; 2 -> null; else -> 2.0 }
+
+    fooWithAnyArg(when(d) { 1 -> 1.0 else -> 2.0 })
+    fooWithAnyNullableArg(when(d) { 1 -> 1.0 else -> 2.0 })
+    fooWithAnyNullableArg(when(d) { 1 -> 1.0; 2 -> null; else -> 2.0 })
+}
+
+fun fooWithAnuNullableResult(s: String?, name: String, optional: Boolean): Any? {
+    return if (s == null) {
+        if (!optional) {
+            throw java.lang.IllegalArgumentException("Parameter '$name' was not found in the request")
+        }
+        null
+    } else {
+        name
+    }
+}
+
+fun bar(a: Unit) {}
+
+fun testStatementInExpressionContext() {
+    var z = 34
+    val a1: Unit = <!EXPRESSION_REQUIRED!>z = 334<!>
+    val f = for (i in 1..10) {}
+    if (true) return <!EXPRESSION_REQUIRED!>z = 34<!>
+    return <!EXPRESSION_REQUIRED!>while (true) {}<!>
+}
+
+fun testStatementInExpressionContext2() {
+    val a2: Unit = <!EXPRESSION_REQUIRED!>while(true) {}<!>
+}

compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt

@@ -95,9 +95,7 @@ fun testImplicitCoercion() {
     }
 
     var <!UNUSED_VARIABLE!>u<!> = when(d) {
-        3 -> {
-        <!IMPLICIT_CAST_TO_ANY!><!UNUSED_VALUE!>z =<!> 34<!>
-    }
+        3 -> { <!IMPLICIT_CAST_TO_ANY!><!UNUSED_VALUE!>z =<!> 34<!> }
         else -> <!IMPLICIT_CAST_TO_ANY, UNUSED_CHANGED_VALUE!>z--<!>
     }
 
@@ -107,10 +105,9 @@ fun testImplicitCoercion() {
     val <!UNUSED_VARIABLE!>g<!> = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 4
     val <!UNUSED_VARIABLE!>h<!> = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
 
-    bar(<!NI;TYPE_MISMATCH!>if (true) {
-        <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
-    }
-        else {
+    bar(<!TYPE_MISMATCH{NI}!>if (true) {
+        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>4<!>
+    } else {
         <!UNUSED_VALUE!>z =<!> 342
     }<!>)
 }
@@ -160,4 +157,4 @@ fun testStatementInExpressionContext() {
 
 fun testStatementInExpressionContext2() {
     val <!UNUSED_VARIABLE!>a2<!>: Unit = <!EXPRESSION_EXPECTED!>while(true) {}<!>
-}
+}

compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.fir.kt

@@ -13,4 +13,4 @@ fun test() {
 
     1 ?: { }
     use(1 ?: { })
-}
+}

compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt

@@ -8,9 +8,9 @@ fun test() {
     use({ }<!NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION!>!!<!>);
 
     // KT-KT-9070
-    <!OI;TYPE_MISMATCH!>{ }<!> <!USELESS_ELVIS!>?: 1<!>
+    <!TYPE_MISMATCH{OI}!>{ }<!> <!USELESS_ELVIS!>?: 1<!>
     use({ 2 } <!USELESS_ELVIS!>?: 1<!>);
 
-    1 <!USELESS_ELVIS!>?: <!OI;TYPE_MISMATCH, UNUSED_LAMBDA_EXPRESSION!>{ }<!><!>
+    1 <!USELESS_ELVIS!>?: <!TYPE_MISMATCH{OI}, UNUSED_LAMBDA_EXPRESSION!>{ }<!><!>
     use(1 <!USELESS_ELVIS!>?: { }<!>)
-}
+}

compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt

@@ -14,11 +14,11 @@ fun foo() : Int {
 }
 
 fun bar() : Int =
-    try <!NI;TYPE_MISMATCH!>{
-        <!OI;TYPE_MISMATCH!>doSmth()<!>
+    try <!TYPE_MISMATCH{NI}!>{
+        <!TYPE_MISMATCH{OI}!>doSmth()<!>
     }<!>
-    catch (e: Exception) <!NI;TYPE_MISMATCH!>{
-        <!OI;TYPE_MISMATCH!>""<!>
+    catch (e: Exception) <!TYPE_MISMATCH{NI}!>{
+        <!TYPE_MISMATCH{OI}!>""<!>
     }<!>
     finally {
         <!UNUSED_EXPRESSION!>""<!>

compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.fir.kt

@@ -18,4 +18,4 @@ fun test11() {
     // not 'String!'
     A.foo()!! checkType { _<String>() }
     A.foo()!! checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
-}
+}

compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt

@@ -13,9 +13,9 @@ fun <T: Any> exclExcl(t: T?): T = t!!
 fun test11() {
     // not 'String!'
     exclExcl(A.foo()) checkType { _<String>() }
-    exclExcl(A.foo()) checkType { <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><String?>() }
+    exclExcl(A.foo()) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String?>() }
 
     // not 'String!'
     A.foo()!! checkType { _<String>() }
-    A.foo()!! checkType { <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><String?>() }
-}
+    A.foo()!! checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String?>() }
+}

compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.fir.kt

@@ -0,0 +1,41 @@
+//KT-234 Force when() expressions to have an 'else' branch
+//KT-973 Unreachable code
+
+package kt234_kt973
+
+class Pair<A, B>(a: A, b: B)
+
+fun test(t : Pair<Int, Int>) : Int {
+    when (t) {
+        Pair(10, 10) -> return 1
+    }
+    return 0 // unreachable code
+}
+
+fun test1(t : Pair<Int, Int>) : Int {
+    when (t) {
+        Pair(10, 10) -> return 1
+        else -> return 2
+    }
+    return 0 // unreachable code
+}
+
+//more tests
+fun t1(x: Int) = when(x) {
+    else -> 1
+}
+
+fun t5(x: Int) = when (x) {
+    is Int -> 1
+    2 -> 2
+}
+
+fun foo3(x: Int) = when(x) {
+    else -> 1
+    2 -> 2
+}
+
+fun foo4(x: Int) = when(x) {
+    2 -> x
+    else -> 3
+}

compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt

@@ -38,4 +38,4 @@ fun foo3(x: Int) = when(x) {
 fun foo4(x: Int) = when(x) {
     2 -> x
     else -> 3
-}
+}

compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt

@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 
-val test1 = { when (true) { true -> <!OI;IMPLICIT_CAST_TO_ANY!>1<!>; else -> <!OI;IMPLICIT_CAST_TO_ANY!>""<!> } }
+val test1 = { when (true) { true -> <!IMPLICIT_CAST_TO_ANY{OI}!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } }
 
-val test2 = { { when (true) { true -> <!OI;IMPLICIT_CAST_TO_ANY!>1<!>; else -> <!OI;IMPLICIT_CAST_TO_ANY!>""<!> } } }
+val test2 = { { when (true) { true -> <!IMPLICIT_CAST_TO_ANY{OI}!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } } }
 
 val test3: (Boolean) -> Any = { when (true) { true -> 1; else -> "" } }