[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
@@ -4,16 +4,16 @@ fun text() {
    "direct:a" on {it.body == "<hello/>"} to "mock:a"
    "direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
    bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}
-    bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
+    bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> 1}
    bar {it, <!UNUSED_ANONYMOUS_PARAMETER!>it1<!> -> it}

    bar1 {1}
    bar1 {it + 1}

-    bar2 <!NI;TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
+    bar2 <!TYPE_MISMATCH{NI}!>{<!TYPE_MISMATCH!><!>}<!>
    bar2 {1}
-    bar2 <!NI;TYPE_MISMATCH!>{<!UNRESOLVED_REFERENCE!>it<!>}<!>
-    bar2 <!NI;TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
+    bar2 <!TYPE_MISMATCH{NI}!>{<!UNRESOLVED_REFERENCE!>it<!>}<!>
+    bar2 <!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
 }

 fun bar(<!UNUSED_PARAMETER!>f<!> :  (Int, Int) -> Int) {}
@@ -6,10 +6,10 @@ class A() {
 fun f(): Unit {
    var x: Int? = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>1<!>
    x = null
-    <!OI;DEBUG_INFO_CONSTANT!>x<!> + 1
+    <!DEBUG_INFO_CONSTANT{OI}!>x<!> + 1
    <!DEBUG_INFO_CONSTANT!>x<!> <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
    <!DEBUG_INFO_CONSTANT!>x<!> <!UNSAFE_OPERATOR_CALL!><<!> 1
-    <!TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>x<!> += 1<!>
+    <!TYPE_MISMATCH!><!DEBUG_INFO_CONSTANT{OI}!>x<!> += 1<!>

    <!DEBUG_INFO_CONSTANT!>x<!> == 1
    <!DEBUG_INFO_CONSTANT!>x<!> != 1
@@ -22,11 +22,11 @@ fun f(): Unit {
    <!IMPLICIT_BOXING_IN_IDENTITY_EQUALS!><!DEBUG_INFO_CONSTANT!>x<!> === 1<!>
    <!IMPLICIT_BOXING_IN_IDENTITY_EQUALS!><!DEBUG_INFO_CONSTANT!>x<!> !== 1<!>

-    <!OI;DEBUG_INFO_CONSTANT!>x<!><!UNSAFE_OPERATOR_CALL!>..<!>2
+    <!DEBUG_INFO_CONSTANT{OI}!>x<!><!UNSAFE_OPERATOR_CALL!>..<!>2
    <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> in 1..2

    val y : Boolean? = true
    <!UNUSED_EXPRESSION!>false || <!TYPE_MISMATCH!>y<!><!>
    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && true<!>
    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
-}
+}
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 fun test() {
-  if (<!UNRESOLVED_REFERENCE!>x<!> <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0) {
+  if (<!UNRESOLVED_REFERENCE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>><!> 0) {

  }
-}
+}
@@ -7,4 +7,4 @@ fun test() {
    <!INVISIBLE_MEMBER!>Byte<!>()
    <!INVISIBLE_MEMBER!>Char<!>()
    <!INVISIBLE_MEMBER!>Boolean<!>()
-}
+}
@@ -29,26 +29,26 @@ fun <T> fooT2() : (t : T) -> T {
 fun main(args : Array<String>) {
    args.foo()()
    args.foo1()(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!UNRESOLVED_REFERENCE!>a<!>.<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()()
-    <!UNRESOLVED_REFERENCE!>a<!>.<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()()
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)

    args.foo1()(1)
    args.foo1()(<!TYPE_MISMATCH!>"1"<!>)
-    <!UNRESOLVED_REFERENCE!>a<!>.<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()("1")
-    <!UNRESOLVED_REFERENCE!>a<!>.<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()("1")
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)

    foo2()({})
    foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
    (foo2()){}
-    (foo2())<!NI;TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_ANONYMOUS_PARAMETER!>x<!> -> }<!>
-    foo2()(<!NI;TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_ANONYMOUS_PARAMETER!>x<!> -> }<!>)
+    (foo2())<!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_ANONYMOUS_PARAMETER!>x<!> -> }<!>
+    foo2()(<!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_ANONYMOUS_PARAMETER!>x<!> -> }<!>)

    val a = fooT1(1)()
    checkSubtype<Int>(a)

    val b = fooT2<Int>()(1)
    checkSubtype<Int>(b)
-    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>fooT2<!>()(1) // : Any?

    <!FUNCTION_EXPECTED!>1<!>()
    <!FUNCTION_EXPECTED!>1<!>{}
@@ -78,7 +78,7 @@ fun main1() {
 fun test() {
    {<!UNUSED_ANONYMOUS_PARAMETER!>x<!> : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
    (fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!OI;TYPE_MISMATCH!>"sd"<!>.<!NI;FUNCTION_EXPECTED!>(fun Int.() = 1)<!>()
+    <!TYPE_MISMATCH{OI}!>"sd"<!>.<!FUNCTION_EXPECTED{NI}!>(fun Int.() = 1)<!>()
    val i : Int? = null
    i<!UNSAFE_CALL!>.<!>(fun Int.() = 1)();
    {}<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>()
@@ -8,4 +8,4 @@ class A(a<!SYNTAX!><!>)
 val bar = fun(a){}

 val la = { a -> }
-val las = { a: Int -> }
+val las = { a: Int -> }
@@ -8,4 +8,4 @@ class A(a<!SYNTAX!><!>)
 val bar = fun(<!CANNOT_INFER_PARAMETER_TYPE!>a<!>){}

 val la = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!> -> }
-val las = { a: Int -> }
+val las = { a: Int -> }
@@ -146,14 +146,14 @@ fun illegalConstantBlock(): String {
    return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
 }
 fun illegalIfBody(): Int =
-        if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!NI;TYPE_MISMATCH!>{ <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> }<!>
+        if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!TYPE_MISMATCH{NI}!>{ <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1.0<!> }<!>
 fun illegalIfBlock(): Boolean {
    if (1 < 2)
        return false
    else { return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
 }
 fun illegalReturnIf(): Char {
-    return if (1 < 2) 'a' else <!NI;TYPE_MISMATCH!>{ <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }<!>
+    return if (1 < 2) 'a' else <!TYPE_MISMATCH{NI}!>{ <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!> }<!>
 }

 fun returnNothing(): Nothing {
@@ -1,4 +1,4 @@
-// FILE: b.kt
+// FILE: a.kt
 interface A<in T> {}
 interface B<T> : A<Int> {}
 interface C<T> : B<T>, A<T> {}
@@ -21,23 +21,23 @@ package x
    interface AB3 : AA1<Comparable<Int>> {}
    interface AB2 : AA1<Number>, AB1, AB3 {}

-// FILE: b.kt
+// FILE: c.kt
 package x2
    interface AA1<out T> {}
    interface AB1 : AA1<Any> {}
    interface AB3 : AA1<Comparable<Int>> {}
    interface AB2 : AA1<Number>, AB1, AB3 {}

-// FILE: b.kt
+// FILE: d.kt
 package x3
    interface AA1<in T> {}
    interface AB1 : AA1<Any> {}
    interface AB3 : AA1<Comparable<Int>> {}
    interface AB2 : AA1<Number>, AB1, AB3 {}

-// FILE: b.kt
+// FILE: e.kt
 package sx2
    interface AA1<in T> {}
    interface AB1 : AA1<Int> {}
    interface AB3 : AA1<Comparable<Int>> {}
-    interface AB2 : AA1<Number>, AB1, AB3 {}
+    interface AB2 : AA1<Number>, AB1, AB3 {}
@@ -1,4 +1,4 @@
-// FILE: b.kt
+// FILE: a.kt
 interface A<in T> {}
 interface B<T> : A<Int> {}
 interface C<T> : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>B<T>, A<T><!> {}
@@ -21,23 +21,23 @@ package x
    interface AB3 : AA1<Comparable<Int>> {}
    interface AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}

-// FILE: b.kt
+// FILE: c.kt
 package x2
    interface AA1<out T> {}
    interface AB1 : AA1<Any> {}
    interface AB3 : AA1<Comparable<Int>> {}
    interface AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}

-// FILE: b.kt
+// FILE: d.kt
 package x3
    interface AA1<in T> {}
    interface AB1 : AA1<Any> {}
    interface AB3 : AA1<Comparable<Int>> {}
    interface AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}

-// FILE: b.kt
+// FILE: e.kt
 package sx2
    interface AA1<in T> {}
    interface AB1 : AA1<Int> {}
    interface AB3 : AA1<Comparable<Int>> {}
-    interface AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}
+    interface AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}
@@ -43,4 +43,4 @@ fun testUnitIncDec() {
  x = <!UNUSED_CHANGED_VALUE!>x<!INC_DEC_SHOULD_NOT_RETURN_UNIT!>--<!><!>
  x = <!INC_DEC_SHOULD_NOT_RETURN_UNIT!>++<!>x
  <!UNUSED_VALUE!>x =<!> <!INC_DEC_SHOULD_NOT_RETURN_UNIT!>--<!>x
-}
+}
@@ -35,4 +35,4 @@ fun test() {
    a <!INFIX_MODIFIER_REQUIRED!>toExtNonInfixDefaultValues<!> b

    a <!INFIX_MODIFIER_REQUIRED!>withLambda<!> { }
-}
+}
@@ -24,4 +24,4 @@ class Example {
    <!INAPPLICABLE_INFIX_MODIFIER("must have a single value parameter")!>infix<!> fun e8(s: String, a: Int = 0) {}
    <!INAPPLICABLE_INFIX_MODIFIER("must have a single value parameter")!>infix<!> fun e9(s: String, a: Int) {}
    <!INAPPLICABLE_INFIX_MODIFIER("must have a single value parameter")!>infix<!> fun e10() {}
-}
+}
@@ -16,4 +16,4 @@ class B {
 class C {
    val bar = test()
    val test = <!UNRESOLVED_REFERENCE!>bar<!>()
-}
+}
@@ -14,6 +14,6 @@ class B {
 }

 class C {
-    val bar = <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;UNINITIALIZED_VARIABLE!>test<!>()<!>
-    val test = <!NI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;FUNCTION_EXPECTED!>bar<!>()<!>
-}
+    val bar = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}, UNINITIALIZED_VARIABLE{OI}!>test<!>()<!>
+    val test = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM{NI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}, FUNCTION_EXPECTED{OI}!>bar<!>()<!>
+}
@@ -149,7 +149,7 @@ fun test() {
  
  while (out2 == null) {
    <!DEBUG_INFO_CONSTANT!>out2<!>?.println();
-    <!OI;DEBUG_INFO_CONSTANT!>out2<!><!UNSAFE_CALL!>.<!>println();
+    <!DEBUG_INFO_CONSTANT{OI}!>out2<!><!UNSAFE_CALL!>.<!>println();
  }
  <!DEBUG_INFO_SMARTCAST!>out2<!>.println()

@@ -21,4 +21,4 @@ class A3 {
    companion object B<!CONSTRUCTOR_IN_OBJECT!>(val prop: Int)<!> {
        public <!CONSTRUCTOR_IN_OBJECT!>constructor()<!> : this(2)
    }
-}
+}
@@ -23,4 +23,4 @@ fun main() {
    (<!NO_COMPANION_OBJECT!>System<!>)
    <!REDUNDANT_LABEL_WARNING!>foo@<!> <!NO_COMPANION_OBJECT!>System<!>
    null in <!NO_COMPANION_OBJECT!>System<!>
-}
+}
@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE
-// FILE: b.kt
+// FILE: a.kt


 package foobar.a
@@ -16,14 +16,14 @@ abstract class Foo<T>() {
    abstract val x : <!TYPE_ARGUMENTS_NOT_ALLOWED!>T<Int><!>
 }

-// FILE: b.kt
+// FILE: c.kt
 package foobar.a
    import java.util.*

    val b : List<Int>? = a
    val b1 : <!UNRESOLVED_REFERENCE!>util.List<Int>?<!> = a

-// FILE: b.kt
+// FILE: d.kt
 package foobar
 val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!UNRESOLVED_REFERENCE!>a<!>
 val x2 = foobar.a.a
@@ -68,4 +68,4 @@ abstract class Collection<E> : Iterable<E> {
      }
      return current.done()
  }
-}
+}
@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE
-// FILE: b.kt
+// FILE: a.kt


 package foobar.a
@@ -16,16 +16,16 @@ abstract class Foo<T>() {
    abstract val x : T<!TYPE_ARGUMENTS_NOT_ALLOWED!><Int><!>
 }

-// FILE: b.kt
+// FILE: c.kt
 package foobar.a
    import java.util.*

    val b : List<Int>? = <!TYPE_MISMATCH!>a<!>
    val b1 : <!UNRESOLVED_REFERENCE!>util<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>List<!><Int>? = a

-// FILE: b.kt
+// FILE: d.kt
 package foobar
-val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
+val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>a<!>
 val x2 = foobar.a.a

 val y1 = foobar.a.b
@@ -68,4 +68,4 @@ abstract class Collection<E> : Iterable<E> {
      }
      return current.done()
  }
-}
+}
@@ -22,4 +22,4 @@ import outer.<!INVISIBLE_REFERENCE!>a<!>
 fun use() {
    <!INVISIBLE_MEMBER!>a<!>()
    outer.<!INVISIBLE_MEMBER!>B<!>()
-}
+}
@@ -5,8 +5,8 @@ fun test(s: IntRange?) {
   val <!UNUSED_VARIABLE!>a<!>: Int = <!TYPE_MISMATCH!>s?.start<!>
   val b: Int? = s?.start
   val <!UNUSED_VARIABLE!>c<!>: Int = s?.start ?: -11
-   val <!UNUSED_VARIABLE!>d<!>: Int = <!NI;TYPE_MISMATCH!>s?.start ?: <!OI;TYPE_MISMATCH!>"empty"<!><!>
-   val e: String = <!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>s?.start<!> ?: "empty"<!>
+   val <!UNUSED_VARIABLE!>d<!>: Int = <!TYPE_MISMATCH{NI}!>s?.start ?: <!TYPE_MISMATCH{OI}!>"empty"<!><!>
+   val e: String = <!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{OI}!>s?.start<!> ?: "empty"<!>
   val <!UNUSED_VARIABLE!>f<!>: Int = s?.endInclusive ?: b ?: 1
   val <!UNUSED_VARIABLE!>g<!>: Boolean? = e.startsWith("s")//?.length
 }
@@ -1,19 +1,19 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE

-// FILE: f.kt
+// FILE: a.kt
 package a
    val foo = bar()

    fun bar() = foo

-// FILE: f.kt
+// FILE: b.kt
 package b
    fun foo() = bar()

    fun bar() = foo()

-// FILE: f.kt
+// FILE: c.kt
 package c
    fun bazz() = bar()

@@ -21,14 +21,14 @@ package c

    fun bar() = foo()

-// FILE: f.kt
+// FILE: d.kt

    package ok.a
        val foo = bar()

        fun bar() : Int = foo

-// FILE: f.kt
+// FILE: e.kt
    package ok.b
        fun foo() : Int = bar()

@@ -1,19 +1,19 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE

-// FILE: f.kt
+// FILE: a.kt
 package a
    val foo = bar()

-    fun bar() = <!NI;DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
+    fun bar() = <!DEBUG_INFO_MISSING_UNRESOLVED{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>

-// FILE: f.kt
+// FILE: b.kt
 package b
    fun foo() = bar()

    fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>()<!>

-// FILE: f.kt
+// FILE: c.kt
 package c
    fun bazz() = bar()

@@ -21,14 +21,14 @@ package c

    fun bar() = foo()

-// FILE: f.kt
+// FILE: d.kt

    package ok.a
        val foo = bar()

        fun bar() : Int = foo

-// FILE: f.kt
+// FILE: e.kt
    package ok.b
        fun foo() : Int = bar()

@@ -20,7 +20,7 @@ fun yield(yield: Int) {
    val foo = <!YIELD_IS_RESERVED!>yield<!> + <!YIELD_IS_RESERVED!>yield<!>
    val foo2 = <!YIELD_IS_RESERVED!>yield<!>

-    bar(<!OI;YIELD_IS_RESERVED!>yield<!> = 5)
+    bar(<!YIELD_IS_RESERVED{OI}!>yield<!> = 5)

    yield(4)
    <!YIELD_IS_RESERVED!>yield<!> {}
@@ -19,4 +19,4 @@ fun test(a : java.util.ArrayList<Int>) {

 fun test(a : java.lang.Class<Int>) {

-}
+}
@@ -5,7 +5,7 @@ fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.annotation.RetentionPolicy) {
 }

 fun test() {
-  java.util.Collections.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
+  java.util.Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()
  val <!UNUSED_VARIABLE!>a<!> : Collection<String>? = java.util.Collections.emptyList()
 }

@@ -19,4 +19,4 @@ fun test(<!UNUSED_PARAMETER!>a<!> : java.util.ArrayList<Int>) {

 fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.Class<Int>) {

-}
+}
@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 // !CHECK_TYPE
-// JAVAC_SKIP
+// SKIP_JAVAC
 // FULL_JDK

-// FILE: f.kt
+// FILE: a.kt

 import java.*
 import java.util.*
@@ -53,6 +53,6 @@ fun test(l : java.util.List<Int>) {
 }


-// FILE: f.kt
+// FILE: b.kt
 package xxx
-  import java.lang.Class;
+  import java.lang.Class;
@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 // !CHECK_TYPE
-// JAVAC_SKIP
+// SKIP_JAVAC
 // FULL_JDK

-// FILE: f.kt
+// FILE: a.kt

 import java.*
 import java.util.*
@@ -22,10 +22,10 @@ fun test(<!UNUSED_PARAMETER!>l<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util

  val <!UNUSED_VARIABLE!>f<!> : java.io.File? = null

-  Collections.<!FUNCTION_CALL_EXPECTED, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>
+  Collections.<!FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>
  Collections.<!FUNCTION_CALL_EXPECTED!>emptyList<Int><!>
  Collections.emptyList<Int>()
-  Collections.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
+  Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()

  checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
  Collections.singleton<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>)
@@ -53,6 +53,6 @@ fun test(<!UNUSED_PARAMETER!>l<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util
 }


-// FILE: f.kt
+// FILE: b.kt
 package xxx
-  import java.lang.Class;
+  import java.lang.Class;
@@ -13,4 +13,4 @@ fun ff() {
    val a = <!NO_COMPANION_OBJECT!>Test<!><!UNEXPECTED_SAFE_CALL!>?.<!>FOO
    val b = <!EXPRESSION_EXPECTED_PACKAGE_FOUND!>foo<!><!UNEXPECTED_SAFE_CALL!>?.<!>s
    <!NO_COMPANION_OBJECT!>System<!><!UNEXPECTED_SAFE_CALL!>?.<!>out.println(a + b)
-}
+}
@@ -8,4 +8,4 @@ class B : A() {
    fun g() {
        super<!UNEXPECTED_SAFE_CALL!>?.<!>f()
    }
-}
+}
@@ -52,4 +52,4 @@ fun testEnums(a: Enum<*>) {

 fun testLists(a: List<Int>) {
    useList(a)
-}
+}
@@ -1,12 +1,12 @@
 // FIR_IDENTICAL
-// FILE: f.kt
+// FILE: a.kt
 class A {
 }

-// FILE: f.kt
+// FILE: b.kt
 package n
  class B
-// FILE: f.kt
+// FILE: c.kt
 abstract class XXX() {
    abstract val a : Int
    abstract val a2 : n.B
@@ -50,4 +50,4 @@ abstract class YYY() {
    abstract val a17 : ((a : Int) -> Int).(a : Int) -> Int
    abstract val a18 : (a : Int) -> ((a : Int) -> Int)
    abstract val a19 : (b : (a : Int) -> Int) -> Int
-}
+}
@@ -6,10 +6,10 @@ fun <A, B, C> getTTT(<!UNUSED_PARAMETER!>x<!> : Any) {}
 fun foo(<!UNUSED_PARAMETER!>a<!> : Any?) {}

 public fun main() {
-    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
    <!UNRESOLVED_REFERENCE!>ggetT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
-    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    foo(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
 }
@@ -16,4 +16,4 @@ fun main() {
  val bx : C<in String> = bar()
  val by : C<out String> = bar()
  val bz : C<*> = bar()
-}
+}
@@ -10,10 +10,10 @@ fun main() {
  val <!UNUSED_VARIABLE!>a<!> : C<Int> = C();
  val <!UNUSED_VARIABLE!>x<!> : C<in String> = C()
  val <!UNUSED_VARIABLE!>y<!> : C<out String> = C()
-  val <!UNUSED_VARIABLE!>z<!> : C<*> = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
+  val <!UNUSED_VARIABLE!>z<!> : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>C<!>()

  val <!UNUSED_VARIABLE!>ba<!> : C<Int> = bar();
  val <!UNUSED_VARIABLE!>bx<!> : C<in String> = bar()
  val <!UNUSED_VARIABLE!>by<!> : C<out String> = bar()
-  val <!UNUSED_VARIABLE!>bz<!> : C<*> = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
-}
+  val <!UNUSED_VARIABLE!>bz<!> : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!>()
+}
@@ -3,4 +3,4 @@ import java.util.ArrayList

 <!NOT_AN_ANNOTATION_CLASS!>@ArrayList<Int>(1, 1)<!> fun b() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
-<!INAPPLICABLE_CANDIDATE!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
+<!INAPPLICABLE_CANDIDATE!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 import java.util.ArrayList

-<!NI;NOT_AN_ANNOTATION_CLASS!>@<!OI;NONE_APPLICABLE!>ArrayList<!><Int>(<!NI;TOO_MANY_ARGUMENTS!>1<!>, <!NI;TOO_MANY_ARGUMENTS!>1<!>)<!> fun b() {}
+<!NOT_AN_ANNOTATION_CLASS{NI}!>@<!NONE_APPLICABLE{OI}!>ArrayList<!><Int>(<!TOO_MANY_ARGUMENTS{NI}!>1<!>, <!TOO_MANY_ARGUMENTS{NI}!>1<!>)<!> fun b() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
-<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
+<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
@@ -7,4 +7,4 @@ class TopLevelClass<<!UNSUPPORTED!>@A1<!> <!UNSUPPORTED!>@A2(3)<!> <!UNSUPPORTED
            class InFun<<!UNSUPPORTED!>@A1<!> <!UNSUPPORTED!>@A2(3)<!> <!UNSUPPORTED!>@A2<!> <!UNSUPPORTED!>@A1(12)<!> <!UNSUPPORTED!>@A2("Test")<!> T>
        }
    }
-}
+}
@@ -9,4 +9,4 @@ class SomeClass {
    fun foo() {
        fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> innerFun() = 12
    }
-}
+}
@@ -11,4 +11,4 @@ class SomeClass {
    fun foo() {
        val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><<!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A1<!><!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!>(3)<!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!><!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A1<!>(12)<!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!>("Test")<!> T><!> <!UNUSED_VARIABLE!>localVal<!> = 12
    }
-}
+}
@@ -19,4 +19,4 @@ class C {
@Ann0
@Ann @Ann3
@Ann2(1)
-@Ann4<!SYNTAX!><!>
+@Ann4<!SYNTAX!><!>
@@ -19,4 +19,4 @@ class C {
@<!UNRESOLVED_REFERENCE!>Ann0<!>
@Ann @<!UNRESOLVED_REFERENCE!>Ann3<!>
@Ann2(<!TOO_MANY_ARGUMENTS!>1<!>)
-@<!UNRESOLVED_REFERENCE!>Ann4<!SYNTAX!><!><!>
+@<!UNRESOLVED_REFERENCE!>Ann4<!><!SYNTAX!><!>
@@ -1,2 +1,2 @@
 // Class constructor parameter CAN be recursively annotated
-class RecursivelyAnnotated(<!NOT_AN_ANNOTATION_CLASS!>@RecursivelyAnnotated(1)<!> val x: Int)
+class RecursivelyAnnotated(<!NOT_AN_ANNOTATION_CLASS!>@RecursivelyAnnotated(1)<!> val x: Int)
@@ -5,4 +5,4 @@ object SomeObject

 val some = SomeObject

-annotation class BadAnnotation(val s: String)
+annotation class BadAnnotation(val s: String)
@@ -12,4 +12,4 @@ enum class MyEnum {
 }

@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, TYPE_MISMATCH!>Test()<!>)
-class Test2
+class Test2
@@ -12,4 +12,4 @@ enum class MyEnum {
 }

@AnnE(<!TYPE_MISMATCH!>Test()<!>)
-class Test2
+class Test2
@@ -4,7 +4,7 @@

 fun f1(x: String) {}
 fun f2(f: () -> Unit) {}
-fun test1() = f2(<!TYPE_MISMATCH("() -> Unit", "KFunction1<String, Unit>")!>::f1<!>)
+fun test1() = f2(<!TYPE_MISMATCH("() -> Unit; KFunction1<String, Unit>")!>::f1<!>)


@Target(AnnotationTarget.TYPE_PARAMETER,  AnnotationTarget.TYPE)
@@ -13,14 +13,14 @@ annotation class Ann
 fun <@Ann R : @Ann Any> f3(a: Array<@Ann R>): Array<@Ann R?> =  null!!

 fun test2(a: @Ann Array<in @Ann Int>) {
-    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!NI;TYPE_MISMATCH("Any", "Int"), NI;TYPE_MISMATCH("Any", "Int")!>a<!>)
+    val r: Array<in Int?> = <!OI{OI}, TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!TYPE_MISMATCH("Any; Int"), TYPE_MISMATCH("Any; Int")!>a<!>)
 }


 var test3: Int = 0
-    set(s: <!WRONG_SETTER_PARAMETER_TYPE("Int", "String")!>@Ann String<!>) {}
+    set(s: <!WRONG_SETTER_PARAMETER_TYPE("Int; String")!>@Ann String<!>) {}


 fun f4(fn: (@Ann Int, @Ann Int) -> Unit) {}

-val test4 = f4 <!NI;TYPE_MISMATCH("(Int, Int) -> Unit", "(Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2", "Int, Int")!>single<!> -> }<!>
+val test4 = f4 <!NI{OI}, TYPE_MISMATCH("(Int, Int) -> Unit; (Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2; Int, Int")!>single<!> -> }<!>
@@ -7,4 +7,4 @@ var bar : Int = 1
 val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}

 class Hello(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
-}
+}
@@ -37,4 +37,4 @@ fun foo(arg: Int) {
    bar(@FunAnn ::gav)
    // Function expression, ok
    fast(f)
-}
+}
@@ -34,7 +34,7 @@ fun foo(arg: Int) {
    val f = @FunAnn fun(): Int { return 42 }
    // But here, f and gav should be annotated instead
    bar(<!WRONG_ANNOTATION_TARGET!>@FunAnn<!> f)
-    bar(<!OI;WRONG_ANNOTATION_TARGET!>@<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>FunAnn<!><!> ::gav)
+    bar(<!WRONG_ANNOTATION_TARGET{OI}!>@<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>FunAnn<!><!> ::gav)
    // Function expression, ok
    fast(f)
-}
+}
@@ -28,7 +28,7 @@ abstract class My(<!WRONG_ANNOTATION_TARGET!>@Field<!> arg: Int, @Field val w: I
    fun foo() {}

    <!WRONG_ANNOTATION_TARGET!>@Field<!>
-    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>lazy<!> { 42 }
+    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>lazy<!> { 42 }
 }

 enum class Your {
@@ -7,9 +7,9 @@ annotation class A
@A
 open class B1 {
    @A
-    <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>open<!> fun foo() {}
+    private open fun foo() {}
 }

 class D1 : B1() {
    override fun foo() {}
-}
+}
@@ -11,5 +11,5 @@ open class B1 {
 }

 class D1 : B1() {
-    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER("public open fun foo(): Unit defined in D1", "private open fun foo(): Unit defined in B1")!>override<!> fun foo() {}
-}
+    <!CANNOT_OVERRIDE_INVISIBLE_MEMBER("public open fun foo(): Unit defined in D1; private open fun foo(): Unit defined in B1")!>override<!> fun foo() {}
+}
@@ -15,4 +15,4 @@ interface B {
    fun foo(@An b : @An Int)
 }

-interface C : A, B
+interface C : A, B
@@ -15,4 +15,4 @@ interface B {
    fun foo(@An b : @An Int)
 }

-<!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES("public abstract fun foo(a: Int): Unit defined in A, public abstract fun foo(b: Int): Unit defined in B", "1")!>interface C<!> : A, B
+<!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES("public abstract fun foo(a: Int): Unit defined in A, public abstract fun foo(b: Int): Unit defined in B; 1")!>interface C<!> : A, B
@@ -13,4 +13,4 @@ class C<T> {

 fun test(a: C<out CharSequence>) {
    <!INAPPLICABLE_CANDIDATE!>a[1] = 25<!>
-}
+}
@@ -12,5 +12,5 @@ class C<T> {
 }

 fun test(a: C<out CharSequence>) {
-    <!OI;MEMBER_PROJECTED_OUT("public final operator fun set(x: Int, y: T): Unit defined in C", "C<out CharSequence>")!>a[1]<!> = <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH("integer", "Nothing")!>25<!>
-}
+    <!MEMBER_PROJECTED_OUT{OI}("public final operator fun set(x: Int, y: T): Unit defined in C", "C<out CharSequence>"), OI{OI}!>a[1]<!> = <!CONSTANT_EXPECTED_TYPE_MISMATCH("integer; Nothing"), NI{OI}!>25<!>
+}
@@ -45,4 +45,4 @@ interface GI : G {
 }

 class AG1(val a: A, val g: G) : A by a, G by g
-class AG2() : AI, GI
+class AG2() : AI, GI
@@ -15,7 +15,7 @@ interface B {
    fun <T> a(@An arg: @An Int)
 }

-<!CONFLICTING_INHERITED_MEMBERS("C", "public abstract fun a(arg: Int): Unit defined in A, public abstract fun <T> a(arg: Int): Unit defined in B")!>interface C<!> : A, B
+<!CONFLICTING_INHERITED_MEMBERS("C; public abstract fun a(arg: Int): Unit defined in A, public abstract fun <T> a(arg: Int): Unit defined in B")!>interface C<!> : A, B

@An
 abstract class D {
@@ -23,8 +23,8 @@ abstract class D {
    abstract val d: @An Int
 }

-<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED("Class 'E'", "public abstract val d: Int defined in D")!>class E<!> : D(), A
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED("Class 'F'", "public abstract fun a(arg: Int): Unit defined in A")!>class F<!> : A
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED("Class 'E'; public abstract val d: Int defined in D")!>class E<!> : D(), A
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED("Class 'F'; public abstract fun a(arg: Int): Unit defined in A")!>class F<!> : A

@An
 interface G {
@@ -44,5 +44,5 @@ interface GI : G {
    override fun a(@An arg: @An Int) {}
 }

-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED("Class 'AG1'", "public open fun a(arg: Int): Unit defined in AG1")!>class AG1<!>(val a: A, val g: G) : A by a, G by g
-<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED("Class 'AG2'", "public open fun a(arg: Int): Unit defined in AI")!>class AG2<!>() : AI, GI
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED("Class 'AG1'; public open fun a(arg: Int): Unit defined in AG1")!>class AG1<!>(val a: A, val g: G) : A by a, G by g
+<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED("Class 'AG2'; public open fun a(arg: Int): Unit defined in AI")!>class AG2<!>() : AI, GI
@@ -15,4 +15,4 @@ class Out<out F>

 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
    a <!INAPPLICABLE_CANDIDATE!>+<!> y
-}
+}
@@ -14,5 +14,5 @@ class C<T> {
 class Out<out F>

 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a + <!NI;TYPE_MISMATCH("Out<Nothing>", "Out<CharSequence>"), OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS("Out<Nothing>", "Out<CharSequence>", "C<out CharSequence>", "public final operator fun plus(x: Out<T>): C<T> defined in C")!>y<!>
-}
+    a + <!"C<out{OI}, "Out<CharSequence>"{OI}, "Out<Nothing>"{OI}, "public{OI}, :{OI}, C"{OI}, C<T>{OI}, CharSequence>"{OI}, NI{OI}, Out<T>{OI}, TYPE_MISMATCH("Out<Nothing>; Out<CharSequence>"), TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}, defined{OI}, final{OI}, fun{OI}, in{OI}, operator{OI}, plus{OI}, x:{OI}!>y<!>
+}
@@ -23,4 +23,4 @@ interface B : A {

 interface C : A {
    override var p2: <!VAR_TYPE_MISMATCH_ON_OVERRIDE!>Int<!>
-}
+}
@@ -15,12 +15,12 @@ interface A {

@An
 interface B : A {
-    override val p1: <!PROPERTY_TYPE_MISMATCH_ON_OVERRIDE("p1", "public abstract val p1: String defined in A")!>Int<!>
+    override val p1: <!PROPERTY_TYPE_MISMATCH_ON_OVERRIDE("p1; public abstract val p1: String defined in A")!>Int<!>
    @An
-    override <!VAR_OVERRIDDEN_BY_VAL("public abstract val p2: String defined in B", "public abstract var p2: String defined in A")!>val<!> p2: @An String
-    override fun test(arg: String): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("test", "public abstract fun test(arg: String): String defined in A")!>Int<!>
+    override <!VAR_OVERRIDDEN_BY_VAL("public abstract val p2: String defined in B; public abstract var p2: String defined in A")!>val<!> p2: @An String
+    override fun test(arg: String): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("test; public abstract fun test(arg: String): String defined in A")!>Int<!>
 }

 interface C : A {
-    override var p2: <!VAR_TYPE_MISMATCH_ON_OVERRIDE("p2", "public abstract var p2: String defined in A")!>Int<!>
-}
+    override var p2: <!VAR_TYPE_MISMATCH_ON_OVERRIDE("p2; public abstract var p2: String defined in A")!>Int<!>
+}
@@ -1,5 +1,5 @@
 // !RENDER_DIAGNOSTICS_MESSAGES
-// JAVAC_SKIP
+// SKIP_JAVAC

 // FILE: A.java

@@ -1,5 +1,5 @@
 // !RENDER_DIAGNOSTICS_MESSAGES
-// JAVAC_SKIP
+// SKIP_JAVAC

 // FILE: A.java

@@ -27,7 +27,7 @@ import org.jetbrains.annotations.NotNull;
 annotation class An

 class B : A {
-    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo", "@NotNull @MyTypeQualifier public abstract fun foo(): String defined in A")!>String?<!> = null
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo; @NotNull @MyTypeQualifier public abstract fun foo(): String defined in A")!>String?<!> = null
 }

@An
@@ -38,5 +38,5 @@ public interface C {
 }

 class D : C {
-    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo", "public abstract fun foo(): String defined in C")!>String?<!> = null
+    override fun foo(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE("foo; public abstract fun foo(): String defined in C")!>String?<!> = null
 }
@@ -8,5 +8,5 @@ annotation class A
 fun test() {
    @A
    var b: @A Int = 0
-    <!UNUSED_VALUE("15", "var b: Int defined in test")!>b =<!> 15
+    <!UNUSED_VALUE("15; var b: Int defined in test")!>b =<!> 15
 }
@@ -6,4 +6,4 @@ class Foo<T> {
 class Bar<T : Annotation> {
    @<!NOT_A_CLASS!>T<!>
    fun foo() = 0
-}
+}
@@ -14,4 +14,4 @@ class My {
    val String.x: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>7<!>
        // Error
        get() = <!UNRESOLVED_REFERENCE!>field<!>
-}
+}
@@ -1,3 +1,9 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-220
+ * PRIMARY LINKS: expressions, call-and-property-access-expressions, callable-references -> paragraph 3 -> sentence 1
+ */
 fun f1() = Map::hashCode
 fun f2() = Map.Entry::hashCode

@@ -26,4 +26,4 @@ class Test {
    val test1a: () -> Right = a.b.c::foo

    val test2: () -> Right = a.b<Int>.c?::foo
-}
+}
@@ -23,7 +23,7 @@ class Test {
    val Int.c: Int get() = 42

    val test1: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
-    val test1a: () -> Right = a.<!NI;DEBUG_INFO_LEAKING_THIS!>b<!>.<!NI;DEBUG_INFO_LEAKING_THIS!>c<!>::foo
+    val test1a: () -> Right = a.<!DEBUG_INFO_LEAKING_THIS{NI}!>b<!>.<!DEBUG_INFO_LEAKING_THIS{NI}!>c<!>::foo

    val test2: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>?::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
-}
+}
@@ -1,17 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_VARIABLE
-// !CHECK_TYPE
-
-import kotlin.reflect.KFunction0
-
-fun test() {
-    val a = if (true) {
-        val x = 1
-        "".length
-        ::foo
-    } else {
-        ::foo
-    }
-    a checkType {  _<KFunction0<Int>>() }
-}
-
-fun foo(): Int = 0
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // !CHECK_TYPE
 /*
@@ -20,4 +21,4 @@ fun test() {
    a checkType {  _<KFunction0<Int>>() }
 }

-fun foo(): Int = 0
+fun foo(): Int = 0
@@ -18,7 +18,6 @@ package a {
    }
 }

-
 // -- Module: <m2> --
 package

@@ -36,10 +35,10 @@ package a {
    }
 }

-
 // -- Module: <m3> --
 package

 package test {
    public fun test(): kotlin.reflect.KFunction1<a.b.c, kotlin.Unit>
 }
+
@@ -19,6 +19,6 @@ fun <K, V> B<K>.star(p: KProperty1<*, V>): B<V> = TODO()
 fun <R : A> B<R>.test(){
    foo(A::bla)
    bar(A::bla)
-    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>baz<!>(<!NI;TYPE_MISMATCH!>A::bla<!>)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>baz<!>(<!TYPE_MISMATCH{NI}!>A::bla<!>)
    star(A::bla)
-}
+}
@@ -1,5 +1,12 @@
 // !LANGUAGE: +NewInference
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-220
+ * PRIMARY LINKS: expressions, call-and-property-access-expressions, navigation-operators -> paragraph 9 -> sentence 2
+ * expressions, call-and-property-access-expressions, navigation-operators -> paragraph 8 -> sentence 1
+ */

 import kotlin.reflect.KProperty1

@@ -3,7 +3,6 @@ package

 public fun </*0*/ T> bar(/*0*/ ff: [ERROR : Err].() -> kotlin.Unit): kotlin.Unit

-
 // -- Module: <m2> --
 package

@@ -18,3 +17,4 @@ public final data class User {
    public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int
    public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String
 }
+
@@ -8,6 +8,6 @@ fun <T> takeIt(x: T, f: SubFunction) {}
 fun cr() {}

 fun test() {
-    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>takeIt<!>(42, <!TYPE_MISMATCH!>::cr<!>)
-    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>takeIt<!>(42, <!TYPE_MISMATCH!>{ }<!>)
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>takeIt<!>(42, <!TYPE_MISMATCH!>::cr<!>)
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>takeIt<!>(42, <!TYPE_MISMATCH!>{ }<!>)
 }
@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION,-UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE
 fun foo(x: Int, y: Any) = x
 fun foo(x: Any, y: Int) = y

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION,-UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE
 fun foo(x: Int, <!UNUSED_PARAMETER!>y<!>: Any) = x
 fun foo(<!UNUSED_PARAMETER!>x<!>: Any, y: Int) = y

@@ -6,9 +6,9 @@ class A<T, U : Any> {
    fun bar() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE!>toString<!><!>

    fun baz() {
-        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS, OI;CALLABLE_REFERENCE_LHS_NOT_A_CLASS, OI;CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!OI;UNRESOLVED_REFERENCE!>toString<!><!>)
+        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!UNRESOLVED_REFERENCE{OI}!>toString<!><!>)

-        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS, OI;CALLABLE_REFERENCE_LHS_NOT_A_CLASS, OI;CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!OI;UNRESOLVED_REFERENCE!>toString<!><!>)
+        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE{OI}!>toString<!><!>)
    }
 }

@@ -21,4 +21,4 @@ fun test2() {
    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::foo<!>)
    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::unresolved<!>)
    <!UNRESOLVED_REFERENCE!>::unresolved<!>
-}
+}
@@ -18,7 +18,7 @@ fun test2() {
    fun foo() {}

    <!UNRESOLVED_REFERENCE!>Unresolved<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
-    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
-    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_MISSING_UNRESOLVED!>unresolved<!>)
+    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, DEBUG_INFO_MISSING_UNRESOLVED{OI}!>foo<!>)
+    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!DEBUG_INFO_MISSING_UNRESOLVED{OI}, UNRESOLVED_REFERENCE{NI}!>unresolved<!>)
    ::<!UNRESOLVED_REFERENCE!>unresolved<!>
-}
+}
@@ -15,4 +15,4 @@ fun bar2(body: (String, Int) -> String): String {
 fun test() {
    bar1(::foo)
    bar2(::foo)
-}
+}
@@ -13,6 +13,6 @@ fun bar2(body: (String, Int) -> String): String {
 }

 fun test() {
-    bar1(<!OI;TYPE_MISMATCH!>::foo<!>)
+    bar1(<!TYPE_MISMATCH{OI}!>::foo<!>)
    bar2(::foo)
-}
+}
@@ -34,4 +34,4 @@ fun <T> test2(x: T) {
    bar(listOf<T>(), setOf<T>(), ::foo).checkType { _<Pair<List<T>, Set<T>>> () }
    bar(listOf<T>(), 1, ::foo).checkType { _<Pair<List<T>, Int>>() }
    bar(1, listOf<T>(), ::foo).checkType { _<Pair<Int, List<T>>>() }
-}
+}
@@ -16,9 +16,9 @@ fun test1() {
    bar("", 1, ::foo).checkType { _<Pair<String, Int>>() }
    bar("", 1, ::fooReturnInt).checkType { _<Pair<String, Int>>() }
    bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
-    bar("", "", ::fooReturnInt).checkType { <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Pair<String, Any>>() }
+    bar("", "", ::fooReturnInt).checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Pair<String, Any>>() }

-    val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
+    val x: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar("", "", ::fooReturnInt)<!>

    baz(Int::toString, ::foo).checkType { _<Pair<Int, String>>() }
 }
@@ -34,4 +34,4 @@ fun <T> test2(x: T) {
    bar(listOf<T>(), setOf<T>(), ::foo).checkType { _<Pair<List<T>, Set<T>>> () }
    bar(listOf<T>(), 1, ::foo).checkType { _<Pair<List<T>, Int>>() }
    bar(1, listOf<T>(), ::foo).checkType { _<Pair<Int, List<T>>>() }
-}
+}
@@ -27,4 +27,4 @@ fun <R> test2(x: R) {
    foo(x, ::bar)

    complex(x, ::bar)
-}
+}
@@ -14,12 +14,12 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()

 fun test() {
    takeFun<String>(::foo)
-    takeFun<String>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>::<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>fooInt<!><!>)
+    takeFun<String>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>::<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>fooInt<!><!>)

    callFun<String, Wrapper<String>>(::createWrapper)
    callFun<Int, Wrapper<Number>>(::createWrapper)
    callFun<String, Wrapper<*>>(::createWrapper)
-    callFun<String, Wrapper<Int>>(::<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>createWrapper<!>)
+    callFun<String, Wrapper<Int>>(::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>createWrapper<!>)

    callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
 }
@@ -23,9 +23,9 @@ fun test1() {
 fun <T> test2() {
    bar<Wrapper, Int, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, Int, String>>() }
    bar<Wrapper, T, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, T, String>>() }
-    bar<Wrapper, T, T>(<!NI;TYPE_MISMATCH!>Wrapper::<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>fooReturnString<!><!>)
-    bar<Wrapper, Int, Int>(<!NI;TYPE_MISMATCH!>Wrapper::<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>fooReturnString<!><!>)
+    bar<Wrapper, T, T>(<!TYPE_MISMATCH{NI}!>Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>fooReturnString<!><!>)
+    bar<Wrapper, Int, Int>(<!TYPE_MISMATCH{NI}!>Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>fooReturnString<!><!>)

    bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
    bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }
-}
+}
@@ -34,4 +34,4 @@ fun <T> test(x: T) {

    val s5: Pair<Int, String> = bar(1, "", ::foo)
    val (a1: Int, b1: String) = bar(1, "", ::foo)
-}
+}
@@ -29,9 +29,9 @@ fun <T> test(x: T) {
    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(1, null, ::foo)
    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(null, null, ::foo)

-    val s3: Pair<Int, String?> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
-    val s4: Pair<Int?, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!NI;IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
+    val s3: Pair<Int, String?> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
+    val s4: Pair<Int?, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>

-    val s5: Pair<Int, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
+    val s5: Pair<Int, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(1, "", ::foo)<!>
    val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
-}
+}
@@ -19,4 +19,4 @@ fun test() {
    baz<(Int) -> Unit>(id(::foo), id(id(::foo)))
    baz(id(::foo), id(id<(Int) -> Unit>(::foo)))
    baz(id(::foo), id<(Int) -> Unit>(id(::foo)))
-}
+}
@@ -11,7 +11,7 @@ fun test() {
    val x2: (Int) -> Unit = baz(id(::foo), ::foo)
    val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
    val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
-    val x5: (Double) -> Unit = baz(id(::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>foo<!>), id(id(::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>foo<!>)))
+    val x5: (Double) -> Unit = baz(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>), id(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)))


    id<(Int) -> Unit>(id(id(::foo)))
@@ -19,4 +19,4 @@ fun test() {
    baz<(Int) -> Unit>(id(::foo), id(id(::foo)))
    baz(id(::foo), id(id<(Int) -> Unit>(::foo)))
    baz(id(::foo), id<(Int) -> Unit>(id(::foo)))
-}
+}
@@ -20,4 +20,4 @@ fun test1() {
    val b1: Int = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
    val b2: String = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
    val b3: Boolean = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
-}
+}
@@ -17,7 +17,7 @@ fun test1() {
    baz<String>(::foo).checkType { _<String?>() }
    baz<Boolean>(::foo).checkType { _<Boolean?>() }

-    val b1: Int = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
-    val b2: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
-    val b3: Boolean = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>baz(::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
-}
+    val b1: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
+    val b2: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
+    val b3: Boolean = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
+}
@@ -5,9 +5,9 @@ fun test() {
    val a1: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Double::minus)
    val a2: Array<Double.(Int) -> Double> = arrayOf(Double::plus, Double::minus)

-    val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>plus<!>, Double::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>minus<!>)
-    val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>minus<!>)
-    val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>minus<!>)
+    val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>plus<!>, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
+    val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
+    val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
 }

 fun foo(x: Int) {}
@@ -18,5 +18,5 @@ fun <T> bar(x: T, f: (T) -> Unit) {}
 fun test2() {
    bar(1, ::foo)
    bar("", ::foo)
-    bar(1.0, ::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>foo<!>)
+    bar(1.0, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
 }
@@ -20,4 +20,4 @@ fun test() {
    val x5: (Int) -> Int = bar(::baz<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>)

    (if (true) ::baz else ::baz)(1)
-}
+}
@@ -2,5 +2,5 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE

 fun main() {
-    val x = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> { <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!><!> } // no error
+    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>run<!><!> } // no error
 }
--- a/Show More
+++ b/Show More