[FIR] Fix tests (ARGUMENT_TYPE_MISMATCH instead of INCOMPATIBLE_CANDIDATE)

compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.fir.txt

@@ -7,7 +7,7 @@ FILE: argParamTypeMismatch.kt
         lval int: R|kotlin/Int| = Int(1)
         <Inapplicable(INAPPLICABLE): /foo>#(R|<local>/int|)
         <Inapplicable(INAPPLICABLE): /foo>#(Int(2))
-        <Inapplicable(INAPPLICABLE): /foo>#(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <kind=EXACTLY_ONCE>  {
+        <Inapplicable(INAPPLICABLE): /foo>#(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <inline=Inline, kind=EXACTLY_ONCE>  {
             ^ Int(20)
         }
         ))

compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt

@@ -9,7 +9,7 @@ public @interface Ann {
 // FILE: main.kt
 
 @Ann(x = 10, s = "")
-<!INAPPLICABLE_CANDIDATE!>@Ann(10, "")<!>
+@Ann(<!ARGUMENT_TYPE_MISMATCH!>10<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 @Ann(x = 10, s = "", y = 10)
 class A
 

compiler/fir/analysis-tests/testData/resolve/arguments/default.kt

@@ -21,6 +21,6 @@ fun test() {
     baz(1, "my", "yours")
     baz(1, z = true)
 
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(0, "", false)
+    baz(0, "", <!ARGUMENT_TYPE_MISMATCH!>false<!>)
 }
 

compiler/fir/analysis-tests/testData/resolve/arguments/destructuring.kt

@@ -6,8 +6,8 @@ fun foo2(block: (C, C) -> Unit) = block(C(0, ""), C(0, ""))
 fun test() {
     foo1 { (x, y) -> C(x, y) }
     foo1 { (x: Int, y: String) -> C(x, y) }
-    foo1 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x, y) }
+    foo1 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>) -> C(<!ARGUMENT_TYPE_MISMATCH!>x<!>, <!ARGUMENT_TYPE_MISMATCH!>y<!>) }
     foo2 { (x, y), (z, w) -> C(x + z, y + w) }
     foo2 { (x: Int, y: String), (z: Int, w: String) -> C(x + z, y + w) }
-    foo2 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>), (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>z: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>w: Int<!>) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x + z, y + w) }
+    foo2 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>), (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>z: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>w: Int<!>) -> C(<!ARGUMENT_TYPE_MISMATCH!>x + z<!>, <!ARGUMENT_TYPE_MISMATCH!>y + w<!>) }
 }

compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt

@@ -17,9 +17,9 @@ fun test_1() {
 }
 
 fun test_2() {
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
+    takeInt(<!ARGUMENT_TYPE_MISMATCH!>10000000000<!>)
     takeLong(10000000000)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000<!>)
 }
 
 fun test_3() {
@@ -35,14 +35,14 @@ fun test_4() {
 }
 
 fun test_5() {
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
+    takeString(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
+    takeString(<!ARGUMENT_TYPE_MISMATCH!>run { 1 }<!>)
 }
 
 annotation class Ann(val x: Byte)
 
 @Ann(10)
 fun test_6() {
-    <!INAPPLICABLE_CANDIDATE!>@Ann(300)<!>
+    @Ann(<!ARGUMENT_TYPE_MISMATCH!>300<!>)
     val x = ""
 }

compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt

@@ -9,7 +9,7 @@ public @interface Ann {
 @Ann("a", "b")
 fun test_1() {}
 
-<!INAPPLICABLE_CANDIDATE!>@Ann(arrayOf("a", "b"))<!>
+@Ann(<!ARGUMENT_TYPE_MISMATCH!>arrayOf("a", "b")<!>)
 fun test_2() {}
 
 @Ann(*arrayOf("a", "b"))

compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt

@@ -13,6 +13,6 @@ fun takeOutA(array: Array<out A>) {}
 
 fun test(array: Array<B>) {
     A.take(array)
-    <!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
+    takeA(<!ARGUMENT_TYPE_MISMATCH!>array<!>)
     takeOutA(array)
 }

compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt

@@ -31,33 +31,33 @@ fun test_3() {
 fun takeByte(b: Byte) {}
 
 fun test_4() {
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 1)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 127<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>-100 - 100<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>10 * 10<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 * 100<!>)
     <!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 % 10<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 % 10<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 and 100<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>128 and 511<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 or 100<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 or 0<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>511 xor 511<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>512 xor 511<!>)
 }
 
 fun test_5() {
     takeByte(-1)
     takeByte(+1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1.inv()<!>)
 }
 
 fun test_6() {
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 127 + 1 }<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + run { 1 }<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 1 + 1 }<!>)
     1 + 1
     run { 1 }
     1 + run { 1 }

compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt

@@ -8,10 +8,10 @@ fun test() {
     foo(third = false, second = 2.71, fourth = "?!", first = 0)
 
     foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>0.0<!>, <!ARGUMENT_TYPE_MISMATCH!>false<!>, <!ARGUMENT_TYPE_MISMATCH!>0<!>, "")
     foo(1, 2.0, third = true, "")
     foo(second = 0.0, first = 0, fourth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
+    foo(first = <!ARGUMENT_TYPE_MISMATCH!>0.0<!>, second = <!ARGUMENT_TYPE_MISMATCH!>0<!>, third = <!ARGUMENT_TYPE_MISMATCH!>""<!>, fourth = <!ARGUMENT_TYPE_MISMATCH!>false<!>)
     foo(first = 0, second = 0.0, third = false, fourth = "", <!ARGUMENT_PASSED_TWICE!>first<!> = 1)
     foo(0, 0.0, false, <!NAMED_PARAMETER_NOT_FOUND!>foth<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt

@@ -7,8 +7,8 @@ fun test() {
     foo(1, "my", "yours")
     foo(1, *arrayOf("my", "yours"))
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
+    foo(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 
     bar(1, z = true, y = *arrayOf("my", "yours"))
 

compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt

@@ -9,7 +9,7 @@ fun bar(x: B) {}
 
 fun test(c: C) {
     // Argument mapping error
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     // Ambiguity
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(c)

compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt

@@ -72,7 +72,7 @@ fun test_4(x: Any, y: Any) {
         }
 
     )
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
+    takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>) // Bad
     takeInt(y) // OK
     takeInt(a) // Bad
 }

compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt

@@ -16,7 +16,7 @@ class B3_3 : A3("", true)
 class B3_4 : <!NONE_APPLICABLE!>A3<!>("", Unit)
 
 open class A4(val x: Byte)
-class B4 : <!INAPPLICABLE_CANDIDATE!>A4<!>( 1 + 1)
+class B4 : A4( <!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
 
 open class A5 {
     constructor(x: Byte)

compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt

@@ -25,7 +25,7 @@ class E<T> {
     // selection of the proper constructor
     // but a type mismatch for the first
     // argument
-    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10) {}
+    constructor(e: T, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 10) {}
 }
 
 class I<T> {
@@ -33,7 +33,7 @@ class I<T> {
     // selection of the proper constructor
     // but a type mismatch for the first
     // argument
-    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10)
+    constructor(e: T, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 10)
 }
 
 class J<T> {

compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt

@@ -7,9 +7,9 @@ class A {
 class B(other: B = <!NO_THIS!>this<!>)
 
 class C() {
-    constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>({
+    constructor(x: Int) : this({
         val a = 10
-        <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
+        <!ARGUMENT_TYPE_MISMATCH, INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
     }) {}
 }
 

compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt

@@ -62,8 +62,8 @@ fun <T> test2(t : T)
   t.bar()
 }
 
-val t1 = <!INAPPLICABLE_CANDIDATE!>test2<!><A>(A())
+val t1 = test2<A>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
-val t2 = <!INAPPLICABLE_CANDIDATE!>test2<!><B>(C())
+val t2 = test2<B>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
 val t3 = test2<C>(C())
 
 val <T, B : T> x : Int = 0

compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt

@@ -26,7 +26,7 @@ class G<E : <!FINAL_UPPER_BOUND!>Double<!>>(val balue: E) : F<E>(balue) {
     override var rest: E = balue
 }
 
-class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
+class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : F<E>(<!ARGUMENT_TYPE_MISMATCH!>balue<!>) {
     override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE
 }
 

compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt

@@ -27,7 +27,7 @@ class G<E : <!FINAL_UPPER_BOUND!>Double<!>>(val balue: E) : F<E>(balue) {
     override fun rest(): E = balue
 }
 
-class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
+class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : F<E>(<!ARGUMENT_TYPE_MISMATCH!>balue<!>) {
     override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE
 }
 

compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.fir.txt

@@ -22,7 +22,7 @@ FILE: upperBoundViolated.kt
         lval b1: R|B<kotlin/Int>| = R|/B.B|<R|kotlin/Int|>()
         lval b2: R|B<C>| = R|/B.B|<R|C|>()
         lval b3: R|B<kotlin/Any?>| = R|/B.B|<R|kotlin/Any?|>()
-        lval b4: R|B<A>| = R|/B.B|<<ERROR TYPE REF: Symbol not found for UnexistingType>>()
+        lval b4: R|ERROR CLASS: Unresolved name: NumberPhile| = R|/B.B|<<ERROR TYPE REF: Symbol not found for UnexistingType>>().<Unresolved name: NL>#(ERROR_EXPR(No right operand)).<Unresolved name: Int>#(<Call has no callee>#()).<Unresolved name: NumberPhile>#(ERROR_EXPR(No right operand))
         lval b5: R|B<B<ERROR CLASS: Symbol not found for UnexistingType>>| = R|/B.B|<R|B<ERROR CLASS: Symbol not found for UnexistingType>|>()
         R|/fest|<R|kotlin/Boolean|>()
         R|/fest|<R|C|>()
@@ -58,8 +58,8 @@ FILE: upperBoundViolated.kt
 
     }
     public final typealias NL<K> = R|NumColl<kotlin/collections/List<K>>|
-    public final val test7: R|NumColl<kotlin/collections/List<kotlin/Int>>| = R|/NumColl.NumColl|<R|kotlin/Int|>()
+    public final val test7: R|ERROR CLASS: Unresolved name: NumberPhile| = R|/NumColl.NumColl|<R|kotlin/Int|>().<Unresolved name: NumberPhile>#(ERROR_EXPR(No right operand))
-        public get(): R|NumColl<kotlin/collections/List<kotlin/Int>>|
+        public get(): R|ERROR CLASS: Unresolved name: NumberPhile|
     public final val test8: R|NumColl<kotlin/collections/List<kotlin/String>>| = R|/NumColl.NumColl|<R|kotlin/String|>()
         public get(): R|NumColl<kotlin/collections/List<kotlin/String>>|
     public final class NumberPhile<T : R|kotlin/Number|> : R|kotlin/Any| {
@@ -70,5 +70,5 @@ FILE: upperBoundViolated.kt
     }
     public final val np1: R|NumberPhile<kotlin/Int>| = R|/NumberPhile.NumberPhile|<R|kotlin/Int|>(Int(10))
         public get(): R|NumberPhile<kotlin/Int>|
-    public final val np2: R|NumberPhile<kotlin/String>| = <Inapplicable(INAPPLICABLE): /NumberPhile.NumberPhile>#<R|kotlin/String|>(String(Test))
+    public final val np2: R|NumberPhile<kotlin/Number>| = <Inapplicable(INAPPLICABLE): /NumberPhile.NumberPhile>#<R|kotlin/Number|>(String(Test))
-        public get(): R|NumberPhile<kotlin/String>|
+        public get(): R|NumberPhile<kotlin/Number>|

compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt

@@ -14,7 +14,7 @@ fun test() {
     val b1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
     val b2 = B<C>()
     val b3 = B<<!UPPER_BOUND_VIOLATED!>Any?<!>>()
-    val b4 = B<<!UNRESOLVED_REFERENCE!>UnexistingType<!>>()
+    val b4 = B<<!UNRESOLVED_REFERENCE!>UnexistingType<!>>()<!UNRESOLVED_REFERENCE{PSI}!>NL<!><!SYNTAX{PSI}!><<!>Int<!SYNTAX{PSI}!>><!>()NumberPhile<!SYNTAX{PSI}!><!>
     val b5 = B<<!UPPER_BOUND_VIOLATED!>B<<!UNRESOLVED_REFERENCE!>UnexistingType<!>><!>>()
     fest<<!UPPER_BOUND_VIOLATED!>Boolean<!>>()
     fest<C>()
@@ -40,9 +40,9 @@ fun <K, L : K> rest() {
 
 class NumColl<T : Collection<Number>>
 typealias NL<K> = NumColl<List<K>>
-val test7 = NL<Int>()
+val test7 = NL<Int>()<!UNRESOLVED_REFERENCE{PSI}!>NumberPhile<!><!SYNTAX{PSI}!><!>
 val test8 = NL<String>()
 
 class NumberPhile<T: Number>(x: T)
 val np1 = NumberPhile(10)
-val np2 = <!INAPPLICABLE_CANDIDATE!>NumberPhile<!>("Test")
+val np2 = NumberPhile(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)

compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt

@@ -18,5 +18,5 @@ fun test() {
     useEnum(TestEnum.THIRD)
 
     useVararg(TestEnum.FIRST, TestEnum.SECOND)
-    <!INAPPLICABLE_CANDIDATE!>useVararg<!>(1, 2, 3, 4, 5)
+    useVararg(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>, <!ARGUMENT_TYPE_MISMATCH!>3<!>, <!ARGUMENT_TYPE_MISMATCH!>4<!>, <!ARGUMENT_TYPE_MISMATCH!>5<!>)
 }

compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.fir.txt

@@ -18,5 +18,5 @@ FILE: typeParameters.kt
     }
     public final fun main(fooImpl: R|FooImpl|, bar: R|Bar|): R|kotlin/Unit| {
         lval a: R|FooImpl| = R|/foo|<R|FooImpl|>(R|<local>/fooImpl|)
-        lval b: R|Bar| = <Inapplicable(INAPPLICABLE): /foo>#<R|Bar|>(R|<local>/bar|)
+        lval b: R|Foo| = <Inapplicable(INAPPLICABLE): /foo>#<R|Foo|>(R|<local>/bar|)
     }

compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt

@@ -7,5 +7,5 @@ fun <T : Foo> foo(t: T) = t
 
 fun main(fooImpl: FooImpl, bar: Bar) {
     val a = foo(fooImpl)
-    val b = <!INAPPLICABLE_CANDIDATE!>foo<!>(bar)
+    val b = foo(<!ARGUMENT_TYPE_MISMATCH!>bar<!>)
 }

compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt

@@ -6,6 +6,6 @@ fun <T : Foo> foo(t: T) = t
 
 
 fun main(fooImpl: FooImpl, fooBarImpl: FooBarImpl) {
-    val a = <!INAPPLICABLE_CANDIDATE!>foo<!><FooImpl>(fooBarImpl)
+    val a = foo<FooImpl>(<!ARGUMENT_TYPE_MISMATCH!>fooBarImpl<!>)
     val b = foo<Foo>(fooImpl)
 }

compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.fir.txt

@@ -11,7 +11,7 @@ FILE: nullableIntegerLiteralType.kt
             }
         }
 
-        <Inapplicable(MAY_THROW_RUNTIME_ERROR): /takeInt>#(R|<local>/x|)
+        <Inapplicable(INAPPLICABLE): /takeInt>#(R|<local>/x|)
     }
     public final fun test_2(b: R|kotlin/Boolean|, y: R|kotlin/Int|): R|kotlin/Unit| {
         lval x: R|kotlin/Int?| = when () {
@@ -23,5 +23,5 @@ FILE: nullableIntegerLiteralType.kt
             }
         }
 
-        <Inapplicable(MAY_THROW_RUNTIME_ERROR): /takeInt>#(R|<local>/x|)
+        <Inapplicable(INAPPLICABLE): /takeInt>#(R|<local>/x|)
     }

compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt

@@ -4,10 +4,10 @@ fun takeInt(x: Int) {}
 
 fun test_1(b: Boolean) {
     val x = if (b) 1 else null
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
+    takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
 
 fun test_2(b: Boolean, y: Int) {
     val x = if (b) y else null
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
+    takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }

compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt

@@ -24,7 +24,7 @@ fun test_1_3(resolvedCall: ResolvedCall<CallableDescriptor>) {
 }
 
 fun test_2_1(resolvedCall: ResolvedCall<out CallableDescriptor>, d: CallableDescriptor) {
-    val x = resolvedCall.<!INAPPLICABLE_CANDIDATE!>updateD<!>(d) // should fail
+    val x = resolvedCall.updateD(<!ARGUMENT_TYPE_MISMATCH!>d<!>) // should fail
 }
 
 fun test_2_2(resolvedCall: ResolvedCall<in CallableDescriptor>, d: CallableDescriptor) {

compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt

@@ -12,10 +12,10 @@ val rr = Outer<String>().Inner<Int>()
 val rrq = Boxed<String>().substitute()
 
 fun check() {
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<Int>().Inner<Int>()) // illegal
+    accept(<!ARGUMENT_TYPE_MISMATCH!>Outer<Int>().Inner<Int>()<!>) // illegal
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
+    accept(<!ARGUMENT_TYPE_MISMATCH!>Outer<String>().Inner<String>()<!>) // illegal
     accept(Outer<String>().Inner<Int>()) // ok
 
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Boxed<Int>().substitute()) // illegal
+    accept(<!ARGUMENT_TYPE_MISMATCH!>Boxed<Int>().substitute()<!>) // illegal
     accept(Boxed<String>().substitute()) // ok
 }

compiler/fir/analysis-tests/testData/resolve/kt41984.fir.txt

@@ -21,6 +21,6 @@ FILE: main.kt
     }
     public final fun test_1(b: R|B<kotlin/Int>|, x: R|kotlin/Int|, inv: R|Inv<kotlin/Int>|): R|kotlin/Unit| {
         R|<local>/b|.R|SubstitutionOverride</B.take: R|kotlin/String|>|(R|<local>/x|)
-        R|<local>/b|.<Inapplicable(MAY_THROW_RUNTIME_ERROR): /B.take>#(Null(null))
+        R|<local>/b|.<Inapplicable(INAPPLICABLE): /B.take>#(Null(null))
         R|<local>/b|.R|SubstitutionOverride</B.takeInv: R|kotlin/String|>|(R|<local>/inv|)
     }

compiler/fir/analysis-tests/testData/resolve/kt41984.kt

@@ -26,6 +26,6 @@ open class B<V> : A<Any, V>() {
 
 fun test_1(b: B<Int>, x: Int, inv: Inv<Int>) {
     b.take(x)
-    b.<!INAPPLICABLE_CANDIDATE!>take<!>(null)
+    b.take(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
     b.takeInv(inv)
 }

compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.fir.txt

@@ -24,5 +24,5 @@ FILE: supertypeGenericsComplex.kt
     }
     public final fun f(list: R|kotlin/collections/MutableList<X>|, s: R|kotlin/collections/MutableList<kotlin/CharSequence>|): R|kotlin/Unit| {
         R|/C.C|().R|SubstitutionOverride</C.f: R|kotlin/Unit|>|<R|X|>(R|<local>/list|, R|<local>/s|)
-        R|/C.C|().<Inapplicable(INAPPLICABLE): /C.f>#<R|kotlin/CharSequence|>(R|<local>/s|, R|<local>/list|)
+        R|/C.C|().<Inapplicable(INAPPLICABLE): /C.f>#<R|Out<kotlin/CharSequence>|>(R|<local>/s|, R|<local>/list|)
     }

compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt

@@ -10,5 +10,5 @@ class C : Base<CharSequence>()
 
 fun f(list: MutableList<X>, s: MutableList<CharSequence>) {
     C().f(list, s)
-    C().<!INAPPLICABLE_CANDIDATE!>f<!>(s, list)
+    C().f(<!ARGUMENT_TYPE_MISMATCH!>s<!>, <!ARGUMENT_TYPE_MISMATCH!>list<!>)
 }

compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt

@@ -11,5 +11,5 @@ public interface SLRUMap<V> {
 // FILE: main.kt
 
 fun <V> SLRUMap<V>.getOrPut(value: V) {
-    <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
+    takeV(<!ARGUMENT_TYPE_MISMATCH!>value<!>)
 }

compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.fir.txt

@@ -14,7 +14,7 @@ FILE: main.kt
             ^ R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
         }
         ))
-        <Inapplicable(INAPPLICABLE): /foo2>#(R|/MyFunction|<R|kotlin/Number|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>| <inline=NoInline>  {
+        <Inapplicable(INAPPLICABLE): /foo2>#(R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>| <inline=NoInline>  {
             ^ R|<local>/x|.R|kotlin/Any.toString|()
         }
         ))

compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt

@@ -18,9 +18,9 @@ fun main() {
         x.toInt().toString()
     })
 
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(MyFunction { x: Int ->
+    foo2(<!ARGUMENT_TYPE_MISMATCH!>MyFunction { x: Int ->
         x.toString()
-    })
+    }<!>)
 
     foo3(
        MyFunction { x ->

compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt

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

compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt

@@ -21,8 +21,8 @@ fun main() {
         x.toInt().toString()
     }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo2<!> { x: Int ->
+    JavaUsage.foo2 { x: Int ->
-        x.toString()
+        <!ARGUMENT_TYPE_MISMATCH!>x.toString()<!>
     }
 
     JavaUsage.foo3(

compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt

@@ -29,11 +29,11 @@ fun main() {
     foo1 { x -> x > 1 }
     foo1(f)
 
-    <!INAPPLICABLE_CANDIDATE!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
+    foo2 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
+    foo2(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
+    foo3 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
-    <!INAPPLICABLE_CANDIDATE!>foo3<!>(f)
+    foo3(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
 
     foo4 { x -> x > 1 }
     foo4(f)

compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt

@@ -18,14 +18,14 @@ public class JavaUsage {
 fun foo(m: MyRunnable) {}
 
 fun main() {
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!> {
+    JavaUsage.foo {
             x ->
-        x <!UNRESOLVED_REFERENCE!>><!> 1
+        <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!>
     }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> > 1 })
+    JavaUsage.foo({ <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> > 1<!> })
 
     val x = { x: Int -> x > 1 }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
+    JavaUsage.foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }

compiler/fir/analysis-tests/testData/resolve/suppress/singleError.fir.txt

@@ -1,6 +1,6 @@
 FILE: singleError.kt
     public final fun foo(x: R|kotlin/String|): R|kotlin/Unit| {
     }
-    @R|kotlin/Suppress|(vararg(String(INAPPLICABLE_CANDIDATE))) public final fun bar(): R|kotlin/Unit| {
+    @R|kotlin/Suppress|(vararg(String(ARGUMENT_TYPE_MISMATCH))) public final fun bar(): R|kotlin/Unit| {
         <Inapplicable(INAPPLICABLE): /foo>#(Int(10))
     }

compiler/fir/analysis-tests/testData/resolve/suppress/singleError.kt

@@ -1,6 +1,6 @@
 fun foo(x: String) {}
 
-@Suppress("INAPPLICABLE_CANDIDATE")
+@Suppress("ARGUMENT_TYPE_MISMATCH")
 fun bar() {
     foo(10)
 }

compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt

@@ -90,5 +90,5 @@ fun test_7(a: A, inv1: Invariant1<A>, inv2: Invariant1<in A>, inv3: Invariant1<o
 
     inv1.take(a)
     inv2.take(a)
-    inv3.<!INAPPLICABLE_CANDIDATE!>take<!>(a)
+    inv3.take(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt

@@ -5,9 +5,9 @@ fun main(k: KSub, vString: SuperClass<String>.NestedInSuperClass, vInt: SuperCla
     k.getImpl().nestedI(vString)
 
     // TODO: Support parametrisized inner classes
-    k.getImpl().<!INAPPLICABLE_CANDIDATE!>nestedI<!>(vInt)
+    k.getImpl().nestedI(<!ARGUMENT_TYPE_MISMATCH!>vInt<!>)
     k.getNestedSubClass().nested("")
-    k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE!>nested<!>(1)
+    k.getNestedSubClass().nested(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 }
 
 // FILE: J1.java

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameter.kt

@@ -9,5 +9,5 @@ public class JavaClass {
 // FILE: K2.kt
 fun main() {
     JavaClass.baz(KotlinClass())
-    JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
+    JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameterGeneric.kt

@@ -10,6 +10,6 @@ public class JavaClass {
 fun main() {
     JavaClass.baz(KotlinClass())
     JavaClass.baz(KotlinClass<Int>())
-    JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>(KotlinClass<String>())
+    JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>KotlinClass<String>()<!>)
-    JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
+    JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }

compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.out

@@ -10,9 +10,9 @@ compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:2:74: error: unresolv
 compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:7:20: error: 'this' is not defined in this context
 class B(other: B = this)
                    ^
-compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:10:27: error: inapplicable candidate(s): /C.C
+compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:12:9: error: argument type mismatch: actual type is ERROR CLASS: Cannot access ''<this>'' before superclass constructor has been called but TypeVariable(_L) was expected
-    constructor(x: Int) : this({
+        this
-                          ^
+        ^
 compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:12:9: error: cannot access '<this>' before superclass constructor has been called
         this
         ^

compiler/testData/diagnostics/tests/AutoCreatedIt.fir.kt

@@ -13,7 +13,7 @@ fun text() {
     <!INAPPLICABLE_CANDIDATE!>bar2<!> {}
     bar2 {1}
     bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
-    <!INAPPLICABLE_CANDIDATE!>bar2<!> {it -> it}
+    bar2 {it -> <!ARGUMENT_TYPE_MISMATCH!>it<!>}
 }
 
 fun bar(f :  (Int, Int) -> Int) {}

compiler/testData/diagnostics/tests/Basic.fir.kt

@@ -2,9 +2,9 @@
 fun foo(u : Unit) : Int = 1
 
 fun test() : Int {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     val a : () -> Unit = {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(1)
+        foo(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     }
     return 1 <!NONE_APPLICABLE!>-<!> "1"
 }

compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.fir.kt

@@ -23,7 +23,7 @@ fun f(): Unit {
     x !== 1
 
     x<!NONE_APPLICABLE!>..<!>2
-    x <!INAPPLICABLE_CANDIDATE!>in<!> 1..2
+    <!ARGUMENT_TYPE_MISMATCH!>x<!> in 1..2
 
     val y : Boolean? = true
     false || y

compiler/testData/diagnostics/tests/Constants.fir.kt

@@ -29,25 +29,25 @@ fun test() {
     checkSubtype<Double>(1e5)
     checkSubtype<Float>(1e-5.toFloat())
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Double>(1)
+    checkSubtype<Double>(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Float>(1)
+    checkSubtype<Float>(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 
     1 as Byte
     1 as Int
     0xff as Long
 
     1.1 as Int
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(1.1)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>1.1<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>varargByte<!>(0x77, 1, 3, 200, 0b111)
+    varargByte(0x77, 1, 3, <!ARGUMENT_TYPE_MISMATCH!>200<!>, 0b111)
-    <!INAPPLICABLE_CANDIDATE!>varargShort<!>(0x777, 1, 2, 3, 200000, 0b111)
+    varargShort(0x777, 1, 2, 3, <!ARGUMENT_TYPE_MISMATCH!>200000<!>, 0b111)
-    <!INAPPLICABLE_CANDIDATE!>varargInt<!>(0x77777777, 0x7777777777, 1, 2, 3, 2000000000, 0b111)
+    varargInt(0x77777777, <!ARGUMENT_TYPE_MISMATCH!>0x7777777777<!>, 1, 2, 3, 2000000000, 0b111)
     varargLong(0x777777777777, 1, 2, 3, 200000, 0b111)
-    <!INAPPLICABLE_CANDIDATE!>varargFloat<!>(1, 1.0, -0.1, 1e4, 1e-4, -1e4)
+    varargFloat(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>1.0<!>, <!ARGUMENT_TYPE_MISMATCH!>-0.1<!>, <!ARGUMENT_TYPE_MISMATCH!>1e4<!>, <!ARGUMENT_TYPE_MISMATCH!>1e-4<!>, <!ARGUMENT_TYPE_MISMATCH!>-1e4<!>)
-    <!INAPPLICABLE_CANDIDATE!>varargDouble<!>(1, 1.0, -0.1, 1e4, 1e-4, -1e4)
+    varargDouble(<!ARGUMENT_TYPE_MISMATCH!>1<!>, 1.0, -0.1, 1e4, 1e-4, -1e4)
 
     testFun(1.0)
-    <!INAPPLICABLE_CANDIDATE!>testFun<!><Float>(1.0)
+    testFun<Float>(<!ARGUMENT_TYPE_MISMATCH!>1.0<!>)
     testFun(1.0.toFloat())
     testFun<Float>(1.0.toFloat())
 }

compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt

@@ -40,8 +40,8 @@ class Example {
     var d by CustomDelegate3()
 
     fun test() {
-        <!INAPPLICABLE_CANDIDATE!>requireString<!>(a)
+        requireString(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
-        <!INAPPLICABLE_CANDIDATE!>requireString<!>(aval)
+        requireString(<!ARGUMENT_TYPE_MISMATCH!>aval<!>)
         requireString(b)
         requireInt(c)
         requireInt(d)

compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.fir.kt

@@ -16,7 +16,7 @@ operator fun String.unaryPlus(): Int = 0
 fun test() {
     requireInt(+ "")
     requireInt(+ Example())
-    <!INAPPLICABLE_CANDIDATE!>requireString<!>(<!INAPPLICABLE_CANDIDATE!>+<!> ExampleDeprecated())
+    requireString(<!ARGUMENT_TYPE_MISMATCH!><!INAPPLICABLE_CANDIDATE!>+<!> ExampleDeprecated()<!>)
 }
 
 fun requireInt(n: Int) {}

compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt

@@ -49,7 +49,7 @@ fun <T> bar(a: Any): T = a as T
 fun <T> foo() {
     foo<<!UNRESOLVED_REFERENCE!>Color.RED<!>>()
     foo<RedAlias>()
-    <!INAPPLICABLE_CANDIDATE!>bar<!><<!UNRESOLVED_REFERENCE!>Color.RED<!>>(Color.RED)
+    bar<<!UNRESOLVED_REFERENCE!>Color.RED<!>>(<!ARGUMENT_TYPE_MISMATCH!>Color.RED<!>)
 }
 
-fun Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>.foo(entries: Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>): Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>> = null!!
+fun Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>.foo(entries: Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>): Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>> = null!!

compiler/testData/diagnostics/tests/ExtensionCallInvoke.fir.kt

@@ -2,6 +2,6 @@ fun bar(doIt: Int.() -> Int) {
     1.doIt()
     1<!UNNECESSARY_SAFE_CALL!>?.<!>doIt()
     val i: Int? = 1
-    i.<!INAPPLICABLE_CANDIDATE!>doIt<!>()
+    <!ARGUMENT_TYPE_MISMATCH!>i<!>.doIt()
     i?.doIt()
 }

compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt

@@ -33,8 +33,8 @@ fun main(args : Array<String>) {
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     args.foo1()(1)
-    <!INAPPLICABLE_CANDIDATE!>args.foo1()<!>("1")
+    args.foo1()(<!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()<!>("1")
+    <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     foo2()({})

compiler/testData/diagnostics/tests/MultipleBounds.fir.kt

@@ -62,8 +62,8 @@ fun <T> test2(t : T)
   t.bar()
 }
 
-val t1 = <!INAPPLICABLE_CANDIDATE!>test2<!><A>(A())
+val t1 = test2<A>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
-val t2 = <!INAPPLICABLE_CANDIDATE!>test2<!><B>(C())
+val t2 = test2<B>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
 val t3 = test2<C>(C())
 
 val <T, B : T> x : Int = 0

compiler/testData/diagnostics/tests/ResolveToJava.fir.kt

@@ -28,7 +28,7 @@ fun test(l : java.util.List<Int>) {
   Collections.emptyList()
 
   checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
-  Collections.<!INAPPLICABLE_CANDIDATE!>singleton<!><Int>(1.0)
+  Collections.singleton<Int>(<!ARGUMENT_TYPE_MISMATCH!>1.0<!>)
 
   List<Int>
 

compiler/testData/diagnostics/tests/Serializable.fir.kt

@@ -36,8 +36,8 @@ fun testLiterals() {
 }
 
 fun testNotSerializable(l: List<Int>) {
-    <!INAPPLICABLE_CANDIDATE!>use<!>(l)
+    use(<!ARGUMENT_TYPE_MISMATCH!>l<!>)
-    <!INAPPLICABLE_CANDIDATE!>use<!>(N())
+    use(<!ARGUMENT_TYPE_MISMATCH!>N()<!>)
 }
 
 enum class C {

compiler/testData/diagnostics/tests/Varargs.fir.kt

@@ -10,7 +10,7 @@ fun test() {
     v1()
     v1({})
     v1({}, {})
-    <!INAPPLICABLE_CANDIDATE!>v1<!>({}, 1, {})
+    v1({}, <!ARGUMENT_TYPE_MISMATCH!>1<!>, {})
     v1({}, {}, {it})
     v1({}) <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
     v1 <!VARARG_OUTSIDE_PARENTHESES!>{}<!>

compiler/testData/diagnostics/tests/Variance.fir.kt

@@ -33,9 +33,9 @@ fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
 fun copy4(from : Array<out Number>, to : Array<in Int>) {}
 
 fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
-    <!INAPPLICABLE_CANDIDATE!>copy1<!>(ints, any)
+    copy1(<!ARGUMENT_TYPE_MISMATCH!>ints<!>, any)
     copy2(ints, any) //ok
-    <!INAPPLICABLE_CANDIDATE!>copy2<!>(ints, numbers)
+    copy2(ints, <!ARGUMENT_TYPE_MISMATCH!>numbers<!>)
     copy3<Int>(ints, numbers)
     copy4(ints, numbers) //ok
 }

compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt

@@ -1,10 +1,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-class TopLevelClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
+class TopLevelClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> {
-    class InnerClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
+    class InnerClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> {
         fun test() {
-            class InFun<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T>
+            class InFun<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T>
         }
     }
 }

compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt

@@ -1,12 +1,12 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> topFun() = 12
+fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> topFun() = 12
 
 class SomeClass {
-    fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> method() = 12
+    fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> method() = 12
 
     fun foo() {
-        fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> innerFun() = 12
+        fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> innerFun() = 12
     }
 }

compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt

@@ -3,10 +3,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> T.topProp: Int get() = 12
+val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> T.topProp: Int get() = 12
 
 class SomeClass {
-    val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.field: Int get() = 12
+    val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> T.field: Int get() = 12
 
     fun foo() {
         val <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> localVal = 12

compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.fir.kt

@@ -1,6 +1,6 @@
 package test
 
-<!INAPPLICABLE_CANDIDATE!>@BadAnnotation(1)<!>
+@BadAnnotation(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 object SomeObject
 
 val some = SomeObject

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.fir.kt

@@ -11,5 +11,5 @@ enum class MyEnum {
     A
 }
 
-<!INAPPLICABLE_CANDIDATE!>@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test()<!>)<!>
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, ARGUMENT_TYPE_MISMATCH!>Test()<!>)
 class Test2

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.fir.kt

@@ -11,5 +11,5 @@ enum class MyEnum {
     A
 }
 
-<!INAPPLICABLE_CANDIDATE!>@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test()<!>)<!>
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, ARGUMENT_TYPE_MISMATCH!>Test()<!>)
 class Test2

compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt

@@ -13,7 +13,7 @@ annotation class Ann
 fun <@Ann R : @Ann Any> f3(a: Array<@Ann R>): Array<@Ann R?> =  null!!
 
 fun test2(a: @Ann Array<in @Ann Int>) {
-    val r: Array<in Int?> = <!INAPPLICABLE_CANDIDATE!>f3<!>(a)
+    val r: Array<in Int?> = f3(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }
 
 

compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.fir.kt

@@ -13,7 +13,7 @@ fun foo() {
         return@l1 103
     }
 
-    bar <!INAPPLICABLE_CANDIDATE!>@Ann("")<!> {
+    bar @Ann(<!ARGUMENT_TYPE_MISMATCH!>""<!>) {
         104
     }
 }

compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.fir.kt

@@ -8,7 +8,7 @@ annotation class Ann(val x: Int = 6)
 
 @Ann(1) @Ann(2) @Ann(3) private class A @Ann constructor() {
     @Ann(x = 5) fun foo() {
-        1 + @Ann(1) 1 * <!INAPPLICABLE_CANDIDATE!>@Ann("")<!> 6
+        1 + @Ann(1) 1 * @Ann(<!ARGUMENT_TYPE_MISMATCH!>""<!>) 6
 
         @Ann fun local() {}
     }

compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.fir.kt

@@ -7,7 +7,7 @@ fun foo1() {}
 @Anno(x = ["a", "b"], y = "a")
 fun foo2() {}
 
-<!INAPPLICABLE_CANDIDATE!>@Anno(x = <!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("a")<!>, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("b")<!>)<!>, y = "a")<!>
+@Anno(x = <!ARGUMENT_TYPE_MISMATCH, NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("a")<!>, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("b")<!>)<!>, y = "a")
 fun foo3() {}
 
 @Anno(x = arrayOf("a", "b"), y = "a")

compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.fir.kt

@@ -12,5 +12,5 @@ class C<T> {
 }
 
 fun test(a: C<out CharSequence>) {
-    <!INAPPLICABLE_CANDIDATE!>a[1]<!> = 25
+    a[1] = <!ARGUMENT_TYPE_MISMATCH!>25<!>
 }

compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.fir.kt

@@ -14,5 +14,5 @@ class C<T> {
 class Out<out F>
 
 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a <!INAPPLICABLE_CANDIDATE!>+<!> y
+    a + <!ARGUMENT_TYPE_MISMATCH!>y<!>
 }

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)
+        expectFunction0String(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(x)
+        expectFunction1Unit(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(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)
+    baz<Int, String?>(<!ARGUMENT_TYPE_MISMATCH!>null<!>, null, ::foo)
-    <!INAPPLICABLE_CANDIDATE!>baz<!><Int?, String>(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()))
+    checkSubtype<Number>(<!ARGUMENT_TYPE_MISMATCH!>base.get(B())<!>)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(base.get(C()))
+    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)
 

compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.fir.kt

@@ -6,5 +6,5 @@ interface G<T>
 fun test(tr: Tr) {
     val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G?<!>
     // If v is not nullable, there will be a warning on this line:
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v!!)
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v!!<!>)
 }

compiler/testData/diagnostics/tests/cast/bare/FromErrorType.fir.kt

@@ -4,5 +4,5 @@ class G<T>
 
 fun foo(p: <!UNRESOLVED_REFERENCE!>P<!>) {
     val v = p as G?
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v!!)
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v!!<!>)
 }

compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.fir.kt

@@ -5,5 +5,5 @@ interface G<T>
 
 fun test(tr: Tr?) {
     val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G<!>
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v)
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
-}
+}

compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.fir.kt

@@ -5,5 +5,5 @@ interface G<T>
 
 fun test(tr: Tr?) {
     val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G?<!>
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v!!)
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v!!<!>)
-}
+}

compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.fir.kt

@@ -5,5 +5,5 @@ interface G<T>
 
 fun test(tr: Tr) {
     val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G<!>
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v)
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
-}
+}

compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.fir.kt

@@ -4,4 +4,4 @@
 interface Tr
 interface G<T>
 
-fun test(tr: Tr) = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>>(tr)
+fun test(tr: Tr) = checkSubtype<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>>(<!ARGUMENT_TYPE_MISMATCH!>tr<!>)

compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt

@@ -11,27 +11,27 @@ fun main() {
     join(1, "2")
     join(1, "2", "3")
     join(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, *"2")
+    join(1, *<!ARGUMENT_TYPE_MISMATCH!>"2"<!>)
     join(x = 1, a = "2")
     join(x = *1, a = *"2")
     join(x = 1, a = a)
-    <!INAPPLICABLE_CANDIDATE!>join<!>(x = 1, a = b)
+    join(x = 1, a = <!ARGUMENT_TYPE_MISMATCH!>b<!>)
     join(1, *a)
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, *b)
+    join(1, *<!ARGUMENT_TYPE_MISMATCH!>b<!>)
     join(1, *a, "3")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, *b, "3")
+    join(1, *<!ARGUMENT_TYPE_MISMATCH!>b<!>, "3")
     join(1, "4", *a, "3")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, "4", *b, "3")
+    join(1, "4", *<!ARGUMENT_TYPE_MISMATCH!>b<!>, "3")
     join(1, "4", *a)
     join(1, "4", *a, *a, "3")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, "4", *a, *b, "3")
+    join(1, "4", *a, *<!ARGUMENT_TYPE_MISMATCH!>b<!>, "3")
     join(a = a, x = 1)
-    <!INAPPLICABLE_CANDIDATE!>join<!>(a = b, x = 1)
+    join(a = <!ARGUMENT_TYPE_MISMATCH!>b<!>, x = 1)
     join(a = a, x = 1)
 
     joinG<String>(1, "2")
     joinG<String>(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!INAPPLICABLE_CANDIDATE!>joinG<!><String>(1, *"2")
+    joinG<String>(1, *<!ARGUMENT_TYPE_MISMATCH!>"2"<!>)
     joinG<String>(x = 1, a = a)
     joinG<String>(x = 1, a = "2")
     joinG<String>(x = *1, a = *"2")
@@ -44,7 +44,7 @@ fun main() {
 
     joinG(1, "2")
     joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!INAPPLICABLE_CANDIDATE!>joinG<!>(1, *"2")
+    joinG(1, *<!ARGUMENT_TYPE_MISMATCH!>"2"<!>)
     joinG(x = 1, a = a)
     joinG(x = 1, a = "2")
     joinG(x = *1, a = *"2")

compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt

@@ -17,9 +17,9 @@ fun test() {
 
     foo(<!NAMED_PARAMETER_NOT_FOUND!>r<!> = <!UNRESOLVED_REFERENCE!>xx<!>, i = "", s = "")
 
-    foo(i = 1, <!ARGUMENT_PASSED_TWICE!>i<!> = 1, s = 11)
+    foo(i = 1, <!ARGUMENT_PASSED_TWICE!>i<!> = 1, s = <!ARGUMENT_TYPE_MISMATCH!>11<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("", s = 2)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, s = <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 
     foo(i = "", s = 2, <!TOO_MANY_ARGUMENTS!>33<!>)
 

compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.txt

@@ -5,3 +5,4 @@ package a {
     public fun foo(/*0*/ i: kotlin.Int, /*1*/ s: kotlin.String): kotlin.Unit
     public fun test(): kotlin.Unit
 }
+

compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.fir.kt

@@ -10,7 +10,7 @@ fun bar(a: Int) {}
 
 fun test() {
     <!NONE_APPLICABLE!>foo<!>(1, 2)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     <!NONE_APPLICABLE!>bar<!>(1, 2)
     <!NONE_APPLICABLE!>bar<!>()

compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt

@@ -4,9 +4,9 @@ package kt1075
 //KT-1075 No type check for 'in range' condition in 'when' expression
 
 fun foo(b: String) {
-    if (b <!INAPPLICABLE_CANDIDATE!>in<!> 1..10) {} //type mismatch
+    if (<!ARGUMENT_TYPE_MISMATCH!>b<!> in 1..10) {} //type mismatch
     when (b) {
-        <!INAPPLICABLE_CANDIDATE!>in<!> 1..10 -> 1 //no type mismatch, but it should be here
+        <!ARGUMENT_TYPE_MISMATCH!>in 1..10<!> -> 1 //no type mismatch, but it should be here
         else -> 2
     }
 }

compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt

@@ -105,11 +105,11 @@ fun testImplicitCoercion() {
     val g = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 4
     val h = if (false) 4 else {}
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (true) {
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (true) {
         4
     } else {
         z = 342
-    })
+    }<!>)
 }
 
 fun fooWithAnyArg(arg: Any) {}

compiler/testData/diagnostics/tests/dataFlow/EmptyIf.fir.kt

@@ -7,14 +7,14 @@ fun f1(s: String?) {
 
 fun f2(s: Number?) {
     if (s is Int);
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(s)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
     if (s as Int == 42);
     checkSubtype<Int>(s)
 }
 
 fun f3(s: Number?) {
     if (s is Int && s as Int == 42);
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(s)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }
 
 fun f4(s: Int?) {

compiler/testData/diagnostics/tests/dataFlow/IsExpression.fir.kt

@@ -1,6 +1,6 @@
 fun f(a: Boolean, b: Int) {}
 
 fun foo(a: Any) {
-    <!INAPPLICABLE_CANDIDATE!>f<!>(a is Int, a)
+    f(a is Int, <!ARGUMENT_TYPE_MISMATCH!>a<!>)
     1 <!NONE_APPLICABLE!>+<!> a
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.fir.kt

@@ -5,9 +5,9 @@ fun foo() {
     val x: Int? = null
 
     if (x != null && bar(x) == 0) bar(bar(x))
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
-    if (x == null || bar(x) == 0) bar(<!INAPPLICABLE_CANDIDATE!>bar<!>(x))
+    if (x == null || bar(x) == 0) bar(bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>))
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     if (x is Int && bar(x)*bar(x) == bar(x)) bar(x)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.fir.kt

@@ -4,10 +4,10 @@ fun foo() {
     val x: Int? = null
     val a = Array<Int>(3, {0})
 
-    if (x != null) bar(a[x]) else bar(<!INAPPLICABLE_CANDIDATE!>a[x]<!>)
+    if (x != null) bar(a[x]) else bar(a[<!ARGUMENT_TYPE_MISMATCH!>x<!>])
     bar(a[if (x == null) 0 else x])
-    bar(<!INAPPLICABLE_CANDIDATE!>a[x]<!>)
+    bar(a[<!ARGUMENT_TYPE_MISMATCH!>x<!>])
-    
+
-    <!INAPPLICABLE_CANDIDATE!>"123"[x]<!>;
+    "123"[<!ARGUMENT_TYPE_MISMATCH!>x<!>];
     if (x != null) "123"[x];
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt

@@ -7,7 +7,7 @@ fun foo() {
     if (x != null) bar(a[<!DEBUG_INFO_SMARTCAST!>x<!>]) else bar(a[<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>])
     bar(a[if (x == null) 0 else <!DEBUG_INFO_SMARTCAST!>x<!>])
     bar(a[<!TYPE_MISMATCH!>x<!>])
-    
+
     "123"[<!TYPE_MISMATCH!>x<!>];
     if (x != null) "123"[<!DEBUG_INFO_SMARTCAST!>x<!>];
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.fir.kt

@@ -6,6 +6,6 @@ fun foo() {
     val x: Int? = null
 
     bar(1 + (if (x == null) 0 else x))
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (x == null) x else x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (x == null) x else x<!>)
     if (x != null) bar(x + x/(x-x*x))
 }