[FIR] Refactor fir resolve tests

Now there is only base test runner for all kinds of diagnostics test
  (`AbstractFirBaseDiagnosticsTest`)

compiler/fir/resolve/testData/resolve/samConstructors/realConstructorFunction.kt

@@ -10,13 +10,13 @@ fun foo(m: MyRunnable) {}
 fun MyRunnable(x: (Int) -> Boolean) = 1
 
 fun main() {
-    foo(MyRunnable { x ->
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable { x ->
         x > 1
     })
 
-    foo(MyRunnable({ it > 1 }))
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable({ it > 1 }))
 
     val x = { x: Int -> x > 1 }
 
-    foo(MyRunnable(x))
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable(x))
 }

compiler/fir/resolve/testData/resolve/samConversions/kotlinSam.kt

@@ -31,12 +31,12 @@ fun main() {
     foo1(f)
 
     foo2 { x -> x > 1 }
-    foo2(f)
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
 
-    foo3 { x -> x > 1 }
+    <!AMBIGUITY!>foo3<!> { x -> x > 1 }
     foo3(f)
 
-    foo4 { x -> x > 1 }
-    foo4(f)
+    <!UNRESOLVED_REFERENCE!>foo4<!> { x -> x > 1 }
+    <!UNRESOLVED_REFERENCE!>foo4<!>(f)
 
 }

compiler/fir/resolve/testData/resolve/samConversions/notSamBecauseOfSupertype.kt

@@ -23,9 +23,9 @@ fun main() {
         x > 1
     }
 
-    JavaUsage.foo({ it > 1 })
+    JavaUsage.foo({ <!UNRESOLVED_REFERENCE!>it<!> > 1 })
 
     val x = { x: Int -> x > 1 }
 
-    JavaUsage.foo(x)
+    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
 }

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/beyoundCalls.kt

@@ -6,7 +6,7 @@ fun <T, R> foobaz(x: T): R = TODO()
 
 fun foo() {
     val x: (String) -> Int = ::bar
-    val y = ::bar
+    val y = <!UNRESOLVED_REFERENCE!>::bar<!>
     val z = ::baz
     val w: (String) -> Int = ::foobaz
 

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/companions.kt

@@ -30,14 +30,14 @@ fun foo3(x: (String) -> Int) {}
 fun main() {
     foo1(KotlinClass::baz)
     foo2(KotlinClass::baz)
-    foo3(KotlinClass::baz)
+    <!AMBIGUITY!>foo3<!>(KotlinClass::baz)
 
     foo1(KotlinClass::bar)
     foo2(KotlinClass::bar)
-    foo3(KotlinClass::bar)
+    <!AMBIGUITY!>foo3<!>(KotlinClass::bar)
 
     foo1(KotlinClass2::bar)
-    foo2(KotlinClass2::bar)
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(KotlinClass2::bar)
     foo3(KotlinClass2::bar)
 }
 

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/fromBasicDiagnosticTests/ambiguityWhenNoApplicableCallableReferenceCandidate.kt

@@ -4,5 +4,5 @@ fun foo(y: String) {}
 fun <T> bar(f: (T) -> Unit) {}
 
 fun test() {
-    bar(::foo)
+    bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
 }

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/fromBasicDiagnosticTests/chooseCallableReferenceDependingOnInferredReceiver.kt

@@ -25,7 +25,7 @@ fun test() {
 
             val t3 = bar(::baz)
 
-            bar(::foo)
+            bar(<!UNRESOLVED_REFERENCE!>::foo<!>)
         }
     }
 }

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/fromBasicDiagnosticTests/eagerAndPostponedCallableReferences.kt

@@ -22,5 +22,5 @@ fun test() {
 
     val a6 = foo(::singleA, ::singleB)
 
-    foo(::multiple, ::multiple)
+    foo(<!UNRESOLVED_REFERENCE!>::multiple<!>, <!UNRESOLVED_REFERENCE!>::multiple<!>)
 }

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt

@@ -7,6 +7,6 @@ fun <T> bar(f: (T) -> Unit, e: T) {}
 fun <T> baz(e: T, f: (T) -> Unit) {}
 
 fun test(a: A, b: B) {
-    baz(a, ::fooB)
-    bar(::fooB, a)
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, ::fooB)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(::fooB, a)
 }

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/implicitTypes.kt

@@ -3,5 +3,5 @@ fun <T, R> use(x: (T) -> R): (T) -> R = x
 fun foo() = use(::bar)
 fun bar(x: String) = 1
 
-fun loop1() = use(::loop2)
+fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(::loop2)
 fun loop2() = loop1()

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/javaStatic.kt

@@ -16,5 +16,5 @@ fun foo3(x: (String) -> Int) {}
 fun main() {
     foo1(JavaClass::bar)
     foo2(JavaClass::bar)
-    foo3(JavaClass::bar)
+    <!AMBIGUITY!>foo3<!>(JavaClass::bar)
 }

compiler/fir/resolve/testData/resolve/stdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt

@@ -6,5 +6,5 @@ fun bar(): Int = 1
 fun bar(x: String): Int = 1
 
 fun main() {
-    foo(::bar)
+    <!AMBIGUITY!>foo<!>(::bar)
 }

compiler/fir/resolve/testData/resolve/stdlib/j+k/FieldAndGetter.kt

@@ -11,5 +11,5 @@ public class JavaClass {
 // FILE: test.kt
 
 fun test(jc: JavaClass) {
-    jc.field
+    jc.<!AMBIGUITY!>field<!>
 }