[FIR] Fix tests (ARGUMENT_TYPE_MISMATCH instead of INCOMPATIBLE_CANDIDATE)

compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.fir.kt

@@ -8,7 +8,7 @@ operator fun <T> T.invoke(a: A<T>) {}
 fun foo(s: String, ai: A<Int>) {
     1(ai)
 
-    <!INAPPLICABLE_CANDIDATE!>s<!>(ai)
+    s(<!ARGUMENT_TYPE_MISMATCH!>ai<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>""<!>(ai)
+    ""(<!ARGUMENT_TYPE_MISMATCH!>ai<!>)
 }

compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt

@@ -6,7 +6,7 @@ fun test1() {
 }
 
 fun test2(f: String.(Int) -> Unit) {
-    11.(<!INAPPLICABLE_CANDIDATE!>f<!>)(1)
+    <!ARGUMENT_TYPE_MISMATCH!>11<!>.(f)(1)
     11.(f)(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }
 

compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt

@@ -10,5 +10,5 @@ fun test(identifier: SomeClass, fn: String.() -> Unit) {
     <!NONE_APPLICABLE!>identifier<!>()
     identifier(123<!NO_VALUE_FOR_PARAMETER!>)<!>
     identifier(1, <!TOO_MANY_ARGUMENTS!>2<!>)
-    1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
+    <!ARGUMENT_TYPE_MISMATCH!>1<!>.fn()
 }

compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt

@@ -17,7 +17,7 @@ fun test(a: A, b: B) {
 
         b.(foo)()
 
-        <!INAPPLICABLE_CANDIDATE!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)<!>()
+        <!ARGUMENT_TYPE_MISMATCH!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)()<!>
 
         foo(b)
         (foo)(b)

compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt

@@ -9,5 +9,5 @@ fun test(identifier: SomeClass, fn: String.() -> Unit) {
     <!INAPPLICABLE_CANDIDATE!>identifier<!>()
     identifier(<!TOO_MANY_ARGUMENTS!>123<!>)
     identifier(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
-    1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
+    <!ARGUMENT_TYPE_MISMATCH!>1<!>.fn()
 }

compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.fir.kt

@@ -5,5 +5,5 @@
 fun foo(i: Int) {}
 
 fun test(s: String?) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(s?.length)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>s?.length<!>)
 }

compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt

@@ -83,9 +83,9 @@ fun testVararg() {
     varargFn(1,2,3) // comment
     // comment
     <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
-    varargFn(1,2,3) {} <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
-    varargFn(1,2,3) {}
-    <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
+    varargFn(1,2,3) <!ARGUMENT_TYPE_MISMATCH!>{}<!> <!ARGUMENT_TYPE_MISMATCH, VARARG_OUTSIDE_PARENTHESES!>{}<!>
+    varargFn(1,2,3) <!ARGUMENT_TYPE_MISMATCH!>{}<!>
+    <!ARGUMENT_TYPE_MISMATCH, VARARG_OUTSIDE_PARENTHESES!>{}<!>
 }
 
 fun testTwoLambdas() {

compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt

@@ -2,13 +2,13 @@
 // !DIAGNOSTICS: -USELESS_ELVIS
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (true) {
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (true) {
         1
     } else {
         2
-    })
+    }<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(1 ?: 2)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>1 ?: 2<!>)
 }
 
 fun bar(s: String) = s

compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.fir.kt

@@ -33,5 +33,5 @@ fun testDataFlowInfo2(a: Int?, b: Int?) {
 }
 
 fun testTypeMismatch(a: String?, b: Any) {
-    <!INAPPLICABLE_CANDIDATE!>doInt<!>(a ?: b)
+    doInt(<!ARGUMENT_TYPE_MISMATCH!>a ?: b<!>)
 }

compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.fir.kt

@@ -4,19 +4,19 @@ package b
 fun bar(i: Int) = i
 
 fun test(a: Int?, b: Int?) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) return else b)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (a == null) return else b<!>)
 }
 
 fun test(a: Int?, b: Int?, c: Int?) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) return else if (b == null) return else c)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (a == null) return else if (b == null) return else c<!>)
 }
 
 fun test(a: Any?, b: Any?, c: Int?) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) if (b == null) c else return else return)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (a == null) if (b == null) c else return else return<!>)
 }
 
 fun test(a: Int?, b: Any?, c: Int?) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) {
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (a == null) {
         return
     } else {
         if (b == null) {
@@ -24,5 +24,5 @@ fun test(a: Int?, b: Any?, c: Int?) {
         } else {
             c
         }
-    })
+    }<!>)
 }