[FIR] Fix tests (ARGUMENT_TYPE_MISMATCH instead of INCOMPATIBLE_CANDIDATE)

compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt

@@ -15,6 +15,6 @@ interface TestInterface<R> {
 
 fun test() {
     val ret = combined({ }) {
-        <!INAPPLICABLE_CANDIDATE!>emit<!>(1)
+        emit(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     }
 }

compiler/testData/diagnostics/tests/inference/capturedTypes/approximateContravariantCapturedTypes.fir.kt

@@ -36,7 +36,7 @@ fun test2() {
     val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.reflect.KFunction2<Foo<*>, CapturedType(*), CapturedType(*)>")!>Foo<*>::setX1<!>
     val foo = Foo<Float>(1f)
 
-    fooSetRef.<!INAPPLICABLE_CANDIDATE!>invoke<!>(foo, 1)
+    fooSetRef.invoke(foo, <!ARGUMENT_TYPE_MISMATCH!>1<!>)
 
     foo.x.bar()
 }
@@ -54,7 +54,7 @@ fun test4() {
     val fooSetRef = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.reflect.KFunction2<Foo2<*>, CapturedType(*), CapturedType(*)>")!>Foo2<*>::setX1<!>
     val foo = Foo2<Int>(1)
 
-    fooSetRef.<!INAPPLICABLE_CANDIDATE!>invoke<!>(foo, "")
+    fooSetRef.invoke(foo, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     foo.x.<!INAPPLICABLE_CANDIDATE!>bar<!>()
 }

compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt

@@ -5,13 +5,13 @@
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!
 
 fun test1(a: Array<in Int>) {
-    val r: Array<in Int?> = <!INAPPLICABLE_CANDIDATE!>bar<!>(a)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(a)
+    val r: Array<in Int?> = bar(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }
 
 fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!
 
 fun test2(a: Array<in Int>) {
-    val r: Array<out Array<in Int?>> = <!INAPPLICABLE_CANDIDATE!>foo<!>(a)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(a)
+    val r: Array<out Array<in Int?>> = foo(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }

compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.fir.kt

@@ -1,11 +1,11 @@
 interface Inv<T>
 
 fun <Y: X, X : Inv<out String>> foo(x: X, y: Y) {
-    val rX = <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
-    rX.length
+    val rX = bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    rX.<!UNRESOLVED_REFERENCE!>length<!>
 
-    val rY = <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
-    rY.length
+    val rY = bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
+    rY.<!UNRESOLVED_REFERENCE!>length<!>
 }
 
 fun <Y> bar(l: Inv<Y>): Y = TODO()

compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.fir.kt

@@ -4,7 +4,7 @@
 fun <T> foo(array: Array<Array<T>>): Array<Array<T>> = array
 
 fun test(array: Array<Array<out Int>>) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(array)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>array<!>)
 
-    val f: Array<out Array<out Int>> = <!INAPPLICABLE_CANDIDATE!>foo<!>(array)
+    val f: Array<out Array<out Int>> = foo(<!ARGUMENT_TYPE_MISMATCH!>array<!>)
 }

compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.fir.kt

@@ -11,8 +11,8 @@ fun bar(b: B<in A<out Number>>, bOut: B<out A<out Number>>, bOut2: B<out A<Numbe
     foo(b)
     foo<Number>(b)
 
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(bOut)
-    <!INAPPLICABLE_CANDIDATE!>baz<!><Number>(bOut)
+    baz(<!ARGUMENT_TYPE_MISMATCH!>bOut<!>)
+    baz<Number>(<!ARGUMENT_TYPE_MISMATCH!>bOut<!>)
 
     baz(bOut2)
     baz<Number>(bOut2)

compiler/testData/diagnostics/tests/inference/capturedTypesInSelfType.fir.kt

@@ -4,5 +4,5 @@
 class Foo<T : Enum<T>>(val values: Array<T>)
 
 fun foo(x: Array<out Enum<*>>) {
-    val y = <!INAPPLICABLE_CANDIDATE!>Foo<!>(x)
+    val y = Foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }

compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.fir.kt

@@ -13,9 +13,9 @@ fun test() {
         materialize<Foo<Bar<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>>()
     )
 
-    <!INAPPLICABLE_CANDIDATE!>consume<!>(
+    consume(
         materialize<Foo<Bar<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>>(),
-        materialize<Foo<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>()
+        <!ARGUMENT_TYPE_MISMATCH!>materialize<Foo<<!UNRESOLVED_REFERENCE!>ErrorType<!>>>()<!>
     )
 
 }

compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.fir.kt

@@ -15,5 +15,5 @@ fun <T: Any> joinT(x: Comparable<*>, y: T): T? {
 
 fun test() {
     val x2 = <!NONE_APPLICABLE!>joinT<!>(Unit, "2")
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String?>(x2)
+    checkSubtype<String?>(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
 }

compiler/testData/diagnostics/tests/inference/completion/withExact.fir.kt

@@ -16,11 +16,11 @@ fun <K> id(arg: K): K = arg
 
 fun test1(arg: Derived) {
     id<Inv<Base>>(Inv(arg))
-    <!INAPPLICABLE_CANDIDATE!>id<!><Inv<Base>>(InvExact(arg))
+    id<Inv<Base>>(<!ARGUMENT_TYPE_MISMATCH!>InvExact(arg)<!>)
 }
 
 fun <R> Inv<@Exact R>.select(first: R, second: R): R = TODO()
 
 fun test2(derived: Derived, other: Other) {
-    Inv(derived).<!INAPPLICABLE_CANDIDATE!>select<!>(derived, other)
+    Inv(derived).select(derived, <!ARGUMENT_TYPE_MISMATCH!>other<!>)
 }

compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt

@@ -12,5 +12,5 @@ fun <R> choose3(c: Inv<Inv<R>>) {}
 fun f(o: Out<Out<*>>, i: In<In<*>>, inv: Inv<Inv<*>>) {
     choose1(o)
     choose2(i)
-    <!INAPPLICABLE_CANDIDATE!>choose3<!>(inv)
+    choose3(<!ARGUMENT_TYPE_MISMATCH!>inv<!>)
 }

compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.fir.kt

@@ -3,7 +3,7 @@ package c
 
 import java.util.ArrayList
 
-fun Array<Int>.toIntArray(): IntArray = this.<!INAPPLICABLE_CANDIDATE!>mapTo<!>(IntArray(size), {it})
+fun Array<Int>.toIntArray(): IntArray = this.mapTo(<!ARGUMENT_TYPE_MISMATCH!>IntArray(size)<!>, {it})
 
 fun Array<Int>.toArrayList(): ArrayList<Int> = this.mapTo(ArrayList<Int>(size), {it})
 

compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt

@@ -140,8 +140,8 @@ class Main<L>(x: L?, y: L) {
     val x120 = foo12(x!!)
     val x121 = foo12(y!!)
 
-    val x122 = <!INAPPLICABLE_CANDIDATE!>foo12<!>(x)
-    val x123 = <!INAPPLICABLE_CANDIDATE!>foo12<!>(y)
+    val x122 = foo12(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    val x123 = foo12(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
 
     val x133 = Foo13(x).foo1(y)
     val x135 = Foo13(y).foo1(y)

compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.fir.kt

@@ -21,6 +21,6 @@ public class Foo {
 
 fun test(e: <!UNRESOLVED_REFERENCE!>ErrorType<!>) {
     Foo.foo {
-        Sam.Result.<!INAPPLICABLE_CANDIDATE!>create<!>(e)
+        Sam.Result.create(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
     }
 }

compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.fir.kt

@@ -18,8 +18,8 @@ fun test(out: Out<Int>, i: In<Int>, inv: A<Int>) {
     r checkType { _<Int>() }
 
     // T? <: Int => error
-    <!INAPPLICABLE_CANDIDATE!>doIn<!>(i)
+    doIn(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
 
     // T? >: Int => error
-    <!INAPPLICABLE_CANDIDATE!>doA<!>(inv)
+    doA(<!ARGUMENT_TYPE_MISMATCH!>inv<!>)
 }

compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt

@@ -43,9 +43,9 @@ fun test1(int: Int, any: Any) {
 
     readFromMyList(getMyList(int), any)
     readFromMyList(getMyList(any), int)
-    <!INAPPLICABLE_CANDIDATE!>readFromMyList<!><Int>(getMyList(any), int)
+    readFromMyList<Int>(<!ARGUMENT_TYPE_MISMATCH!>getMyList(any)<!>, int)
 
-    <!INAPPLICABLE_CANDIDATE!>readFromMyList<!><Int>(getMyListToReadFrom(any), int)
+    readFromMyList<Int>(<!ARGUMENT_TYPE_MISMATCH!>getMyListToReadFrom(any)<!>, int)
     readFromMyList(getMyListToReadFrom(any), int)
 
     readFromMyList(getMyListToReadFrom(int), any)
@@ -61,7 +61,7 @@ fun test1(int: Int, any: Any) {
 
     readFromMyList(getMyListToWriteTo(any), any)
 
-    <!INAPPLICABLE_CANDIDATE!>writeToMyList<!>(getMyListToReadFrom(any), any)
+    writeToMyList(getMyListToReadFrom(any), <!ARGUMENT_TYPE_MISMATCH!>any<!>)
 
     use(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)
 }

compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.fir.kt

@@ -4,5 +4,5 @@ fun <T> foo(t: T, t1: T) {}
 
 fun test() {
     //no type inference error
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>aaab<!>, <!UNRESOLVED_REFERENCE!>bbb<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>aaab<!>, <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>bbb<!>)
 }

compiler/testData/diagnostics/tests/inference/kt1293.fir.kt

@@ -6,7 +6,7 @@ package kt1293
 fun main() {
     val intArray = arrayOfNulls<Int>(10)
     val i : Int = intArray[0]
-    <!INAPPLICABLE_CANDIDATE!>requiresInt<!>(intArray[0])
+    requiresInt(<!ARGUMENT_TYPE_MISMATCH!>intArray[0]<!>)
 }
 
 fun requiresInt(i: Int) {}

compiler/testData/diagnostics/tests/inference/mapFunction.fir.kt

@@ -20,8 +20,8 @@ fun foo() {
     checkSubtype<List<Int>>(b)
 
     //check for non-error types
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(u)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(b)
+    checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>u<!>)
+    checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>b<!>)
 }
 
 

compiler/testData/diagnostics/tests/inference/mostSpecificAfterInference.fir.kt

@@ -12,7 +12,7 @@ fun <T, R> java.lang.Iterable<T>.map1(f : (T) -> R) : List<R> {}
 fun test(list: List<Int>) {
     val res = list.map1 { it }
     //check res is not of error type
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(res)
+    checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>res<!>)
 }
 
 fun <T> Collection<T>.foo() {}
@@ -21,5 +21,5 @@ fun <T> java.lang.Iterable<T>.foo() {}
 fun test1(list: List<Int>) {
     val res = list.foo()
     //check res is not of error type
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(res)
+    checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>res<!>)
 }

compiler/testData/diagnostics/tests/inference/nestedCalls/checkTypesForQualifiedProperties.fir.kt

@@ -1,7 +1,7 @@
 package a
 
 fun test(c: C) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(c.b)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>c.b<!>)
 }
 
 fun foo(s: String) = s

compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.fir.kt

@@ -10,6 +10,6 @@ fun foo(s: String) {}
 fun r(): Int? = null
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(F().p())
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(r())
+    foo(<!ARGUMENT_TYPE_MISMATCH!>F().p()<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>r()<!>)
 }

compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionLocations.fir.kt

@@ -38,7 +38,7 @@ fun testStarProjection() = BiParam(
     intersect(First, Second),
     makeStarProjection()
 )
-fun testErrorType() = <!INAPPLICABLE_CANDIDATE!>BiParam<!>(
+fun testErrorType() = BiParam(
     intersect(First, Second),
-    <!UNRESOLVED_REFERENCE!>unresolved<!>
+    <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>
 )

compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.fir.kt

@@ -3,7 +3,7 @@ fun foo() {
     fun bar1() = bar1()
 
     fun bar2() = 1 <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> bar2()
-    fun bar3() = <!INAPPLICABLE_CANDIDATE!>id<!>(bar3())
+    fun bar3() = id(<!ARGUMENT_TYPE_MISMATCH!>bar3()<!>)
 }
 
 fun <T> id(x: T) = x

compiler/testData/diagnostics/tests/inference/regressions/kt1145.fir.kt

@@ -8,7 +8,7 @@ import checkSubtype
 
 fun test(numbers: Iterable<Int>) {
     val s = numbers.map{it.toString()}.fold(""){it, it2 -> it + it2}
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(s)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }
 
 //from library

compiler/testData/diagnostics/tests/inference/regressions/kt1718.fir.kt

@@ -10,7 +10,7 @@ fun test() {
     val list = arrayList("foo", "bar") + arrayList("cheese", "wine")
     checkSubtype<List<String>>(list)
     //check it's not an error type
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(list)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>list<!>)
 }
 
 //from library

compiler/testData/diagnostics/tests/inference/regressions/kt2407.fir.kt

@@ -8,7 +8,7 @@ import checkSubtype
 fun test() {
     val foo = arrayList("").map { it -> it.length }.fold(0, { x, y -> Math.max(x, y) })
     checkSubtype<Int>(foo)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(foo)
+    checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>foo<!>)
 }
 
 //from library

compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt

@@ -8,7 +8,7 @@ fun <T> bar(a: T, b: Map<T, String>) = b.get(a)
 
 fun test(a: Int) {
     foo(a, null)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(a, null)
+    bar(a, <!ARGUMENT_TYPE_MISMATCH!>null<!>)
 }
 fun test1(a: Int) {
     foo(a, throw Exception())

compiler/testData/diagnostics/tests/inference/regressions/kt36342.fir.kt

@@ -5,21 +5,21 @@ import java.lang.Exception
 fun <K> id(arg: K): K = arg
 
 fun test() {
-    id(<!UNRESOLVED_REFERENCE!>unresolved<!>)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
+    id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)!!
     <!UNRESOLVED_REFERENCE!>unresolved<!>!!!!
     try {
-        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
     } catch (e: Exception) {
-        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
     }
 
     if (true)
-        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
     else
-        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
 
     when {
-        true -> <!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+        true -> id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
     }
-    id(<!UNRESOLVED_REFERENCE!>unresolved<!>) ?: id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+    id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>) ?: id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
 }

compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.fir.kt

@@ -4,8 +4,8 @@ fun <K> id(arg: K): K = arg
 fun <M> materialize(): M = TODO()
 
 fun test(b: Boolean) {
-    <!INAPPLICABLE_CANDIDATE!>id<!>(if (b) {
-        <!INAPPLICABLE_CANDIDATE!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+    id(if (b) {
+        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
     } else {
         id(
             materialize()

compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt

@@ -1,7 +1,7 @@
 // !LANGUAGE: +NewInference
 
 open class Test<T1, T2>(val map1 : Map<T1, T2>, val map2 : Map<T2, T1>) {
-    open val inverse: Test<T2, T1> = object : <!INAPPLICABLE_CANDIDATE!>Test<T2, T1><!>(map2, map1) {
+    open val inverse: Test<T2, T1> = object : Test<T2, T1>(<!ARGUMENT_TYPE_MISMATCH!>map2<!>, <!ARGUMENT_TYPE_MISMATCH!>map1<!>) {
         override val inverse: Test<T1, T2>
             get() = this@Test
     }

compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt

@@ -4,6 +4,6 @@ fun <T, R, S> foo(block: (T)-> R, second: (T)-> S) = block
 
 fun main() {
     val fff = { x: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(fff, { x -> x + 1 })
+    foo(<!ARGUMENT_TYPE_MISMATCH!>fff<!>, { x -> x <!UNRESOLVED_REFERENCE!>+<!> 1 })
 }
 

compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt

@@ -7,9 +7,9 @@ fun <T, R> foo(a: A<T, R>) = a
 fun <T, R> bar(f: (T) -> R) = f
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> }
-    <!INAPPLICABLE_CANDIDATE!>foo<!> { x -> x}
-    <!INAPPLICABLE_CANDIDATE!>foo<!> { x: Int -> x}
+    foo { <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }
+    foo { x -> <!ARGUMENT_TYPE_MISMATCH!>x<!>}
+    foo { x: Int -> <!ARGUMENT_TYPE_MISMATCH!>x<!>}
 
     bar { it <!UNRESOLVED_REFERENCE!>+<!> 1 }
     bar { x -> x <!UNRESOLVED_REFERENCE!>+<!> 1}

compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt

@@ -5,9 +5,9 @@ fun <K> id2(x: K, s: String): K = x
 fun <K> ret(s: String): K = TODO()
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>id2<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>, "foo")
-    <!INAPPLICABLE_CANDIDATE!>id2<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>, 42)
+    id2(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>, "foo")
+    id2(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>, <!ARGUMENT_TYPE_MISMATCH!>42<!>)
 
     ret("foo")
-    <!INAPPLICABLE_CANDIDATE!>ret<!>(42)
+    ret(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.fir.kt

@@ -4,5 +4,5 @@ class A
 fun A.fn(b: Int): Nothing = TODO()
 
 fun A.run() {
-    "".apply { <!INAPPLICABLE_CANDIDATE!>fn<!>("") }
+    "".apply { fn(<!ARGUMENT_TYPE_MISMATCH!>""<!>) }
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.fir.kt

@@ -2,20 +2,20 @@
 // WITH_RUNTIME
 
 fun Runnable.test(f: Runnable.(Int) -> Unit) {
-    <!INAPPLICABLE_CANDIDATE!>f<!>("")
+    f(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }
 
 fun test(f: Runnable.(Int) -> Unit, runnable: Runnable) {
     with (runnable) {
-        <!INAPPLICABLE_CANDIDATE!>f<!>("")
+        f(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
     }
 }
 
 fun Int.test(f: String.(Int) -> Unit) {
     f("", 0)
-    <!INAPPLICABLE_CANDIDATE!>f<!>("")
+    <!ARGUMENT_TYPE_MISMATCH!>f<!>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
     with("") {
         f(0)
-        <!INAPPLICABLE_CANDIDATE!>f<!>(0.0)
+        f(<!ARGUMENT_TYPE_MISMATCH!>0.0<!>)
     }
 }

compiler/testData/diagnostics/tests/inference/substitutions/simpleSubstitutionCheckTypeArgumentsNotTypeParameters.fir.kt

@@ -6,5 +6,5 @@ class A<T> {
 
 fun test1() {
     A<Int>().newA<String>().useT("")
-    A<Int>().newA<String>().<!INAPPLICABLE_CANDIDATE!>useT<!>(1)
+    A<Int>().newA<String>().useT(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 }

compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.fir.kt

@@ -20,6 +20,6 @@ class Foo<R> {
 
     fun test() {
         Foo<Int>().bar<String>().baz().getR(1)
-        Foo<Int>().bar<String>().baz().<!INAPPLICABLE_CANDIDATE!>getR<!>("")
+        Foo<Int>().bar<String>().baz().getR(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
     }
 }

compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoInnerClass.fir.kt

@@ -10,7 +10,7 @@ class Outer<T> {
 
 fun test1() {
     Outer<Int>().Inner<String>().getOuter().useOuterParam(22)
-    Outer<Int>().Inner<String>().getOuter().<!INAPPLICABLE_CANDIDATE!>useOuterParam<!>("")
+    Outer<Int>().Inner<String>().getOuter().useOuterParam(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }
 
 

compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.fir.kt

@@ -5,9 +5,9 @@ package typeConstructorMismatch
 import java.util.*
 
 fun test(set: Set<String>) {
-    <!INAPPLICABLE_CANDIDATE!>elemAndList<!>("2", set)
+    elemAndList("2", <!ARGUMENT_TYPE_MISMATCH!>set<!>)
 
-    "".<!INAPPLICABLE_CANDIDATE!>elemAndListWithReceiver<!>("", set)
+    "".elemAndListWithReceiver("", <!ARGUMENT_TYPE_MISMATCH!>set<!>)
 }
 
 fun <R> elemAndList(r: R, t: List<R>): R = r

compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt

@@ -33,9 +33,9 @@ fun test1(outA: Out<A>, inB: In<B>) {
 fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")
 
 fun test2(outA: Out<A>, inC: In<C>) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(outA, inC)
+    bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)
 
-    val b: Two<A, B> = <!INAPPLICABLE_CANDIDATE!>bar<!>(outA, inC)
+    val b: Two<A, B> = bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)
     use(b)
 }
 

compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.fir.kt

@@ -221,18 +221,18 @@ fun case_13() {
     val x3 = null as MutableList<Int>
     val x4 = select(null as List<Int>, null)
 
-    val result_1 = <!INAPPLICABLE_CANDIDATE!>select<!>(x1, x2, x3, x4)
-    val result_2 = <!INAPPLICABLE_CANDIDATE!>select<!>(x2, x1)
-    val result_3 = <!INAPPLICABLE_CANDIDATE!>select<!>(x2, x1, x3)
-    val result_4 = <!INAPPLICABLE_CANDIDATE!>select<!>(x3, x2)
-    val result_5 = <!INAPPLICABLE_CANDIDATE!>select<!>(x4, x2)
-    val result_6 = <!INAPPLICABLE_CANDIDATE!>select<!>(x4, x3, x2)
-    val result_7 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x1), <!INAPPLICABLE_CANDIDATE!>A<!>(x2), A(x3), A(x4))
-    val result_8 = <!INAPPLICABLE_CANDIDATE!>select<!>(<!INAPPLICABLE_CANDIDATE!>A<!>(x2), A(x1))
-    val result_9 = <!INAPPLICABLE_CANDIDATE!>select<!>(<!INAPPLICABLE_CANDIDATE!>A<!>(x2), A(x1), A(x3))
-    val result_10 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x3), <!INAPPLICABLE_CANDIDATE!>A<!>(x2))
-    val result_11 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x4), <!INAPPLICABLE_CANDIDATE!>A<!>(x2))
-    val result_12 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x4), A(x3), <!INAPPLICABLE_CANDIDATE!>A<!>(x2))
+    val result_1 = select(x1, <!ARGUMENT_TYPE_MISMATCH!>x2<!>, x3, x4)
+    val result_2 = select(<!ARGUMENT_TYPE_MISMATCH!>x2<!>, x1)
+    val result_3 = select(<!ARGUMENT_TYPE_MISMATCH!>x2<!>, x1, x3)
+    val result_4 = select(x3, <!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    val result_5 = select(x4, <!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    val result_6 = select(x4, x3, <!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    val result_7 = select(A(x1), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>), A(x3), A(x4))
+    val result_8 = select(A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>), A(x1))
+    val result_9 = select(A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>), A(x1), A(x3))
+    val result_10 = select(A(x3), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>))
+    val result_11 = select(A(x4), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>))
+    val result_12 = select(A(x4), A(x3), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>))
 
     result_1
     result_2

compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.ni.fir.kt

@@ -221,18 +221,18 @@ fun case_13() {
     val x3 = null as MutableList<Int>
     val x4 = select(null as List<Int>, null)
 
-    val result_1 = <!INAPPLICABLE_CANDIDATE!>select<!>(x1, x2, x3, x4)
-    val result_2 = <!INAPPLICABLE_CANDIDATE!>select<!>(x2, x1)
-    val result_3 = <!INAPPLICABLE_CANDIDATE!>select<!>(x2, x1, x3)
-    val result_4 = <!INAPPLICABLE_CANDIDATE!>select<!>(x3, x2)
-    val result_5 = <!INAPPLICABLE_CANDIDATE!>select<!>(x4, x2)
-    val result_6 = <!INAPPLICABLE_CANDIDATE!>select<!>(x4, x3, x2)
-    val result_7 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x1), <!INAPPLICABLE_CANDIDATE!>A<!>(x2), A(x3), A(x4))
-    val result_8 = <!INAPPLICABLE_CANDIDATE!>select<!>(<!INAPPLICABLE_CANDIDATE!>A<!>(x2), A(x1))
-    val result_9 = <!INAPPLICABLE_CANDIDATE!>select<!>(<!INAPPLICABLE_CANDIDATE!>A<!>(x2), A(x1), A(x3))
-    val result_10 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x3), <!INAPPLICABLE_CANDIDATE!>A<!>(x2))
-    val result_11 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x4), <!INAPPLICABLE_CANDIDATE!>A<!>(x2))
-    val result_12 = <!INAPPLICABLE_CANDIDATE!>select<!>(A(x4), A(x3), <!INAPPLICABLE_CANDIDATE!>A<!>(x2))
+    val result_1 = select(x1, <!ARGUMENT_TYPE_MISMATCH!>x2<!>, x3, x4)
+    val result_2 = select(<!ARGUMENT_TYPE_MISMATCH!>x2<!>, x1)
+    val result_3 = select(<!ARGUMENT_TYPE_MISMATCH!>x2<!>, x1, x3)
+    val result_4 = select(x3, <!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    val result_5 = select(x4, <!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    val result_6 = select(x4, x3, <!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    val result_7 = select(A(x1), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>), A(x3), A(x4))
+    val result_8 = select(A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>), A(x1))
+    val result_9 = select(A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>), A(x1), A(x3))
+    val result_10 = select(A(x3), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>))
+    val result_11 = select(A(x4), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>))
+    val result_12 = select(A(x4), A(x3), A(<!ARGUMENT_TYPE_MISMATCH!>x2<!>))
 
     result_1
     result_2

compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt

@@ -16,7 +16,7 @@ fun <T> checkItIsExactlyAny(t: T, l: MutableList<T>) {}
 fun <V : U, U> baz(v: V, u: MutableSet<U>) = u
 
 fun test(a: Any, s: MutableSet<String>) {
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, s)
+    baz(a, <!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }
 
 //from standard library

compiler/testData/diagnostics/tests/inference/violatingUpperBoundForSelfType.fir.kt

@@ -5,5 +5,5 @@ fun <E : Enum<E>> createMap(enumClass: Class<E>) {}
 
 fun reproduce() {
     val enumClass: Class<Enum<*>> = "any" as Class<Enum<*>>
-    <!INAPPLICABLE_CANDIDATE!>createMap<!>(enumClass)
+    createMap(<!ARGUMENT_TYPE_MISMATCH!>enumClass<!>)
 }