[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
@@ -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
 }
@@ -4,5 +4,5 @@
 fun <T> materialize(): T = TODO()

 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!>materialize<!>() }
+    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materialize<!>() }
 }
@@ -7,5 +7,5 @@ fun <D> create(fn: () -> D): D {
 }

 fun main() {
-    create(::<!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, OI;CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, OI;CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>Abstract<!>)
+    create(::<!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>Abstract<!>)
 }
@@ -15,4 +15,4 @@ fun test() {
    varargToElement(<!TYPE_MISMATCH!>A::foo<!>)
    defaultAndVararg(<!TYPE_MISMATCH!>A::foo<!>)
    allOfTheAbove(<!TYPE_MISMATCH!>A::foo<!>)
-}
+}
@@ -8,4 +8,4 @@ fun foo(s: String) {}

 val x1 = ofType<() -> Unit>(::foo)
 val x2 = ofType<(String) -> Unit>(::foo)
-val x3 = <!INAPPLICABLE_CANDIDATE!>ofType<!><(Int) -> Unit>(<!UNRESOLVED_REFERENCE!>::foo<!>)
+val x3 = <!INAPPLICABLE_CANDIDATE!>ofType<!><(Int) -> Unit>(<!UNRESOLVED_REFERENCE!>::foo<!>)
@@ -8,4 +8,4 @@ fun foo(s: String) {}

 val x1 = ofType<() -> Unit>(::foo)
 val x2 = ofType<(String) -> Unit>(::foo)
-val x3 = ofType<(Int) -> Unit>(::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>foo<!>)
+val x3 = ofType<(Int) -> Unit>(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
@@ -11,9 +11,9 @@ class Foo {
    }

    fun foo() {
-        <!NI;NONE_APPLICABLE, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>installRoute<!><Any>(::route)
+        <!NONE_APPLICABLE{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>installRoute<!><Any>(::route)
    }

 }

-fun route(s: String): Any? = null
+fun route(s: String): Any? = null
@@ -27,4 +27,4 @@ fun test() {
    B::<!OVERLOAD_RESOLUTION_AMBIGUITY!>bas<!>

    ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>fas<!>
-}
+}
@@ -13,4 +13,4 @@ fun test(a: A, b: B) {
    // Note that diagnostic is always on callable references as they are resolved after simple arguments
    baz(a, <!TYPE_MISMATCH!>::fooB<!>)
    bar(<!TYPE_MISMATCH!>::fooB<!>, a)
-}
+}
@@ -9,4 +9,4 @@ fun foo(s: String) {}

 val x1 = apply(1, ::foo)
 val x2 = apply("hello", ::foo)
-val x3 = <!INAPPLICABLE_CANDIDATE!>apply<!>(true, <!UNRESOLVED_REFERENCE!>::foo<!>)
+val x3 = <!INAPPLICABLE_CANDIDATE!>apply<!>(true, <!UNRESOLVED_REFERENCE!>::foo<!>)
@@ -9,4 +9,4 @@ fun foo(s: String) {}

 val x1 = apply(1, ::foo)
 val x2 = apply("hello", ::foo)
-val x3 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!>(true, ::<!NI;CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY, OI;NONE_APPLICABLE!>foo<!>)
+val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>apply<!>(true, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE
-// !DIAGNOSTICS: -UNUSED_PARAMETER,-CONFLICTING_JVM_DECLARATIONS
+// !DIAGNOSTICS: -UNUSED_PARAMETER -CONFLICTING_JVM_DECLARATIONS
 // NI_EXPECTED_FILE

 fun foo(i: Int) = "$i"
@@ -25,4 +25,4 @@ val x3 = fn2(::bar, ::foo)
 val x4 = <!AMBIGUITY!>fn2<!>(<!UNRESOLVED_REFERENCE!>::foo<!>, ::bar)
 val x5 = <!AMBIGUITY!>fn2<!>(<!UNRESOLVED_REFERENCE!>::foo<!>, <!UNRESOLVED_REFERENCE!>::foo<!>)

-val x6 = fn3(1, ::qux)
+val x6 = fn3(1, ::qux)
@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE
-// !DIAGNOSTICS: -UNUSED_PARAMETER,-CONFLICTING_JVM_DECLARATIONS
+// !DIAGNOSTICS: -UNUSED_PARAMETER -CONFLICTING_JVM_DECLARATIONS
 // NI_EXPECTED_FILE

 fun foo(i: Int) = "$i"
@@ -22,7 +22,7 @@ val x1 = fn1(1, ::foo, ::foo)
 val x2 = fn1(1, ::foo, ::bar)

 val x3 = fn2(::bar, ::foo)
-val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>, ::bar)
-val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>)
+val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>, ::bar)
+val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>)

-val x6 = fn3(1, ::qux)
+val x6 = fn3(1, ::qux)