[FIR] Fix tests (ARGUMENT_TYPE_MISMATCH instead of INCOMPATIBLE_CANDIDATE)

compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.fir.kt

@@ -7,11 +7,11 @@ fun <E : CharSequence> foo1(x: E) {}
 fun <E : CharSequence> E.foo2() {}
 
 fun <F : String?> bar(x: F) {
-    <!INAPPLICABLE_CANDIDATE!>A<!>(x)
-    <!INAPPLICABLE_CANDIDATE!>A<!><F>(x)
+    A(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    A<F>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(x)
-    <!INAPPLICABLE_CANDIDATE!>foo1<!><F>(x)
+    foo1(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    foo1<F>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
     x.<!INAPPLICABLE_CANDIDATE!>foo2<!>()
     x.<!INAPPLICABLE_CANDIDATE!>foo2<!><F>()

compiler/testData/diagnostics/tests/generics/nullability/functionalBound.fir.kt

@@ -4,7 +4,7 @@ fun <E : String?, T : ((CharSequence) -> Unit)?> foo(x: E, y: T) {
     }
 
     if (y != null) {
-        <!INAPPLICABLE_CANDIDATE!>y<!>(x)
+        y(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     }
 
     if (x != null && y != null) {

compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt

@@ -6,7 +6,7 @@ fun <T> foo(): T {
     val x1: T = null
     val x2: T? = null
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!><T>(null)
+    bar<T>(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
     bar<T?>(null)
 
     return null
@@ -23,7 +23,7 @@ class A<F> {
         val x1: F = null
         val x2: F? = null
 
-        <!INAPPLICABLE_CANDIDATE!>xyz<!>(null)
+        xyz(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
         bar<F?>(null)
 
         return null

compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt

@@ -17,7 +17,7 @@ fun <T : CharSequence?> foo(x: T) {
         bar1(x)
         bar1<CharSequence>(x)
         bar2(x)
-        <!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
+        bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     }
 
     if (x is String) {
@@ -35,7 +35,7 @@ fun <T : CharSequence?> foo(x: T) {
 
         bar1(x)
         bar2(x)
-        <!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
+        bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     }
 
     if (1 == 1) {
@@ -43,10 +43,10 @@ fun <T : CharSequence?> foo(x: T) {
         bar1(x)
         bar1<CharSequence>(x)
         bar2(x)
-        <!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
+        bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
         bar1(y)
         bar2(y)
-        <!INAPPLICABLE_CANDIDATE!>bar3<!>(y)
+        bar3(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
     }
 }

compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt

@@ -17,15 +17,15 @@ class A<F> {
         val x2 = foo2(x)
         x2.checkType { _<F>() }
 
-        <!INAPPLICABLE_CANDIDATE!>foo1<!><F?>(y)
-        <!INAPPLICABLE_CANDIDATE!>foo1<!>(y)
+        foo1<F?>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
+        foo1(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
         foo2<F?>(y)
 
         val x3 = foo2(y)
         x3.checkType { _<F?>() }
 
-        <!INAPPLICABLE_CANDIDATE!>foo1<!><F>(y)
-        <!INAPPLICABLE_CANDIDATE!>foo2<!><F>(y)
+        foo1<F>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
+        foo2<F>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
 
         foo1<Z>(z)
 
@@ -37,13 +37,13 @@ class A<F> {
         val x5 = foo2(z)
         x4.checkType { _<Z>() }
 
-        <!INAPPLICABLE_CANDIDATE!>foo1<!><W>(w)
-        <!INAPPLICABLE_CANDIDATE!>foo1<!>(w)
+        foo1<W>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
+        foo1(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
         foo2<W>(w)
 
         val x6 = foo2(w)
         x6.checkType { _<W>() }
 
-        <!INAPPLICABLE_CANDIDATE!>foo1<!><W>(w)
+        foo1<W>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
     }
 }

compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.fir.kt

@@ -18,9 +18,9 @@ class A<F> {
     fun <Z : F, W : Z?> bar() {
         // F
         fooInv1<Inv<F>>(Inv<F>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv2<!><Inv<F>>(Inv<F>())
+        fooInv2<Inv<F>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<F>()<!>)
         fooInv1(Inv<F>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv2<!>(Inv<F>())
+        fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<F>()<!>)
 
         fooIn1<In<F?>>(In<F?>())
         fooIn2<In<F?>>(In<F?>())
@@ -33,15 +33,15 @@ class A<F> {
         fooOut2(Out<F>())
 
         // Z
-        <!INAPPLICABLE_CANDIDATE!>fooInv1<!><Inv<Z>>(Inv<Z>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv2<!><Inv<Z>>(Inv<Z>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv1<!>(Inv<Z>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv2<!>(Inv<Z>())
+        fooInv1<Inv<Z>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
+        fooInv2<Inv<Z>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
+        fooInv1(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
+        fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
 
-        <!INAPPLICABLE_CANDIDATE!>fooIn1<!><In<Z?>>(In<Z?>())
-        <!INAPPLICABLE_CANDIDATE!>fooIn2<!><In<Z?>>(In<Z?>())
-        <!INAPPLICABLE_CANDIDATE!>fooIn1<!>(In<Z?>())
-        <!INAPPLICABLE_CANDIDATE!>fooIn2<!>(In<Z?>())
+        fooIn1<In<Z?>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
+        fooIn2<In<Z?>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
+        fooIn1(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
+        fooIn2(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
 
         fooOut1<Out<Z>>(Out<Z>())
         fooOut2<Out<Z>>(Out<Z>())
@@ -49,19 +49,19 @@ class A<F> {
         fooOut2(Out<Z>())
 
         // W
-        <!INAPPLICABLE_CANDIDATE!>fooInv1<!><Inv<W>>(Inv<W>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv2<!><Inv<W>>(Inv<W>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv1<!>(Inv<W>())
-        <!INAPPLICABLE_CANDIDATE!>fooInv2<!>(Inv<W>())
+        fooInv1<Inv<W>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
+        fooInv2<Inv<W>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
+        fooInv1(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
+        fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
 
-        <!INAPPLICABLE_CANDIDATE!>fooIn1<!><In<W?>>(In<W?>())
-        <!INAPPLICABLE_CANDIDATE!>fooIn2<!><In<W?>>(In<W?>())
-        <!INAPPLICABLE_CANDIDATE!>fooIn1<!>(In<W?>())
-        <!INAPPLICABLE_CANDIDATE!>fooIn2<!>(In<W?>())
+        fooIn1<In<W?>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
+        fooIn2<In<W?>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
+        fooIn1(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
+        fooIn2(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
 
-        <!INAPPLICABLE_CANDIDATE!>fooOut1<!><Out<W>>(Out<W>())
+        fooOut1<Out<W>>(<!ARGUMENT_TYPE_MISMATCH!>Out<W>()<!>)
         fooOut2<Out<W>>(Out<W>())
-        <!INAPPLICABLE_CANDIDATE!>fooOut1<!>(Out<W>())
+        fooOut1(<!ARGUMENT_TYPE_MISMATCH!>Out<W>()<!>)
         fooOut2(Out<W>())
     }
 }

compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt

@@ -13,6 +13,6 @@ fun <T : String?> foo(x: T) {
     bar1(x)
     bar2(x)
 
-    <!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
-    <!INAPPLICABLE_CANDIDATE!>bar4<!>(x)
+    bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    bar4(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }