[FIR] Fix tests (ARGUMENT_TYPE_MISMATCH instead of INCOMPATIBLE_CANDIDATE)

compiler/testData/diagnostics/tests/callableReference/bound/companionObject.fir.kt

@@ -28,10 +28,10 @@ fun test() {
     checkSubtype<() -> String>(r4)
 
     val r5 = (C)::foo
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><() -> String>(r5)
+    checkSubtype<() -> String>(<!ARGUMENT_TYPE_MISMATCH!>r5<!>)
 
     val r6 = (test.C)::foo
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><() -> String>(r6)
+    checkSubtype<() -> String>(<!ARGUMENT_TYPE_MISMATCH!>r6<!>)
 
     val c = C.Companion
     val r7 = c::foo

compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt

@@ -9,5 +9,5 @@ fun cr() {}
 
 fun test() {
     <!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, ::<!UNRESOLVED_REFERENCE!>cr<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, { })
+    takeIt(42, <!ARGUMENT_TYPE_MISMATCH!>{ }<!>)
 }

compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt

@@ -13,5 +13,5 @@ class B : A() {
 fun test() {
     B::foo checkType { _<KFunction2<B, String, String>>() }
 
-    <!INAPPLICABLE_CANDIDATE!>(B::hashCode)<!>("No.")
+    (B::hashCode)(<!ARGUMENT_TYPE_MISMATCH!>"No."<!>)
 }

compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt

@@ -12,16 +12,16 @@ fun foo(): String = ""
 
 class A {
     fun foo() {}
-    
+
     fun main() {
         val x = ::foo
 
         checkSubtype<KFunction0<Unit>>(x)
 
         expectFunction0Unit(x)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction0String<!>(x)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(x)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(x)
+        expectFunction0String(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+        expectFunction1Unit(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+        expectFunction1String(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
         expectFunction0Unit(::foo)
         expectFunction0String(::foo)

compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt

@@ -12,7 +12,7 @@ fun foo(): String = ""
 
 class A {
     fun foo() {}
-    
+
     fun main() {
         val x = ::foo
 

compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt

@@ -23,8 +23,8 @@ fun <T> test(x: T) {
 
     baz<Int?, String?>(null, null, ::foo)
 
-    <!INAPPLICABLE_CANDIDATE!>baz<!><Int, String?>(null, null, ::foo)
-    <!INAPPLICABLE_CANDIDATE!>baz<!><Int?, String>(null, null, ::foo)
+    baz<Int, String?>(<!ARGUMENT_TYPE_MISMATCH!>null<!>, null, ::foo)
+    baz<Int?, String>(null, <!ARGUMENT_TYPE_MISMATCH!>null<!>, ::foo)
     baz(null, "", ::foo)
     baz(1, null, ::foo)
     baz(null, null, ::foo)

compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.fir.kt

@@ -22,15 +22,15 @@ fun test() {
     val base = Base::x
     checkSubtype<KProperty1<Base, Any>>(base)
     checkSubtype<Any>(base.get(A()))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Number>(base.get(B()))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(base.get(C()))
+    checkSubtype<Number>(<!ARGUMENT_TYPE_MISMATCH!>base.get(B())<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>base.get(C())<!>)
 
     val a = A::x
     checkSubtype<KProperty1<A, String>>(a)
     checkSubtype<String>(a.get(A()))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Number>(a.<!INAPPLICABLE_CANDIDATE!>get<!>(B()))
+    checkSubtype<Number>(<!ARGUMENT_TYPE_MISMATCH!>a.get(<!ARGUMENT_TYPE_MISMATCH!>B()<!>)<!>)
 
     val b = B::x
     checkSubtype<KProperty1<B, Number>>(b)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(b.get(C()))
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>b.get(C())<!>)
 }

compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.fir.kt

@@ -13,7 +13,7 @@ fun test() {
     val f = String::countCharacters
 
     checkSubtype<KProperty1<String, Int>>(f)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty1<String, Int>>(f)
+    checkSubtype<KMutableProperty1<String, Int>>(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
     checkSubtype<Int>(f.get("abc"))
     f.<!UNRESOLVED_REFERENCE!>set<!>("abc", 0)
 

compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt

@@ -11,7 +11,7 @@ fun test() {
     val p = A::foo
 
     checkSubtype<KProperty1<A, Int>>(p)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty1<A, Int>>(p)
+    checkSubtype<KMutableProperty1<A, Int>>(<!ARGUMENT_TYPE_MISMATCH!>p<!>)
     checkSubtype<Int>(p.get(A()))
     p.get(<!NO_VALUE_FOR_PARAMETER!>)<!>
     p.<!UNRESOLVED_REFERENCE!>set<!>(A(), 239)

compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.fir.kt

@@ -20,9 +20,9 @@ fun testX() {
 
 fun testY() {
     val yy = ::y
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty0<String>>(yy)
+    checkSubtype<KMutableProperty0<String>>(<!ARGUMENT_TYPE_MISMATCH!>yy<!>)
     checkSubtype<KProperty0<String>>(yy)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty<String>>(yy)
+    checkSubtype<KMutableProperty<String>>(<!ARGUMENT_TYPE_MISMATCH!>yy<!>)
     checkSubtype<KProperty<String>>(yy)
     checkSubtype<KCallable<String>>(yy)