[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
2020-12-07 10:08:56 +03:00
parent 1d04fecd29
commit e6b5cb5216
1823 changed files with 3014 additions and 2662 deletions
@@ -20,4 +20,4 @@ val a = <!NO_COMPANION_OBJECT!>A<!>
 val <!EXPOSED_PROPERTY_TYPE!>b<!> = <!INVISIBLE_MEMBER!>B<!>
 val c = <!NO_COMPANION_OBJECT!>C<!>
 val d = D
-val e = E(42)
+val e = E(42)
@@ -13,12 +13,12 @@ typealias YBar = <!RECURSIVE_TYPEALIAS_EXPANSION!>ZBar<!>
 typealias ZBar = <!RECURSIVE_TYPEALIAS_EXPANSION!>YBar<!>

 fun Foo.foo(body: Foo.() -> Unit) = body()
-fun Foo.zbar(<!OI;UNUSED_PARAMETER!>body<!>: <!RECURSIVE_TYPEALIAS_EXPANSION!>ZBar<!>.() -> Unit) = Bar().<!OI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>body<!>()
+fun Foo.zbar(<!UNUSED_PARAMETER{OI}!>body<!>: <!RECURSIVE_TYPEALIAS_EXPANSION!>ZBar<!>.() -> Unit) = Bar().<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{OI}!>body<!>()

 fun test() {
    Foo().foo {
        zbar {
-            <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo<!> {}
+            <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo<!> {}
        }
    }
-}
+}
@@ -5,7 +5,7 @@ fun Int.invoke(i: Int, a: Any) {}
 fun Int.invoke(a: Any, i: Int) {}

 fun foo(i: Int) {
-    <!NI;NONE_APPLICABLE, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>i<!>(1, 1)
+    <!NONE_APPLICABLE{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>i<!>(1, 1)

-    <!NI;NONE_APPLICABLE, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>5<!>(1, 2)
+    <!NONE_APPLICABLE{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>5<!>(1, 2)
 }
@@ -8,7 +8,7 @@ operator fun <T> T.invoke(a: A<T>) {}
 fun foo(s: String, ai: A<Int>) {
    1(ai)

-    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>s<!>(<!NI;TYPE_MISMATCH!>ai<!>)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>s<!>(<!TYPE_MISMATCH{NI}!>ai<!>)

-    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>""<!>(<!NI;TYPE_MISMATCH!>ai<!>)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>""<!>(<!TYPE_MISMATCH{NI}!>ai<!>)
 }
@@ -6,5 +6,5 @@ operator fun String.invoke(i: Int) {}
 fun foo(s: String?) {
    <!UNSAFE_CALL!>s<!>(1)

-    <!NI;UNSAFE_IMPLICIT_INVOKE_CALL, OI;UNSAFE_CALL!>(s <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)<!>(1)
+    <!UNSAFE_CALL{OI}, UNSAFE_IMPLICIT_INVOKE_CALL{NI}!>(s <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)<!>(1)
 }
@@ -14,4 +14,4 @@ fun test3() {
    fun foo(): String.(Int) -> Unit = {}

    1.<!UNRESOLVED_REFERENCE!>(foo())(1)<!>
-}
+}
@@ -1,17 +1,17 @@
 // !WITH_NEW_INFERENCE

 fun test1() {
-    <!OI;TYPE_MISMATCH!>1<!>. <!NI;FUNCTION_EXPECTED!>(fun String.(i: Int) = i )<!>(1)
-    <!OI;TYPE_MISMATCH!>1<!>.<!NI;FUNCTION_EXPECTED!>(label@ fun String.(i: Int) = i )<!>(1)
+    <!TYPE_MISMATCH{OI}!>1<!>. <!FUNCTION_EXPECTED{NI}!>(fun String.(i: Int) = i )<!>(1)
+    <!TYPE_MISMATCH{OI}!>1<!>.<!FUNCTION_EXPECTED{NI}!>(label@ fun String.(i: Int) = i )<!>(1)
 }

 fun test2(f: String.(Int) -> Unit) {
-    <!OI;TYPE_MISMATCH!>11<!>.<!NI;FUNCTION_EXPECTED!>(f)<!>(1)
-    <!OI;TYPE_MISMATCH!>11<!>.<!NI;FUNCTION_EXPECTED!>(f)<!>(<!OI;NO_VALUE_FOR_PARAMETER!>)<!>
+    <!TYPE_MISMATCH{OI}!>11<!>.<!FUNCTION_EXPECTED{NI}!>(f)<!>(1)
+    <!TYPE_MISMATCH{OI}!>11<!>.<!FUNCTION_EXPECTED{NI}!>(f)<!>(<!NO_VALUE_FOR_PARAMETER{OI}!>)<!>
 }

 fun test3() {
    fun foo(): String.(Int) -> Unit = {}

-    <!OI;TYPE_MISMATCH!>1<!>.<!NI;FUNCTION_EXPECTED!>(foo())<!>(1)
-}
+    <!TYPE_MISMATCH{OI}!>1<!>.<!FUNCTION_EXPECTED{NI}!>(foo())<!>(1)
+}
@@ -20,4 +20,4 @@ fun foo(): A.() -> Int {
    val c: Int = (foo())(A())

    return null!!
-}
+}
@@ -19,5 +19,5 @@ fun foo(): A.() -> Int {
    val b: Int = foo()(A())
    val c: Int = (foo())(A())

-    <!OI;UNREACHABLE_CODE!>return<!> null!!
-}
+    <!UNREACHABLE_CODE{OI}!>return<!> null!!
+}
@@ -7,8 +7,8 @@ fun Int.invoke(a: Int, b: Int) {}
 class SomeClass

 fun test(identifier: SomeClass, fn: String.() -> Unit) {
-    <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;DEBUG_INFO_MISSING_UNRESOLVED, OI;FUNCTION_EXPECTED!>identifier<!>()
+    <!DEBUG_INFO_MISSING_UNRESOLVED{OI}, FUNCTION_EXPECTED{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>identifier<!>()
    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>identifier<!>(123)
    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>identifier<!>(1, 2)
    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fn<!>()
-}
+}
@@ -41,7 +41,7 @@ fun test(a: A, b: B) {
    }
 }

-// FILE: 1.kt
+// FILE: 2.kt
 package fooIsMember

 class A {
@@ -41,7 +41,7 @@ fun test(a: A, b: B) {
    }
 }

-// FILE: 1.kt
+// FILE: 2.kt
 package fooIsMember

 class A {
@@ -10,4 +10,4 @@ fun test(identifier: SomeClass, fn: String.() -> Unit) {
    <!INAPPLICABLE_CANDIDATE!>identifier<!>(123)
    <!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
    1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
-}
+}
@@ -6,8 +6,8 @@ fun Int.invoke() {}
 class SomeClass

 fun test(identifier: SomeClass, fn: String.() -> Unit) {
-    <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;DEBUG_INFO_MISSING_UNRESOLVED, OI;FUNCTION_EXPECTED!>identifier<!>()
+    <!DEBUG_INFO_MISSING_UNRESOLVED{OI}, FUNCTION_EXPECTED{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>identifier<!>()
    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>identifier<!>(123)
    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>identifier<!>(1, 2)
    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fn<!>()
-}
+}
@@ -12,7 +12,7 @@ class Cls {

    fun test(s: String) {
        if (s.ext is B)
-            take(<!OI;SMARTCAST_IMPOSSIBLE!>s.ext<!>)
+            take(<!SMARTCAST_IMPOSSIBLE{OI}!>s.ext<!>)
    }
 }

@@ -5,7 +5,7 @@ fun foo(i: Int) = i
 fun foo(s: String) = s

 fun test() {
-    <!NONE_APPLICABLE!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
+    <!NONE_APPLICABLE!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>())
 }

-fun <T> emptyList(): List<T> {throw Exception()}
+fun <T> emptyList(): List<T> {throw Exception()}
@@ -14,4 +14,4 @@ public class ResolutionTaskHolder<F, G : F> {
        tasks.bar(ResolutionTask(candidate))
        tasks.add(ResolutionTask(candidate))
    }
-}
+}
@@ -11,7 +11,7 @@ public class ResolutionTaskHolder<F, G : F> {
        tasks.add(ResolutionTask<F, G>(candidate))

        //todo the problem is the type of ResolutionTask is inferred as ResolutionTask<F, F> too early
-        tasks.<!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(ResolutionTask(candidate))
+        tasks.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(ResolutionTask(candidate))
        tasks.add(ResolutionTask(candidate))
    }
-}
+}
@@ -100,8 +100,8 @@ fun testTwoLambdas() {
        {}
        <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!>

-        return if (true) <!NI;TYPE_MISMATCH!>{
-            <!OI;TYPE_MISMATCH!>twoLambdaArgs({})
+        return if (true) <!TYPE_MISMATCH{NI}!>{
+            <!TYPE_MISMATCH{OI}!>twoLambdaArgs({})
            {}
            <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!><!>
        }<!> else {
@@ -112,7 +112,7 @@ fun testTwoLambdas() {

 fun f1(): (() -> Unit) -> (() -> Unit) -> Unit {
    return { l1 ->
-        <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>l1()
-        <!UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{ <!CANNOT_INFER_PARAMETER_TYPE, NI;UNUSED_ANONYMOUS_PARAMETER!>l2<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>l2<!>()<!> }<!><!>
+        <!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>l1()
+        <!UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{ <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER{NI}!>l2<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>l2<!>()<!> }<!><!>
    }
 }
@@ -16,4 +16,4 @@ fun test() {
 fun <T> bar() {
    val typeParameter_as_val = <!TYPE_PARAMETER_IS_NOT_AN_EXPRESSION!>T<!>
    val typeParameter_as_fun = <!RESOLUTION_TO_CLASSIFIER!>T<!>()
-}
+}
@@ -36,4 +36,4 @@ fun test(x: X) {

    val object_as_fun = x.<!RESOLUTION_TO_CLASSIFIER!>B<!>()
    val class_as_val = x.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>C<!>
-}
+}
@@ -7,4 +7,4 @@ object X2
 fun <T1> foo(x: T1, f: (T1) -> T1) = X1
 fun <T2> foo(xf: () -> T2, f: (T2) -> T2) = X2

-val test: X2 = foo({ 0 }, { it -> it + 1 })
+val test: X2 = foo({ 0 }, { it -> it + 1 })
@@ -7,4 +7,4 @@ object X2
 fun <T1> foo(x: T1, f: (T1) -> T1) = X1
 fun <T2> foo(xf: () -> T2, f: (T2) -> T2) = X2

-val test: X2 = <!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>foo<!>({ 0 }, { <!OI;CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 })
+val test: X2 = <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!>({ 0 }, { <!CANNOT_INFER_PARAMETER_TYPE{OI}!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> 1 })
@@ -15,6 +15,6 @@ fun <E> baz(x: String, y: E) {}
 fun bar(x: A<String>) {
    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>("")

-    x.<!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>baz<!>("", "")
-    <!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>baz<!>("", "")
+    x.<!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>baz<!>("", "")
+    <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>baz<!>("", "")
 }
@@ -7,4 +7,4 @@ fun <T2 : Closeable, R2> T2.myUse(f: (T2) -> R2): R2 = f(this)

 fun test1(x: Closeable) = x.myUse { 42 }
 fun test2(x: Closeable) = x.myUse<Closeable, Int> { 42 }
-fun test3(x: Closeable) = x.myUse<AutoCloseable, Int> { 42 } // TODO KT-10681
+fun test3(x: Closeable) = x.myUse<AutoCloseable, Int> { 42 } // TODO KT-10681
@@ -7,4 +7,4 @@ fun <T2 : Closeable, R2> T2.myUse(f: (T2) -> R2): R2 = f(this)

 fun test1(x: Closeable) = x.myUse { 42 }
 fun test2(x: Closeable) = x.myUse<Closeable, Int> { 42 }
-fun test3(x: Closeable) = x.myUse<<!OI;UPPER_BOUND_VIOLATED!>AutoCloseable<!>, Int> { 42 } // TODO KT-10681
+fun test3(x: Closeable) = x.myUse<<!UPPER_BOUND_VIOLATED{OI}!>AutoCloseable<!>, Int> { 42 } // TODO KT-10681
@@ -13,4 +13,4 @@ fun <T> B<T>.foo(block: (T) -> Unit) {

 fun main() {
    B("string").<!AMBIGUITY!>foo<!> {  }
-}
+}
@@ -12,5 +12,5 @@ fun <T> B<T>.foo(block: (T) -> Unit) {
 }

 fun main() {
-    B("string").<!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {  }
-}
+    B("string").<!OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!> {  }
+}
@@ -23,4 +23,4 @@ import b.*

 fun test() {
    <!AMBIGUITY!>foo<!><A> { }
-}
+}
@@ -22,5 +22,5 @@ import a.*
 import b.*

 fun test() {
-    <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!><A> { }
-}
+    <!OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!><A> { }
+}
@@ -21,4 +21,4 @@ import b.*

 fun main() {
    foo<String> {  }
-}
+}
@@ -20,5 +20,5 @@ import a.*
 import b.*

 fun main() {
-    <!OI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!><String> {  }
-}
+    <!OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!><String> {  }
+}
@@ -10,4 +10,4 @@ fun overloadedFun5(s: String, vararg ss: String) = X2
 val test1 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>overloadedFun5<!>("")
 val test2 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>overloadedFun5<!>("", "")
 val test3: X2 = <!NONE_APPLICABLE!>overloadedFun5<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>s<!> = "", <!DEBUG_INFO_MISSING_UNRESOLVED!>ss<!> = "")
-val test4: X1 = overloadedFun5(ss = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>""<!>)
+val test4: X1 = overloadedFun5(ss = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>""<!>)
@@ -7,4 +7,4 @@ class A<T>
 fun <T1> A<T1>.foo() = X1
 fun <T2> A<out T2>.foo() = X2

-fun <T> A<out T>.test() = foo() // TODO fix constraint system
+fun <T> A<out T>.test() = foo() // TODO fix constraint system
@@ -7,4 +7,4 @@ class A<T>
 <!CONFLICTING_OVERLOADS!>fun <T1> A<T1>.foo()<!> = X1
 <!CONFLICTING_OVERLOADS!>fun <T2> A<out T2>.foo()<!> = X2

-fun <T> A<out T>.test() = <!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>foo<!>() // TODO fix constraint system
+fun <T> A<out T>.test() = <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!>() // TODO fix constraint system
@@ -11,4 +11,4 @@ fun test() {
    <!INAPPLICABLE_CANDIDATE!>bar<!>(1 ?: 2)
 }

-fun bar(s: String) = s
+fun bar(s: String) = s
@@ -2,13 +2,13 @@
 // !DIAGNOSTICS: -USELESS_ELVIS

 fun test() {
-    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (true) {
-        <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
+    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>if (true) {
+        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>
    } else {
-        <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>
+        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>2<!>
    }<!>)

-    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
+    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
 }

-fun bar(s: String) = s
+fun bar(s: String) = s
@@ -14,7 +14,7 @@ fun testElvis(a: Int?, b: Int?) {
    if (a != null) {
        doInt(b ?: <!DEBUG_INFO_SMARTCAST!>a<!>)
    }
-    doList(getList() ?: <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>emptyListOfA<!>()) //should be an error
+    doList(getList() ?: <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>emptyListOfA<!>()) //should be an error
    doList(getList() ?: strangeList { doInt(it) }) //lambda was not analyzed
 }

@@ -33,5 +33,5 @@ fun testDataFlowInfo2(a: Int?, b: Int?) {
 }

 fun testTypeMismatch(a: String?, b: Any) {
-    doInt(<!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>a<!> ?: <!OI;TYPE_MISMATCH!>b<!><!>)
-}
+    doInt(<!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{OI}!>a<!> ?: <!TYPE_MISMATCH{OI}!>b<!><!>)
+}
@@ -26,4 +26,4 @@ fun testDataFlowInfoAfterExclExcl(a: Int?) {

 fun testUnnecessaryExclExcl(a: Int) {
    doInt(a!!) //should be warning
-}
+}
@@ -13,8 +13,8 @@ fun <T: A> emptyNullableListOfA(): List<T>? = null
 //-------------------------------

 fun testExclExcl() {
-    doList(<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>emptyNullableListOfA<!>()!!) //should be an error here
-    val <!UNUSED_VARIABLE!>l<!>: List<Int> = id(<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>emptyNullableListOfA<!>()!!)
+    doList(<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>emptyNullableListOfA<!>()!!) //should be an error here
+    val <!UNUSED_VARIABLE!>l<!>: List<Int> = id(<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>emptyNullableListOfA<!>()!!)

    doList(strangeNullableList { doInt(it) }!!) //lambda should be analyzed (at completion phase)
 }
@@ -26,4 +26,4 @@ fun testDataFlowInfoAfterExclExcl(a: Int?) {

 fun testUnnecessaryExclExcl(a: Int) {
    doInt(a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>) //should be warning
-}
+}
@@ -26,4 +26,4 @@ fun foo(c: C?, d: D?, e: E?) {
        2 -> d
        else -> e
    }
-}
+}
@@ -9,7 +9,7 @@ interface D: A, B
 interface E: A, B

 fun foo(c: C?, d: D?, e: E?) {
-    val test1: A? = <!OI;TYPE_MISMATCH!>c ?: d<!> ?: e
+    val test1: A? = <!TYPE_MISMATCH{OI}!>c ?: d<!> ?: e

    val test2: B? = if (false) if (true) c else d else e

@@ -26,4 +26,4 @@ fun foo(c: C?, d: D?, e: E?) {
        2 -> d
        else -> e
    }
-}
+}
@@ -4,25 +4,25 @@ package b
 fun bar(i: Int) = i

 fun test(a: Int?, b: Int?) {
-    bar(<!NI;TYPE_MISMATCH!>if (a == null) return else <!OI;TYPE_MISMATCH!>b<!><!>)
+    bar(<!TYPE_MISMATCH{NI}!>if (a == null) return else <!TYPE_MISMATCH{OI}!>b<!><!>)
 }

 fun test(a: Int?, b: Int?, c: Int?) {
-    bar(<!NI;TYPE_MISMATCH!>if (a == null) return else if (b == null) return else <!OI;TYPE_MISMATCH!>c<!><!>)
+    bar(<!TYPE_MISMATCH{NI}!>if (a == null) return else if (b == null) return else <!TYPE_MISMATCH{OI}!>c<!><!>)
 }

 fun test(a: Any?, b: Any?, c: Int?) {
-    bar(<!NI;TYPE_MISMATCH!>if (a == null) if (b == null) <!OI;TYPE_MISMATCH!>c<!> else return else return<!>)
+    bar(<!TYPE_MISMATCH{NI}!>if (a == null) if (b == null) <!TYPE_MISMATCH{OI}!>c<!> else return else return<!>)
 }

 fun test(a: Int?, b: Any?, c: Int?) {
-    bar(<!NI;TYPE_MISMATCH!>if (a == null) {
+    bar(<!TYPE_MISMATCH{NI}!>if (a == null) {
        return
    } else {
        if (b == null) {
            return
        } else {
-            <!OI;TYPE_MISMATCH!>c<!>
+            <!TYPE_MISMATCH{OI}!>c<!>
        }
    }<!>)
 }
@@ -12,4 +12,4 @@ fun <T, R> bar(t: T, r: R) {}

 fun test2() {
    <!INAPPLICABLE_CANDIDATE!>bar<!><Int>("", "")
-}
+}
@@ -4,12 +4,12 @@
 fun <T> foo(t: T) = t

 fun test1() {
-    foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int, String><!>(<!OI;TYPE_MISMATCH!>""<!>)
+    foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int, String><!>(<!TYPE_MISMATCH{OI}!>""<!>)
 }


 fun <T, R> bar(t: T, r: R) {}

 fun test2() {
-    bar<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>(<!OI;TYPE_MISMATCH!>""<!>, "")
-}
+    bar<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>(<!TYPE_MISMATCH{OI}!>""<!>, "")
+}