diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.fir.txt b/compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.fir.txt
index 118a68db748..a5f0a67c993 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.fir.txt
+++ b/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)
         }
         ))
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt
index 53f208b8d12..6cc468f8ad9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt
+++ b/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
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
index b663afc10d8..a107b117ea9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
+++ b/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<!>)
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/destructuring.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/destructuring.kt
index 9bbfc169681..7e2a09e7bb6 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/destructuring.kt
+++ b/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<!>) }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
index 0aa726d7740..ab2b98af4f4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
+++ b/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)
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
+    takeString(<!ARGUMENT_TYPE_MISMATCH!>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 = ""
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt
index 836351935b1..e5f808959c1 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt
+++ b/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"))
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
index 5972c59efdb..30065fc999c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
+++ 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)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
index 242b333b0a0..b2b537bd106 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
+++ b/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)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 127<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>-100 - 100<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>10 * 10<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 * 100<!>)
     <!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 % 10<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 % 10<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 and 100<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>128 and 511<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 or 100<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 or 0<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>511 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 })
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 127 + 1 }<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + run { 1 }<!>)
+    takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 1 + 1 }<!>)
     1 + 1
     run { 1 }
     1 + run { 1 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
index 38d5c6046a8..18bbb53cdd8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
+++ b/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!>)<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
index 3bf7a428880..d37913b1703 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
+++ b/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<!>("")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    foo(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 
     bar(1, z = true, y = *arrayOf("my", "yours"))
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
index bd6a5a00a3e..be7f3df64ad 100644
--- a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
+++ b/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)
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
index f91d92380d2..6d36b74cadf 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
+++ b/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
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
index 237b64d4f3f..b4a312e62e3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
+++ b/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)
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
index 0ff6c499e81..b0386efbaf0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
+++ b/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> {
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
index bd69a862cac..3803e5b1085 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
+++ b/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<!>
     }) {}
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt
index 529a97b9729..ee395cf250d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt
+++ b/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 t2 = <!INAPPLICABLE_CANDIDATE!>test2<!><B>(C())
+val t1 = test2<A>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
+val t2 = test2<B>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
 val t3 = test2<C>(C())
 
 val <T, B : T> x : Int = 0
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
index 778680b90bd..9f8d1902b4c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
+++ b/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
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
index a6f64235b3b..5e9975af944 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
+++ b/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
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.fir.txt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.fir.txt
index f7943cccf56..34f05662a1a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.fir.txt
+++ b/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 get(): R|NumColl<kotlin/collections/List<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|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 get(): R|NumberPhile<kotlin/String>|
+    public final val np2: R|NumberPhile<kotlin/Number>| = <Inapplicable(INAPPLICABLE): /NumberPhile.NumberPhile>#<R|kotlin/Number|>(String(Test))
+        public get(): R|NumberPhile<kotlin/Number>|
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
index 82d44bb7e8b..879967259a8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
+++ b/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"<!>)
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
index a9d5bb7a440..c0687a74c03 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
+++ b/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<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.fir.txt b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.fir.txt
index 72def902fd6..31a39eb0025 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.fir.txt
+++ b/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|)
     }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt
index 651ca4c1e6f..7ebefdd94d8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt
+++ b/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<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt
index f4bf4ac52f5..2b9db6b8193 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt
+++ b/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)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.fir.txt b/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.fir.txt
index 60c1c692117..5c4218a0dd5 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.fir.txt
+++ b/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|)
     }
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
index 14fcd4dd0ff..2f1d982257c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
+++ b/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<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt
index 0a52fd88247..1ffb333939d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt
+++ b/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) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
index 6e298256607..c9664810eb3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
+++ b/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
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
+    accept(<!ARGUMENT_TYPE_MISMATCH!>Outer<Int>().Inner<Int>()<!>) // 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
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/kt41984.fir.txt b/compiler/fir/analysis-tests/testData/resolve/kt41984.fir.txt
index 733d8d6dfd2..0de2d198e4f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/kt41984.fir.txt
+++ b/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|)
     }
diff --git a/compiler/fir/analysis-tests/testData/resolve/kt41984.kt b/compiler/fir/analysis-tests/testData/resolve/kt41984.kt
index e693f6acce1..51825da4bfa 100644
--- a/compiler/fir/analysis-tests/testData/resolve/kt41984.kt
+++ b/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)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.fir.txt b/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.fir.txt
index 01055594087..0ef94536121 100644
--- a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.fir.txt
+++ b/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|)
     }
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
index 5fd73df0428..b8d49b08dc4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
+++ b/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<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt b/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
index 0230fdf919f..ff5893b19b7 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
+++ b/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<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.fir.txt b/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.fir.txt
index d1533921669..dbd0384b396 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.fir.txt
+++ b/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|()
         }
         ))
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt b/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
index dda848e2b85..60bc320c4c2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
+++ b/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 ->
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt b/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt
index d2426e224ed..fe930323611 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt
+++ b/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)<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt b/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
index c4eac6be67d..15623b888e3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
@@ -21,8 +21,8 @@ fun main() {
         x.toInt().toString()
     }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo2<!> { x: Int ->
-        x.toString()
+    JavaUsage.foo2 { x: Int ->
+        <!ARGUMENT_TYPE_MISMATCH!>x.toString()<!>
     }
 
     JavaUsage.foo3(
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt b/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
index 5fb027ccb83..9993c16eaf8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
+++ b/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 }
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
+    foo2 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
+    foo2(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
-    <!INAPPLICABLE_CANDIDATE!>foo3<!>(f)
+    foo3 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
+    foo3(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
 
     foo4 { x -> x > 1 }
     foo4(f)
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt
index 6235c6e8a92..c9955ff8ac2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt
+++ b/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<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/suppress/singleError.fir.txt b/compiler/fir/analysis-tests/testData/resolve/suppress/singleError.fir.txt
index 1baaf30ee06..81c85d22164 100644
--- a/compiler/fir/analysis-tests/testData/resolve/suppress/singleError.fir.txt
+++ b/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))
     }
diff --git a/compiler/fir/analysis-tests/testData/resolve/suppress/singleError.kt b/compiler/fir/analysis-tests/testData/resolve/suppress/singleError.kt
index d80a4283953..4dbdac633d7 100644
--- a/compiler/fir/analysis-tests/testData/resolve/suppress/singleError.kt
+++ b/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)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt b/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
index 15dd68d4062..3bd1b472d05 100644
--- a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
+++ b/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<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt
index e8c12d5cbf3..b56220f6c3b 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt
+++ b/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
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameter.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameter.kt
index c2256f265e2..3b2fbab2883 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameter.kt
+++ b/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!>""<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameterGeneric.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameterGeneric.kt
index 970b06ffc7e..25fb5fa7862 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameterGeneric.kt
+++ b/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.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
+    JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>KotlinClass<String>()<!>)
+    JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }
diff --git a/compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.out b/compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.out
index e6268d3d157..9027f0cc778 100644
--- a/compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.out
+++ b/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
-    constructor(x: Int) : this({
-                          ^
+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
+        this
+        ^
 compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:12:9: error: cannot access '<this>' before superclass constructor has been called
         this
         ^
diff --git a/compiler/testData/diagnostics/tests/AutoCreatedIt.fir.kt b/compiler/testData/diagnostics/tests/AutoCreatedIt.fir.kt
index 161b60abe88..4dd88964faa 100644
--- a/compiler/testData/diagnostics/tests/AutoCreatedIt.fir.kt
+++ b/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) {}
diff --git a/compiler/testData/diagnostics/tests/Basic.fir.kt b/compiler/testData/diagnostics/tests/Basic.fir.kt
index 4aabd12047d..6f7f519ef99 100644
--- a/compiler/testData/diagnostics/tests/Basic.fir.kt
+++ b/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"
 }
diff --git a/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.fir.kt b/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.fir.kt
index 34f681b3add..339a7a6219d 100644
--- a/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/Constants.fir.kt b/compiler/testData/diagnostics/tests/Constants.fir.kt
index 8570c374394..e925d1b8252 100644
--- a/compiler/testData/diagnostics/tests/Constants.fir.kt
+++ b/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)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Float>(1)
+    checkSubtype<Double>(<!ARGUMENT_TYPE_MISMATCH!>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)
-    <!INAPPLICABLE_CANDIDATE!>varargShort<!>(0x777, 1, 2, 3, 200000, 0b111)
-    <!INAPPLICABLE_CANDIDATE!>varargInt<!>(0x77777777, 0x7777777777, 1, 2, 3, 2000000000, 0b111)
+    varargByte(0x77, 1, 3, <!ARGUMENT_TYPE_MISMATCH!>200<!>, 0b111)
+    varargShort(0x777, 1, 2, 3, <!ARGUMENT_TYPE_MISMATCH!>200000<!>, 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)
-    <!INAPPLICABLE_CANDIDATE!>varargDouble<!>(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<!>)
+    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())
 }
diff --git a/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt b/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
index 2da4f2f2f99..49e4d905c33 100644
--- a/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
+++ b/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
@@ -40,8 +40,8 @@ class Example {
     var d by CustomDelegate3()
 
     fun test() {
-        <!INAPPLICABLE_CANDIDATE!>requireString<!>(a)
-        <!INAPPLICABLE_CANDIDATE!>requireString<!>(aval)
+        requireString(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+        requireString(<!ARGUMENT_TYPE_MISMATCH!>aval<!>)
         requireString(b)
         requireInt(c)
         requireInt(d)
diff --git a/compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.fir.kt b/compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.fir.kt
index 9b208538a2a..199638af940 100644
--- a/compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.fir.kt
+++ b/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) {}
diff --git a/compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt b/compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt
index c51d4d4acf2..40af8425223 100644
--- a/compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt
+++ b/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!!
\ No newline at end of file
+fun Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>.foo(entries: Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>): Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>> = null!!
diff --git a/compiler/testData/diagnostics/tests/ExtensionCallInvoke.fir.kt b/compiler/testData/diagnostics/tests/ExtensionCallInvoke.fir.kt
index 197f060bd67..01e89d765f6 100644
--- a/compiler/testData/diagnostics/tests/ExtensionCallInvoke.fir.kt
+++ b/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()
 }
diff --git a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
index 7d5eaa6b3aa..0447a576c88 100644
--- a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
+++ b/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")
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()<!>("1")
+    args.foo1()(<!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     foo2()({})
diff --git a/compiler/testData/diagnostics/tests/MultipleBounds.fir.kt b/compiler/testData/diagnostics/tests/MultipleBounds.fir.kt
index 529a97b9729..ee395cf250d 100644
--- a/compiler/testData/diagnostics/tests/MultipleBounds.fir.kt
+++ b/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 t2 = <!INAPPLICABLE_CANDIDATE!>test2<!><B>(C())
+val t1 = test2<A>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
+val t2 = test2<B>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
 val t3 = test2<C>(C())
 
 val <T, B : T> x : Int = 0
diff --git a/compiler/testData/diagnostics/tests/ResolveToJava.fir.kt b/compiler/testData/diagnostics/tests/ResolveToJava.fir.kt
index f693a338940..29fce207662 100644
--- a/compiler/testData/diagnostics/tests/ResolveToJava.fir.kt
+++ b/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>
 
diff --git a/compiler/testData/diagnostics/tests/Serializable.fir.kt b/compiler/testData/diagnostics/tests/Serializable.fir.kt
index 7654789a46d..6f194a3aa5f 100644
--- a/compiler/testData/diagnostics/tests/Serializable.fir.kt
+++ b/compiler/testData/diagnostics/tests/Serializable.fir.kt
@@ -36,8 +36,8 @@ fun testLiterals() {
 }
 
 fun testNotSerializable(l: List<Int>) {
-    <!INAPPLICABLE_CANDIDATE!>use<!>(l)
-    <!INAPPLICABLE_CANDIDATE!>use<!>(N())
+    use(<!ARGUMENT_TYPE_MISMATCH!>l<!>)
+    use(<!ARGUMENT_TYPE_MISMATCH!>N()<!>)
 }
 
 enum class C {
diff --git a/compiler/testData/diagnostics/tests/Varargs.fir.kt b/compiler/testData/diagnostics/tests/Varargs.fir.kt
index 310854f59e0..a4af30dba5b 100644
--- a/compiler/testData/diagnostics/tests/Varargs.fir.kt
+++ b/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!>{}<!>
diff --git a/compiler/testData/diagnostics/tests/Variance.fir.kt b/compiler/testData/diagnostics/tests/Variance.fir.kt
index 72753b660a2..28aae719b0e 100644
--- a/compiler/testData/diagnostics/tests/Variance.fir.kt
+++ b/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
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt
index 07d16e28c0f..a0ce821693b 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt
+++ b/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 InnerClass<@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<!>) @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>
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt
index 02536a4b56a..37fb73fef5c 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt
+++ b/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
     }
 }
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt
index 06ed2a04db2..1e0c7ae0af2 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.fir.kt b/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.fir.kt
index ccb3633cc31..4bd5c7a754e 100644
--- a/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.fir.kt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.fir.kt
index 7bdd18f618c..97af855e4e8 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.fir.kt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.fir.kt
index b583f7a5305..51de2417d88 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt b/compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
index 18a2fec23fe..aa1e4d17c51 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
+++ b/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<!>)
 }
 
 
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.fir.kt b/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.fir.kt
index 949c2da42a4..243b003acf3 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.fir.kt
+++ b/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
     }
 }
diff --git a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.fir.kt b/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.fir.kt
index ac941a87cd9..46a0216b795 100644
--- a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.fir.kt
+++ b/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() {}
     }
diff --git a/compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.fir.kt b/compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.fir.kt
index 2fa4a8b4483..b1f7ae541cf 100644
--- a/compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.fir.kt
+++ b/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")
diff --git a/compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.fir.kt b/compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.fir.kt
index 42f6c83229a..8346964ae3e 100644
--- a/compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.fir.kt
+++ b/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<!>
 }
diff --git a/compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.fir.kt b/compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.fir.kt
index 53093bc40c4..12eee8e21eb 100644
--- a/compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.fir.kt
+++ b/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<!>
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/companionObject.fir.kt b/compiler/testData/diagnostics/tests/callableReference/bound/companionObject.fir.kt
index c14f2527175..0b4350dd405 100644
--- a/compiler/testData/diagnostics/tests/callableReference/bound/companionObject.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
index b271e0ba01a..411505e1fcc 100644
--- a/compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
+++ b/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!>{ }<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt
index f2dac1b0c43..99a315c4f5a 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt
+++ b/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."<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
index f7eb0039da3..20060820bfa 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
+++ b/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)
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt
index 8d1f5558aa6..8e24a7c6111 100644
--- a/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt
@@ -12,7 +12,7 @@ fun foo(): String = ""
 
 class A {
     fun foo() {}
-    
+
     fun main() {
         val x = ::foo
 
diff --git a/compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt b/compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt
index 092be2981f6..f8504fe88f0 100644
--- a/compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt
+++ b/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)
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.fir.kt b/compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.fir.kt
index 4a0a3b0b4c2..8d2a0f86741 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.fir.kt
+++ b/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())<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.fir.kt b/compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.fir.kt
index f48a550a72e..a3441dde4ca 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.fir.kt
+++ b/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)
 
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt b/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt
index 8c32de43108..7f8ed220694 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt
+++ b/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)
diff --git a/compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.fir.kt b/compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.fir.kt
index cff6bfaaf0b..d112e5971e2 100644
--- a/compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.fir.kt
+++ b/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)
 
diff --git a/compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.fir.kt b/compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.fir.kt
index 09e12b59bcb..b035f0012a6 100644
--- a/compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.fir.kt
+++ b/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!!<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/cast/bare/FromErrorType.fir.kt b/compiler/testData/diagnostics/tests/cast/bare/FromErrorType.fir.kt
index 32da7c8aecb..7dc989eb0a6 100644
--- a/compiler/testData/diagnostics/tests/cast/bare/FromErrorType.fir.kt
+++ b/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!!<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.fir.kt b/compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.fir.kt
index e28e2ab748d..d60e629c112 100644
--- a/compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.fir.kt
+++ b/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)
-}
\ No newline at end of file
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
+}
diff --git a/compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.fir.kt b/compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.fir.kt
index 43ed0729518..a4c197e79af 100644
--- a/compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.fir.kt
+++ b/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!!)
-}
\ No newline at end of file
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v!!<!>)
+}
diff --git a/compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.fir.kt b/compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.fir.kt
index 54347639674..10897001912 100644
--- a/compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.fir.kt
+++ b/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)
-}
\ No newline at end of file
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
+}
diff --git a/compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.fir.kt b/compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.fir.kt
index 10a098124b5..3e0312ceab2 100644
--- a/compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.fir.kt
+++ b/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)
\ No newline at end of file
+fun test(tr: Tr) = checkSubtype<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>>(<!ARGUMENT_TYPE_MISMATCH!>tr<!>)
diff --git a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt
index 49eac651e55..2d63d3da046 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt
+++ b/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")
diff --git a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt
index 49e6d2c1c1e..443337ad83c 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt
+++ b/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<!>)
 
diff --git a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.txt b/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.txt
index c772849ebbb..c29b7ff5ec1 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.txt
+++ b/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
 }
+
diff --git a/compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.fir.kt b/compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.fir.kt
index ae8211a85f7..708ebb6df78 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.fir.kt
+++ b/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<!>()
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt
index 467ad06f857..811be4565f0 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt
+++ b/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
     }
 }
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt
index 2aa1d500c0d..87589398a2f 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt
+++ b/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) {}
diff --git a/compiler/testData/diagnostics/tests/dataFlow/EmptyIf.fir.kt b/compiler/testData/diagnostics/tests/dataFlow/EmptyIf.fir.kt
index 71a28eb64f4..cb03e48686e 100644
--- a/compiler/testData/diagnostics/tests/dataFlow/EmptyIf.fir.kt
+++ b/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?) {
diff --git a/compiler/testData/diagnostics/tests/dataFlow/IsExpression.fir.kt b/compiler/testData/diagnostics/tests/dataFlow/IsExpression.fir.kt
index 3ede29e6027..13cefbe0141 100644
--- a/compiler/testData/diagnostics/tests/dataFlow/IsExpression.fir.kt
+++ b/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
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.fir.kt
index 77c6d0b1f6d..280af4e640d 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.fir.kt
+++ b/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)
-    if (x == null || bar(x) == 0) bar(<!INAPPLICABLE_CANDIDATE!>bar<!>(x))
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    if (x == null || bar(x) == 0) bar(bar(<!ARGUMENT_TYPE_MISMATCH!>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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.fir.kt
index acd4e6f6036..4280bac11f5 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.fir.kt
+++ b/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]<!>)
-    
-    <!INAPPLICABLE_CANDIDATE!>"123"[x]<!>;
+    bar(a[<!ARGUMENT_TYPE_MISMATCH!>x<!>])
+
+    "123"[<!ARGUMENT_TYPE_MISMATCH!>x<!>];
     if (x != null) "123"[x];
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt
index 40d2733bbdb..6b5ac5a4100 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt
+++ b/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<!>];
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.fir.kt
index 8186fa93023..d78990199bb 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.fir.kt
+++ b/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))
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionBooleanOperations.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionBooleanOperations.fir.kt
index 6dcd58c1a3d..be24dab7e4b 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionBooleanOperations.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionBooleanOperations.fir.kt
@@ -2,7 +2,7 @@
 
 fun foo1(x: Number, cond: Boolean): Boolean {
     val result = cond && ((x as Int) == 42)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     return result
 }
 
@@ -14,7 +14,7 @@ fun foo2(x: Number, cond: Boolean): Boolean {
 
 fun foo3(x: Number, cond: Boolean): Boolean {
     val result = cond || ((x as Int) == 42)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     return result
 }
 
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionElvis.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionElvis.fir.kt
index 395d4b3ded5..f9b849dfa4c 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionElvis.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionElvis.fir.kt
@@ -11,6 +11,6 @@ fun elvis(x: Number?): Int {
 
 fun elvisWithRHSTypeInfo(x: Number?): Any? {
     val result = x ?: x!!
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int?>(x)
+    checkSubtype<Int?>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     return result
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.fir.kt
index f9453268461..088ac49ad83 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.fir.kt
@@ -17,14 +17,14 @@ fun foo() {
         if (x == null) bar(x) else bar(x)
         bar(bar(x))
     } else if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         if (x != null) {
             bar(x)
             if (x == null) bar(x)
             if (x == null) bar(x) else bar(x)
             bar(bar(x) + bar(x))
         } else if (x == null) {
-            <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+            bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         }
     }
 
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.fir.kt
index 6f47bde260d..340e88326c9 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.fir.kt
@@ -4,13 +4,13 @@ fun foo() {
     val x: Int? = null
 
     do {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     } while (x == null)
     bar(x)
-    
+
     val y: Int? = null
     do {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
     } while (y != null)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt
index 01de3666935..8143f9f68c6 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt
@@ -7,7 +7,7 @@ fun foo() {
         bar(<!TYPE_MISMATCH!>x<!>)
     } while (x == null)
     bar(<!DEBUG_INFO_SMARTCAST!>x<!>)
-    
+
     val y: Int? = null
     do {
         bar(<!TYPE_MISMATCH!>y<!>)
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.fir.kt
index 86b63f4d258..9ccfda71690 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.fir.kt
@@ -16,5 +16,5 @@ fun doWhileWithBreak(x: Int?, y0: Int) {
         y++
         if (y > 0) break
     } while (x!! == y)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.fir.kt
index f7042dc5e38..18b3858584e 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.fir.kt
@@ -5,5 +5,5 @@ fun foo() {
 
     bar(x ?: 0)
     if (x != null) bar(x ?: x)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.fir.kt
index 02ddbc32ee5..0a7f2140faf 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.fir.kt
@@ -1,23 +1,23 @@
 fun bar(x: Int) = x + 1
 
 fun f1(x: Int?) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
     if (x == null) bar(x!!)
 }
 
-fun f2(x: Int?) {    
+fun f2(x: Int?) {
     if (x != null) else x!!
 }
 
-fun f3(x: Int?) {    
+fun f3(x: Int?) {
     if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>) else x!!
 }
-    
-fun f4(x: Int?) {    
+
+fun f4(x: Int?) {
     if (x == null) x!! else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
 
-fun f5(x: Int?) {    
+fun f5(x: Int?) {
     if (x == null) else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt
index 7a28dad77a9..db6d32f7d0b 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt
@@ -6,18 +6,18 @@ fun f1(x: Int?) {
     if (x == null) <!UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!UNREACHABLE_CODE!>)<!>
 }
 
-fun f2(x: Int?) {    
+fun f2(x: Int?) {
     if (x != null) else <!ALWAYS_NULL!>x<!>!!
 }
 
-fun f3(x: Int?) {    
+fun f3(x: Int?) {
     if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>) else <!ALWAYS_NULL!>x<!>!!
 }
-    
-fun f4(x: Int?) {    
+
+fun f4(x: Int?) {
     if (x == null) <!ALWAYS_NULL!>x<!>!! else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
 
-fun f5(x: Int?) {    
+fun f5(x: Int?) {
     if (x == null) else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.fir.kt
index 5463fe9bafe..a952d89a860 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.fir.kt
@@ -5,7 +5,7 @@ fun foo() {
     val a = Array<Int>(3, {0})
 
     for (p in a) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         if (x == null) continue
         bar(x)
         for (q in a) {
@@ -15,7 +15,7 @@ fun foo() {
     }
 
     for (p in a) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         if (x == null) break
         bar(x)
     }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.fir.kt
index 9b732f1e2ab..1ea15be97b5 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.fir.kt
@@ -3,7 +3,7 @@ fun bar(x: Int) = x + 1
 fun foo() {
     val x: Int? = null
 
-    fun baz() = <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    fun baz() = bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     fun quux() = if (x != null) bar(x) else baz()
     fun quuux() = bar(if (x == null) 0 else x)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.fir.kt
index a3e32d13887..819a5590836 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.fir.kt
@@ -25,7 +25,7 @@ fun ifThenElse(x: Int?) {
 
 fun ifIs(x: Int?, cond: Boolean) {
     if ((x is Int) == cond) {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.fir.kt
index ab045d4abcc..ba5755eb913 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.fir.kt
@@ -6,7 +6,7 @@ fun foo() {
     bar(if (x == null) 0 else x)
 
     if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         return
     } else {
         bar(x)
@@ -17,14 +17,14 @@ fun foo() {
     if (y is Int) {
         bar(y)
     } else {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
         return
     }
     bar(y)
 
     val z: Int? = null
     if (z != null) bar(z)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>z<!>)
     bar(z!!)
     if (z != null) bar(z<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.fir.kt
index 4c5495cd267..74f13d8954f 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.fir.kt
@@ -3,7 +3,7 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
     val x: Int? = null
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     if (x != 2) {
         if (x == null) return
         2<!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!><!SYNTAX!><!>
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.fir.kt
index e74aec692cc..4f0f723d8e8 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.fir.kt
@@ -16,17 +16,17 @@ fun dataFlowInfoAnd(a: Array<Number>) {
     if (a[15] is Int) { if (a[16] is Int) { if (a[17] is Int) { if (a[18] is Int) { if (a[19] is Int) {
     if (a[20] is Int) { if (a[21] is Int) { if (a[22] is Int) { if (a[23] is Int) { if (a[24] is Int) {
     if (a[25] is Int) { if (a[26] is Int) { if (a[27] is Int) { if (a[28] is Int) { if (a[29] is Int) {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(a[0])
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>a[0]<!>)
     } } } } } } } } } } } } } } } } } } } } } } } } } } } } } }
 }
 
 fun dataFlowInfoOr(a: Array<Number>) {
-    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int || 
-        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int || 
-        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int || 
-        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int || 
-        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int || 
+    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int ||
+        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int ||
+        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int ||
+        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int ||
+        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int ||
         a[50] is Int || a[51] is Int || a[52] is Int || a[53] is Int || a[54] is Int || a[55] is Int || a[56] is Int || a[57] is Int || a[58] is Int || a[59] is Int) {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(a[0])
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>a[0]<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.kt
index 7d45bc9e2e1..a497be4a279 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.kt
@@ -21,11 +21,11 @@ fun dataFlowInfoAnd(a: Array<Number>) {
 }
 
 fun dataFlowInfoOr(a: Array<Number>) {
-    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int || 
-        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int || 
-        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int || 
-        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int || 
-        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int || 
+    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int ||
+        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int ||
+        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int ||
+        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int ||
+        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int ||
         a[50] is Int || a[51] is Int || a[52] is Int || a[53] is Int || a[54] is Int || a[55] is Int || a[56] is Int || a[57] is Int || a[58] is Int || a[59] is Int) {
         checkSubtype<Int>(<!TYPE_MISMATCH!>a[0]<!>)
     }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.fir.kt
index 7882754d287..467920710ec 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.fir.kt
@@ -7,7 +7,7 @@ class A {
 fun foo() {
     val x: Int? = null
 
-    A().<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    A().bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     if (x == null) return
     A().bar(x)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.fir.kt
index 27dac386db6..36b0d153106 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.fir.kt
@@ -5,14 +5,14 @@ fun bar(x: Int): Int = x + 1
 fun foo(): Int {
     val x: Int? = null
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     if (x != null) return x
-    
+
     val y: Int? = null
     if (y == null) return if (y != null) y else y
-    
+
     val z: Int? = null
     if (z != null) return if (z == null) z else z
-    
+
     return z
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
index 861d7d02672..be6571d2e0d 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
@@ -7,12 +7,12 @@ fun foo(): Int {
 
     bar(<!TYPE_MISMATCH!>x<!>)
     if (x != null) return x
-    
+
     val y: Int? = null
     if (y == null) return if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>y<!> != null<!>) y else <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>
-    
+
     val z: Int? = null
     if (z != null) return if (<!SENSELESS_COMPARISON!>z == null<!>) z else z
-    
+
     return <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.fir.kt
index 346b7ed6ed9..3f4dbf30939 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.fir.kt
@@ -8,14 +8,14 @@ class Derived : Base() {
     fun foo() {
         val x: Int? = null
 
-        super.<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
-        this.<!INAPPLICABLE_CANDIDATE!>baz<!>(x)
+        super.bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+        this.baz(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         if (x == null) return
         super.bar(x)
         this.baz(x)
 
         val y: Int? = null
         if (y != null) super.bar(this.baz(y))
-        else this.baz(super.<!INAPPLICABLE_CANDIDATE!>bar<!>(y))
+        else this.baz(super.bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>))
     }
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.fir.kt
index 49c3f665296..ea864dd2faa 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.fir.kt
@@ -3,7 +3,7 @@ fun bar(x: Int): RuntimeException = RuntimeException(x.toString())
 fun foo() {
     val x: Int? = null
 
-    if (x == null) throw <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    if (x == null) throw bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     throw bar(x)
     throw bar(x)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.fir.kt
index a58338d2cbd..3c6cce525eb 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.fir.kt
@@ -2,8 +2,8 @@ fun bar(x: Int): Int = x + 1
 
 fun foo() {
     val x: Int? = null
-    
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     if (x == null) return
     try {
         bar(x)
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.kt
index 6998e05ec1c..69fbbd6ec14 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.kt
@@ -2,7 +2,7 @@ fun bar(x: Int): Int = x + 1
 
 fun foo() {
     val x: Int? = null
-    
+
     bar(<!TYPE_MISMATCH!>x<!>)
     if (x == null) return
     try {
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.fir.kt
index 91107e9017d..db001ac3d3f 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.fir.kt
@@ -14,7 +14,7 @@ fun tryCatchFinally(x: Int?) {
     } catch (e: Exception) {
         x!!
     } finally {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         x!!
     }
     checkSubtype<Int>(x)
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryIs.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryIs.fir.kt
index 1b923955510..47e7a20702d 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryIs.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryIs.fir.kt
@@ -6,7 +6,7 @@ fun foo(x: Number, y: Int) {
         y -> {}
         else -> {}
     }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
 
 fun bar(x: Number) {
@@ -14,7 +14,7 @@ fun bar(x: Number) {
         is Int -> checkSubtype<Int>(x)
         else -> {}
     }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
 
 fun whenWithoutSubject(x: Number) {
@@ -22,5 +22,5 @@ fun whenWithoutSubject(x: Number) {
         (x is Int) -> checkSubtype<Int>(x)
         else -> {}
     }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.fir.kt
index 1c3f30fb578..c40c0398f81 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.fir.kt
@@ -3,20 +3,20 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
     val x: Int? = null
     while (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     }
     bar(x)
-    
+
     val y: Int? = null
     while (y != null) {
         bar(y)
     }
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
-    
+    bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
+
     val z: Int? = null
     while (z == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>z<!>)
         break
     }
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>z<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt
index fd01fee12cb..0662fb50085 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt
@@ -6,13 +6,13 @@ fun foo() {
         bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
     }
     bar(<!DEBUG_INFO_SMARTCAST!>x<!>)
-    
+
     val y: Int? = null
     while (y != null) {
         bar(<!DEBUG_INFO_SMARTCAST!>y<!>)
     }
     bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>)
-    
+
     val z: Int? = null
     while (z == null) {
         bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>)
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhileCondition.fir.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhileCondition.fir.kt
index 85e3b6e9cdd..7d465dd304d 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhileCondition.fir.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhileCondition.fir.kt
@@ -22,5 +22,5 @@ fun whileWithNoCondition(x: Int?) {
     while (<!SYNTAX!><!>) {
         x!!
     }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.fir.kt
index 5760a1440ba..9d6e1135d55 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.fir.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.fir.kt
@@ -43,7 +43,7 @@ fun test() {
 
     val (_, `_`) = A()
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(_, y)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>_<!>, y)
 
     val (unused, _) = A()
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.fir.kt
index a87fe97c06a..9ec21122498 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.fir.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.fir.kt
@@ -23,7 +23,7 @@ fun test(mc1: MyClass, mc2: MyClass2) {
     checkSubtype<Double>(c)
 
     //check no error types
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(a)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(b)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(c)
+    checkSubtype<Boolean>(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    checkSubtype<Boolean>(<!ARGUMENT_TYPE_MISMATCH!>b<!>)
+    checkSubtype<Boolean>(<!ARGUMENT_TYPE_MISMATCH!>c<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt
index 7276f6c9207..87acfd28246 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt
@@ -11,7 +11,7 @@ fun test() {
     const val <T> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
     val <T> a5 by Delegate<Int>()
-    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
+    val <T> a6 by <!ARGUMENT_TYPE_MISMATCH, ARGUMENT_TYPE_MISMATCH!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
 }
 
 class Delegate<F> {
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt
index 8d09b2a5612..10ffe8941be 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt
@@ -11,7 +11,7 @@ fun test() {
     const val <T> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
     val <T> a5 by Delegate<Int>()
-    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
+    val <T> a6 by <!ARGUMENT_TYPE_MISMATCH, ARGUMENT_TYPE_MISMATCH!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
 }
 
 class Delegate<F> {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt
index bbe1ab30618..c27ce230540 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt
@@ -4,10 +4,10 @@ package foo
 import kotlin.reflect.KProperty
 
 open class A {
-    val B.w: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
+    val B.w: Int by <!ARGUMENT_TYPE_MISMATCH!>MyProperty()<!>
 }
 
-val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
+val B.r: Int by <!ARGUMENT_TYPE_MISMATCH!>MyProperty()<!>
 
 val A.e: Int by MyProperty()
 
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt
index 90b54acd693..88cc87b76c3 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt
@@ -5,7 +5,7 @@
 import kotlin.reflect.KProperty
 
 class B {
-    val c by <!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)
+    val c by Delegate(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>ag<!>)
 }
 
 class Delegate<T: Any>(val init: T) {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver1.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver1.fir.kt
index 516ff85718f..9a306209f14 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver1.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver1.fir.kt
@@ -5,5 +5,5 @@ object T1 {
     operator fun Long.getValue(receiver: String, p: Any): Double = 1.0
 
     val String.test1 by 1
-    val test2 by <!INAPPLICABLE_CANDIDATE!>1<!>
+    val test2 by <!ARGUMENT_TYPE_MISMATCH!>1<!>
 }
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt
index 840e8feb846..130f6497beb 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt
@@ -10,5 +10,5 @@ object T2 {
     operator fun <T> Foo<T>.getValue(receiver: String, p: Any?): T = TODO()
 
     val String.test1: String by delegate()
-    val test2: String by <!INAPPLICABLE_CANDIDATE!>delegate<!>()
+    val test2: String by <!ARGUMENT_TYPE_MISMATCH!>delegate()<!>
 }
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.fir.kt
index 0e530390d01..8b2936465f4 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.fir.kt
@@ -13,7 +13,7 @@ fun wrong(arg: Wrong) {}
 class Wrong
 
 class Right {
-    val prop: () -> Unit by ::<!UNRESOLVED_REFERENCE!>wrong<!>
+    val prop: () -> Unit by <!ARGUMENT_TYPE_MISMATCH, ARGUMENT_TYPE_MISMATCH!>::wrong<!>
 }
 
 fun box(): String {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.fir.kt
index e3892b9832e..75fccb01a14 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.fir.kt
@@ -5,7 +5,7 @@ import kotlin.reflect.KProperty
 val Int.a by Delegate(<!NO_THIS!>this<!>)
 
 class A {
-  val Int.a by <!INAPPLICABLE_CANDIDATE!>Delegate<!>(this)
+  val Int.a by Delegate(<!ARGUMENT_TYPE_MISMATCH!>this<!>)
 }
 
 class Delegate(i: Int) {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt
index a52285427e2..d8bdff29b9e 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt
@@ -4,7 +4,7 @@
 import kotlin.reflect.KProperty
 
 class A {
-  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+  var a: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 }
 
 var aTopLevel: Int by Delegate()
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt
index 69230fdcd4a..00014ba19ea 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt
@@ -4,10 +4,10 @@
 import kotlin.reflect.KProperty
 
 class A {
-  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+  var a: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 }
 
-var aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+var aTopLevel: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 
 class Delegate {
   fun getValue(t: Nothing, p: KProperty<*>): Int {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.fir.kt
index aa603f3f806..2025f032ec2 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.fir.kt
@@ -5,10 +5,10 @@ import kotlin.reflect.KProperty
 class A
 
 class B {
-  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!><A>()
+  val b: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate<A>()<!>
 }
 
-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!><A>()
+val bTopLevel: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate<A>()<!>
 
 class C {
   val c: Int by Delegate<C>()
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.fir.kt
index 41ba3d5bafe..c901f8c7115 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.fir.kt
@@ -4,10 +4,10 @@
 import kotlin.reflect.KProperty
 
 class B {
-  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+  val b: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 }
 
-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+val bTopLevel: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 
 class A
 
diff --git a/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.fir.kt b/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.fir.kt
index b622087a287..cab0f189f59 100644
--- a/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.fir.kt
@@ -15,14 +15,14 @@ fun test(i: Int?) {
 
     val a: Int = l4@ ""
     val b: Int = ("")
-    val c: Int = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>("")
-    val d: Int = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>("")
+    val c: Int = checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    val d: Int = checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(l4@ "")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>((""))
-    foo(<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(""))
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(""))
+    foo(l4@ <!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    foo((<!ARGUMENT_TYPE_MISMATCH!>""<!>))
+    foo(checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>""<!>))
+    foo(<!ARGUMENT_TYPE_MISMATCH!>checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)<!>)
 
     use(a, b, c, d)
 }
diff --git a/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.fir.kt b/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.fir.kt
index 1d66c2651bb..dfc34368757 100644
--- a/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.fir.kt
@@ -7,24 +7,24 @@ fun test() {
     fooInt(1 - 1)
     fooInt(1 - 1.toInt())
     fooInt(1 - 1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(1 - 1.toLong())
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toLong()<!>)
     fooInt(1 - 1.toShort())
 
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toShort())
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toInt()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toByte()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toLong()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toShort()<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toByte())
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toInt()<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toByte()<!>)
     fooLong(1 - 1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toShort())
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toShort()<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toShort())
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toInt()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toByte()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toLong()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toShort()<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/evaluate/binaryMinusIndepWoExpType.fir.kt b/compiler/testData/diagnostics/tests/evaluate/binaryMinusIndepWoExpType.fir.kt
index 15c7b377c16..938aadfe0cf 100644
--- a/compiler/testData/diagnostics/tests/evaluate/binaryMinusIndepWoExpType.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/binaryMinusIndepWoExpType.fir.kt
@@ -11,26 +11,26 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(p2)
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
     fooInt(p3)
     fooInt(p4)
     fooInt(p5)
 
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p1)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
     fooLong(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p5)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p5)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p5)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.fir.kt b/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.fir.kt
index 42c4642839d..01f84741a3f 100644
--- a/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.fir.kt
@@ -4,5 +4,5 @@ fun bar() {
 
 // See exception in KT-13421
 fun foo() {
-    42 <!INAPPLICABLE_CANDIDATE!>and<!> false
+    42 and <!ARGUMENT_TYPE_MISMATCH!>false<!>
 }
diff --git a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.fir.kt b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.fir.kt
index 698a000dfc9..b9785525765 100644
--- a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.fir.kt
@@ -5,22 +5,22 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(1 + 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 + 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 + 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 + 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
 
     fooInt(1 * 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 * 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 * 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 * 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 * 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 * 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 * 1<!>)
 
     fooInt(1 / 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 / 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 / 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 / 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 / 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 / 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 / 1<!>)
 
     fooInt(1 % 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 % 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 % 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 % 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 % 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 % 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 % 1<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.fir.kt b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.fir.kt
index 4b970d3fd07..c1ea31e6e42 100644
--- a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.fir.kt
@@ -5,22 +5,22 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(1.plus(1))
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.plus(1))
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.plus(1))
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.plus(1))
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1.plus(1)<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1.plus(1)<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1.plus(1)<!>)
 
     fooInt(1.times(1))
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.times(1))
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.times(1))
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.times(1))
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1.times(1)<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1.times(1)<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1.times(1)<!>)
 
     fooInt(1.div(1))
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.div(1))
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.div(1))
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.div(1))
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1.div(1)<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1.div(1)<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1.div(1)<!>)
 
     fooInt(1.rem(1))
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1.rem(1))
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1.rem(1))
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1.rem(1))
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1.rem(1)<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1.rem(1)<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1.rem(1)<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.fir.kt b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.fir.kt
index ae38cf02081..b59f24a8b8a 100644
--- a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.fir.kt
@@ -5,22 +5,22 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(1 plus 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 plus 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 plus 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 plus 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 plus 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 plus 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 plus 1<!>)
 
     fooInt(1 times 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 times 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 times 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 times 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 times 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 times 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 times 1<!>)
 
     fooInt(1 div 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 div 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 div 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 div 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 div 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 div 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 div 1<!>)
 
     fooInt(1 rem 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 rem 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 rem 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 rem 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 rem 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 rem 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 rem 1<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/evaluate/unaryMinusDepOnExpType.fir.kt b/compiler/testData/diagnostics/tests/evaluate/unaryMinusDepOnExpType.fir.kt
index 361eff19dee..fcd6fb84995 100644
--- a/compiler/testData/diagnostics/tests/evaluate/unaryMinusDepOnExpType.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/unaryMinusDepOnExpType.fir.kt
@@ -5,32 +5,32 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(-1)
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(-1111111111111111111)
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>-1111111111111111111<!>)
     fooInt(-1.toInt())
     fooInt(-1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(-1.toLong())
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>-1.toLong()<!>)
     fooInt(-1.toShort())
 
     fooByte(-1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(-1111111111111111111)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(-1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(-1.toByte())
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>-1111111111111111111<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>-1.toInt()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>-1.toByte()<!>)
     fooByte((-1).toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(-1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(-1.toShort())
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>-1.toLong()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>-1.toShort()<!>)
 
     fooLong(-1)
     fooLong(-1111111111111111111)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(-1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(-1.toByte())
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>-1.toInt()<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>-1.toByte()<!>)
     fooLong(-1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(-1.toShort())
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>-1.toShort()<!>)
 
     fooShort(-1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(-1111111111111111111)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(-1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(-1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(-1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(-1.toShort())
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>-1111111111111111111<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>-1.toInt()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>-1.toByte()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>-1.toLong()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>-1.toShort()<!>)
     fooShort((-1).toShort())
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.fir.kt b/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.fir.kt
index 6e72ce11f08..b845ebce35b 100644
--- a/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.fir.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.fir.kt
@@ -12,30 +12,30 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(p3)
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
     fooInt(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(p5)
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(p6)
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>p6<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p1)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
     fooLong(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p5)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)
     fooLong(p6)
 
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p4)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
     fooShort(p5)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p6)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p6<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p2)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
     fooByte(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p5)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p6)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p6<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/approximation.fir.kt b/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/approximation.fir.kt
index 36679f0c4c4..77f22f30f25 100644
--- a/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/approximation.fir.kt
+++ b/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/approximation.fir.kt
@@ -4,7 +4,7 @@ fun <T> foo(x: T, y: T!!) = x!!
 
 fun main() {
     foo<String>("", "").length
-    <!INAPPLICABLE_CANDIDATE!>foo<!><String>("", null).length
+    foo<String>("", <!ARGUMENT_TYPE_MISMATCH!>null<!>).length
     foo<String?>(null, "").length
     foo<String?>(null, null).length
 
diff --git a/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/simple.fir.kt b/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/simple.fir.kt
index bfd4fbdb084..8bf5d49104b 100644
--- a/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/simple.fir.kt
+++ b/compiler/testData/diagnostics/tests/explicitDefinitelyNotNull/simple.fir.kt
@@ -4,7 +4,7 @@ fun <T> foo(x: T, y: T!!): T!! = x ?: y
 
 fun main() {
     foo<String>("", "").length
-    <!INAPPLICABLE_CANDIDATE!>foo<!><String>("", null).length
+    foo<String>("", <!ARGUMENT_TYPE_MISMATCH!>null<!>).length
     foo<String?>(null, "")<!UNSAFE_CALL!>.<!>length
     foo<String?>(null, null)<!UNSAFE_CALL!>.<!>length
 
diff --git a/compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt b/compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt
index 319b8106ee9..c4eaa5dceb9 100644
--- a/compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt
+++ b/compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt
@@ -17,6 +17,6 @@ class C : T {
         super.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
         super.buzz() // OK, resolved to a member
         super.buzz1(<!NO_VALUE_FOR_PARAMETER!>)<!> // Resolved to an extension
-        super.<!INAPPLICABLE_CANDIDATE!>buzz1<!>("") // Resolved to a member
+        super.buzz1(<!ARGUMENT_TYPE_MISMATCH!>""<!>) // Resolved to a member
     }
-}
+}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/funInterface/funIsNotInheritedFromBaseInterface.fir.kt b/compiler/testData/diagnostics/tests/funInterface/funIsNotInheritedFromBaseInterface.fir.kt
index 6d0e0dbefa7..050c9a5a518 100644
--- a/compiler/testData/diagnostics/tests/funInterface/funIsNotInheritedFromBaseInterface.fir.kt
+++ b/compiler/testData/diagnostics/tests/funInterface/funIsNotInheritedFromBaseInterface.fir.kt
@@ -14,6 +14,6 @@ fun takeWithFun(a: WithFun) {}
 
 fun test() {
     takeBase {}
-    <!INAPPLICABLE_CANDIDATE!>takeWithoutFun<!>({})
+    takeWithoutFun(<!ARGUMENT_TYPE_MISMATCH!>{}<!>)
     takeWithFun {}
 }
diff --git a/compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.fir.kt b/compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.fir.kt
index c1f0fb14c2e..cec3a4354d4 100644
--- a/compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.fir.kt
+++ b/compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.fir.kt
@@ -8,5 +8,5 @@ fun referIsolatedFunFace(iff: IsolatedFunFace) {}
 fun callIsolatedFunFace() {
     referIsolatedFunFace(<!UNRESOLVED_REFERENCE!>IsolatedFunFace<!> {})
     referIsolatedFunFace(<!UNRESOLVED_REFERENCE!>FunAlias<!> {})
-    <!INAPPLICABLE_CANDIDATE!>referIsolatedFunFace<!>({})
+    referIsolatedFunFace(<!ARGUMENT_TYPE_MISMATCH!>{}<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.fir.kt
index 65b92ccea1f..842cc372edb 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.fir.kt
@@ -16,6 +16,6 @@ fun test(s: Sub) {
         t: Trait -> s
     }
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(fun(t: Sub) = s)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(fun(t): Super = s)
+    foo(fun(t: Sub) = <!ARGUMENT_TYPE_MISMATCH!>s<!>)
+    foo(fun(t): Super = <!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.fir.kt
index ac97071f7f6..f026618df0f 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.fir.kt
@@ -9,21 +9,21 @@ fun test1() {
     foo0 {
         ""
     }
-    <!INAPPLICABLE_CANDIDATE!>foo0<!> {
-        s: String-> ""
+    foo0 {
+        s: String-> <!ARGUMENT_TYPE_MISMATCH!>""<!>
     }
-    <!INAPPLICABLE_CANDIDATE!>foo0<!> {
-        x, y -> ""
+    foo0 {
+        x, y -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
     }
 
     foo1 {
         ""
     }
-    <!INAPPLICABLE_CANDIDATE!>foo1<!> {
-        s: String -> ""
+    foo1 {
+        s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
     }
-    <!INAPPLICABLE_CANDIDATE!>foo1<!> {
-        x, y -> ""
+    foo1 {
+        x, y -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
     }
     foo1 {
         -> 42
@@ -33,11 +33,11 @@ fun test1() {
     foo2 {
         ""
     }
-    <!INAPPLICABLE_CANDIDATE!>foo2<!> {
-        s: String -> ""
+    foo2 {
+        s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
     }
-    <!INAPPLICABLE_CANDIDATE!>foo2<!> {
-        x -> ""
+    foo2 {
+        x -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
     }
     foo2 {
          -> 42
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt
index e7b45efa280..487b5682ca2 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt
@@ -7,4 +7,4 @@ object Z {
     infix fun add(b : Foo.() -> Unit) : Z = Z
 }
 
-val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> { } <!TOO_MANY_ARGUMENTS!>{ }<!>
+val t2 = Z add <!ARGUMENT_TYPE_MISMATCH!>{ } <!TOO_MANY_ARGUMENTS!>{ }<!><!>
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.fir.kt
index b5a2705d497..abb1198ef3e 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.fir.kt
@@ -3,5 +3,5 @@
 
 fun foo() {
     val f : Function1<*, *> = { x -> x.toString() }
-    <!INAPPLICABLE_CANDIDATE!>f<!>(1)
+    f(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.fir.kt
index 21c7540c3c1..44a1e3f13a8 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.fir.kt
@@ -20,8 +20,8 @@ fun main() {
     val a8: () -> Int = fun(): String = "1"
     val a9: () -> () -> () -> Int = fun(): () -> () -> String = fun(): () -> String = fun(): String = "1"
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(fun(): String = "1")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(((fun(): String = "1")))
+    foo(fun(): String = <!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
+    foo(((fun(): String = <!ARGUMENT_TYPE_MISMATCH!>"1"<!>)))
 
     val a10: Int.(String) -> Int = fun (x: String) = 10
     val a11: () -> () -> () -> Int = fun() = fun() = fun(): String = "1"
diff --git a/compiler/testData/diagnostics/tests/generics/Projections.fir.kt b/compiler/testData/diagnostics/tests/generics/Projections.fir.kt
index 8ef6bf22fe4..71832d2488d 100644
--- a/compiler/testData/diagnostics/tests/generics/Projections.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/Projections.fir.kt
@@ -37,16 +37,16 @@ fun testInOut() {
 
     Inv<Int>().f(1)
     (null as Inv<in Int>).f(1)
-    (null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!
-    (null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!
+    (null as Inv<out Int>).f(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
+    (null as Inv<*>).f(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
 
     Inv<Int>().inf(1)
     (null as Inv<in Int>).inf(1)
-    (null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!
-    (null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!
+    (null as Inv<out Int>).inf(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
+    (null as Inv<*>).inf(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
 
     Inv<Int>().outf()
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>((null as Inv<in Int>).outf()) // Type mismatch
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>(null as Inv<in Int>).outf()<!>) // Type mismatch
     (null as Inv<out Int>).outf()
     (null as Inv<*>).outf()
 
diff --git a/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.fir.kt b/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.fir.kt
index 354763be0a3..93d5795cd96 100644
--- a/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.fir.kt
@@ -10,11 +10,11 @@ class X {
 
 
 fun testStar(y: X.Y<*>, t: Any) {
-    X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
+    X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
 }
 
 fun testOut(y: X.Y<out Any>, t: Any) {
-    X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
+    X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
 }
 
 fun testIn(y: X.Y<in Any>, t: Any) {
@@ -22,9 +22,9 @@ fun testIn(y: X.Y<in Any>, t: Any) {
 }
 
 fun <T : Any> testWithParameter(y: X.Y<T>, t: Any) {
-    X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
+    X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
 }
 
 fun <T : Any> testWithCapturedParameter(y: X.Y<out T>, t: Any) {
-    X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
+    X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt b/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
index 03a6774fddb..f68d382f530 100644
--- a/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
@@ -33,4 +33,4 @@ fun <T: Foo<<!UNRESOLVED_REFERENCE!>String.Bar<!>>> x() {}
 fun Foo<String>.Bar.ext() {}
 
 fun ex1(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!>): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!> {
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.fir.kt
index f21b8a298e3..e6715840002 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.fir.kt
@@ -31,8 +31,8 @@ fun main() {
     checkSubtype<Outer<*>.Inner<*>>(outer.bar())
     checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.bar())
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.Inner())
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>outer.bar()<!>)
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>outer.Inner()<!>)
 
     outer.set(outer.bar())
     outer.set(outer.Inner())
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/simple.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/simple.fir.kt
index 50641cc1111..6b049f5c704 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/simple.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/simple.fir.kt
@@ -25,8 +25,8 @@ fun main() {
     checkSubtype<Outer<*>.Inner>(outer.bar())
     checkSubtype<Outer<*>.Inner>(outer.Inner())
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner>(outer.bar())
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner>(outer.Inner())
+    checkSubtype<Outer<CharSequence>.Inner>(<!ARGUMENT_TYPE_MISMATCH!>outer.bar()<!>)
+    checkSubtype<Outer<CharSequence>.Inner>(<!ARGUMENT_TYPE_MISMATCH!>outer.Inner()<!>)
 
     outer.set(outer.bar())
     outer.set(outer.Inner())
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.fir.kt
index 3f09cfe537b..92df856d594 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.fir.kt
@@ -32,7 +32,7 @@ fun main() {
     outer.set(outer.Inner())
 
     val x: Outer<String>.Inner = factoryString()
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
+    outer.set(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
     val y: Outer<CharSequence>.Inner = infer<CharSequence>("")
     outer.set(y)
 
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.fir.kt
index c16e0722bb5..f8586a9c92b 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.fir.kt
@@ -29,9 +29,9 @@ fun main() {
     checkSubtype<Outer<out CharSequence>.Inner>(outer.bar())
     checkSubtype<Outer<out CharSequence>.Inner>(outer.Inner())
 
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.bar())
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.Inner())
+    outer.set(<!ARGUMENT_TYPE_MISMATCH!>outer.bar()<!>)
+    outer.set(<!ARGUMENT_TYPE_MISMATCH!>outer.Inner()<!>)
 
     val x: Outer<String>.Inner = factoryString()
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
+    outer.set(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.fir.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.fir.kt
index 235de26c5bc..9cf418ef0be 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.fir.kt
@@ -18,8 +18,8 @@ class Outer<E> {
             bar(outerE(), baz())
             bar(instance().outerE(), baz())
 
-            <!INAPPLICABLE_CANDIDATE!>bar<!>(topLevel().Inner<E>().baz(), topLevel().Inner<E>().baz())
-            <!INAPPLICABLE_CANDIDATE!>bar<!>(topLevel().Inner<E>().foo(), topLevel().Inner<E>().baz())
+            bar(topLevel().Inner<E>().baz(), <!ARGUMENT_TYPE_MISMATCH!>topLevel().Inner<E>().baz()<!>)
+            bar(<!ARGUMENT_TYPE_MISMATCH!>topLevel().Inner<E>().foo()<!>, <!ARGUMENT_TYPE_MISMATCH!>topLevel().Inner<E>().baz()<!>)
 
             setE(foo())
         }
@@ -45,5 +45,5 @@ fun foo() {
     strInt.instance().Inner<Double>().checkType { _<Outer<String>.Inner<Double>>() }
 
     Outer<String>().setInner(strInt)
-    Outer<CharSequence>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)
+    Outer<CharSequence>().setInner(<!ARGUMENT_TYPE_MISMATCH!>strInt<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.fir.kt
index 03e3a5d44db..b5582d032e6 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.fir.kt
+++ b/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>()
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/functionalBound.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/functionalBound.fir.kt
index f5a37d10a32..08d44428c98 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/functionalBound.fir.kt
+++ b/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) {
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt
index 98f6fa489f0..ad512613934 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt
index 75812a0174a..7af4c403d9b 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt
+++ b/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<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt
index 2d2cdac7f92..bbb5fd5457d 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt
+++ b/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<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.fir.kt
index 24fb210b617..f21a8a01c4b 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.fir.kt
+++ b/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>())
     }
 }
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt
index 311cb420ec3..825afde72d5 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.fir.kt
index 0283c5eb433..f838a567a99 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.fir.kt
@@ -15,18 +15,18 @@ fun <T> mc(): MC<T> = null!!
 fun <T> c(): C<T> = null!!
 
 fun foo(x: MC<out Open>) {
-    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(x)
-    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(x)
+    x.addAll(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    x.addAllMC(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
-    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Open>())
-    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Open>())
+    x.addAll(<!ARGUMENT_TYPE_MISMATCH!>mc<Open>()<!>)
+    x.addAllMC(<!ARGUMENT_TYPE_MISMATCH!>mc<Open>()<!>)
 
-    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Derived>())
-    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Derived>())
+    x.addAll(<!ARGUMENT_TYPE_MISMATCH!>mc<Derived>()<!>)
+    x.addAllMC(<!ARGUMENT_TYPE_MISMATCH!>mc<Derived>()<!>)
 
     x.addAll(c())
     x.addAll(c<Nothing>())
 
-    x.<!INAPPLICABLE_CANDIDATE!>addAllInv<!>(mc<Open>())
-    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(1)
+    x.addAllInv(<!ARGUMENT_TYPE_MISMATCH!>mc<Open>()<!>)
+    x.addAll(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.fir.kt
index 11fa0b761b8..11c53b219ee 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.fir.kt
@@ -5,5 +5,5 @@ interface B<E> {
 }
 
 fun foo(x: B<in CharSequence>, y: A<CharSequence>) {
-    x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
+    x.foo(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.fir.kt
index 7660b1dedb8..bfe78a04eb2 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.fir.kt
@@ -14,6 +14,6 @@ fun test(a: A<out CharSequence>, y: Out<CharSequence>) {
     val i = a.foo()
     // TODO: These diagnostic are wrong, type of 'i' --- 'In<Nothing>' is not projected itself,
     // but it's approximation result caused by 'a' projection
-    i.<!INAPPLICABLE_CANDIDATE!>invoke1<!>("")
-    i.<!INAPPLICABLE_CANDIDATE!>invoke2<!>(y)
+    i.invoke1(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    i.invoke2(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.fir.kt
index dc8ef0fce76..f75905a9af0 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.fir.kt
@@ -6,5 +6,5 @@ class A<T> {
 }
 
 fun test(a: A<out CharSequence>) {
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "")
+    a.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.fir.kt
index 3dd7ce34287..0a3c82c5e05 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.fir.kt
@@ -8,7 +8,7 @@ class A<T> {
 }
 
 fun test(a: A<out CharSequence>) {
-    a <!INAPPLICABLE_CANDIDATE!>+<!> ""
-    <!INAPPLICABLE_CANDIDATE!>a[1]<!> = ""
-    <!INAPPLICABLE_CANDIDATE!>a[""]<!>
+    a + <!ARGUMENT_TYPE_MISMATCH!>""<!>
+    a[1] = <!ARGUMENT_TYPE_MISMATCH!>""<!>
+    a[<!ARGUMENT_TYPE_MISMATCH!>""<!>]
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.fir.kt
index 7b905950ad9..7f79fcf4a6f 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.fir.kt
@@ -6,18 +6,18 @@ class C<R> {
 }
 
 fun foo(x: Any?, y: C<*>) {
-    y.<!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
+    y.bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     if (x is C<*>) {
-        x.<!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
+        x.bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
         with(x) {
-            <!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
+            bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
         }
     }
 
     with(x) {
         if (this is C<*>) {
-            <!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
+            bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.fir.kt
index c2abfc7d52e..442969a9fcf 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.fir.kt
@@ -4,7 +4,7 @@ interface A<T>
 interface B<T> : A<A<T>>
 
 fun foo(x : B<*>) {
-    <!INAPPLICABLE_CANDIDATE!>bar1<!>(x) // this should not be valid
+    bar1(<!ARGUMENT_TYPE_MISMATCH!>x<!>) // this should not be valid
     bar2(x)
     bar3(x)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.fir.kt
index 48265c7ce2f..01340ed7b96 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.fir.kt
@@ -12,5 +12,5 @@ fun acceptA(a: A) {
 
 fun main(i: I<*>) {
     i.foo() checkType { _<A?>() }
-    <!INAPPLICABLE_CANDIDATE!>acceptA<!>(i.foo()) // i.foo() should be nullable but isn't
+    acceptA(<!ARGUMENT_TYPE_MISMATCH!>i.foo()<!>) // i.foo() should be nullable but isn't
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.fir.kt
index bf1c53064b6..7a128a0ceea 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.fir.kt
@@ -10,9 +10,9 @@ class A<T> {
 class Out<out F>
 
 fun test(a: A<out CharSequence>, y: Out<CharSequence>) {
-    a <!INAPPLICABLE_CANDIDATE!>+<!> y
-    <!INAPPLICABLE_CANDIDATE!>a[1]<!> = y
-    <!INAPPLICABLE_CANDIDATE!>a[y]<!>
+    a + <!ARGUMENT_TYPE_MISMATCH!>y<!>
+    a[1] = <!ARGUMENT_TYPE_MISMATCH!>y<!>
+    a[<!ARGUMENT_TYPE_MISMATCH!>y<!>]
 
     a + Out<Nothing>()
     a[1] = Out<Nothing>()
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.fir.kt
index b7ec4f2145a..b0ab7830151 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.fir.kt
@@ -13,15 +13,15 @@ class A<T> {
 }
 
 fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
-    a.<!INAPPLICABLE_CANDIDATE!>foo1<!>(Out<CharSequence>())
-    a.<!INAPPLICABLE_CANDIDATE!>foo1<!><Out<CharSequence>>(Out())
+    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>Out<CharSequence>()<!>)
+    a.foo1<Out<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Out()<!>)
 
     a.foo1(Out())
     a.foo1(Out<Nothing>())
 
     a.foo2(Inv())
-    a.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
-    a.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())
+    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>Inv<CharSequence>()<!>)
+    a.foo2<Inv<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)
 
     a.foo3(In())
     a.foo3(In<CharSequence>())
@@ -32,12 +32,12 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
     b.foo1<Out<CharSequence>>(Out())
 
     b.foo2(Inv())
-    b.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
-    b.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())
+    b.foo2(<!ARGUMENT_TYPE_MISMATCH!>Inv<CharSequence>()<!>)
+    b.foo2<Inv<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)
 
 
-    b.<!INAPPLICABLE_CANDIDATE!>foo3<!>(In<CharSequence>())
-    b.<!INAPPLICABLE_CANDIDATE!>foo3<!><In<CharSequence>>(In())
+    b.foo3(<!ARGUMENT_TYPE_MISMATCH!>In<CharSequence>()<!>)
+    b.foo3<In<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>In()<!>)
 
     b.foo3(In<Any?>())
     b.foo3(In())
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.fir.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.fir.kt
index 59951f0d8df..c21154f95f3 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.fir.kt
@@ -6,8 +6,8 @@ class A<T> {
 }
 
 fun test(a: A<out CharSequence>, y: Array<out CharSequence>) {
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "", "")
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y)
+    a.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    a.foo(*<!ARGUMENT_TYPE_MISMATCH!>y<!>)
     // TODO: TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS probably redundant
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y, "")
+    a.foo(*<!ARGUMENT_TYPE_MISMATCH!>y<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/generics/starProjections/invalid.fir.kt b/compiler/testData/diagnostics/tests/generics/starProjections/invalid.fir.kt
index 23be8a295d5..7fa36d8ecf7 100644
--- a/compiler/testData/diagnostics/tests/generics/starProjections/invalid.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/starProjections/invalid.fir.kt
@@ -17,7 +17,7 @@ fun main(a: A<*>, j: JavaClass<*>, i2: Inv2<*>) {
     j.foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
     i2.x checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
 
-    j.<!INAPPLICABLE_CANDIDATE!>bar<!>(1, 2, Any())
+    j.bar(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>, <!ARGUMENT_TYPE_MISMATCH!>Any()<!>)
     j.bar(null)
 }
 
diff --git a/compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt b/compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt
index ddb591346bb..e3b863f05ee 100644
--- a/compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt
@@ -10,8 +10,8 @@ class A<out T, in E> {
 fun foo(x: A<String, Any?>, cs: CharSequence, ls: List<CharSequence>) {
     val y: A<CharSequence, String> = x
 
-    y.<!INAPPLICABLE_CANDIDATE!>foo<!>(cs)
-    val s: String = y.<!INAPPLICABLE_CANDIDATE!>foo<!>(cs, ls)
+    y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>)
+    val s: String = y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>, <!ARGUMENT_TYPE_MISMATCH!>ls<!>)
 
     val ls2: List<String> = y.bar()
 }
diff --git a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt
index f0568b2dff3..65e91ba8ee7 100644
--- a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt
+++ b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt
@@ -9,6 +9,6 @@ public class JavaClass {
 // FILE: main.kt
 fun foo() {
     JavaClass().foo(Any())
-    JavaClass().<!INAPPLICABLE_CANDIDATE!>bar<!>(Any())
+    JavaClass().bar(<!ARGUMENT_TYPE_MISMATCH!>Any()<!>)
     JavaClass().bar("")
 }
diff --git a/compiler/testData/diagnostics/tests/imports/ImportFromCompanionObject.fir.kt b/compiler/testData/diagnostics/tests/imports/ImportFromCompanionObject.fir.kt
index 6c01868ec0f..1bc5870127d 100644
--- a/compiler/testData/diagnostics/tests/imports/ImportFromCompanionObject.fir.kt
+++ b/compiler/testData/diagnostics/tests/imports/ImportFromCompanionObject.fir.kt
@@ -132,7 +132,7 @@ fun testMembersFromSupertypes() {
     fromI()
 
     genericFromI(3)
-    <!INAPPLICABLE_CANDIDATE!>genericFromI<!>("a")
+    genericFromI(<!ARGUMENT_TYPE_MISMATCH!>"a"<!>)
 
     own
-}
\ No newline at end of file
+}
diff --git a/compiler/testData/diagnostics/tests/imports/ImportFromObject.fir.kt b/compiler/testData/diagnostics/tests/imports/ImportFromObject.fir.kt
index 8da9103fbc1..14ca7028292 100644
--- a/compiler/testData/diagnostics/tests/imports/ImportFromObject.fir.kt
+++ b/compiler/testData/diagnostics/tests/imports/ImportFromObject.fir.kt
@@ -126,7 +126,7 @@ fun testMembersFromSupertypes() {
     fromI()
 
     genericFromI(3)
-    <!INAPPLICABLE_CANDIDATE!>genericFromI<!>("a")
+    genericFromI(<!ARGUMENT_TYPE_MISMATCH!>"a"<!>)
 
     own
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
index 3902c5b8ef1..3afe8b10396 100644
--- a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
+++ b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
@@ -37,7 +37,7 @@ fun test() {
 
     two()
     two(1)
-    <!INAPPLICABLE_CANDIDATE!>two<!>("")
+    two(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     all()
     all(1)
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt
index da8923cfadc..392bb16b338 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt
+++ b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt
@@ -7,7 +7,7 @@ interface A<T>
 fun <T> infer(a: A<T>) : T {}
 
 fun test(nothing: Nothing?) {
-    val i = <!INAPPLICABLE_CANDIDATE!>infer<!>(nothing)
+    val i = infer(<!ARGUMENT_TYPE_MISMATCH!>nothing<!>)
 }
 
 fun sum(a : IntArray) : Int {
diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt
index 2aa0ed9abff..8b52ab11722 100644
--- a/compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.fir.kt
+++ b/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<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/approximateContravariantCapturedTypes.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/approximateContravariantCapturedTypes.fir.kt
index 7b36c7a0a02..2a95bc7574d 100644
--- a/compiler/testData/diagnostics/tests/inference/capturedTypes/approximateContravariantCapturedTypes.fir.kt
+++ b/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<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt
index f340ddb3f7e..02a88a1740b 100644
--- a/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.fir.kt
index ef490e8875a..a9c9bf21908 100644
--- a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.fir.kt
+++ b/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()
diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.fir.kt
index 1d437d55c57..af760e4fdc5 100644
--- a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.fir.kt
index 29dc2d569ec..ab9488a78f9 100644
--- a/compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.fir.kt
+++ b/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)
diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypesInSelfType.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypesInSelfType.fir.kt
index 31edfecd0f8..c6c4582bd8f 100644
--- a/compiler/testData/diagnostics/tests/inference/capturedTypesInSelfType.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.fir.kt b/compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.fir.kt
index c1c3e279798..0a0f2941a85 100644
--- a/compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.fir.kt
+++ b/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<!>>>()<!>
     )
 
 }
diff --git a/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.fir.kt b/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.fir.kt
index e2f422cf43c..c31d96cdb22 100644
--- a/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/completion/withExact.fir.kt b/compiler/testData/diagnostics/tests/inference/completion/withExact.fir.kt
index 8a9c36b2f74..c8e5dfb8245 100644
--- a/compiler/testData/diagnostics/tests/inference/completion/withExact.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt
index f8f2a5ee9e9..8bf396cd3e6 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.fir.kt
index 04d68257dba..122525114b8 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.fir.kt
+++ b/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})
 
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt
index 76a93b26011..f1dc8c0c3bd 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt
+++ b/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)
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.fir.kt
index 3895321adef..38ef8e2f11d 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.fir.kt
+++ b/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<!>)
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.fir.kt
index 2d90e788e21..907ab33178d 100644
--- a/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt b/compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt
index 754a8b78dc7..63bea3fbf23 100644
--- a/compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt
+++ b/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)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.fir.kt b/compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.fir.kt
index 61e2939c97d..1186903faf0 100644
--- a/compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.fir.kt
+++ b/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<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/kt1293.fir.kt b/compiler/testData/diagnostics/tests/inference/kt1293.fir.kt
index a16738e4f05..ea29e46f681 100644
--- a/compiler/testData/diagnostics/tests/inference/kt1293.fir.kt
+++ b/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) {}
diff --git a/compiler/testData/diagnostics/tests/inference/mapFunction.fir.kt b/compiler/testData/diagnostics/tests/inference/mapFunction.fir.kt
index 54cf1e0dc54..df6c165eea9 100644
--- a/compiler/testData/diagnostics/tests/inference/mapFunction.fir.kt
+++ b/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<!>)
 }
 
 
diff --git a/compiler/testData/diagnostics/tests/inference/mostSpecificAfterInference.fir.kt b/compiler/testData/diagnostics/tests/inference/mostSpecificAfterInference.fir.kt
index a64c7fa2700..04730ed66f5 100644
--- a/compiler/testData/diagnostics/tests/inference/mostSpecificAfterInference.fir.kt
+++ 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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/nestedCalls/checkTypesForQualifiedProperties.fir.kt b/compiler/testData/diagnostics/tests/inference/nestedCalls/checkTypesForQualifiedProperties.fir.kt
index ef4e3dfba39..58a821ac5c4 100644
--- a/compiler/testData/diagnostics/tests/inference/nestedCalls/checkTypesForQualifiedProperties.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.fir.kt b/compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.fir.kt
index a3edf6a5978..ba71a918aa9 100644
--- a/compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.fir.kt
+++ b/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()<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionLocations.fir.kt b/compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionLocations.fir.kt
index 743999aa99e..1ab84ed60cf 100644
--- a/compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionLocations.fir.kt
+++ b/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<!>
 )
diff --git a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.fir.kt b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.fir.kt
index 3313fa3c6fe..fecf410cbb3 100644
--- a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt1145.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt1145.fir.kt
index 12d9a7c5a9f..fde772c35a1 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt1145.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt1718.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt1718.fir.kt
index b7727bba810..e88657b9d2e 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt1718.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2407.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2407.fir.kt
index b9c208001d8..6d14b228639 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2407.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt
index eb292dfecd2..251bcd5cc03 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt
+++ b/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())
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt36342.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt36342.fir.kt
index e91f493dd55..a86f711f102 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt36342.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.fir.kt
index 5e8254c4013..9624c28f2a1 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.fir.kt
+++ b/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()
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt
index 81e07c9dfc7..cb7137d18d0 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt
+++ b/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
     }
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt
index 297a148019c..fd7ffbafc96 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.fir.kt
+++ b/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 })
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt
index 06cc3058d82..23aba2b62af 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt
+++ b/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}
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt
index 7874eeadf0e..c7be5251afd 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.fir.kt
index 5b3f5b533e1..8ad50aae265 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.fir.kt
+++ b/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!>""<!>) }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.fir.kt
index 71c1e1b753b..216e5d1a791 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.fir.kt
+++ b/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<!>)
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/simpleSubstitutionCheckTypeArgumentsNotTypeParameters.fir.kt b/compiler/testData/diagnostics/tests/inference/substitutions/simpleSubstitutionCheckTypeArgumentsNotTypeParameters.fir.kt
index 5f9f2718b55..409cca765bd 100644
--- a/compiler/testData/diagnostics/tests/inference/substitutions/simpleSubstitutionCheckTypeArgumentsNotTypeParameters.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.fir.kt b/compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.fir.kt
index 89310e995d3..603610016fa 100644
--- a/compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.fir.kt
+++ b/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!>""<!>)
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoInnerClass.fir.kt b/compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoInnerClass.fir.kt
index 394619704fa..4c8a9884c86 100644
--- a/compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoInnerClass.fir.kt
+++ b/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!>""<!>)
 }
 
 
diff --git a/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.fir.kt b/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.fir.kt
index d6f97330e59..f56ada63152 100644
--- a/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt b/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt
index 65adab20a79..f98ecebf7f6 100644
--- a/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt
+++ b/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)
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.fir.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.fir.kt
index 38ae04e2545..3672992af62 100644
--- a/compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.fir.kt
+++ 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
diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.ni.fir.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.ni.fir.kt
index bbfcd1839ba..314b48179dd 100644
--- a/compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.ni.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt
index 5980f137ce2..675483b1ffe 100644
--- a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/inference/violatingUpperBoundForSelfType.fir.kt b/compiler/testData/diagnostics/tests/inference/violatingUpperBoundForSelfType.fir.kt
index 3b5cad23443..760bbb2af4e 100644
--- a/compiler/testData/diagnostics/tests/inference/violatingUpperBoundForSelfType.fir.kt
+++ b/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<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/infos/SmartCasts.fir.kt b/compiler/testData/diagnostics/tests/infos/SmartCasts.fir.kt
index 2c7a28cbc00..1e0631d1dc3 100644
--- a/compiler/testData/diagnostics/tests/infos/SmartCasts.fir.kt
+++ b/compiler/testData/diagnostics/tests/infos/SmartCasts.fir.kt
@@ -189,11 +189,11 @@ fun returnFunctionLiteralExpressionBody(a: Any?): Function0<Int> =
 
 fun mergeSmartCasts(a: Any?) {
   if (a is String || a is Int) {
-    a.<!INAPPLICABLE_CANDIDATE!>compareTo<!>("")
+    a.compareTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
     a.toString()
   }
   if (a is Int || a is String) {
-    a.<!INAPPLICABLE_CANDIDATE!>compareTo<!>("")
+    a.compareTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
   }
   when (a) {
     is String, is Any -> a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
diff --git a/compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt b/compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt
index 05527d81a2a..f6aaf5693f1 100644
--- a/compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt
+++ b/compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt
@@ -21,7 +21,7 @@ class Outer {
 
 fun foo() {
     Outer.Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    Outer.<!INAPPLICABLE_CANDIDATE!>Inner<!>(1)
+    Outer.Inner(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     Outer.Inner("")
 }
 
diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.fir.kt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.fir.kt
index 9492d128b0a..244b83e407f 100644
--- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.fir.kt
@@ -19,5 +19,5 @@ public class Y extends X<String> {
 
 fun main() {
     checkSubtype<Any>(Y().fooN())
-    Y().<!INAPPLICABLE_CANDIDATE!>barN<!>(null);
+    Y().barN(<!ARGUMENT_TYPE_MISMATCH!>null<!>);
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.fir.kt b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.fir.kt
index 49780d0e7e3..549c3e7e7eb 100644
--- a/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.fir.kt
@@ -19,5 +19,5 @@ public class Y extends X<A> {
 
 fun main() {
     checkSubtype<Any>(Y().fooN())
-    Y().<!INAPPLICABLE_CANDIDATE!>barN<!>(null);
+    Y().barN(<!ARGUMENT_TYPE_MISMATCH!>null<!>);
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/commonCollections.fir.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/commonCollections.fir.kt
index 592b6c233ff..bf9fb91134f 100644
--- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/commonCollections.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/commonCollections.fir.kt
@@ -2,7 +2,7 @@ import java.util.*
 fun foo() {
     val al = ArrayList<String>()
     al.size
-    al.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    al.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     al.contains("")
 
     al.remove("")
@@ -10,7 +10,7 @@ fun foo() {
 
     val hs = HashSet<String>()
     hs.size
-    hs.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    hs.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     hs.contains("")
 
     hs.remove("")
@@ -18,10 +18,10 @@ fun foo() {
 
     val hm = HashMap<String, Int>()
     hm.size
-    hm.<!INAPPLICABLE_CANDIDATE!>containsKey<!>(1)
+    hm.containsKey(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     hm.containsKey("")
 
-    <!INAPPLICABLE_CANDIDATE!>hm[1]<!>
+    hm[<!ARGUMENT_TYPE_MISMATCH!>1<!>]
     hm[""]
 
     hm.remove("")
diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.fir.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.fir.kt
index 574fa9177aa..933e72eac6a 100644
--- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.fir.kt
@@ -35,32 +35,32 @@ fun foo(
         al: java.util.ArrayList<String>
 ) {
     a.contains("")
-    a.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    a.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     "" in a
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> a
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in a
 
     b.contains("")
-    b.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    b.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     "" in b
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> b
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in b
 
     ic.contains("")
-    ic.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    ic.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     "" in ic
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> ic
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in ic
 
     ka.contains("")
-    ka.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    ka.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     "" in ka
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> ka
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in ka
 
     kb.contains("")
-    kb.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    kb.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     "" in kb
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> kb
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in kb
 
     al.contains("")
-    al.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    al.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     "" in al
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> al
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in al
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.fir.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.fir.kt
index 6d8492519a4..62b148dfde6 100644
--- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.fir.kt
@@ -37,20 +37,20 @@ fun foo(
         cs: Collection<String>, ca: Collection<Any?>
 ) {
     a.containsAll(cs)
-    a.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    a.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)
 
     b.containsAll(cs)
-    b.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    b.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)
 
     ic.containsAll(cs)
-    ic.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    ic.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)
 
     ka.containsAll(cs)
-    ka.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    ka.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)
 
     kb.containsAll(cs)
-    kb.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    kb.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)
 
     al.containsAll(cs)
-    al.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    al.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.fir.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.fir.kt
index 922dee9c897..f13b2046c8d 100644
--- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.fir.kt
@@ -18,7 +18,7 @@ fun foo(a: A, ka: KA) {
     1 <!NONE_APPLICABLE!>in<!> a
 
     ka.contains("")
-    ka.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    ka.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     "" in ka
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> ka
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in ka
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.fir.kt
index 1042d4ef213..07814a5a1a4 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.fir.kt
@@ -12,6 +12,6 @@ fun test(x: List<Int>, y: List<String>) {
     A("", x) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any?>>() }
     A("", y) checkType { _<A<String?>>() }
 
-    <!INAPPLICABLE_CANDIDATE!>A<!><CharSequence, String>("", x)
+    A<CharSequence, String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
     A<CharSequence, String>("", y)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.fir.kt
index c867e5747d2..1012262d2c3 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.fir.kt
@@ -14,5 +14,5 @@ fun test(x: List<Int>, y: List<String>) {
     Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }
 
     Outer<Int>().Inner("", x, 1) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<Int>.Inner<Any>>() }
-    Outer<Int>().<!INAPPLICABLE_CANDIDATE!>Inner<!><CharSequence, String, Int>("", x, 1)
+    Outer<Int>().Inner<CharSequence, String, Int>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>, 1)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParameters.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParameters.fir.kt
index fd33141f842..ac9ddeaabb3 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParameters.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParameters.fir.kt
@@ -10,7 +10,7 @@ fun test(x: List<Int>, y: List<String>) {
     A("", x) // inferred as Any!
     A("", y)
 
-    <!INAPPLICABLE_CANDIDATE!>A<!><String>("", x)
+    A<String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
     A<Any>("", x)
     A<String>("", y)
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.fir.kt
index b2c873d053b..0045756feac 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.fir.kt
@@ -10,12 +10,12 @@ public class A {
 class Inv<T>
 
 fun test(x: Inv<Int>, y: Inv<String>) {
-    <!INAPPLICABLE_CANDIDATE!>A<!>("", x)
+    A("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
     A("", y)
 
-    <!INAPPLICABLE_CANDIDATE!>A<!><String>("", x)
+    A<String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>A<!><Any>("", x)
+    A<Any>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
     A<String>("", y)
-    <!INAPPLICABLE_CANDIDATE!>A<!><CharSequence>("", y)
+    A<CharSequence>("", <!ARGUMENT_TYPE_MISMATCH!>y<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.fir.kt
index 9cd1000405e..06556bae449 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.fir.kt
@@ -10,9 +10,9 @@ public class A<E> {
 // FILE: main.kt
 
 class B1(x: List<String>) : A<CharSequence>("", x)
-class B2(x: List<Int>) : <!INAPPLICABLE_CANDIDATE!>A<CharSequence><!>("", x)
+class B2(x: List<Int>) : A<CharSequence>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
 class C : A<CharSequence> {
     constructor(x: List<String>) : super("", x)
-    constructor(x: List<Int>, y: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>("", x)
+    constructor(x: List<Int>, y: Int) : super("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.fir.kt
index a5fb8aabaed..39e676b31ea 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.fir.kt
@@ -13,9 +13,9 @@ public class A<E> {
 // if there is not enough information to infer corresponding arguments
 // May be we could add some special syntax for such arguments
 class B1(x: List<String>) : A<CharSequence>("", x)
-class B2(x: List<Int>) : <!INAPPLICABLE_CANDIDATE!>A<CharSequence><!>("", x)
+class B2(x: List<Int>) : A<CharSequence>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
 class C : A<CharSequence> {
     constructor(x: List<String>) : super("", x)
-    constructor(x: List<Int>, y: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>("", x)
+    constructor(x: List<Int>, y: Int) : super("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/withClassTypeParameters.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/withClassTypeParameters.fir.kt
index 4ff0ddd0b6e..0bf9e025b11 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/withClassTypeParameters.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/withClassTypeParameters.fir.kt
@@ -11,7 +11,7 @@ fun test(x: List<Int>, y: List<String>) {
     var z: A<Double> = A("", x) // E inferred from expected type
     z = A("", y)
 
-    z = <!INAPPLICABLE_CANDIDATE!>A<!><Double, String>("", x)
+    z = A<Double, String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
     z = A<Double, Any>("", x)
     z = A<Double, String>("", y)
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.fir.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.fir.kt
index dc79ff1dce8..fad33b8fb85 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.fir.kt
@@ -11,8 +11,8 @@ public class J {
 
 import java.io.Serializable
 
-fun cloneable(c: Cloneable) = <!INAPPLICABLE_CANDIDATE!>J<!>(c)
+fun cloneable(c: Cloneable) = J(<!ARGUMENT_TYPE_MISMATCH!>c<!>)
 
-fun serializable(s: Serializable) = <!INAPPLICABLE_CANDIDATE!>J<!>(s)
+fun serializable(s: Serializable) = J(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
 
 fun <T> both(t: T) where T : Cloneable, T : Serializable = J(t)
diff --git a/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.fir.kt b/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.fir.kt
index f2960f1f362..e6b82938b98 100644
--- a/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.fir.kt
@@ -100,7 +100,7 @@ public class SpecializedMap extends AbstractSpecializedMap {
 // FILE: main.kt
 fun foo(x: SpecializedMap) {
     x.containsKey(1)
-    x.<!INAPPLICABLE_CANDIDATE!>containsKey<!>(null)
+    x.containsKey(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
 
     x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>get<!>(2)
     x.<!NONE_APPLICABLE!>get<!>(null)
diff --git a/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.fir.kt b/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.fir.kt
index 0b5a2d8db28..15462da0915 100644
--- a/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.fir.kt
@@ -16,12 +16,12 @@ public interface J2 extends J {
 
 // FILE: main.kt
 fun main() {
-    <!INAPPLICABLE_CANDIDATE!>J<!> { s: String -> s} // should be prohibited, because SAM value parameter has nullable type
+    J { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>} // should be prohibited, because SAM value parameter has nullable type
     J { "" + it<!UNSAFE_CALL!>.<!>length }
     J { null }
     J { it?.length?.toString() }
 
-    <!INAPPLICABLE_CANDIDATE!>J2<!> { s: String -> s}
+    J2 { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>}
     J2 { "" + it<!UNSAFE_CALL!>.<!>length }
     J2 { null }
     J2 { it?.length?.toString() }
diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.fir.kt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.fir.kt
index 1c2ee9979c3..0c79d1e27c3 100644
--- a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.fir.kt
@@ -48,6 +48,6 @@ fun main() {
         x -> x.toString()
     }
 
-    A.<!INAPPLICABLE_CANDIDATE!>baz<!>(block)
+    A.baz(<!ARGUMENT_TYPE_MISMATCH!>block<!>)
     A.baz(block2)
 }
diff --git a/compiler/testData/diagnostics/tests/j+k/serializable.fir.kt b/compiler/testData/diagnostics/tests/j+k/serializable.fir.kt
index 33d4685ad52..94a19b1b6b5 100644
--- a/compiler/testData/diagnostics/tests/j+k/serializable.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/serializable.fir.kt
@@ -33,8 +33,8 @@ fun testLiterals() {
 }
 
 fun testNotSerializable(l: List<Int>) {
-    <!INAPPLICABLE_CANDIDATE!>use<!>(l)
-    <!INAPPLICABLE_CANDIDATE!>use<!>(N())
+    use(<!ARGUMENT_TYPE_MISMATCH!>l<!>)
+    use(<!ARGUMENT_TYPE_MISMATCH!>N()<!>)
 }
 
 enum class C {
diff --git a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt
index 06f07e576f9..680e2244b3c 100644
--- a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt
@@ -18,7 +18,7 @@ public interface SLRUMap<V> {
 // FILE: main.kt
 
 fun <V> SLRUMap<V>.getOrPut(value: V, l: List<V>) {
-    <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
+    takeV(<!ARGUMENT_TYPE_MISMATCH!>value<!>)
     takeVList(l)
 
     takeE(value)
diff --git a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt
index f85cd4aa40b..5d5d3c7b95c 100644
--- a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt
@@ -18,7 +18,7 @@ public interface SLRUMap<V> {
 // FILE: main.kt
 
 fun <V> SLRUMap<V>.getOrPut(value: V, l: List<V>) {
-    <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
+    takeV(<!ARGUMENT_TYPE_MISMATCH!>value<!>)
     takeVList(l)
 
     takeE(value)
diff --git a/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.fir.kt b/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.fir.kt
index 0c3a1fd26da..0995db885ab 100644
--- a/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.fir.kt
+++ b/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.fir.kt
@@ -20,5 +20,5 @@ class In<in F> {
 
 fun test() {
     A.foo().x() checkType { _<Any?>() }
-    A.bar().<!INAPPLICABLE_CANDIDATE!>y<!>(null)
+    A.bar().y(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/library/Collections.fir.kt b/compiler/testData/diagnostics/tests/library/Collections.fir.kt
index 688e3b4aa77..85fa039e77b 100644
--- a/compiler/testData/diagnostics/tests/library/Collections.fir.kt
+++ b/compiler/testData/diagnostics/tests/library/Collections.fir.kt
@@ -4,7 +4,7 @@ package collections
 fun <T> testCollection(c: Collection<T>, t: T) {
     c.size
     c.isEmpty()
-    c.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    c.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     val iterator: Iterator<T> = c.iterator()
     c.containsAll(c)
 
@@ -20,7 +20,7 @@ fun <T> testCollection(c: Collection<T>, t: T) {
 fun <T> testMutableCollection(c: MutableCollection<T>, t: T) {
     c.size
     c.isEmpty()
-    c.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    c.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     val iterator: Iterator<T> = c.iterator()
     c.containsAll(c)
 
@@ -62,7 +62,7 @@ fun <T> testMutableList(l: MutableList<T>, t: T) {
 fun <T> testSet(s: Set<T>, t: T) {
     s.size
     s.isEmpty()
-    s.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    s.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     val iterator: Iterator<T> = s.iterator()
     s.containsAll(s)
 
@@ -78,7 +78,7 @@ fun <T> testSet(s: Set<T>, t: T) {
 fun <T> testMutableSet(s: MutableSet<T>, t: T) {
     s.size
     s.isEmpty()
-    s.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    s.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     val iterator: Iterator<T> = s.iterator()
     s.containsAll(s)
 
diff --git a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.fir.kt b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.fir.kt
index 69a7f9ebd6e..dd32cd0f96d 100644
--- a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.fir.kt
+++ b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.fir.kt
@@ -21,10 +21,10 @@ fun a() {
             val b = Example()
 
             consumeString(a + b)
-            <!INAPPLICABLE_CANDIDATE!>consumeInt<!>(a - b)
+            consumeInt(<!ARGUMENT_TYPE_MISMATCH!>a - b<!>)
 
             consumeString(a plus b)
-            <!INAPPLICABLE_CANDIDATE!>consumeInt<!>(a minus b)
+            consumeInt(<!ARGUMENT_TYPE_MISMATCH!>a minus b<!>)
 
             a * b
             a / b
diff --git a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.fir.kt b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.fir.kt
index 514ef6a0ccc..03a213f7177 100644
--- a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.fir.kt
+++ b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.fir.kt
@@ -30,12 +30,12 @@ fun a() {
 
     with (Example()) {
         consumeInt(this + a)
-        <!INAPPLICABLE_CANDIDATE!>consumeString<!>(this - b)
+        consumeString(<!ARGUMENT_TYPE_MISMATCH!>this - b<!>)
         consumeInt(this * a)
         consumeInt(this / b)
 
         consumeInt(this plus a)
-        <!INAPPLICABLE_CANDIDATE!>consumeString<!>(this minus b)
+        consumeString(<!ARGUMENT_TYPE_MISMATCH!>this minus b<!>)
         consumeInt(this times a)
         consumeInt(this div b)
     }
diff --git a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.fir.kt b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.fir.kt
index 2ecb1895096..b52086ac493 100644
--- a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.fir.kt
+++ b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.fir.kt
@@ -28,16 +28,16 @@ fun test() {
     var a = Example()
     val b = Example()
 
-    <!INAPPLICABLE_CANDIDATE!>consumeString<!>(a())
-    <!INAPPLICABLE_CANDIDATE!>consumeString<!>(a[1])
+    consumeString(<!ARGUMENT_TYPE_MISMATCH!>a()<!>)
+    consumeString(<!ARGUMENT_TYPE_MISMATCH!>a[1]<!>)
 
     val (x, y) = Example()
-    <!INAPPLICABLE_CANDIDATE!>consumeString<!>(x)
-    <!INAPPLICABLE_CANDIDATE!>consumeString<!>(y)
+    consumeString(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    consumeString(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>consumeExample2<!>(++a)
+    consumeExample2(<!ARGUMENT_TYPE_MISMATCH!>++a<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>consumeString<!>(a plus b)
+    consumeString(<!ARGUMENT_TYPE_MISMATCH!>a plus b<!>)
 }
 
 fun consumeInt(i: Int) {}
diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.fir.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.fir.kt
index 97610c28a91..f5970be8728 100644
--- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.fir.kt
+++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.fir.kt
@@ -25,5 +25,5 @@ public fun foo(a: A) {
 import p.*
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(M1().a)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>M1().a<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.fir.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.fir.kt
index 6fc7ff0296c..1f1d4f33b08 100644
--- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.fir.kt
+++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.fir.kt
@@ -64,5 +64,5 @@ fun test(m1: M1) {
     d(m1.d)
     e(m1.e)
     f(m1.f)
-    <!INAPPLICABLE_CANDIDATE!>g<!>(m1.g)
+    g(<!ARGUMENT_TYPE_MISMATCH!>m1.g<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.fir.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.fir.kt
index 9de45048e8f..435f8d8a150 100644
--- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.fir.kt
+++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.fir.kt
@@ -36,7 +36,7 @@ public fun d(d: D<Int>) {
 import p.*
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>a<!>(M1().b) // Type arguments do not match
-    <!INAPPLICABLE_CANDIDATE!>c<!>(M1().b) // Type arguments do not match
+    a(<!ARGUMENT_TYPE_MISMATCH!>M1().b<!>) // Type arguments do not match
+    c(<!ARGUMENT_TYPE_MISMATCH!>M1().b<!>) // Type arguments do not match
     d(M1().b) // Type arguments do match
 }
diff --git a/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt
index 0204e21d7ed..8b524aee227 100644
--- a/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt
+++ b/compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt
@@ -7,7 +7,7 @@ fun bar(x : Int = 1, y : Int = 1, z : String) {
 fun test() {
     foo()
     foo(2)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
     foo(b = "")
     foo(1, "")
     foo(a = 2)
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt
index c30dd5c1fd0..82aa7aee305 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt
@@ -35,5 +35,5 @@ fun main() {
     }
 
     val f : String = a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><String>(a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
+    checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>)
 }
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.fir.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.fir.kt
index 1d567c4e277..0c7e1257a61 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.fir.kt
@@ -6,25 +6,25 @@ class Foo {
 fun main() {
     val x: Foo? = null
     val y: Foo? = null
-    
+
     x<!UNSAFE_CALL!>.<!>foo(y)
-    x!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
+    x!!.foo(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
     x.foo(y!!)
     x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(y<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
-    
+
     val a: Foo? = null
     val b: Foo? = null
     val c: Foo? = null
-    
+
     a<!UNSAFE_CALL!>.<!>foo(b<!UNSAFE_CALL!>.<!>foo(c))
     a!!.foo(b<!UNSAFE_CALL!>.<!>foo(c))
-    a.foo(b!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
-    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
+    a.foo(b!!.foo(<!ARGUMENT_TYPE_MISMATCH!>c<!>))
+    a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(<!ARGUMENT_TYPE_MISMATCH!>c<!>))
     a.foo(b.foo(c!!))
     a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
     a.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
     a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
-    
+
     val z: Foo? = null
     z!!.foo(z<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.kt
index e28faf8df67..baff72dd922 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.kt
@@ -6,16 +6,16 @@ class Foo {
 fun main() {
     val x: Foo? = null
     val y: Foo? = null
-    
+
     x<!UNSAFE_CALL!>.<!>foo(<!TYPE_MISMATCH!>y<!>)
     x!!.foo(<!TYPE_MISMATCH!>y<!>)
     x.foo(y!!)
     x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(y<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
-    
+
     val a: Foo? = null
     val b: Foo? = null
     val c: Foo? = null
-    
+
     a<!UNSAFE_CALL!>.<!>foo(b<!UNSAFE_CALL!>.<!>foo(<!TYPE_MISMATCH!>c<!>))
     a!!.foo(b<!UNSAFE_CALL!>.<!>foo(<!TYPE_MISMATCH!>c<!>))
     a.foo(b!!.foo(<!TYPE_MISMATCH!>c<!>))
@@ -24,7 +24,7 @@ fun main() {
     a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
     a.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
     a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(b<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.foo(c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
-    
+
     val z: Foo? = null
     z!!.foo(z<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.fir.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.fir.kt
index 0cc13b612c3..4ee20cf434b 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.fir.kt
@@ -7,7 +7,7 @@ fun foo(x: Int): Int = x + 1
 fun main() {
     val x: Int? = null
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
     if (x != null) {
         foo(x)
@@ -15,14 +15,14 @@ fun main() {
         foo(x)
     }
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
     if (x != null) {
         foo(x)
         foo(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         foo(x)
     } else {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
+        foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         foo(x!!)
         foo(x)
     }
@@ -30,7 +30,7 @@ fun main() {
     foo(x)
     foo(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
     foo(x)
-    
+
     val y: Int? = null
     y!!
     y<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
index 50032992b3a..0e4193fc611 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
@@ -30,7 +30,7 @@ fun main() {
     foo(<!DEBUG_INFO_SMARTCAST!>x<!>)
     foo(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
     foo(<!DEBUG_INFO_SMARTCAST!>x<!>)
-    
+
     val y: Int? = null
     y!!
     y<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.fir.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.fir.kt
index d1621f806a5..a5f67469b54 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.fir.kt
@@ -15,8 +15,8 @@ fun foo() {
 
     val y: Int? = 0
     val z: Int? = 0
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (y != null) y else z, y)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (y != null) y else z<!>, <!ARGUMENT_TYPE_MISMATCH!>y<!>)
     y <!NONE_APPLICABLE!>+<!> 2
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(y, y, if (y == null) return else y, y)
+    baz(<!ARGUMENT_TYPE_MISMATCH!>y<!>, <!ARGUMENT_TYPE_MISMATCH!>y<!>, if (y == null) return else y, y)
     baz(y, z!!, z, y)
 }
diff --git a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.fir.kt b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.fir.kt
index 6adf2af7c53..fd58d87825e 100644
--- a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.fir.kt
@@ -1,3 +1,3 @@
 fun test(x: Int?) {
-     x <!INAPPLICABLE_CANDIDATE!>in<!> 1..2
+     <!ARGUMENT_TYPE_MISMATCH!>x<!> in 1..2
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.fir.kt b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.fir.kt
index 93e05a43a71..13ee4dbdf08 100644
--- a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.fir.kt
@@ -13,6 +13,6 @@ public class J {
 
 fun test(j: J, nullStr: String?, nullByte: Byte?, nullDouble: Double?) {
     j.foo(nullStr)
-    j.<!INAPPLICABLE_CANDIDATE!>foo<!>(nullDouble)
+    j.<!NONE_APPLICABLE!>foo<!>(nullDouble)
     j.foo(nullByte)
 }
diff --git a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.fir.kt b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.fir.kt
index abbe5c5e7c1..ac2ee3313fc 100644
--- a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.fir.kt
@@ -6,8 +6,8 @@ fun foo(x: Int) {}
 fun foo(x: Int, y: String) {}
 
 fun bar(nullX: Int?, nullY: String?, notNullY: String) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(nullX)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(nullX, notNullY)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(nullX, nullY)
+    <!NONE_APPLICABLE!>foo<!>(nullX)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>nullX<!>, notNullY)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>nullX<!>, <!ARGUMENT_TYPE_MISMATCH!>nullY<!>)
     <!NONE_APPLICABLE!>foo<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.fir.kt b/compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.fir.kt
index b3eadb00e43..4394ffb1230 100644
--- a/compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.fir.kt
@@ -8,5 +8,5 @@ fun foo(i: Int) = i
 
 fun test(a: A?) {
     a?.b(1) //should be no warning
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(a?.b(1)) //no warning, only error
+    foo(a?.<!ARGUMENT_TYPE_MISMATCH!>b(1)<!>) //no warning, only error
 }
diff --git a/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.fir.kt b/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.fir.kt
index 6e89529d5b1..754458888ea 100644
--- a/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.fir.kt
+++ b/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.fir.kt
@@ -2,11 +2,11 @@
 fun foo(n: Number) = n
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>('a')
-    
+    foo(<!ARGUMENT_TYPE_MISMATCH!>'a'<!>)
+
     val c = 'c'
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(c)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>c<!>)
 
     val d: Char? = 'd'
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(d!!)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>d!!<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt b/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt
index 0b478abd11b..a8b30693cef 100644
--- a/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt
+++ b/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt
@@ -3,7 +3,7 @@ fun foo(n: Number) = n
 
 fun test() {
     foo(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!>)
-    
+
     val c = 'c'
     foo(<!TYPE_MISMATCH!>c<!>)
 
diff --git a/compiler/testData/diagnostics/tests/numbers/literalReceiverWithIntegerValueType.fir.kt b/compiler/testData/diagnostics/tests/numbers/literalReceiverWithIntegerValueType.fir.kt
index c215250faf9..9f5a178350a 100644
--- a/compiler/testData/diagnostics/tests/numbers/literalReceiverWithIntegerValueType.fir.kt
+++ b/compiler/testData/diagnostics/tests/numbers/literalReceiverWithIntegerValueType.fir.kt
@@ -6,62 +6,62 @@ abstract class C<L> {
 }
 
 fun testLongDotCall(c1: C<Long>) {
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.plus(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.minus(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.times(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.div(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.rem(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.inc())
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.dec())
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.unaryPlus())
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.unaryMinus())
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.shl(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.shr(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.ushr(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.and(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.or(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.xor(2))
-    c1.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.inv())
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.plus(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.minus(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.times(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.div(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.rem(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.inc()<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.dec()<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.unaryPlus()<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.unaryMinus()<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.shl(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.shr(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.ushr(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.and(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.or(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.xor(2)<!>)
+    c1.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.inv()<!>)
 }
 
 fun testShortDotCall(c2: C<Short>) {
-    c2.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.plus(2))
-    c2.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.inc())
-    c2.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.dec())
-    c2.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.shr(2))
-    c2.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.inv())
+    c2.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.plus(2)<!>)
+    c2.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.inc()<!>)
+    c2.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.dec()<!>)
+    c2.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.shr(2)<!>)
+    c2.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.inv()<!>)
 }
 
 fun testByteDotCall(c3: C<Byte>) {
-    c3.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.plus(2))
-    c3.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.inc())
-    c3.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.dec())
-    c3.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.shr(2))
-    c3.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1.inv())
+    c3.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.plus(2)<!>)
+    c3.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.inc()<!>)
+    c3.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.dec()<!>)
+    c3.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.shr(2)<!>)
+    c3.takeT(<!ARGUMENT_TYPE_MISMATCH!>1.inv()<!>)
 }
 
 fun testLongOperatorInfixCall(c4: C<Long>) {
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 + 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 - 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 * 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 / 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 % 2)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 + 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 - 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 * 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 / 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 % 2<!>)
     c4.takeT(+1)
     c4.takeT(-1)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 shl 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 shr 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 ushr 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 and 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 or 2)
-    c4.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 xor 2)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 shl 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 shr 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 ushr 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 and 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 or 2<!>)
+    c4.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 xor 2<!>)
 }
 
 fun testShortOperatorInfixCall(c5: C<Short>) {
-    c5.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 + 2)
-    c5.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 shr 2)
+    c5.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 + 2<!>)
+    c5.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 shr 2<!>)
 }
 
 fun testByteOperatorInfixCall(c6: C<Byte>) {
-    c6.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 + 2)
-    c6.<!INAPPLICABLE_CANDIDATE!>takeT<!>(1 shr 2)
+    c6.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 + 2<!>)
+    c6.takeT(<!ARGUMENT_TYPE_MISMATCH!>1 shr 2<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.fir.kt b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.fir.kt
index c6f1f114cc0..295e47da674 100644
--- a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.fir.kt
+++ b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.fir.kt
@@ -31,9 +31,9 @@ fun test() {
 
     val g: Byte = either(1, 300)
 
-    <!INAPPLICABLE_CANDIDATE!>other<!>(11)
+    other(<!ARGUMENT_TYPE_MISMATCH!>11<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>otherGeneric<!>(1)
+    otherGeneric(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 
     val r = either(1, "")
     r checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }
@@ -48,7 +48,7 @@ interface Inv<T>
 fun <T> exactBound(t: T, l: Inv<T>): T = throw Exception("$t $l")
 
 fun testExactBound(invS: Inv<String>, invI: Inv<Int>, invB: Inv<Byte>) {
-    <!INAPPLICABLE_CANDIDATE!>exactBound<!>(1, invS)
+    exactBound(1, <!ARGUMENT_TYPE_MISMATCH!>invS<!>)
     exactBound(1, invI)
 
     val b = exactBound(1, invB)
@@ -72,7 +72,7 @@ interface Contr<in T>
 fun <T> upperBound(t: T, l: Contr<T>): T = throw Exception("$t $l")
 
 fun testUpperBound(contrS: Contr<String>, contrB: Contr<Byte>, contrN: Contr<Number>) {
-    <!INAPPLICABLE_CANDIDATE!>upperBound<!>(1, contrS)
+    upperBound(1, <!ARGUMENT_TYPE_MISMATCH!>contrS<!>)
 
     val n = upperBound(1, contrN)
     n checkType { _<Int>() }
diff --git a/compiler/testData/diagnostics/tests/objects/invokeOnInnerObject.fir.kt b/compiler/testData/diagnostics/tests/objects/invokeOnInnerObject.fir.kt
index 6720e33f495..ea5206f40a9 100644
--- a/compiler/testData/diagnostics/tests/objects/invokeOnInnerObject.fir.kt
+++ b/compiler/testData/diagnostics/tests/objects/invokeOnInnerObject.fir.kt
@@ -1,6 +1,6 @@
 //no nested class access via instance reference error
 fun test() {
-    A.Companion.<!INAPPLICABLE_CANDIDATE!>f<!>("")
+    A.Companion.f(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }
 
 class A() {
diff --git a/compiler/testData/diagnostics/tests/objects/kt5527.fir.kt b/compiler/testData/diagnostics/tests/objects/kt5527.fir.kt
index 24c1fc278ae..27ae3be0f08 100644
--- a/compiler/testData/diagnostics/tests/objects/kt5527.fir.kt
+++ b/compiler/testData/diagnostics/tests/objects/kt5527.fir.kt
@@ -9,12 +9,12 @@ class A {
 fun foo() {
     val i1: Int = Boo
     val i2: Int = A.Boo
-    <!INAPPLICABLE_CANDIDATE!>useInt<!>(Boo)
-    <!INAPPLICABLE_CANDIDATE!>useInt<!>(A.Boo)
+    useInt(<!ARGUMENT_TYPE_MISMATCH!>Boo<!>)
+    useInt(A.<!ARGUMENT_TYPE_MISMATCH!>Boo<!>)
 }
 fun bar() {
     val i1: Int = Unit
-    <!INAPPLICABLE_CANDIDATE!>useInt<!>(Unit)
+    useInt(<!ARGUMENT_TYPE_MISMATCH!>Unit<!>)
 }
 
 fun useInt(i: Int) = i
diff --git a/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.fir.kt b/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.fir.kt
index c0f7356621d..60f181adef4 100644
--- a/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.fir.kt
+++ b/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.fir.kt
@@ -7,9 +7,9 @@ fun fooShort(p: Short) = p
 
 fun test() {
     fooInt(1 % 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 % 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 % 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 % 1)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 % 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 % 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 % 1<!>)
 }
 
 public operator fun Int.rem(other: Int): Int = 0
diff --git a/compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.fir.kt b/compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.fir.kt
index 60c26d0d1d6..23e503d87a8 100644
--- a/compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.fir.kt
+++ b/compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.fir.kt
@@ -9,7 +9,7 @@ object A {
 }
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(A % 123)
+    takeString(<!ARGUMENT_TYPE_MISMATCH!>A % 123<!>)
 }
 
 fun takeString(s: String) {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/operatorRem/resolveToModWhenNoOperatorRemFeature.fir.kt b/compiler/testData/diagnostics/tests/operatorRem/resolveToModWhenNoOperatorRemFeature.fir.kt
index 1d608206b05..f0ff5155834 100644
--- a/compiler/testData/diagnostics/tests/operatorRem/resolveToModWhenNoOperatorRemFeature.fir.kt
+++ b/compiler/testData/diagnostics/tests/operatorRem/resolveToModWhenNoOperatorRemFeature.fir.kt
@@ -22,10 +22,10 @@ object OnlyRem {
 }
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(ModAndRem % 1)
+    takeInt(<!ARGUMENT_TYPE_MISMATCH!>ModAndRem % 1<!>)
 
     val c = ModAssignAndRemAssign
-    c <!INAPPLICABLE_CANDIDATE!>%=<!> ""
+    c %= <!ARGUMENT_TYPE_MISMATCH!>""<!>
 
     var c1 = RemAndModAssign
     c1 %= 1
@@ -36,4 +36,4 @@ fun test() {
     c2 %= 1
 }
 
-fun takeInt(x: Int) {}
+fun takeInt(x: Int) {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt
index 5b151c50d65..66880ac154d 100644
--- a/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt
+++ b/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt
@@ -18,8 +18,8 @@ object MismatchingTypes {
 }
 
 fun testMismatchingTypes() {
-    ++<!INAPPLICABLE_CANDIDATE!>MismatchingTypes[0]<!>
-    <!INAPPLICABLE_CANDIDATE!>MismatchingTypes[0]<!>++
+    ++<!ARGUMENT_TYPE_MISMATCH!>MismatchingTypes[0]<!>
+    <!ARGUMENT_TYPE_MISMATCH!>MismatchingTypes[0]++<!>
     MismatchingTypes[0] <!UNRESOLVED_REFERENCE!>+=<!> 1
 }
 
@@ -42,3 +42,4 @@ fun testMismatchingArities() {
     <!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]++<!>
     <!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]<!> <!UNRESOLVED_REFERENCE!>+=<!> 1
 }
+
diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.fir.kt
index 01b8afecf1b..9c94624f2d9 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.fir.kt
@@ -12,5 +12,5 @@ import p.*
 
 fun test() {
     J()._int(1)
-    J().<!INAPPLICABLE_CANDIDATE!>_int<!>(null)
+    J()._int(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.fir.kt
index a0599c7d3c1..837df1f1c86 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.fir.kt
@@ -17,10 +17,10 @@ public class A<T> {
 // FILE: k.kt
 
 fun test() {
-    A.create().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
+    A.create().bar(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
     A.create().bar("")
 
-    A<String>().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
-    A<String?>().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
+    A<String>().bar(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
+    A<String?>().bar(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
     A<String?>().bar("")
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.fir.kt
index 011ed315190..9589725a8a9 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.fir.kt
@@ -33,9 +33,9 @@ class C2 : A<String?>() {
 }
 
 fun test() {
-    B1().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
-    B2().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
+    B1().bar(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
+    B2().bar(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
 
-    C1().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
+    C1().bar(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.fir.kt
index c9275ffedc1..2a39733a4c9 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.fir.kt
@@ -15,7 +15,7 @@ public class J {
 
 fun test() {
     val n = J.staticN
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(n)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>n<!>)
     J.staticNN = n
     if (n != null) {
         foo(n)
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.fir.kt
index e276ae877b4..4b92ca4060d 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.fir.kt
@@ -23,7 +23,7 @@ fun test() {
     val platformJ = J.staticJ
 
     checkSubtype<J>(platformNN)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><J>(platformN)
+    checkSubtype<J>(<!ARGUMENT_TYPE_MISMATCH!>platformN<!>)
     checkSubtype<J>(platformJ)
 
     checkSubtype<J?>(platformNN)
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.fir.kt
index c3324690eea..da118c85f9d 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.fir.kt
@@ -15,7 +15,7 @@ public class J {
 
 fun test() {
     foo(J.staticNN)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(J.staticN)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>J.staticN<!>)
     foo(J.staticJ)
 
     bar(J.staticNN)
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.fir.kt
index 86f49b1f8d2..a7da5a027ea 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.fir.kt
@@ -54,8 +54,8 @@ fun test(n: J?, nn: J) {
 
     J.staticSet(nn, nn, nn)
     J.staticSet(platformNN, platformNN, platformNN)
-    J.<!INAPPLICABLE_CANDIDATE!>staticSet<!>(n, n, n)
-    J.<!INAPPLICABLE_CANDIDATE!>staticSet<!>(platformN, platformN, platformN)
+    J.staticSet(<!ARGUMENT_TYPE_MISMATCH!>n<!>, n, n)
+    J.staticSet(<!ARGUMENT_TYPE_MISMATCH!>platformN<!>, platformN, platformN)
     J.staticSet(platformJ, platformJ, platformJ)
 
     J().nn = n
@@ -78,13 +78,13 @@ fun test(n: J?, nn: J) {
 
     J().set(nn, nn, nn)
     J().set(platformNN, platformNN, platformNN)
-    J().<!INAPPLICABLE_CANDIDATE!>set<!>(n, n, n)
-    J().<!INAPPLICABLE_CANDIDATE!>set<!>(platformN, platformN, platformN)
+    J().set(<!ARGUMENT_TYPE_MISMATCH!>n<!>, n, n)
+    J().set(<!ARGUMENT_TYPE_MISMATCH!>platformN<!>, platformN, platformN)
     J().set(platformJ, platformJ, platformJ)
 
     J(nn, nn, nn)
     J(platformNN, platformNN, platformNN)
-    <!INAPPLICABLE_CANDIDATE!>J<!>(n, n, n)
-    <!INAPPLICABLE_CANDIDATE!>J<!>(platformN, platformN, platformN)
+    J(<!ARGUMENT_TYPE_MISMATCH!>n<!>, n, n)
+    J(<!ARGUMENT_TYPE_MISMATCH!>platformN<!>, platformN, platformN)
     J(platformJ, platformJ, platformJ)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.fir.kt
index 5f920cab0f7..f8a226c0cd5 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.fir.kt
@@ -27,8 +27,8 @@ val strList: List<String> = null!!
 
 fun main() {
     val rawA = Test.rawAField
-    var rawInner = rawA.<!INAPPLICABLE_CANDIDATE!>Inner<!><Double>("", "", strList)
-    rawInner.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "", strList)
-    rawInner.bar().<!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    var rawInner = rawA.Inner<Double>(<!ARGUMENT_TYPE_MISMATCH!>""<!>, "", strList)
+    rawInner.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, "", strList)
+    rawInner.bar().foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.fir.kt
index ef3a7846b4c..9deda8f1a72 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.fir.kt
@@ -30,5 +30,5 @@ val strList: List<String> = null!!
 fun main() {
     val rawB = Test.rawAField.b;
     // Raw(A).b is not erased because it have no type parameters
-    var rawInner = rawB.<!INAPPLICABLE_CANDIDATE!>bar<!>(strList)
+    var rawInner = rawB.bar(<!ARGUMENT_TYPE_MISMATCH!>strList<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.fir.kt
index 9cb68995aa6..7d17053aec8 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.fir.kt
@@ -32,5 +32,5 @@ fun main() {
 
     val rawA = rawADerived.bar()
     rawA.x = strList
-    rawA.<!INAPPLICABLE_CANDIDATE!>foo<!>("", strList)
+    rawA.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>strList<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.fir.kt
index a66207ef414..6348481ec04 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.fir.kt
@@ -36,6 +36,6 @@ fun foo(x: B<*>) {
     // FIR doesn't work here, because
     // field has a type of just 'A' and it's not clear why should it accept 'String' at consume
     // NB: some kind of BareTypeScope should be in use here
-    Test.rawB.field.<!INAPPLICABLE_CANDIDATE!>consume<!>("")
+    Test.rawB.field.consume(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
     val y: Any = Test.rawB.field.produce()
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.fir.kt
index c095717a028..4e3dc5c1856 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.fir.kt
@@ -29,11 +29,11 @@ fun main() {
     val rawA = Test.rawAField
     rawA.x = strList
     rawA.y = strMap
-    rawA.<!INAPPLICABLE_CANDIDATE!>foo<!>("", strList, strList)
+    rawA.foo("", strList, <!ARGUMENT_TYPE_MISMATCH!>strList<!>)
 
     val barResult = rawA.bar()
 
     barResult.x = strList
     barResult.y = strMap
-    barResult.<!INAPPLICABLE_CANDIDATE!>foo<!>("", strList, null)
+    barResult.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>strList<!>, null)
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.fir.kt
index f4ebcf67d44..01a463b476a 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.fir.kt
@@ -21,7 +21,7 @@ class Test {
 val doubleList: List<Double?> = null!!
 
 fun main() {
-    Test.rawField.<!INAPPLICABLE_CANDIDATE!>foo<!>("", doubleList)
-    Test.rawField.<!INAPPLICABLE_CANDIDATE!>foo<!>(null, doubleList)
-    Test.DerivedRawA().<!INAPPLICABLE_CANDIDATE!>foo<!>(null, doubleList)
+    Test.rawField.foo("", <!ARGUMENT_TYPE_MISMATCH!>doubleList<!>)
+    Test.rawField.foo(<!ARGUMENT_TYPE_MISMATCH!>null<!>, <!ARGUMENT_TYPE_MISMATCH!>doubleList<!>)
+    Test.DerivedRawA().foo(<!ARGUMENT_TYPE_MISMATCH!>null<!>, <!ARGUMENT_TYPE_MISMATCH!>doubleList<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.fir.kt
index 6050510761f..c6a07306533 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.fir.kt
@@ -10,7 +10,7 @@ class E : B1() {
 
         x<!UNSAFE_CALL!>.<!>foo(x)
         x<!UNSAFE_CALL!>.<!>foo("")
-        x.<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        x.bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
         x.bar("")
     }
 
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt
index eb78d1bccf5..e56fd8d69f4 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt
@@ -7,7 +7,7 @@ object Outer {
                 get() = 0
 
             override fun get(index: Int): Char {
-                <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><CharSequence>(x)
+                checkSubtype<CharSequence>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
                 return ' '
             }
 
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt
index 97deba12572..dadfa97842d 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt
@@ -10,8 +10,8 @@ class A {
     val a get() = b
     val b get() = a
 
-    val z1 get() = <!INAPPLICABLE_CANDIDATE!>id<!>(z1)
-    val z2 get() = <!INAPPLICABLE_CANDIDATE!>l<!>(z2)
+    val z1 get() = id(<!ARGUMENT_TYPE_MISMATCH!>z1<!>)
+    val z2 get() = l(<!ARGUMENT_TYPE_MISMATCH!>z2<!>)
 
     val u get() = <!UNRESOLVED_REFERENCE!>field<!>
 }
diff --git a/compiler/testData/diagnostics/tests/regressions/CoercionToUnit.fir.kt b/compiler/testData/diagnostics/tests/regressions/CoercionToUnit.fir.kt
index 575b3387c25..22878c00167 100644
--- a/compiler/testData/diagnostics/tests/regressions/CoercionToUnit.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/CoercionToUnit.fir.kt
@@ -1,9 +1,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
 }
diff --git a/compiler/testData/diagnostics/tests/regressions/DoubleDefine.fir.kt b/compiler/testData/diagnostics/tests/regressions/DoubleDefine.fir.kt
index 6ec5de4f0a3..c2fd41b21ea 100644
--- a/compiler/testData/diagnostics/tests/regressions/DoubleDefine.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/DoubleDefine.fir.kt
@@ -10,7 +10,7 @@ fun takeFirst(expr: StringBuilder): Char {
 
 fun evaluateArg(expr: CharSequence, numbers: ArrayList<Int>): Int {
   if (expr.length == 0) throw Exception("Syntax error: Character expected");
-  val c = <!INAPPLICABLE_CANDIDATE!>takeFirst<!>(expr)
+  val c = takeFirst(<!ARGUMENT_TYPE_MISMATCH!>expr<!>)
   if (c >= '0' && c <= '9') {
     val n = c - '0'
     if (!numbers.contains(n)) throw Exception("You used incorrect number: " + n)
diff --git a/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.fir.kt b/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.fir.kt
index 66b4444b6da..84aaf3d524e 100644
--- a/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.fir.kt
@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 fun test(a: Int, b: Boolean) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(a.<!INAPPLICABLE_CANDIDATE!>foo<!>(b))
+    bar(a.foo(<!ARGUMENT_TYPE_MISMATCH!>b<!>))
 }
 
 fun <T, R> T.foo(l: (T) -> R): R = TODO()
diff --git a/compiler/testData/diagnostics/tests/regressions/kt1489_1728.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt1489_1728.fir.kt
index cf2fd9afae7..450b0be92c7 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt1489_1728.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt1489_1728.fir.kt
@@ -19,7 +19,7 @@ class C {
     fun p() : Resource? = null
 
     fun bar() {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(p()) {
+        foo(<!ARGUMENT_TYPE_MISMATCH!>p()<!>) {
 
         }
     }
diff --git a/compiler/testData/diagnostics/tests/regressions/kt30245.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt30245.fir.kt
index 8ab57f61314..d621faff8f1 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt30245.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt30245.fir.kt
@@ -44,9 +44,9 @@ fun test1() { // to extension lambda 0
     val f10 = W1(fun Int.(): Int = this) // oi+ ni+
     val g10: E0 = id(fun Int.(): Int = this) // oi+ ni+
 
-    val w11 = <!INAPPLICABLE_CANDIDATE!>W1<!> { i: Int -> i } // oi- ni-
+    val w11 = W1 { i: Int -> <!ARGUMENT_TYPE_MISMATCH!>i<!> } // oi- ni-
     val i11: E0 = id { i: Int -> i } // o1+ ni+
-    val w12 = <!INAPPLICABLE_CANDIDATE!>W1<!> { i -> i } // oi- ni-
+    val w12 = W1 { i -> <!ARGUMENT_TYPE_MISMATCH!>i<!> } // oi- ni-
     val i12: E0 = id { i -> i } // oi- ni-
     val j12 = id<E0> { i -> i } // oi- ni-
 
@@ -78,14 +78,14 @@ fun test2() { // to extension lambda 1
     val i26: E1 = id { s: String -> this + s.length } // oi- ni+
     val i26a: E1 = id { s -> this + s.length } // oi+ ni+
     val e = E.VALUE
-    val w27 = <!INAPPLICABLE_CANDIDATE!>W2<!>(when (e) { E.VALUE ->  { s: String -> <!NO_THIS!>this<!> + s.length } }) // oi- ni+
-    val w27a = <!INAPPLICABLE_CANDIDATE!>W2<!>(when (e) { E.VALUE ->  { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } }) // oi+ ni+
+    val w27 = W2(<!ARGUMENT_TYPE_MISMATCH!>when (e) { E.VALUE ->  { s: String -> <!NO_THIS!>this<!> + s.length } }<!>) // oi- ni+
+    val w27a = W2(<!ARGUMENT_TYPE_MISMATCH!>when (e) { E.VALUE ->  { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } }<!>) // oi+ ni+
     val i27: E1 = when (e) { E.VALUE ->  { s: String -> <!NO_THIS!>this<!> + s.length } } // oi+ ni+
     val i27a: E1 = when (e) { E.VALUE ->  { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } } // oi+ ni+
 
-    val w28 = <!INAPPLICABLE_CANDIDATE!>W2<!> { i: Int, s -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
+    val w28 = W2 { i: Int, s -> <!ARGUMENT_TYPE_MISMATCH!>i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!><!> } // oi- ni-
     val i28: E1 = id { i: Int, s -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
-    val w29 = <!INAPPLICABLE_CANDIDATE!>W2<!> { i: Int, s: String -> i + s.length } // oi- ni-
+    val w29 = W2 { i: Int, s: String -> <!ARGUMENT_TYPE_MISMATCH!>i + s.length<!> } // oi- ni-
     val i29: E1 = id { i: Int, s: String -> i + s.length } // oi+ ni+
 
     // yet unsupported cases with ambiguity for the lambda conversion (commented constructors in wrappers above)
@@ -111,7 +111,7 @@ fun test3() { // to non-extension lambda 1
 //    val i32: L1 = id { this } // this or it: oi- ni-
 //    val j32 = id<L1> { this } // this or it: oi- ni-
 
-    val w33 = <!INAPPLICABLE_CANDIDATE!>W3<!>(fun Int.(): Int = this) // oi- ni+
+    val w33 = W3(fun Int.(): Int = <!ARGUMENT_TYPE_MISMATCH!>this<!>) // oi- ni+
     val i33: L1 = id(fun Int.(): Int = this) // oi+ ni+
 
     // yet unsupported cases with ambiguity for the lambda conversion (commented constructors in wrappers above)
diff --git a/compiler/testData/diagnostics/tests/regressions/kt32205.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt32205.fir.kt
index b8b6498cc7a..c2061cf81ce 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt32205.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt32205.fir.kt
@@ -8,5 +8,5 @@ public class A {
 
 fun test(vararg values: A) {
     A.foo(*values)
-    A.<!INAPPLICABLE_CANDIDATE!>foo<!>(values)
+    A.foo(<!ARGUMENT_TYPE_MISMATCH!>values<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/regressions/kt334.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt334.fir.kt
index 3daf03e8233..06825f13115 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt334.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt334.fir.kt
@@ -3,6 +3,6 @@
 import java.lang.Comparable as Comparable
 
 fun f(c: Comparable<*>) {
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><kotlin.Comparable<*>>(c)
+    checkSubtype<kotlin.Comparable<*>>(<!ARGUMENT_TYPE_MISMATCH!>c<!>)
     checkSubtype<java.lang.Comparable<*>>(c)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/regressions/kt5362.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt5362.fir.kt
index 273270909f5..c1fc5dadfbc 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt5362.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt5362.fir.kt
@@ -25,7 +25,7 @@ public class Manager {
 
     class Task(val callback: Manager.() -> Unit) : Runnable {
         override public fun run() {
-            <!INAPPLICABLE_CANDIDATE!>callback<!>() // Manager is not accessible here, but no error is shown
+            <!ARGUMENT_TYPE_MISMATCH!>callback<!>() // Manager is not accessible here, but no error is shown
         }
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/regressions/kt7585/base.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt7585/base.fir.kt
index f0170d5a349..787912a190b 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt7585/base.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt7585/base.fir.kt
@@ -7,7 +7,7 @@ abstract class Wrapper<T: A>(protected val t: T)
 class MyWrapper(a: A): Wrapper<A>(a)
 
 // This wrapper is not legal
-class TheirWrapper(e: E): <!INAPPLICABLE_CANDIDATE!>Wrapper<E><!>(e)
+class TheirWrapper(e: E): Wrapper<E>(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
 
 data class Pair<out T>(val a: T, val b: T)
 
diff --git a/compiler/testData/diagnostics/tests/regressions/kt7585/java.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt7585/java.fir.kt
index c73bcd67b3e..ae842e22e14 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt7585/java.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt7585/java.fir.kt
@@ -17,7 +17,7 @@ class E
 class MyWrapper(a: A): Wrapper<A>(a)
 
 // This wrapper is not legal
-class TheirWrapper(e: E): <!INAPPLICABLE_CANDIDATE!>Wrapper<E><!>(e)
+class TheirWrapper(e: E): Wrapper<E>(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
 
 data class Pair<out T>(val a: T, val b: T)
 
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.fir.kt
index 40954777dd8..1d4a539deb1 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt
index e565821cbee..7e64054a47e 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt
+++ b/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!>)<!>
 }
 
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt
index 42798dd77f2..ac3698b8b5b 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt
+++ b/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()
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
index 4541883398a..71ca8ad03e3 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
+++ b/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)
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt
index 2632e43b888..e6edf1f1c3e 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt
+++ 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()
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.fir.kt b/compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.fir.kt
index 0acde4900a5..6bc9de2c7d0 100644
--- a/compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt b/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
index 27d0a82836a..364d1d77525 100644
--- a/compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt
+++ b/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() {
diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt
index e675a31a9f8..4929b83062d 100644
--- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt
+++ b/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
diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.fir.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.fir.kt
index 730066d811c..f5e5e217963 100644
--- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.fir.kt
+++ b/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<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.fir.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.fir.kt
index a7a9efbbcb3..5af75bc0fb8 100644
--- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.fir.kt
+++ 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
         }
-    })
+    }<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgument.fir.kt b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgument.fir.kt
index cbab12a2f2b..0a27998e0f1 100644
--- a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgument.fir.kt
+++ b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgument.fir.kt
@@ -20,19 +20,19 @@ fun main(x2: Runnable) {
     val x1 = {}
     val x3 = arrayOf<String>()
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>({}, arrayOf())
+    Test.foo1({}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1({}, *arrayOf())
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>({}, x3)
+    Test.foo1({}, <!ARGUMENT_TYPE_MISMATCH!>x3<!>)
     Test.foo1({}, *arrayOf(""))
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x1, arrayOf())
+    Test.foo1(x1, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1(x1, *arrayOf())
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x2, arrayOf())
+    Test.foo1(x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1(x2, *arrayOf())
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x1, x3)
+    Test.foo1(x1, <!ARGUMENT_TYPE_MISMATCH!>x3<!>)
     Test.foo1(x1, *x3)
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x2, arrayOf(""))
+    Test.foo1(x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf("")<!>)
     Test.foo1(x2, *arrayOf(""))
 
     val i1 = <!NONE_APPLICABLE!>Test<!>({}, arrayOf())
@@ -42,13 +42,13 @@ fun main(x2: Runnable) {
     val i5 = Test({}, {}, *arrayOf(""))
     val i6 = <!NONE_APPLICABLE!>Test<!>({}, {}, arrayOf())
 
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, {}, arrayOf())
+    i2.foo2({}, {}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     i2.foo2({}, {}, *arrayOf())
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, x2, arrayOf())
+    i2.foo2({}, x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     i2.foo2(x2, {}, *arrayOf())
 
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, {}, arrayOf(""))
+    i2.foo2({}, {}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf("")<!>)
     i2.foo2({}, {}, *x3)
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, x2, x3)
+    i2.foo2({}, x2, <!ARGUMENT_TYPE_MISMATCH!>x3<!>)
     i2.foo2(x2, {}, *arrayOf(""))
 }
diff --git a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.fir.kt b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.fir.kt
index 56210493208..417dd9ccaeb 100644
--- a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.fir.kt
+++ b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.fir.kt
@@ -20,19 +20,19 @@ fun main(x2: Runnable) {
     val x1 = {}
     val x3 = arrayOf<String>()
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>({}, arrayOf())
+    Test.foo1({}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1({}, *arrayOf())
     Test.foo1({}, *x3)
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>({}, arrayOf(""))
+    Test.foo1({}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf("")<!>)
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x1, arrayOf())
+    Test.foo1(x1, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1(x1, *arrayOf())
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x2, arrayOf())
+    Test.foo1(x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1(x2, *arrayOf())
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x1, x3)
+    Test.foo1(x1, <!ARGUMENT_TYPE_MISMATCH!>x3<!>)
     Test.foo1(x1, *x3)
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x2, arrayOf(""))
+    Test.foo1(x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf("")<!>)
     Test.foo1(x2, *arrayOf(""))
 
     val i1 = <!NONE_APPLICABLE!>Test<!>({}, arrayOf())
@@ -42,13 +42,13 @@ fun main(x2: Runnable) {
     val i5 = Test({}, {}, *arrayOf(""))
     val i6 = <!NONE_APPLICABLE!>Test<!>({}, {}, arrayOf())
 
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, {}, arrayOf())
+    i2.foo2({}, {}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     i2.foo2({}, {}, *arrayOf())
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, x2, arrayOf())
+    i2.foo2({}, x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     i2.foo2(x2, {}, *arrayOf())
 
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, {}, arrayOf(""))
+    i2.foo2({}, {}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf("")<!>)
     i2.foo2({}, {}, *x3)
-    i2.<!INAPPLICABLE_CANDIDATE!>foo2<!>({}, x2, x3)
+    i2.foo2({}, x2, <!ARGUMENT_TYPE_MISMATCH!>x3<!>)
     i2.foo2(x2, {}, *arrayOf(""))
 }
diff --git a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.fir.kt b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.fir.kt
index 04bf1ebba3b..0a831875e5a 100644
--- a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.fir.kt
+++ b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.fir.kt
@@ -20,19 +20,19 @@ fun main(x2: Runnable) {
     val x1 = {}
     val x3 = arrayOf<String>()
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>({}, arrayOf())
+    Test.foo1({}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1({}, *arrayOf())
     Test.foo1({}, *x3)
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>({}, arrayOf(""))
+    Test.foo1({}, <!ARGUMENT_TYPE_MISMATCH!>arrayOf("")<!>)
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x1, arrayOf())
+    Test.foo1(x1, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1(x1, *arrayOf())
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x2, arrayOf())
+    Test.foo1(x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf()<!>)
     Test.foo1(x2, *arrayOf())
 
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x1, x3)
+    Test.foo1(x1, <!ARGUMENT_TYPE_MISMATCH!>x3<!>)
     Test.foo1(x1, *x3)
-    Test.<!INAPPLICABLE_CANDIDATE!>foo1<!>(x2, arrayOf(""))
+    Test.foo1(x2, <!ARGUMENT_TYPE_MISMATCH!>arrayOf("")<!>)
     Test.foo1(x2, *arrayOf(""))
 
     val i1 = <!NONE_APPLICABLE!>Test<!>({}, arrayOf())
diff --git a/compiler/testData/diagnostics/tests/sealed/protectedConstructors_disabled.fir.kt b/compiler/testData/diagnostics/tests/sealed/protectedConstructors_disabled.fir.kt
index 09d0542dfd5..68a31c07293 100644
--- a/compiler/testData/diagnostics/tests/sealed/protectedConstructors_disabled.fir.kt
+++ b/compiler/testData/diagnostics/tests/sealed/protectedConstructors_disabled.fir.kt
@@ -22,7 +22,7 @@ sealed class Case3 private constructor(val x: Int) {
     class Inheritor2 : Case3("Hello")
 }
 
-class Case3Inheritor3 : <!INAPPLICABLE_CANDIDATE!>Case3<!>(20) // should be an error in 1.6 (?)
+class Case3Inheritor3 : Case3(<!ARGUMENT_TYPE_MISMATCH!>20<!>) // should be an error in 1.6 (?)
 
 sealed class Case4 {
     protected constructor(x: Int)
diff --git a/compiler/testData/diagnostics/tests/sealed/protectedConstructors_enabled.fir.kt b/compiler/testData/diagnostics/tests/sealed/protectedConstructors_enabled.fir.kt
index c601bf18f43..f905104e112 100644
--- a/compiler/testData/diagnostics/tests/sealed/protectedConstructors_enabled.fir.kt
+++ b/compiler/testData/diagnostics/tests/sealed/protectedConstructors_enabled.fir.kt
@@ -22,7 +22,7 @@ sealed class Case3 private constructor(val x: Int) {
     class Inheritor2 : Case3("Hello")
 }
 
-class Case3Inheritor3 : <!INAPPLICABLE_CANDIDATE!>Case3<!>(20) // should be an error in 1.6 (?)
+class Case3Inheritor3 : Case3(<!ARGUMENT_TYPE_MISMATCH!>20<!>) // should be an error in 1.6 (?)
 
 sealed class Case4 {
     protected constructor(x: Int)
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/argumentsResolveInBodyAndDelegationCall.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/argumentsResolveInBodyAndDelegationCall.fir.kt
index 10ec62d7609..2cc3e8ac552 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/argumentsResolveInBodyAndDelegationCall.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/argumentsResolveInBodyAndDelegationCall.fir.kt
@@ -13,8 +13,8 @@ class A : B {
         foo(x.toInt(), y, myProp)
         x + y + myProp + parentProp + super.parentProp
     }
-    constructor(x: String, y: Int): <!INAPPLICABLE_CANDIDATE!>super<!>(x) {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(x, y, myProp)
+    constructor(x: String, y: Int): super(<!ARGUMENT_TYPE_MISMATCH!>x<!>) {
+        foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>, y, myProp)
         x + y + myProp + parentProp + super.parentProp
     }
     constructor(x: B, y: Int = <!UNRESOLVED_REFERENCE!>global2<!>): <!NONE_APPLICABLE!>this<!>("", x) {
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/generics.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/generics.fir.kt
index ac12d88ab30..2473ba9f297 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/generics.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/generics.fir.kt
@@ -17,5 +17,5 @@ class A1<R> : B<R> {
 }
 
 class A2<R> {
-    constructor(t: R, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 1)
+    constructor(t: R, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 1)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.fir.kt
index 0c16f42cc5b..47870e18ba1 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.fir.kt
@@ -14,14 +14,14 @@ class A0<T1, T2> {
 
 class A1<T1, T2> : B<T1, T2> {
     constructor(x: T1, y: T2): super(x, y)
-    constructor(x: T1, y: Int): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
-    constructor(x: T1, y: T1, z: T1): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T1, y: Int): super(x, <!ARGUMENT_TYPE_MISMATCH!>y<!>)
+    constructor(x: T1, y: T1, z: T1): super(x, <!ARGUMENT_TYPE_MISMATCH!>y<!>)
 }
 
 class A2<T1, T2> : B<T1, Int> {
-    constructor(x: T1, y: T2): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T1, y: T2): super(x, <!ARGUMENT_TYPE_MISMATCH!>y<!>)
     constructor(x: T1, y: Int): super(x, y)
-    constructor(x: T1, y: T1, z: T1): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
-    constructor(x: T1, y: T2, z: String): <!INAPPLICABLE_CANDIDATE!>super<!>(y, 1)
+    constructor(x: T1, y: T1, z: T1): super(x, <!ARGUMENT_TYPE_MISMATCH!>y<!>)
+    constructor(x: T1, y: T2, z: String): super(<!ARGUMENT_TYPE_MISMATCH!>y<!>, 1)
 }
 
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.fir.kt
index d3a39f171e3..03809337f68 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.fir.kt
@@ -6,7 +6,7 @@ open class Base<T>(p: Any?) {
 
 class D: Base<Int>("") {
     inner class B : Base<String> {
-        constructor() : super(<!INAPPLICABLE_CANDIDATE!>foo1<!>(""))
+        constructor() : super(foo1(<!ARGUMENT_TYPE_MISMATCH!>""<!>))
         constructor(x: Int) : super(foo1(1))
     }
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.fir.kt
index 2c1c4ad9613..672d0b95b96 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.fir.kt
@@ -5,7 +5,7 @@ open class Base<T>(p: Any?) {
 
 fun Base<Int>.foo() {
     class B : Base<String> {
-        constructor() : super(<!INAPPLICABLE_CANDIDATE!>foo1<!>(""))
+        constructor() : super(foo1(<!ARGUMENT_TYPE_MISMATCH!>""<!>))
         constructor(x: Int) : super(foo1(1))
         constructor(x: Int, y: Int) : super(this@foo.foo1(12))
         constructor(x: Int, y: Int, z: Int) : super(<!UNRESOLVED_LABEL!>this@B<!>.<!UNRESOLVED_REFERENCE!>foo1<!>(""))
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt
index e208dce08c2..96b58ce3770 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt
@@ -3,5 +3,5 @@ class A {
     fun foo() = 1
     constructor(x: Int)
     constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()) :
-        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>())
+        this(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt
index 82e8f6d4025..ee8342d6e19 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt
@@ -3,5 +3,5 @@ class A {
     val prop = 1
     constructor(x: Int)
     constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
-        <!INAPPLICABLE_CANDIDATE!>this<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>)
+        this(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt
index 21ce8d1cc69..c8c5b7abf28 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt
@@ -3,5 +3,5 @@ open class B(x: Int)
 class A : B {
     val prop = 1
     constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>)
+        super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt
index bb7f9953e6d..0112b5a8813 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt
@@ -4,5 +4,5 @@ open class B(x: Int) {
 }
 class A : B {
     constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>())
+        super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt
index 3dab69e60f7..611fd7813a8 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt
@@ -5,5 +5,5 @@ open class B(x: Int) {
 class A : B {
     override fun foo() = 2
     constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>())
+        super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt
index 1303d995e52..0b52e0a30cb 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt
@@ -2,5 +2,5 @@
 open class B(val prop: Int)
 class A : B {
     constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>) :
-        <!INAPPLICABLE_CANDIDATE!>super<!>(x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>)
+        super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!><!>)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.fir.kt
index 888899be4f8..f2723b50411 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.fir.kt
@@ -5,11 +5,11 @@ val A.prop: Int get() = 2
 
 class A {
     constructor(x: Int)
-    constructor() : <!INAPPLICABLE_CANDIDATE!>this<!>(
-            <!UNRESOLVED_REFERENCE!>foobar<!>() +
+    constructor() : this(
+            <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>foobar<!>() +
             <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.foobar() +
             <!UNRESOLVED_REFERENCE!>prop<!> +
             <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.prop +
-            <!UNRESOLVED_LABEL!>this@A<!>.prop
+            <!UNRESOLVED_LABEL!>this@A<!>.prop<!>
     )
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.fir.kt
index 490207fb280..4dfe5fc198e 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.fir.kt
@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !WITH_NEW_INFERENCE
 class X<T>(val t: T) {
-    constructor(t: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i)
+    constructor(t: T, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/kt6994.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/kt6994.fir.kt
index 89b1ce9431e..13a4c35928f 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/kt6994.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/kt6994.fir.kt
@@ -1,4 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 class X<T> {
-    constructor(t: T, i: Int): <!INAPPLICABLE_CANDIDATE!>this<!>(i, 1)
+    constructor(t: T, i: Int): this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 1)
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/classObjectMember.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/classObjectMember.fir.kt
index 48a44761283..7a2cc4dc692 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/classObjectMember.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/classObjectMember.fir.kt
@@ -15,8 +15,8 @@ class B {
 fun test() {
     if (A.x != null) {
         useInt(A.x)
-        <!INAPPLICABLE_CANDIDATE!>useInt<!>(B.x)
+        useInt(<!ARGUMENT_TYPE_MISMATCH!>B.x<!>)
     }
 }
 
-fun useInt(i: Int) = i
\ No newline at end of file
+fun useInt(i: Int) = i
diff --git a/compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.fir.kt
index fe045272d63..872c9199096 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.fir.kt
@@ -19,7 +19,7 @@ fun bar(x: String) = x
 fun test(x: String?): Any {
     val y = My.create()
     val z = x ?: y!!
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
     // !! / ?. is necessary here, because y!! above may not be executed
     y?.hashCode()
     y!!.hashCode()
diff --git a/compiler/testData/diagnostics/tests/smartCasts/equals.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/equals.fir.kt
index 1de64d0d3b6..aec616263c4 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/equals.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/equals.fir.kt
@@ -7,19 +7,19 @@ class TestWithEquals {
 }
 
 fun bar(i: Test?) {
-    if (i == null) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+    if (i == null) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
 }
 
 fun bar(i: TestWithEquals?) {
-    if (i == null) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
-    if (null == i) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+    if (i == null) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
+    if (null == i) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
     when (i) {
-        null -> <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+        null -> foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
     }
 }
 
 fun gav(i: TestWithEquals?, j: TestWithEquals?) {
     if (j == null) {
-        if (i == j) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+        if (i == j) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.fir.kt
index c2269721d49..7d242f7cdd9 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.fir.kt
@@ -30,7 +30,7 @@ fun test(a: A, b: B, c: C) {
 
         val k = three(a, b, c)
         checkSubtype<A>(k)
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><B>(k)
+        checkSubtype<B>(<!ARGUMENT_TYPE_MISMATCH!>k<!>)
         val l: Int = three(a, b, c)
 
         use(d, e, f, g, h, k, l)
@@ -41,11 +41,11 @@ fun <T> foo(t: T, l: MutableList<T>): T = t
 
 fun testErrorMessages(a: A, ml: MutableList<String>) {
     if (a is B && a is C) {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(a, ml)
+        foo(a, <!ARGUMENT_TYPE_MISMATCH!>ml<!>)
     }
 
     if(a is C) {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(a, ml)
+        foo(a, <!ARGUMENT_TYPE_MISMATCH!>ml<!>)
     }
 }
 
@@ -53,7 +53,7 @@ fun rr(s: String?) {
     if (s != null) {
         val l = arrayListOf("", s)
         checkSubtype<MutableList<String>>(l)
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><MutableList<String?>>(l)
+        checkSubtype<MutableList<String?>>(<!ARGUMENT_TYPE_MISMATCH!>l<!>)
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt2422.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/kt2422.fir.kt
index 6040b1460de..8c1ee7d4dfa 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/kt2422.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/kt2422.fir.kt
@@ -6,10 +6,10 @@ class Test {
 
     fun bar(a: Test, b: Test) {
         if (a.foo != null) {
-            <!INAPPLICABLE_CANDIDATE!>useInt<!>(b.foo)
+            useInt(<!ARGUMENT_TYPE_MISMATCH!>b.foo<!>)
         }
         if (a.foo != null) {
-            <!INAPPLICABLE_CANDIDATE!>useInt<!>(foo)
+            useInt(<!ARGUMENT_TYPE_MISMATCH!>foo<!>)
         }
         if (this.foo != null) {
             useInt(foo)
diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt
index 8bb32d4e48a..901cbc1fb40 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt
@@ -7,6 +7,6 @@ fun foo(a: MutableMap<String, String>, x: String?) {
 }
 
 fun foo1(a: MutableMap<String, String>, x: String?) {
-    <!INAPPLICABLE_CANDIDATE!>a[x]<!> = x!!
+    a[<!ARGUMENT_TYPE_MISMATCH!>x<!>] = x!!
     a[x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>] = x
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.fir.kt
index c24ca8ed274..124d529aeb3 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.fir.kt
@@ -11,14 +11,14 @@ val i: Int? = 1
 class A(val i: Int?) {
     fun testUseFromClass() {
         if (foo.i != null) {
-            <!INAPPLICABLE_CANDIDATE!>useInt<!>(i)
+            useInt(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
         }
     }
 }
 
 fun testUseFromOtherPackage() {
     if (bar.i != null) {
-        <!INAPPLICABLE_CANDIDATE!>useInt<!>(i)
+        useInt(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.fir.kt
index fd23b53d520..1a0da886e31 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.fir.kt
@@ -3,4 +3,4 @@ fun Any?.foo(my: My) = my === this
 class My(val x: Any)
 
 // my is nullable in brackets because Any?.foo has nullable receiver
-fun foo(my: My?) = my?.x.<!INAPPLICABLE_CANDIDATE!>foo<!>(my)
\ No newline at end of file
+fun foo(my: My?) = my?.x.foo(<!ARGUMENT_TYPE_MISMATCH!>my<!>)
diff --git a/compiler/testData/diagnostics/tests/smartCasts/throwInTry.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/throwInTry.fir.kt
index b9d6ac6f20d..acac8f86dfb 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/throwInTry.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/throwInTry.fir.kt
@@ -50,7 +50,7 @@ fun conditionalThrowInTry_noSmartcastAfterTryCatch(a: A) {
             throw AssertionError()
         }
     } catch (e: Throwable) {}
-    <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+    takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }
 
 fun conditionalThrowInTry_rethrow_smartcastAfterTryCatch(a: A) {
@@ -61,7 +61,7 @@ fun conditionalThrowInTry_rethrow_smartcastAfterTryCatch(a: A) {
     } catch (e: Throwable) {
         throw e
     }
-    <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+    takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }
 
 fun conditionalThrowInTry_rethrow_smartcastAfterTryCatchFinally(a: A) {
@@ -72,7 +72,7 @@ fun conditionalThrowInTry_rethrow_smartcastAfterTryCatchFinally(a: A) {
     } catch (e: Throwable) {
         throw e
     } finally {}
-    <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+    takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }
 
 fun conditionalThrowInTry_rethrow_noSmartcastInFinally(a: A) {
@@ -83,6 +83,6 @@ fun conditionalThrowInTry_rethrow_noSmartcastInFinally(a: A) {
     } catch (e: Throwable) {
         throw e
     } finally {
-        <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+        takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsChanged.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsChanged.fir.kt
index 770d9dd55df..e3135c0c7a7 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsChanged.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsChanged.fir.kt
@@ -6,6 +6,6 @@ public fun foo() {
     var s: Any = "not null"
     if (s is String) {
         s = 42
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(s)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt
index 3d667d5f787..470ad17d171 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt
@@ -6,5 +6,5 @@ fun foo(x: Int, f: () -> Unit, y: Int) {}
 fun bar() {
     var x: Int?
     x = 4
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(x, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, x)
+    foo(x, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt
index b12b92d08c8..a98e9f3fe82 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt
@@ -7,5 +7,5 @@ fun bar(s: String): Int {
 
 fun foo(m: MyClass): Int {
     m.p = "xyz"
-    return <!INAPPLICABLE_CANDIDATE!>bar<!>(m.p)
+    return bar(<!ARGUMENT_TYPE_MISMATCH!>m.p<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/subtyping/javaAndKotlinSuperType.fir.kt b/compiler/testData/diagnostics/tests/subtyping/javaAndKotlinSuperType.fir.kt
index 3b949012032..054bfda7853 100644
--- a/compiler/testData/diagnostics/tests/subtyping/javaAndKotlinSuperType.fir.kt
+++ b/compiler/testData/diagnostics/tests/subtyping/javaAndKotlinSuperType.fir.kt
@@ -38,5 +38,5 @@ class W: B(), Z
 
 fun test2(w: W) {
     eatAString(w)
-    <!INAPPLICABLE_CANDIDATE!>eatAStringN<!>(w)
+    eatAStringN(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversion.fir.kt b/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversion.fir.kt
index da4be44f525..ef2b4fa529f 100644
--- a/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversion.fir.kt
+++ b/compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversion.fir.kt
@@ -18,6 +18,6 @@ fun test(
     foo2(f2)
     foo3(f3)
 
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(f2)
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(f3)
+    foo1(<!ARGUMENT_TYPE_MISMATCH!>f2<!>)
+    foo1(<!ARGUMENT_TYPE_MISMATCH!>f3<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionDisabled.fir.kt b/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionDisabled.fir.kt
index fb5b1104d95..28447bee963 100644
--- a/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionDisabled.fir.kt
+++ b/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionDisabled.fir.kt
@@ -22,6 +22,6 @@ fun test(
 
     foo1(::bar)
 
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(f2)
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(f3)
+    foo1(<!ARGUMENT_TYPE_MISMATCH!>f2<!>)
+    foo1(<!ARGUMENT_TYPE_MISMATCH!>f3<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.fir.kt
index 99d47ef1928..b4fa44d5245 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.fir.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.fir.kt
@@ -23,7 +23,7 @@ fun foo(k: KotlinClass) {
 
     k.setSomething4("")
     k.something4 += ""
-    k.<!INAPPLICABLE_CANDIDATE!>setSomething4<!>(null)
+    k.setSomething4(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
     k.something4 = null
 
     useString(k.getSomething5())
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt
index e49e9eba107..2730e8314f6 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt
@@ -1,7 +1,7 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<String>): String {
-    return javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething<!>("", 1) { s: String -> "" }
+    return javaClass.doSomething("", 1) { s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!> }
 }
 
 // FILE: JavaClass.java
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.fir.kt
index 029ab9b26da..a5dff1d25d7 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.fir.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.fir.kt
@@ -1,7 +1,7 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass): String {
-    return javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething<!>("") { <!UNRESOLVED_REFERENCE!>it<!> }
+    return javaClass.doSomething("") { <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }
 }
 
 // FILE: JavaClass.java
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt
index 036f6bcf97f..dc9c84221df 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt
@@ -1,8 +1,8 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>) {
-    val a: String = javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething1<!>("", 1) { p: String -> p }
-    val b: String = javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething2<!>("", 1, true) { p: Int -> p }
+    val a: String = javaClass.doSomething1("", 1) { p: String -> <!ARGUMENT_TYPE_MISMATCH!>p<!> }
+    val b: String = javaClass.doSomething2("", 1, true) { p: Int -> <!ARGUMENT_TYPE_MISMATCH!>p<!> }
 }
 
 // FILE: JavaClass.java
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.fir.kt
index 7d1d24a3487..4aed075a786 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.fir.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.fir.kt
@@ -2,7 +2,7 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>): Int {
     val inner = javaClass.createInner<String>()
-    return inner.<!INAPPLICABLE_CANDIDATE!>doSomething<!>(1, "") { }
+    return inner.doSomething(<!ARGUMENT_TYPE_MISMATCH!>1<!>, "") { }
 }
 
 // FILE: JavaClass.java
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.fir.kt
index a800a633332..f7bdb35c13a 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.fir.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.fir.kt
@@ -1,8 +1,8 @@
 // !WITH_NEW_INFERENCE
 // FILE: KotlinFile.kt
 fun foo(javaInterface: JavaInterface) {
-    javaInterface.<!INAPPLICABLE_CANDIDATE!>doIt<!>(null) { }
-    javaInterface.<!INAPPLICABLE_CANDIDATE!>doIt<!>("", null)
+    javaInterface.doIt(<!ARGUMENT_TYPE_MISMATCH!>null<!>) { }
+    javaInterface.doIt("", <!ARGUMENT_TYPE_MISMATCH!>null<!>)
 }
 
 // FILE: JavaInterface.java
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.fir.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.fir.kt
index aa494b9e7e5..a2e2a2f4d66 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.fir.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.fir.kt
@@ -16,8 +16,8 @@ fun foo(javaClass: JavaClass, kotlinClass: KotlinClass) {
         bar()
     }
 
-    javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething2<!> {
-        bar()
+    javaClass.doSomething2 {
+        <!ARGUMENT_TYPE_MISMATCH!>bar()<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/targetedBuiltIns/concurrentMapRemove.fir.kt b/compiler/testData/diagnostics/tests/targetedBuiltIns/concurrentMapRemove.fir.kt
index 49c3fbfc73b..17fca7ffac3 100644
--- a/compiler/testData/diagnostics/tests/targetedBuiltIns/concurrentMapRemove.fir.kt
+++ b/compiler/testData/diagnostics/tests/targetedBuiltIns/concurrentMapRemove.fir.kt
@@ -8,9 +8,9 @@ val concurrentHash: ConcurrentHashMap<String, Int> = null!!
 
 fun foo() {
     concurrent.remove("", 1)
-    concurrent.<!INAPPLICABLE_CANDIDATE!>remove<!>("", "")
+    concurrent.remove("", <!ARGUMENT_TYPE_MISMATCH!>""<!>)
     concurrentHash.remove("", 1)
-    concurrentHash.<!INAPPLICABLE_CANDIDATE!>remove<!>("", "")
+    concurrentHash.remove("", <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
     // Flexible types
     concurrent.remove(null, 1)
diff --git a/compiler/testData/diagnostics/tests/targetedBuiltIns/forEachRemainingNullability.fir.kt b/compiler/testData/diagnostics/tests/targetedBuiltIns/forEachRemainingNullability.fir.kt
index 77dc6f828de..63d48ffc6f3 100644
--- a/compiler/testData/diagnostics/tests/targetedBuiltIns/forEachRemainingNullability.fir.kt
+++ b/compiler/testData/diagnostics/tests/targetedBuiltIns/forEachRemainingNullability.fir.kt
@@ -32,7 +32,7 @@ abstract class MyIt7 : Iterator<String> {
 
 
 fun foo(x: Iterator<String>, y: Iterator<String?>) {
-    x.<!INAPPLICABLE_CANDIDATE!>forEachRemaining<!>(null)
+    x.forEachRemaining(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
 
     x.forEachRemaining { it -> it.length }
     x.forEachRemaining { it -> it?.length }
diff --git a/compiler/testData/diagnostics/tests/targetedBuiltIns/getOrDefault.fir.kt b/compiler/testData/diagnostics/tests/targetedBuiltIns/getOrDefault.fir.kt
index b4b0ecc3eae..2d940ccf600 100644
--- a/compiler/testData/diagnostics/tests/targetedBuiltIns/getOrDefault.fir.kt
+++ b/compiler/testData/diagnostics/tests/targetedBuiltIns/getOrDefault.fir.kt
@@ -4,17 +4,17 @@ abstract class A : Map<Int, String>
 
 fun foo(x: Map<Int, String>, a: A, b: java.util.HashMap<Int, String>) {
     x.getOrDefault(1, "")
-    x.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>("", "")
-    x.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>(1, 2)
-    x.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>("", 2)
+    x.getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>""<!>, "")
+    x.getOrDefault(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
+    x.getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 
     a.getOrDefault(1, "")
-    a.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>("", "")
-    a.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>(1, 2)
-    a.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>("", 2)
+    a.getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>""<!>, "")
+    a.getOrDefault(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
+    a.getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 
     b.getOrDefault(1, "")
-    b.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>("", "")
-    b.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>(1, 2)
-    b.<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>("", 2)
+    b.getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>""<!>, "")
+    b.getOrDefault(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
+    b.getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/targetedBuiltIns/mutableMapRemove.fir.kt b/compiler/testData/diagnostics/tests/targetedBuiltIns/mutableMapRemove.fir.kt
index 80bfe7c919c..001df3f2519 100644
--- a/compiler/testData/diagnostics/tests/targetedBuiltIns/mutableMapRemove.fir.kt
+++ b/compiler/testData/diagnostics/tests/targetedBuiltIns/mutableMapRemove.fir.kt
@@ -18,14 +18,14 @@ class KotlinMap2 : java.util.AbstractMap<String, Int>() {
 
 fun foo(x: MutableMap<String, Int>, y: java.util.HashMap<String, Int>, z: java.util.AbstractMap<String, Int>) {
     x.remove("", 1)
-    x.<!INAPPLICABLE_CANDIDATE!>remove<!>("", "")
-    x.<!INAPPLICABLE_CANDIDATE!>remove<!>("", null)
+    x.remove("", <!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    x.remove("", <!ARGUMENT_TYPE_MISMATCH!>null<!>)
 
     y.remove("", 1)
-    y.<!INAPPLICABLE_CANDIDATE!>remove<!>("", "")
+    y.remove("", <!ARGUMENT_TYPE_MISMATCH!>""<!>)
     y.remove("", null)
 
     z.remove("", 1)
-    z.<!INAPPLICABLE_CANDIDATE!>remove<!>("", "")
+    z.remove("", <!ARGUMENT_TYPE_MISMATCH!>""<!>)
     z.remove("", null)
 }
diff --git a/compiler/testData/diagnostics/tests/typeParameters/kt42396.fir.kt b/compiler/testData/diagnostics/tests/typeParameters/kt42396.fir.kt
index 2f2dee34a5d..946fe50c23f 100644
--- a/compiler/testData/diagnostics/tests/typeParameters/kt42396.fir.kt
+++ b/compiler/testData/diagnostics/tests/typeParameters/kt42396.fir.kt
@@ -13,5 +13,5 @@ fun <F> wrapAAndBToOut(x: F): Out<F> where F : A, F : B = Out()
 fun main(a: A) {
     val x: Out<A> = materializeOutOfAAndB() // OI: inferred type A is not a subtype of B; `F` is instantiated as `A`, so upper bounds was violated
     val y: Inv<A> = materializeInvOfAAndB() // OI and NI: required B, found A
-    val z: Out<A> = <!INAPPLICABLE_CANDIDATE!>wrapAAndBToOut<!>(a) // OI and NI: required B, found A
+    val z: Out<A> = wrapAAndBToOut(<!ARGUMENT_TYPE_MISMATCH!>a<!>) // OI and NI: required B, found A
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.fir.kt b/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.fir.kt
index 92c6786e45c..8c4b1df4396 100644
--- a/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.fir.kt
@@ -4,7 +4,7 @@ class Num<T: Number>(val x: T)
 typealias N<T> = Num<T>
 typealias N2<T> = N<T>
 
-val x1 = <!INAPPLICABLE_CANDIDATE!>Num<!><String>("")
+val x1 = Num<String>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 val x2 = N<String>("")
 val x3 = N2<String>("")
 
diff --git a/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.fir.kt b/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.fir.kt
index c18d9f69a1e..b0081a293f8 100644
--- a/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.fir.kt
@@ -6,7 +6,7 @@ typealias Array2D<T> = Array<Array<T>>
 fun foo1(a: Array2D<out Number>) = a
 
 fun bar1(a: Array2D<Int>) =
-        <!INAPPLICABLE_CANDIDATE!>foo1<!>(a)
+        foo1(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 
 
 typealias TMap<T> = Map<T, T>
@@ -14,4 +14,4 @@ typealias TMap<T> = Map<T, T>
 fun <T> foo2(m: TMap<T>) = m
 
 fun bar2(m: TMap<*>) =
-        <!INAPPLICABLE_CANDIDATE!>foo2<!>(m)
+        foo2(<!ARGUMENT_TYPE_MISMATCH!>m<!>)
diff --git a/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt b/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt
index a760eb31598..76e97407452 100644
--- a/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt
@@ -10,6 +10,6 @@ fun test2(x: Map<String, Int>) = check(x)
 
 fun test3(x: Map<Int, String>) = check(x).size
 
-fun test4(x: Map<Int, String>) = <!INAPPLICABLE_CANDIDATE!>check(x)["42"]<!>
+fun test4(x: Map<Int, String>) = check(x)[<!ARGUMENT_TYPE_MISMATCH!>"42"<!>]
 
-fun test5(x: Map<Int, String>) = <!INAPPLICABLE_CANDIDATE!>check(x)[42]<!>
+fun test5(x: Map<Int, String>) = check(x)[<!ARGUMENT_TYPE_MISMATCH!>42<!>]
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt
index 23887da1590..2ea38ab934a 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt
@@ -11,6 +11,6 @@ fun <T> listOf(): List<T> = null!!
 // Unresolved reference is ok here:
 // we can't create a substituted signature for type alias constructor
 // since it has 'out' type projection in 'in' position.
-val test1 = <!INAPPLICABLE_CANDIDATE!>BOutIn<!>(listOf(), null!!)
+val test1 = BOutIn(<!ARGUMENT_TYPE_MISMATCH!>listOf()<!>, null!!)
 
 val test2 = BInIn(listOf(), null!!)
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.fir.kt
index b7008cf51e6..7a88b7d993a 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.fir.kt
@@ -12,8 +12,8 @@ class Cons<T>(val head: T, val tail: Cons<T>?)
 typealias C<T> = Cons<T>
 typealias CC<T> = C<C<T>>
 
-val test2 = <!INAPPLICABLE_CANDIDATE!>C<!>(1, 2)
-val test3 = <!INAPPLICABLE_CANDIDATE!>CC<!>(1, 2)
+val test2 = C(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
+val test3 = CC(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
 val test4 = CC(C(1, null), null)
 
 
@@ -21,13 +21,13 @@ class Pair<X, Y>(val x: X, val y: Y)
 typealias PL<T> = Pair<T, List<T>>
 typealias PN<T> = Pair<T, Num<T>>
 
-val test5 = <!INAPPLICABLE_CANDIDATE!>PL<!>(1, null)
+val test5 = PL(1, <!ARGUMENT_TYPE_MISMATCH!>null<!>)
 
 
 class Foo<T>(val p: Pair<T, T>)
 typealias F<T> = Foo<T>
 
-fun testProjections1(x: Pair<in Int, out String>) = <!INAPPLICABLE_CANDIDATE!>F<!>(x)
-fun testProjections2(x: Pair<in Int, out Number>) = <!INAPPLICABLE_CANDIDATE!>F<!>(x)
-fun testProjections3(x: Pair<in Number, out Int>) = <!INAPPLICABLE_CANDIDATE!>F<!>(x)
-fun testProjections4(x: Pair<in Int, in Int>) = <!INAPPLICABLE_CANDIDATE!>F<!>(x)
+fun testProjections1(x: Pair<in Int, out String>) = F(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+fun testProjections2(x: Pair<in Int, out Number>) = F(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+fun testProjections3(x: Pair<in Number, out Int>) = F(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+fun testProjections4(x: Pair<in Int, in Int>) = F(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.fir.kt
index d46ab13a6f4..79aee5579fc 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.fir.kt
@@ -10,11 +10,11 @@ open class MyClass private constructor(val x: Int) {
 
 typealias MyAlias = MyClass
 
-val test1 = <!INAPPLICABLE_CANDIDATE!>MyAlias<!>(1)
-val test1a = <!INAPPLICABLE_CANDIDATE!>MyClass<!>(1)
+val test1 = MyAlias(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
+val test1a = MyClass(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 
-val test2 = <!INAPPLICABLE_CANDIDATE!>MyAlias<!>("")
-val test2a = <!INAPPLICABLE_CANDIDATE!>MyClass<!>("")
+val test2 = MyAlias(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+val test2a = MyClass(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
 val test3 = MyAlias(1.0)
 val test3a = MyClass(1.0)
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt
index bb0c017ef31..79972549f79 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.fir.kt
@@ -20,5 +20,5 @@ val test2 = WI(<!TOO_MANY_ARGUMENTS!>null<!>)
 
 val test3 = CWI()
 val test4 = CWI("")
-val test5 = <!INAPPLICABLE_CANDIDATE!>CWI<!>(null)
-val test5a = <!INAPPLICABLE_CANDIDATE!>ClassWithCompanionObjectWithInvoke<!>(null)
+val test5 = CWI(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
+val test5a = ClassWithCompanionObjectWithInvoke(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
diff --git a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt
index d321469fd3b..4d9f140bfed 100644
--- a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt
+++ b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.fir.kt
@@ -22,7 +22,7 @@ val test3p2 = <!INAPPLICABLE_CANDIDATE!>P2<!><Int, Int, Int>(1, 1)
 
 val test0pr = PR(1, "")
 val test1pr = <!INAPPLICABLE_CANDIDATE!>PR<!><Int>(1, "")
-val test2pr = <!INAPPLICABLE_CANDIDATE!>PR<!><Int, String>(1, "")
+val test2pr = PR<Int, String>(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
 val test2pra = PR<String, Int>(1, "")
 val test3pr = <!INAPPLICABLE_CANDIDATE!>P2<!><String, Int, Int>(1, "")
 
@@ -38,5 +38,5 @@ class MyPair<T1 : CharSequence, T2 : Number>(val string: T1, val number: T2)
 typealias MP<T1> = MyPair<String, T1>
 
 val testMP0 = MP<Int>("", 1)
-val testMP1 = <!INAPPLICABLE_CANDIDATE!>MP<!>(1, "")
+val testMP1 = MP(<!ARGUMENT_TYPE_MISMATCH!>1<!>, "")
 val testMP2 = MP<String>("", "")
diff --git a/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.fir.kt b/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.fir.kt
index ba4a1583d71..1d630c5d007 100644
--- a/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.fir.kt
+++ b/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.fir.kt
@@ -12,7 +12,7 @@ fun bar(): String = ""
 abstract class SubInt : () -> Int
 
 fun test(f: () -> String, s: SubInt) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(f)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(s)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
     foo(::bar)
 }
diff --git a/compiler/testData/diagnostics/tests/unitConversion/chainedFunUnitConversion.fir.kt b/compiler/testData/diagnostics/tests/unitConversion/chainedFunUnitConversion.fir.kt
index 663d9bc3718..f16b065ee34 100644
--- a/compiler/testData/diagnostics/tests/unitConversion/chainedFunUnitConversion.fir.kt
+++ b/compiler/testData/diagnostics/tests/unitConversion/chainedFunUnitConversion.fir.kt
@@ -10,6 +10,6 @@ fun foo(r: KRunnable) {}
 abstract class SubInt : () -> Int
 
 fun test(f: () -> Int, s: SubInt) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(f)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(s)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.fir.kt b/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.fir.kt
index fc807ad7dd3..e541778711c 100644
--- a/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.fir.kt
+++ b/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.fir.kt
@@ -9,6 +9,6 @@ abstract class SubInt : () -> Int
 
 fun test(g: () -> Double, s: SubInt) {
     foo(::bar)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(g)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(s)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>g<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/unitConversion/unitConversionCompatibility.fir.kt b/compiler/testData/diagnostics/tests/unitConversion/unitConversionCompatibility.fir.kt
index f8db62e5ae8..ca60944607b 100644
--- a/compiler/testData/diagnostics/tests/unitConversion/unitConversionCompatibility.fir.kt
+++ b/compiler/testData/diagnostics/tests/unitConversion/unitConversionCompatibility.fir.kt
@@ -23,7 +23,7 @@ object Test2 {
         fun foo(f: KRunnable) {}
 
         fun test(f: () -> Int) {
-            <!DEBUG_INFO_CALL("fqName: fqName is unknown; typeCall: unresolved")!><!INAPPLICABLE_CANDIDATE!>foo<!>(f)<!>
+            <!DEBUG_INFO_CALL("fqName: fqName is unknown; typeCall: unresolved")!>foo(<!ARGUMENT_TYPE_MISMATCH!>f<!>)<!>
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/unitConversion/unitConversionDisabledForSimpleArguments.fir.kt b/compiler/testData/diagnostics/tests/unitConversion/unitConversionDisabledForSimpleArguments.fir.kt
index 9e6eda14483..947c2add77d 100644
--- a/compiler/testData/diagnostics/tests/unitConversion/unitConversionDisabledForSimpleArguments.fir.kt
+++ b/compiler/testData/diagnostics/tests/unitConversion/unitConversionDisabledForSimpleArguments.fir.kt
@@ -15,8 +15,8 @@ fun test(f: () -> String, g: () -> Nothing, h: () -> Nothing?, s: SubInt) {
     foo({ TODO() }.freeze())
     foo(g)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(h)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>h<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(f)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(s)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.fir.kt b/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.fir.kt
index ce697bd68b2..706990943ce 100644
--- a/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.fir.kt
+++ b/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.fir.kt
@@ -10,7 +10,7 @@ fun createCall(): () -> Int = TODO()
 fun test(g: () -> String, h: (Float) -> String) {
     foo(::bar)
     foo { "something" }
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(g)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>g<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>fooGeneric<!>(h)
+    fooGeneric(<!ARGUMENT_TYPE_MISMATCH!>h<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.fir.kt b/compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.fir.kt
index 237022dddfe..74258132220 100644
--- a/compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.fir.kt
+++ b/compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.fir.kt
@@ -7,16 +7,16 @@ abstract class SubInt : (Int, String) -> Int
 abstract class SubIntWrong : (String, String) -> Int
 
 fun test1(s: SubInt, sWrong: SubIntWrong) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(s)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(sWrong)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>sWrong<!>)
 
     val a = "foo"
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(a)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 
     a as (Int, String) -> String
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(a)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }
 
 fun <T> test2(x: T) where T : (Int, String) -> Int, T : (Double) -> Int {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
-}
\ No newline at end of file
+    foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+}
diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt
index 41cfd451177..0503e7a49ec 100644
--- a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt
+++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt
@@ -43,27 +43,27 @@ fun takeUIntWithoutAnnotaion(u: UInt) {}
 fun takeIntWithoutAnnotation(i: Int) {}
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(IMPLICIT_INT)
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(EXPLICIT_INT)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>IMPLICIT_INT<!>)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>EXPLICIT_INT<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUShort<!>(IMPLICIT_INT)
-    <!INAPPLICABLE_CANDIDATE!>takeUShort<!>(BIGGER_THAN_UBYTE)
+    takeUShort(<!ARGUMENT_TYPE_MISMATCH!>IMPLICIT_INT<!>)
+    takeUShort(<!ARGUMENT_TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(IMPLICIT_INT)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>IMPLICIT_INT<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeULong<!>(IMPLICIT_INT)
+    takeULong(<!ARGUMENT_TYPE_MISMATCH!>IMPLICIT_INT<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUBytes<!>(IMPLICIT_INT, EXPLICIT_INT, 42u)
+    takeUBytes(<!ARGUMENT_TYPE_MISMATCH!>IMPLICIT_INT<!>, <!ARGUMENT_TYPE_MISMATCH!>EXPLICIT_INT<!>, 42u)
 
-    <!INAPPLICABLE_CANDIDATE!>takeLong<!>(IMPLICIT_INT)
+    takeLong(<!ARGUMENT_TYPE_MISMATCH!>IMPLICIT_INT<!>)
 
     takeIntWithoutAnnotation(IMPLICIT_INT)
 
     takeUIntWithoutAnnotaion(UINT_CONST)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(LONG_CONST)
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(NON_CONST)
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(BIGGER_THAN_UBYTE)
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(UINT_CONST)
-    <!INAPPLICABLE_CANDIDATE!>takeUIntWithoutAnnotaion<!>(IMPLICIT_INT)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>LONG_CONST<!>)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>NON_CONST<!>)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>UINT_CONST<!>)
+    takeUIntWithoutAnnotaion(<!ARGUMENT_TYPE_MISMATCH!>IMPLICIT_INT<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt
index 7b1e8c134a6..a54ea46fbde 100644
--- a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt
+++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt
@@ -11,10 +11,10 @@ fun takeUByte(u: UByte) {}
 
 fun foo() {
     select(1, 1u) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Comparable<*>>() }
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(id(1))
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>id(1)<!>)
 
     1 <!NONE_APPLICABLE!>+<!> 1u
     (1u <!NONE_APPLICABLE!>+<!> 1) <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><UInt>() }
 
-    <!INAPPLICABLE_CANDIDATE!>id<!><UInt>(1)
+    id<UInt>(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt
index 0c918bf0301..8569081069a 100644
--- a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt
+++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt
@@ -11,47 +11,47 @@ fun takeUBytes(vararg u: UByte) {}
 fun takeNullableUInt(u: UInt?) {}
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1 + 2)
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1.plus(2))
-    <!INAPPLICABLE_CANDIDATE!>takeNullableUInt<!>(4)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>1 + 2<!>)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>1.plus(2)<!>)
+    takeNullableUInt(<!ARGUMENT_TYPE_MISMATCH!>4<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(Int.MAX_VALUE * 2L)
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(-1)
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(Int.MAX_VALUE * 2L + 2)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>Int.MAX_VALUE * 2L<!>)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>-1<!>)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>Int.MAX_VALUE * 2L + 2<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(1)
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(255)
-    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(1.toByte())
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>255<!>)
+    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>1.toByte()<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUShort<!>(1)
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1)
-    <!INAPPLICABLE_CANDIDATE!>takeULong<!>(1)
+    takeUShort(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
+    takeULong(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 
     takeULong(<!ILLEGAL_CONST_EXPRESSION!>18446744073709551615<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeULong<!>(1844674407370955161)
+    takeULong(<!ARGUMENT_TYPE_MISMATCH!>1844674407370955161<!>)
     takeULong(18446744073709551615u)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(Int.MAX_VALUE * 2)
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(4294967294)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>Int.MAX_VALUE * 2<!>)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>4294967294<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUBytes<!>(1, 2, 255, 256, 0, -1, 40 + 2)
+    takeUBytes(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>, <!ARGUMENT_TYPE_MISMATCH!>255<!>, <!ARGUMENT_TYPE_MISMATCH!>256<!>, <!ARGUMENT_TYPE_MISMATCH!>0<!>, <!ARGUMENT_TYPE_MISMATCH!>-1<!>, <!ARGUMENT_TYPE_MISMATCH!>40 + 2<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1.myPlus(2))
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>1.myPlus(2)<!>)
 
     val localVariable = 42
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(localVariable)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>localVariable<!>)
 
     var localMutableVariable = 42
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(localMutableVariable)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>localMutableVariable<!>)
 
     val localNegativeVariable = -1
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(localNegativeVariable)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>localNegativeVariable<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(globalVariable)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>globalVariable<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(constVal)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>constVal<!>)
 
-    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(globalVariableWithGetter)
+    takeUInt(<!ARGUMENT_TYPE_MISMATCH!>globalVariableWithGetter<!>)
 }
 
 val globalVariable = 10
diff --git a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt
index 454b4716190..ad9295cb666 100644
--- a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt
@@ -31,8 +31,8 @@ fun getArr(): Array<String>? = null
 
 fun f() {
     A().foo(1, *args)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(2, *args)
-    baz(<!NON_VARARG_SPREAD!>*<!>args)
+    bar(2, *<!ARGUMENT_TYPE_MISMATCH!>args<!>)
+    baz(<!NON_VARARG_SPREAD!>*<!><!ARGUMENT_TYPE_MISMATCH!>args<!>)
 }
 
 fun g(args: Array<String>?) {
@@ -55,8 +55,8 @@ fun h(b: B) {
 
 fun k() {
     A().foo(1, *getArr())
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(2, *getArr())
-    baz(<!NON_VARARG_SPREAD!>*<!>getArr())
+    bar(2, *<!ARGUMENT_TYPE_MISMATCH!>getArr()<!>)
+    baz(<!NON_VARARG_SPREAD!>*<!><!ARGUMENT_TYPE_MISMATCH!>getArr()<!>)
 }
 
 fun invokeTest(goodArgs: Array<String>) {
diff --git a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.fir.kt b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.fir.kt
index 56098cdc698..86691dfabc5 100644
--- a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.fir.kt
@@ -10,13 +10,13 @@ fun withVararg(vararg s: String) {}
 fun foo() {}
 
 fun test_fun(s: String, arr: Array<String>) {
-    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(arr) // Error
+    withVararg(<!ARGUMENT_TYPE_MISMATCH!>arr<!>) // Error
     withVararg(*arr) // OK
     withVararg(s = arr) // Error
     withVararg(s = *arr) // OK
 
     withVararg(s) // OK
-    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(s = s) // Error
+    withVararg(s = <!ARGUMENT_TYPE_MISMATCH!>s<!>) // Error
 }
 
 fun test_ann(s: String, arr: Array<String>) {
diff --git a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.fir.kt b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.fir.kt
index 971e060e747..63fd72c7599 100644
--- a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.fir.kt
@@ -10,13 +10,13 @@ fun withVararg(vararg s: String) {}
 fun foo() {}
 
 fun test_fun(s: String, arr: Array<String>) {
-    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(arr) // Error
+    withVararg(<!ARGUMENT_TYPE_MISMATCH!>arr<!>) // Error
     withVararg(*arr) // OK
     withVararg(s = arr) // OK
     withVararg(s = *arr) // Warning
 
     withVararg(s) // OK
-    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(s = s) // Error
+    withVararg(s = <!ARGUMENT_TYPE_MISMATCH!>s<!>) // Error
 }
 
 fun test_ann(s: String, arr: Array<String>) {
diff --git a/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.fir.kt b/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.fir.kt
index 93696283bf2..7b1615467ed 100644
--- a/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.fir.kt
@@ -15,10 +15,10 @@ annotation class Ann(vararg val s: String)
 @Ann(s = arrayOf())
 fun test1() {}
 
-<!INAPPLICABLE_CANDIDATE!>@Ann(s = intArrayOf())<!>
+@Ann(s = <!ARGUMENT_TYPE_MISMATCH!>intArrayOf()<!>)
 fun test2() {}
 
-<!INAPPLICABLE_CANDIDATE!>@Ann(s = arrayOf(1))<!>
+@Ann(s = <!ARGUMENT_TYPE_MISMATCH!>arrayOf(1)<!>)
 fun test3() {}
 
 @Ann("value1", "value2")
diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.fir.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.fir.kt
index 464a298a01e..4349a317c6c 100644
--- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.fir.kt
@@ -53,8 +53,8 @@ fun testMany(a: Any) {
     manyFoo(s = "")
 
     <!NONE_APPLICABLE!>manyFoo<!>(a)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(v = a)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(s = a)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(v = a as Int)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(s = a as String)
+    manyFoo(v = <!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    manyFoo(s = <!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    manyFoo(v = <!ARGUMENT_TYPE_MISMATCH!>a as Int<!>)
+    manyFoo(s = <!ARGUMENT_TYPE_MISMATCH!>a as String<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.fir.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.fir.kt
index a2e2455a240..af7880ac0f1 100644
--- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.fir.kt
@@ -53,8 +53,8 @@ fun testMany(a: Any) {
     manyFoo(s = "")
 
     <!NONE_APPLICABLE!>manyFoo<!>(a)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(v = a)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(s = a)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(v = a as Int)
-    <!INAPPLICABLE_CANDIDATE!>manyFoo<!>(s = a as String)
+    manyFoo(v = <!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    manyFoo(s = <!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    manyFoo(v = <!ARGUMENT_TYPE_MISMATCH!>a as Int<!>)
+    manyFoo(s = <!ARGUMENT_TYPE_MISMATCH!>a as String<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.fir.kt b/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.fir.kt
index 1a2627826f7..8381c0b7e0c 100644
--- a/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.fir.kt
@@ -15,10 +15,10 @@ annotation class Ann(vararg val s: String)
 @Ann(s = arrayOf())
 fun test1() {}
 
-<!INAPPLICABLE_CANDIDATE!>@Ann(s = intArrayOf())<!>
+@Ann(s = <!ARGUMENT_TYPE_MISMATCH!>intArrayOf()<!>)
 fun test2() {}
 
-<!INAPPLICABLE_CANDIDATE!>@Ann(s = arrayOf(1))<!>
+@Ann(s = <!ARGUMENT_TYPE_MISMATCH!>arrayOf(1)<!>)
 fun test3() {}
 
 @Ann(s = ["value"])
diff --git a/compiler/testData/diagnostics/tests/varargs/varargsAndPair.fir.kt b/compiler/testData/diagnostics/tests/varargs/varargsAndPair.fir.kt
index cc2a581ceb8..7cd3700ad14 100644
--- a/compiler/testData/diagnostics/tests/varargs/varargsAndPair.fir.kt
+++ b/compiler/testData/diagnostics/tests/varargs/varargsAndPair.fir.kt
@@ -6,5 +6,5 @@ class Pair<A>(a: A)
 
 fun test() {
     val v = foo(Pair(1))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(v) // check that it is not error type
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>v<!>) // check that it is not error type
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/when/kt10439.fir.kt b/compiler/testData/diagnostics/tests/when/kt10439.fir.kt
index c30fc705cc3..87de67c97e7 100644
--- a/compiler/testData/diagnostics/tests/when/kt10439.fir.kt
+++ b/compiler/testData/diagnostics/tests/when/kt10439.fir.kt
@@ -14,12 +14,12 @@
 fun foo(x: Int) = x
 
 fun test0(flag: Boolean) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(if (flag) true else "")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>if (flag) true else ""<!>)
 }
 
 fun test1(flag: Boolean) {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(when (flag) {
+    foo(<!ARGUMENT_TYPE_MISMATCH!>when (flag) {
         true -> true
         else -> ""
-    })
+    }<!>)
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.fir.kt
index 502b2d7dc9a..808ca550b9c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.fir.kt
@@ -3,12 +3,12 @@
 fun test(mc: MutableCollection<out CharSequence>) {
     mc.addAll(mc)
 
-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(arrayListOf<CharSequence>())
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>arrayListOf<CharSequence>()<!>)
     mc.addAll(arrayListOf())
 
-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf(""))
-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf<String>(""))
-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf<CharSequence>(""))
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>listOf("")<!>)
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>listOf<String>("")<!>)
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>listOf<CharSequence>("")<!>)
 
     mc.addAll(emptyList())
     mc.addAll(emptyList<Nothing>())
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.fir.kt
index 58e77fcb919..e4cc980f080 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.fir.kt
@@ -6,7 +6,7 @@ annotation class Ann(val i: IntArray)
 @Ann(intArrayOf(i2))
 @Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
 @Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(<!INAPPLICABLE_CANDIDATE!>intArrayOf<!>(intArrayOf(i, i2, i3)))
+@Ann(intArrayOf(<!ARGUMENT_TYPE_MISMATCH!>intArrayOf(i, i2, i3)<!>))
 class Test
 
 var i = 1
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.fir.kt
index 4d9dec1b658..7a5f9cd9e05 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.fir.kt
@@ -6,6 +6,6 @@ public @interface A {
 }
 
 // FILE: b.kt
-<!INAPPLICABLE_CANDIDATE!>@A(*arrayOf(1, "b"))<!>
+@A(*<!ARGUMENT_TYPE_MISMATCH!>arrayOf(1, "b")<!>)
 fun test() {
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.fir.kt
index c2424ad10b4..e40d885f3df 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.fir.kt
@@ -2,6 +2,6 @@
 
 annotation class B(vararg val args: String)
 
-<!INAPPLICABLE_CANDIDATE!>@B(*arrayOf(1, "b"))<!>
+@B(*<!ARGUMENT_TYPE_MISMATCH!>arrayOf(1, "b")<!>)
 fun test() {
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.fir.kt
index a1b34642fdd..3a442cbe244 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.fir.kt
@@ -14,7 +14,7 @@ class MyClass1
 @Ann1(arrayOf(Any::class))
 class MyClass1a
 
-<!INAPPLICABLE_CANDIDATE!>@Ann1(arrayOf(B1::class))<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(B1::class)<!>)
 class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -25,5 +25,5 @@ class MyClass3
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(B2::class))<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(B2::class)<!>)
 class MyClass5
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.fir.kt
index 11bce1bb6b5..d7c81d3d00a 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.fir.kt
@@ -11,7 +11,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
 @Ann1(arrayOf(A::class))
 class MyClass1
 
-<!INAPPLICABLE_CANDIDATE!>@Ann1(arrayOf(Any::class))<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(Any::class)<!>)
 class MyClass1a
 
 @Ann1(arrayOf(B1::class))
@@ -19,11 +19,11 @@ class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<out B1>>)
 
-<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(A::class))<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(A::class)<!>)
 class MyClass3
 
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(B2::class))<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(B2::class)<!>)
 class MyClass5
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.fir.kt
index f73ba7764ee..bccf4b7247f 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.fir.kt
@@ -12,7 +12,7 @@ class MyClass1
 @Ann1(Any::class)
 class MyClass1a
 
-<!INAPPLICABLE_CANDIDATE!>@Ann1(B1::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>B1::class<!>)
 class MyClass2
 
 annotation class Ann2(val arg: KClass<in B1>)
@@ -23,5 +23,5 @@ class MyClass3
 @Ann2(B1::class)
 class MyClass4
 
-<!INAPPLICABLE_CANDIDATE!>@Ann2(B2::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>B2::class<!>)
 class MyClass5
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.fir.kt
index 64ecb487ef4..6db9d2a03a0 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.fir.kt
@@ -9,7 +9,7 @@ annotation class Ann1(val arg: KClass<out A>)
 @Ann1(A::class)
 class MyClass1
 
-<!INAPPLICABLE_CANDIDATE!>@Ann1(Any::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>Any::class<!>)
 class MyClass1a
 
 @Ann1(B1::class)
@@ -17,11 +17,11 @@ class MyClass2
 
 annotation class Ann2(val arg: KClass<out B1>)
 
-<!INAPPLICABLE_CANDIDATE!>@Ann2(A::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>A::class<!>)
 class MyClass3
 
 @Ann2(B1::class)
 class MyClass4
 
-<!INAPPLICABLE_CANDIDATE!>@Ann2(B2::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>B2::class<!>)
 class MyClass5
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.fir.kt
index de094f1cce6..a3574aa666c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.fir.kt
@@ -8,15 +8,15 @@ annotation class Ann1(val arg: KClass<A>)
 @Ann1(A::class)
 class MyClass1
 
-<!INAPPLICABLE_CANDIDATE!>@Ann1(Any::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>Any::class<!>)
 class MyClass1a
 
-<!INAPPLICABLE_CANDIDATE!>@Ann1(B::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>B::class<!>)
 class MyClass2
 
 annotation class Ann2(val arg: KClass<B>)
 
-<!INAPPLICABLE_CANDIDATE!>@Ann2(A::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>A::class<!>)
 class MyClass3
 
 @Ann2(B::class)
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.fir.kt
index 412093c90fe..f8055aefa28 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.fir.kt
@@ -6,8 +6,8 @@ public @interface A {
 }
 
 // FILE: b.kt
-<!INAPPLICABLE_CANDIDATE!>@A(false,
+@A(<!ARGUMENT_TYPE_MISMATCH!>false<!>,
 1.0,
-false)<!> fun foo1() {}
+false) fun foo1() {}
 
-<!INAPPLICABLE_CANDIDATE!>@A(2.0, x = true, b = 2.0)<!> fun foo2() {}
+@A(<!ARGUMENT_TYPE_MISMATCH!>2.0<!>, x = true, b = 2.0) fun foo2() {}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/typeMismatch.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/typeMismatch.fir.kt
index 18ffdb6b2f3..8d756c88dc0 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/typeMismatch.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/typeMismatch.fir.kt
@@ -14,6 +14,6 @@ fun <T> myRun(block: () -> T): T {
 fun foo(x: Int): Int = x + 1
 
 fun typeMismatchInLambda(y: String): Int {
-    val x = myRun { <!INAPPLICABLE_CANDIDATE!>foo<!>(y) }
+    val x = myRun { foo(<!ARGUMENT_TYPE_MISMATCH!>y<!>) }
     return x
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/kt36818.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/kt36818.fir.kt
index 100afc833b4..669438916b9 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/kt36818.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/kt36818.fir.kt
@@ -1,7 +1,7 @@
 fun main(x1: Double?, range: ClosedRange<Double>) {
     when (x1) {
         null -> throw Exception()
-        <!INAPPLICABLE_CANDIDATE!>in<!> range -> {} // error, no smartcast from previous branch, OK in OI
+        <!ARGUMENT_TYPE_MISMATCH!>in range<!> -> {} // error, no smartcast from previous branch, OK in OI
     }
 
     when {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt
index 93bc5b88964..f829ef04e8f 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt
@@ -11,24 +11,24 @@ fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 
 val test1 = generate {
     apply {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(4)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>4<!>)
     }
 }
 
 val test2 = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>(B)
+    yield(<!ARGUMENT_TYPE_MISMATCH!>B<!>)
     apply {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(C)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>C<!>)
     }
 }
 
 val test3 = generate {
     this.let {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(B)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>B<!>)
     }
 
     apply {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(C)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>C<!>)
     }
 }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.fir.kt
index ad18793da9d..030107672a2 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.fir.kt
@@ -12,6 +12,6 @@ fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 suspend fun Base.baseExtension() {}
 
 val test1 = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>("foo")
+    yield(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
     baseExtension()
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.fir.kt
index dcb7ce0f233..b80ff0e4fd0 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.fir.kt
@@ -14,17 +14,17 @@ fun <S> Builder<S>.extensionAdd(s: S) {}
 suspend fun <S> Builder<S>.safeExtensionAdd(s: S) {}
 
 val member = build {
-    <!INAPPLICABLE_CANDIDATE!>add<!>(42)
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }
 
 val memberWithoutAnn = wrongBuild {
-    <!INAPPLICABLE_CANDIDATE!>add<!>(42)
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }
 
 val extension = build {
-    <!INAPPLICABLE_CANDIDATE!>extensionAdd<!>("foo")
+    extensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
 }
 
 val safeExtension = build {
-    <!INAPPLICABLE_CANDIDATE!>safeExtensionAdd<!>("foo")
+    safeExtensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt33542.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt33542.fir.kt
index abafc519962..40b6129a5c5 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt33542.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt33542.fir.kt
@@ -20,8 +20,8 @@ suspend fun yield() {}
 
 fun test() {
     builder {
-        <!INAPPLICABLE_CANDIDATE!>send<!>(run {
+        send(<!ARGUMENT_TYPE_MISMATCH!>run {
             yield() // No error but `yield` is not inside "suspension" context actually
-        })
+        }<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignInCoroutineContext.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignInCoroutineContext.fir.kt
index 73f2e088755..83353ec36e7 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignInCoroutineContext.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignInCoroutineContext.fir.kt
@@ -24,7 +24,7 @@ suspend fun foo(x: Int) = flow {
 
     var newValue = 1
     newValue += listOf<Int>().asSequence().fold(0) { total, next ->
-        <!INAPPLICABLE_CANDIDATE!>call<!>(11)
+        call(<!ARGUMENT_TYPE_MISMATCH!>11<!>)
         total + next
     }
     newValue += listOf<Int>().asSequence().fold(0, fun(total, next): Int { return total + next })
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.fir.kt
index 6a393ec0908..af677bc41dd 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.fir.kt
@@ -9,7 +9,7 @@ fun call(x: String) {}
 fun foo(x: Float, y: Float) = {
     var newValue = 1
     newValue += listOf<Int>().asSequence().fold(0) { total, next ->
-        <!INAPPLICABLE_CANDIDATE!>call<!>(11)
+        call(<!ARGUMENT_TYPE_MISMATCH!>11<!>)
         total + next
     }
     newValue += listOf<Int>().asSequence().fold(0, fun(total, next): Int { return total + next })
@@ -26,7 +26,7 @@ fun <T> id(x: T) = x
 
 fun foo2() = {
     var x = A()
-    x <!INAPPLICABLE_CANDIDATE!>+=<!> { "" }
+    x += { <!ARGUMENT_TYPE_MISMATCH!>""<!> }
     var y = A()
     y += 1
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.fir.kt
index a03169e2e17..76fa4fb0803 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.fir.kt
@@ -25,7 +25,7 @@ val member = build {
 }
 
 val memberWithoutAnn = wrongBuild {
-    <!INAPPLICABLE_CANDIDATE!>add<!>(42)
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }
 
 val extension = build {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt
index 5cb3cc89a30..c0a1aeee3d5 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt
@@ -9,5 +9,5 @@ class Controller<T : Number> {
 fun <S : Number> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 
 val test = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>("foo")
+    yield(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.fir.kt
index 5fe162f1c98..67d9f1db67e 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.fir.kt
@@ -9,7 +9,7 @@ class GenericController<T> {
 fun <S> generate(g: suspend GenericController<S>.(S) -> Unit): S = TODO()
 
 val test1 = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>(4)
+    yield(<!ARGUMENT_TYPE_MISMATCH!>4<!>)
 }
 
 val test2 = generate<Int> {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt37309.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt37309.fir.kt
index c97c28694cc..67afccd697d 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt37309.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt37309.fir.kt
@@ -12,12 +12,12 @@ fun <E> myBuildList(@BuilderInference builderAction: MutableList<E>.() -> Unit)
 fun main() {
     val newList1 = myBuildList {
         addAll(
-            listOf(1).map { <!INAPPLICABLE_CANDIDATE!>Foo<!>(null) }
+            listOf(1).map { Foo(<!ARGUMENT_TYPE_MISMATCH!>null<!>) }
         )
     }
 
     val newList2 = buildList {
-        addAll(listOf(1,2,3).map{ <!INAPPLICABLE_CANDIDATE!>Foo<!>(null) })
+        addAll(listOf(1,2,3).map{ Foo(<!ARGUMENT_TYPE_MISMATCH!>null<!>) })
     }
 }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.fir.kt
index f065c107b35..988fcda25db 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.fir.kt
@@ -19,7 +19,7 @@ class Controller {
     suspend fun yieldString(value: String) = suspendCoroutineUninterceptedOrReturn<Int> {
         it.resume(1)
         it checkType { _<Continuation<Int>>() }
-        it.<!INAPPLICABLE_CANDIDATE!>resume<!>("")
+        it.resume(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
 
         // We can return anything here, 'suspendCoroutineUninterceptedOrReturn' is not very type-safe
         // Also we can call resume and then return the value too, but it's still just our problem
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt
index 9a5ad755e6c..80fb3b0e80c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.fir.kt
@@ -22,7 +22,7 @@ fun test() {
     builder {
         noParams()
         yieldString("abc") checkType { _<Unit>() }
-        <!INAPPLICABLE_CANDIDATE!>yieldString<!>(1) checkType { _<Unit>() }
+        yieldString(<!ARGUMENT_TYPE_MISMATCH!>1<!>) checkType { _<Unit>() }
 
         await<String> { "123" } checkType { _<String>() }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.fir.kt
index 31da9e048d3..09adccbbf6c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.fir.kt
@@ -7,7 +7,7 @@ fun useFn(fn: () -> Unit) = fn
 fun ambiguous(sfn: suspend () -> Unit) = sfn
 fun ambiguous(fn: () -> Unit) = fn
 
-fun test1(sfn: suspend () -> Unit) = <!INAPPLICABLE_CANDIDATE!>useFn<!>(sfn)
+fun test1(sfn: suspend () -> Unit) = useFn(<!ARGUMENT_TYPE_MISMATCH!>sfn<!>)
 fun test2(fn: () -> Unit) = useSuspendFn(fn)
 
 fun test3(sfn: suspend () -> Unit) = useSuspendFn(sfn)
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt
index 2663d0780de..02d1088e025 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.fir.kt
@@ -22,7 +22,7 @@ fun test() {
     builder {
         noParams()
         yieldString("abc") checkType { _<Unit>() }
-        <!INAPPLICABLE_CANDIDATE!>yieldString<!>(1) checkType { _<Unit>() }
+        yieldString(<!ARGUMENT_TYPE_MISMATCH!>1<!>) checkType { _<Unit>() }
 
         await<String> { "123" } checkType { _<String>() }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.fir.kt
index 270b165146e..8b6d3c16fc9 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.fir.kt
@@ -22,5 +22,5 @@ interface TypePredicate : (KotlinType) -> Boolean {
 
 fun <T : Any?> TypePredicate.expectedTypeFor(keys: Iterable<T>): Map<T, TypePredicate> =
     keys.fold(SmartFMap.emptyMap<T, TypePredicate>()) { map, key ->
-        map.<!INAPPLICABLE_CANDIDATE!>plus<!>(key, this)
+        map.plus(<!ARGUMENT_TYPE_MISMATCH!>key<!>, this)
     }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.fir.kt
index 8626a66681c..c692170151f 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.fir.kt
@@ -21,12 +21,12 @@ fun test(
     invOut.onlyOut(42)
     invOut.onlyOut(1L)
 
-    invOut.<!INAPPLICABLE_CANDIDATE!>onlyOutUB<!>("str")
+    invOut.onlyOutUB(<!ARGUMENT_TYPE_MISMATCH!>"str"<!>)
     invStar.<!INAPPLICABLE_CANDIDATE!>onlyOutUB<!>(0)
     invOut.onlyOutUB(42)
     invOut.onlyOutUB(1L)
 
-    invIn.<!INAPPLICABLE_CANDIDATE!>onlyIn<!>("str")
+    invIn.onlyIn(<!ARGUMENT_TYPE_MISMATCH!>"str"<!>)
     invIn.onlyIn(42)
     invIn.onlyIn(1L)
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt
index 3eac7717eb6..adfd486c01c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt
@@ -21,5 +21,5 @@ fun main() {
     // Here, the error should be
     val x2: (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
     val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
-    val x4: (Int) -> Unit = <!INAPPLICABLE_CANDIDATE!>takeSimpleFunction<!>(id<suspend (Int) -> Unit> {}, <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown")!>{}<!>)
+    val x4: (Int) -> Unit = takeSimpleFunction(<!ARGUMENT_TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<kotlin.Int, kotlin.Unit>")!>{}<!>)
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt
index 24f7c942f03..0a2061564ac 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.fir.kt
@@ -10,7 +10,7 @@ fun <T : Any> T?.sure() : T = this!!
 fun <E> List<*>.toArray(ar: Array<E>): Array<E> = ar
 
 fun testArrays(ci: List<Int?>, cii: List<Int?>?) {
-    val c1: Array<Int?> = cii.sure().<!INAPPLICABLE_CANDIDATE!>toArray<!>(Array<Int?>)
+    val c1: Array<Int?> = cii.sure().toArray(<!ARGUMENT_TYPE_MISMATCH!>Array<!><Int?>)
 
     val c2: Array<Int?> = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt
index 3680f122cf3..73682ace08f 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt
@@ -4,6 +4,6 @@
 
 class Base<T : T> : HashSet<T>() {
     fun foo() {
-        super.<!INAPPLICABLE_CANDIDATE!>remove<!>("")
+        super.remove(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
     }
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt38737.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt38737.fir.kt
index b8e71f703a8..7f312aad3d8 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt38737.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt38737.fir.kt
@@ -3,7 +3,7 @@ private const val dateRangeEnd: String = "2020-05-01"
 
 private fun String?.toIconList(): List<String> = when (this) {
     null -> listOf("DATE_IS_NULL")
-    <!INAPPLICABLE_CANDIDATE!>in<!> dateRangeStart..dateRangeEnd -> emptyList()
+    <!ARGUMENT_TYPE_MISMATCH!>in dateRangeStart..dateRangeEnd<!> -> emptyList()
     else -> listOf("DATE_IS_OUT_OF_RANGE")
 }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.fir.kt
index 29af733c4e9..8bcc67304aa 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.fir.kt
@@ -6,7 +6,7 @@ class O : Function2<Int, String, Unit> {
 fun test() {
     val a = fun(o: O) {
     }
-    <!INAPPLICABLE_CANDIDATE!>a<!> {}
+    a <!ARGUMENT_TYPE_MISMATCH!>{}<!>
 }
 
 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Ext<!> : String.() -> Unit {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt
index e75585de35b..b93ac607a60 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt
@@ -1,7 +1,7 @@
 @JvmName(<!NO_VALUE_FOR_PARAMETER!>)<!>
 fun foo() {}
 
-<!INAPPLICABLE_CANDIDATE!>@JvmName(42)<!>
+@JvmName(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 fun bar() {}
 
 @JvmName("a", <!TOO_MANY_ARGUMENTS!>"b"<!>)
diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.fir.kt
index fd5c1c83709..bbd01a4f89b 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.fir.kt
@@ -2,7 +2,7 @@ fun foo(c : Collection<String>) = {
     c.filter{
         val s : String? = bar()
         if (s == null) false // here!
-        <!INAPPLICABLE_CANDIDATE!>zoo<!>(s)
+        zoo(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
     }
 }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/lambdaArgumentOfInapplicableCall.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/lambdaArgumentOfInapplicableCall.fir.kt
index 77ad857b90f..1356e1e550e 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/resolve/lambdaArgumentOfInapplicableCall.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/lambdaArgumentOfInapplicableCall.fir.kt
@@ -1,6 +1,6 @@
 // KT-45010
 fun foo(map: MutableMap<Int, String>) {
-    map.<!INAPPLICABLE_CANDIDATE!>getOrPut<!>("Not an Int") {
+    map.getOrPut(<!ARGUMENT_TYPE_MISMATCH!>"Not an Int"<!>) {
         "Hello" + " world"
     }
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.fir.kt
index 9aef644def0..569fd007729 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.fir.kt
@@ -3,7 +3,7 @@
 fun indexOfMax(a: IntArray): Int? {
     var maxI: Int? = 0
     a.forEachIndexed { i, value ->
-        if (value >= <!INAPPLICABLE_CANDIDATE!>a[maxI]<!>) {
+        if (value >= a[<!ARGUMENT_TYPE_MISMATCH!>maxI<!>]) {
             maxI = i
         }
         else if (value < 0) {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.fir.kt
index b71491bbadc..2a8349677af 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.fir.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.fir.kt
@@ -46,7 +46,7 @@ fun foo(x: List<String>, y: Throwable, z: A3) {
 
     y.fillInStackTrace() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
-    HashMap<String, Int>().<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>(Any(), null)
+    HashMap<String, Int>().getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>Any()<!>, null)
 
     // Falls back to extension in stdlib
     y.printStackTrace()
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.2.fir.kt
index 258dc53741d..d80b765e275 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.2.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.2.fir.kt
@@ -9,10 +9,10 @@ fun case_1() {
     0b100_000_111_111L checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     0b0L checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(0L)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(1000000L)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(0XAf10cDL)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(0x0_0L)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(0b100_000_111_111L)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(0b0L)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>0L<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>1000000L<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>0XAf10cDL<!>)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>0x0_0L<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>0b100_000_111_111L<!>)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>0b0L<!>)
 }
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.3.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.3.fir.kt
index d699364d62f..3a32e14e067 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.3.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.3.fir.kt
@@ -13,7 +13,7 @@ fun case_2() {
     127 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     127 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(128)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>128<!>)
     128 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     128 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     128 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
@@ -22,7 +22,7 @@ fun case_2() {
     -128 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     -128 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(-129)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>-129<!>)
     -129 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     -129 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     -129 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
@@ -30,24 +30,24 @@ fun case_2() {
 
 // TESTCASE NUMBER: 3
 fun case_3() {
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(32767)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>32767<!>)
     32767 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     32767 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     32767 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(32768)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(32768)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>32768<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>32768<!>)
     32768 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     32768 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     32768 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(-32768)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>-32768<!>)
     -32768 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     -32768 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     -32768 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(-32769)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(-32769)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>-32769<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>-32769<!>)
     -32769 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     -32769 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     -32769 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
@@ -55,28 +55,28 @@ fun case_3() {
 
 // TESTCASE NUMBER: 4
 fun case_4() {
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(2147483647)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(2147483647)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>2147483647<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>2147483647<!>)
     2147483647 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     2147483647 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     2147483647 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(2147483648)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(2147483648)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(2147483648)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>2147483648<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>2147483648<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>2147483648<!>)
     2147483648 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     2147483648 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     2147483648 checkType { <!NONE_APPLICABLE!>check<!><Int>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(-2147483648)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(-2147483648)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>-2147483648<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>-2147483648<!>)
     -2147483648 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     -2147483648 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     -2147483648 checkType { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(-2147483649)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(-2147483649)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(-2147483649)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>-2147483649<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>-2147483649<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>-2147483649<!>)
     -2147483649 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     -2147483649 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     -2147483649 checkType { <!NONE_APPLICABLE!>check<!><Int>() }
@@ -84,16 +84,16 @@ fun case_4() {
 
 // TESTCASE NUMBER: 5
 fun case_5() {
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(9223372036854775807)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(9223372036854775807)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(9223372036854775807)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
     9223372036854775807 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     9223372036854775807 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     9223372036854775807 checkType { <!NONE_APPLICABLE!>check<!><Int>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(-9223372036854775807)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(-9223372036854775807)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(-9223372036854775807)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
     -9223372036854775807 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
     -9223372036854775807 checkType { <!NONE_APPLICABLE!>check<!><Short>() }
     -9223372036854775807 checkType { <!NONE_APPLICABLE!>check<!><Int>() }
@@ -101,10 +101,10 @@ fun case_5() {
 
 // TESTCASE NUMBER: 6
 fun case_6() {
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Byte>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!>)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!>)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!>)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!>)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Byte>() }
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Short>() }
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Int>() }
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.4.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.4.fir.kt
index 562a11cf94e..800df3eba7c 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.4.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.4.fir.kt
@@ -2,24 +2,24 @@
 
 // TESTCASE NUMBER: 1
 fun case_1() {
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!><!>)
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!>)
     <!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }
 
 // TESTCASE NUMBER: 2
 fun case_2() {
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!>)
     <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!>)
     <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!><!>)
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!><!>)
     <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.5.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.5.fir.kt
index 35748287864..acc3c5b77fe 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.5.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.5.fir.kt
@@ -19,34 +19,34 @@ import functions.*
 
 // TESTCASE NUMBER: 1
 fun case_1() {
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(128)
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(-129)
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(32767)
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(-32768)
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(2147483647)
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(-2147483648)
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(9223372036854775807)
-    <!INAPPLICABLE_CANDIDATE!>f1<!>(-9223372036854775807)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>128<!>)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>-129<!>)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>32767<!>)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>-32768<!>)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>2147483647<!>)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>-2147483648<!>)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
+    f1(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
     f1(<!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
     f1(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
 }
 
 // TESTCASE NUMBER: 2
 fun case_2() {
-    <!INAPPLICABLE_CANDIDATE!>f2<!>(32768)
-    <!INAPPLICABLE_CANDIDATE!>f2<!>(-32769)
-    <!INAPPLICABLE_CANDIDATE!>f2<!>(2147483647)
-    <!INAPPLICABLE_CANDIDATE!>f2<!>(-2147483648)
-    <!INAPPLICABLE_CANDIDATE!>f2<!>(9223372036854775807)
-    <!INAPPLICABLE_CANDIDATE!>f2<!>(-9223372036854775807)
+    f2(<!ARGUMENT_TYPE_MISMATCH!>32768<!>)
+    f2(<!ARGUMENT_TYPE_MISMATCH!>-32769<!>)
+    f2(<!ARGUMENT_TYPE_MISMATCH!>2147483647<!>)
+    f2(<!ARGUMENT_TYPE_MISMATCH!>-2147483648<!>)
+    f2(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
+    f2(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
     f2(<!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
     f2(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
 }
 
 // TESTCASE NUMBER: 3
 fun case_3() {
-    <!INAPPLICABLE_CANDIDATE!>f3<!>(9223372036854775807)
-    <!INAPPLICABLE_CANDIDATE!>f3<!>(-9223372036854775807)
+    f3(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
+    f3(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
     f3(<!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
     f3(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.fir.kt
index c69828fe00a..66499e6797d 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.fir.kt
@@ -237,9 +237,9 @@ fun case_3(value_1: Any?) {
 fun case_4(value_1: Any?) {
     case_4_1(value_1)
     value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
-    <!INAPPLICABLE_CANDIDATE!>case_4_2<!>(value_1)
+    case_4_2(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>)
     value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-    <!INAPPLICABLE_CANDIDATE!>case_4_3<!>(value_1)
+    case_4_3(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>)
     value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
 }
 
@@ -331,30 +331,30 @@ fun case_7(value_1: Any?) {
 fun case_8(value_1: Any?) {
     if (case_8_1(value_1)) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
-        if (<!INAPPLICABLE_CANDIDATE!>case_8_2<!>(value_1)) {
+        if (case_8_2(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>)) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (<!INAPPLICABLE_CANDIDATE!>case_8_3<!>(value_1)) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
+            if (case_8_3(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>)) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
     if (!case_8_4(value_1)) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
-        if (!<!INAPPLICABLE_CANDIDATE!>case_8_5<!>(value_1)) {
+        if (!case_8_5(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>)) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (!<!INAPPLICABLE_CANDIDATE!>case_8_6<!>(value_1)) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
+            if (!case_8_6(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>)) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
     if (case_8_7(value_1) == null) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
-        if (<!INAPPLICABLE_CANDIDATE!>case_8_8<!>(value_1) != null) {
+        if (case_8_8(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>) != null) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (<!INAPPLICABLE_CANDIDATE!>case_8_9<!>(value_1) != null) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
+            if (case_8_9(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>) != null) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
     if (case_8_10(value_1) != null) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
-        if (<!INAPPLICABLE_CANDIDATE!>case_8_11<!>(value_1) == null) {
+        if (case_8_11(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>) == null) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (<!INAPPLICABLE_CANDIDATE!>case_8_12<!>(value_1) == null) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
+            if (case_8_12(<!ARGUMENT_TYPE_MISMATCH!>value_1<!>) == null) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/4.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/4.fir.kt
index eaf488edb7e..55e406b51b6 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/4.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/4.fir.kt
@@ -6,18 +6,18 @@ import kotlin.contracts.*
 
 // TESTCASE NUMBER: 1
 fun case_1(): Boolean? {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returnsNotNull() <!INAPPLICABLE_CANDIDATE!>implies<!> (null)<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returnsNotNull() implies (<!ARGUMENT_TYPE_MISMATCH!>null<!>)<!> }
     return true
 }
 
 // TESTCASE NUMBER: 2
 fun case_2(): Boolean {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(false) <!INAPPLICABLE_CANDIDATE!>implies<!> 0.000001<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(false) implies <!ARGUMENT_TYPE_MISMATCH!>0.000001<!><!> }
     return true
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(): Boolean? {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) <!INAPPLICABLE_CANDIDATE!>implies<!> ""<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) implies <!ARGUMENT_TYPE_MISMATCH!>""<!><!> }
     return null
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.fir.kt
index 4474d9ed507..10b33bf4e7c 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.fir.kt
@@ -6,7 +6,7 @@ import kotlin.contracts.*
 
 // TESTCASE NUMBER: 1
 fun case_1(): Boolean {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(true) <!INAPPLICABLE_CANDIDATE!>implies<!> (-10)<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(true) implies (<!ARGUMENT_TYPE_MISMATCH!>-10<!>)<!> }
     return true
 }
 
@@ -18,7 +18,7 @@ fun case_2(): Boolean {
 
 // TESTCASE NUMBER: 3
 fun case_3(): Boolean {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(false) <!INAPPLICABLE_CANDIDATE!>implies<!> ("..." + "$<!UNRESOLVED_REFERENCE!>value_1<!>")<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(false) implies (<!ARGUMENT_TYPE_MISMATCH!>"..." + "$<!UNRESOLVED_REFERENCE!>value_1<!>"<!>)<!> }
     return true
 }
 
@@ -27,19 +27,19 @@ fun case_3(): Boolean {
  * ISSUES: KT-26386
  */
 fun case_4(): Boolean? {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) <!INAPPLICABLE_CANDIDATE!>implies<!> case_4()<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) implies <!ARGUMENT_TYPE_MISMATCH!>case_4()<!><!> }
     return null
 }
 
 // TESTCASE NUMBER: 5
 fun case_5(): Boolean? {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) <!INAPPLICABLE_CANDIDATE!>implies<!> listOf(0)<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) implies <!ARGUMENT_TYPE_MISMATCH!>listOf(0)<!><!> }
     return null
 }
 
 // TESTCASE NUMBER: 6
 fun case_6(value_1: Boolean): Boolean? {
-    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) <!INAPPLICABLE_CANDIDATE!>implies<!> contract { returns(null) implies (!value_1) }<!> }
+    contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returns(null) implies <!ARGUMENT_TYPE_MISMATCH!>contract { returns(null) implies (!value_1) }<!><!> }
     return null
 }
 
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/15.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/15.fir.kt
index 895bd4ef64d..fe612d46382 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/15.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/15.fir.kt
@@ -96,7 +96,7 @@ fun case_7() {
 fun case_8(y: MutableList<Boolean>) {
     var x: Boolean? = true
     if (x != null) {
-        <!INAPPLICABLE_CANDIDATE!>y[if (true) {x = null;0} else 0]<!> = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Boolean?")!>x<!>
+        y[if (true) {x = null;0} else 0] = <!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Boolean?")!>x<!>
     }
 }
 
@@ -130,6 +130,6 @@ fun case_10() {
 fun case_11(y: MutableList<MutableList<Int>>) {
     var x: Int? = 10
     if (x != null) {
-        <!INAPPLICABLE_CANDIDATE!>y[if (true) {x = null;0} else 0][x]<!> = 10
+        y[if (true) {x = null;0} else 0][<!ARGUMENT_TYPE_MISMATCH!>x<!>] = 10
     }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/28.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/28.fir.kt
index 18806d60f39..fd59f42ba7d 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/28.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/28.fir.kt
@@ -6,6 +6,6 @@
 fun <T : List<T>> Inv<out T>.case_1() {
     if (this is MutableList<*>) {
         <!DEBUG_INFO_EXPRESSION_TYPE("Inv<out T> & kotlin.collections.MutableList<*> & Inv<out T>")!>this<!>
-        <!INAPPLICABLE_CANDIDATE!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<out T> & kotlin.collections.MutableList<*> & Inv<out T>")!>this<!>[0]<!> = <!DEBUG_INFO_EXPRESSION_TYPE("Inv<out T> & kotlin.collections.MutableList<*> & Inv<out T>")!>this<!>[1]
+        <!DEBUG_INFO_EXPRESSION_TYPE("Inv<out T> & kotlin.collections.MutableList<*> & Inv<out T>")!>this<!>[0] = <!ARGUMENT_TYPE_MISMATCH!><!DEBUG_INFO_EXPRESSION_TYPE("Inv<out T> & kotlin.collections.MutableList<*> & Inv<out T>")!>this<!>[1]<!>
     }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/32.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/32.fir.kt
index 68b7a915f63..4c60decae17 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/32.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/32.fir.kt
@@ -12,7 +12,7 @@ fun stringArg(number: String) {}
  */
 fun case_1(x: Int?) {
     if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>stringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>x!!<!>)
+        stringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>x!!<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>
     }
 }
@@ -24,7 +24,7 @@ fun case_1(x: Int?) {
  */
 fun case_2(x: Int?, y: Nothing?) {
     if (x == y) {
-        <!INAPPLICABLE_CANDIDATE!>stringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>x!!<!>)
+        stringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>x!!<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>
     }
 }
@@ -37,7 +37,7 @@ fun case_2(x: Int?, y: Nothing?) {
 fun case_3(x: Int?) {
     if (x == null) {
         x as Int
-        <!INAPPLICABLE_CANDIDATE!>stringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>)
+        stringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>
     }
 }
@@ -50,7 +50,7 @@ fun case_3(x: Int?) {
 fun case_4(x: Int?) {
     if (x == null) {
         x!!
-        <!INAPPLICABLE_CANDIDATE!>stringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>)
+        stringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>
     }
 }
@@ -64,7 +64,7 @@ fun case_5(x: Int?) {
     if (x == null) {
         var y = x
         y!!
-        <!INAPPLICABLE_CANDIDATE!>stringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>y<!>)
+        stringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>y<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>y<!>
     }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/33.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/33.fir.kt
index 09f7ad29aa3..0cb3d4cbb07 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/33.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/33.fir.kt
@@ -12,7 +12,7 @@ fun nullableStringArg(number: String?) {}
  */
 fun case_1(x: Int?) {
     if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>nullableStringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
+        nullableStringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
     }
 }
 
@@ -23,7 +23,7 @@ fun case_1(x: Int?) {
  */
 fun case_2(x: Int?, y: Nothing?) {
     if (x == y) {
-        <!INAPPLICABLE_CANDIDATE!>nullableStringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
+        nullableStringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
     }
 }
 
@@ -34,7 +34,7 @@ fun case_2(x: Int?, y: Nothing?) {
  */
 fun case_3(x: Int?) {
     if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>nullableStringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
+        nullableStringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
     }
 }
 
@@ -45,7 +45,7 @@ fun case_3(x: Int?) {
  */
 fun case_4(x: Int?) {
     if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>nullableStringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
+        nullableStringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
     }
 }
 
@@ -57,6 +57,6 @@ fun case_4(x: Int?) {
 fun case_5(x: Int?) {
     if (x == null) {
         var y = x
-        <!INAPPLICABLE_CANDIDATE!>nullableStringArg<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>y<!>)
+        nullableStringArg(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>y<!>)
     }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/52.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/52.fir.kt
index 763e156a4b6..caa259385cb 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/52.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/52.fir.kt
@@ -29,7 +29,7 @@ fun case_3(x: String?) = x
 fun case_3() {
     var x: Int? = 10
     x = null
-    <!INAPPLICABLE_CANDIDATE!>case_3<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
+    case_3(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>)
 }
 
 /*
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/58.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/58.fir.kt
index 224d362be6e..fa31392cd1f 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/58.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/58.fir.kt
@@ -74,7 +74,7 @@ fun case_6() {
     var y: Inv<out Number> = Inv<Int>()
     if (true)
         y = x
-    y.<!INAPPLICABLE_CANDIDATE!>put<!>(0)
+    y.put(<!ARGUMENT_TYPE_MISMATCH!>0<!>)
     val z: Inv<out Number> = x
     z.put(0)
 }
diff --git a/idea/testData/checker/AnnotationSupressing.fir.kt b/idea/testData/checker/AnnotationSupressing.fir.kt
index 46037a0394f..077bc499ca9 100644
--- a/idea/testData/checker/AnnotationSupressing.fir.kt
+++ b/idea/testData/checker/AnnotationSupressing.fir.kt
@@ -1,32 +1,32 @@
 annotation class A(val i: Int)
 annotation class Z(val i: Int)
 
-<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /Z.Z">@Z("BAD")</error> @Suppress("TYPE_MISMATCH")
+@Z(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>) @Suppress("TYPE_MISMATCH")
 fun some0() {}
 
-<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /Z.Z">@Z("BAD")</error> <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /Z.Z">@Z("BAD")</error> @Suppress("TYPE_MISMATCH")
+@Z(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>) @Z(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>) @Suppress("TYPE_MISMATCH")
 fun some01() {}
 
-@Suppress("TYPE_MISMATCH") <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /Z.Z">@Z("BAD")</error>
+@Suppress("TYPE_MISMATCH") @Z(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>)
 fun some1() {
 }
 
-@Suppress("TYPE_MISMATCH") <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /Z.Z">@Z("BAD")</error> <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /Z.Z">@Z("BAD")</error>
+@Suppress("TYPE_MISMATCH") @Z(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>) @Z(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>)
 fun some11() {
 }
 
-<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /A.A">@A("BAD")</error> @Suppress("TYPE_MISMATCH")
+@A(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>) @Suppress("TYPE_MISMATCH")
 fun some2() {
 }
 
-@Suppress("TYPE_MISMATCH") <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /A.A">@A("BAD")</error>
+@Suppress("TYPE_MISMATCH") @A(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>)
 fun some3() {
 }
 
-<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /A.A">@A("BAD")</error> <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /A.A">@A("BAD")</error>
+@A(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>) @A(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>)
 fun some4() {
 }
 
-<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /Z.Z">@Z("BAD")</error>
+@Z(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but kotlin/Int was expected">"BAD"</error>)
 fun someN() {
 }
diff --git a/idea/testData/checker/Constants.fir.kt b/idea/testData/checker/Constants.fir.kt
deleted file mode 100644
index c7b35013476..00000000000
--- a/idea/testData/checker/Constants.fir.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-fun <T> checkSubtype(t: T) = t
-
-fun test() {
-  checkSubtype<Byte>(1)
-  checkSubtype<Int>(1)
-  <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /checkSubtype">checkSubtype</error><Double>(1)
-  1 as Byte
-  1 as Int
-  1 as Double
-}
diff --git a/idea/testData/checker/Constants.kt b/idea/testData/checker/Constants.kt
index 312c194d9f7..da2cd3f8c06 100644
--- a/idea/testData/checker/Constants.kt
+++ b/idea/testData/checker/Constants.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun <T> checkSubtype(t: T) = t
 
 fun test() {
diff --git a/idea/testData/checker/MultipleBounds.fir.kt b/idea/testData/checker/MultipleBounds.fir.kt
index a66fb827ef7..cfca76480f3 100644
--- a/idea/testData/checker/MultipleBounds.fir.kt
+++ b/idea/testData/checker/MultipleBounds.fir.kt
@@ -56,8 +56,8 @@ fun <T> test2(t : T)
   t.bar()
 }
 
-val t1 = <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): Jet87/test2">test2</error><A>(A())
-val t2 = <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): Jet87/test2">test2</error><B>(C())
+val t1 = test2<A>(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is Jet87/A but T was expected">A()</error>)
+val t2 = test2<B>(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is Jet87/C but T was expected">C()</error>)
 val t3 = test2<C>(C())
 
 val <T, B: T> Pair<T, B>.x : Int get() = 0
diff --git a/idea/testData/checker/NullAsAnnotationArgument.fir.kt b/idea/testData/checker/NullAsAnnotationArgument.fir.kt
index 167b03e5522..d9b53396379 100644
--- a/idea/testData/checker/NullAsAnnotationArgument.fir.kt
+++ b/idea/testData/checker/NullAsAnnotationArgument.fir.kt
@@ -3,8 +3,8 @@ package test
 
 annotation class A(val value: String)
 
-<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): test/A.A">@A(null)</error>
+@A(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/Nothing? but kotlin/String was expected">null</error>)
 fun foo() {}
 
-<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): test/A.A">@A(null)</error>
+@A(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/Nothing? but kotlin/String was expected">null</error>)
 class B
diff --git a/idea/testData/checker/ResolveToJava.fir.kt b/idea/testData/checker/ResolveToJava.fir.kt
index 5252d6efc96..36601dd3f2f 100644
--- a/idea/testData/checker/ResolveToJava.fir.kt
+++ b/idea/testData/checker/ResolveToJava.fir.kt
@@ -24,7 +24,7 @@ fun test(l : List<Int>) {
   Collections.emptyList()
 
   checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
-  Collections.<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): java/util/Collections.singleton">singleton</error><Int>(1.0)
+  Collections.singleton<Int>(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/Double but ft<TypeVariable(T), TypeVariable(T)?> was expected">1.0</error>)
 
   List<Int>
 
diff --git a/idea/testData/checker/Variance.fir.kt b/idea/testData/checker/Variance.fir.kt
index f198effe496..bae418ec31d 100644
--- a/idea/testData/checker/Variance.fir.kt
+++ b/idea/testData/checker/Variance.fir.kt
@@ -32,9 +32,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>) {
-    <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): variance/copy1">copy1</error>(ints, any)
+    copy1(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is variance/Array<kotlin/Int> but variance/Array<kotlin/Any> was expected">ints</error>, any)
     copy2(ints, any) //ok
-    <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): variance/copy2">copy2</error>(ints, numbers)
+    copy2(ints, <error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is variance/Array<kotlin/Number> but variance/Array<in kotlin/Any> was expected">numbers</error>)
     copy3<Int>(ints, numbers)
     copy4(ints, numbers) //ok
 }
diff --git a/idea/testData/checker/diagnosticsMessage/noSubstitutedTypeParameter.fir.kt b/idea/testData/checker/diagnosticsMessage/noSubstitutedTypeParameter.fir.kt
index c0b3c5b9176..7c0533bf03a 100644
--- a/idea/testData/checker/diagnosticsMessage/noSubstitutedTypeParameter.fir.kt
+++ b/idea/testData/checker/diagnosticsMessage/noSubstitutedTypeParameter.fir.kt
@@ -1,6 +1,6 @@
 // COMPILER_ARGUMENTS: -XXLanguage:-NewInference
 
-val f = listOf("").<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /firstOrNull">firstOrNull</error>(1)
+val f = listOf("").firstOrNull(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/Int but kotlin/Function1<TypeVariable(T), kotlin/Boolean> was expected">1</error>)
 
 fun <T> listOf(element: T): List<T> = java.util.Collections.singletonList(element)
-fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T? = null
+fun <T> Iterable<T>.firstOrNull(<warning>predicate</warning>: (T) -> Boolean): T? = null
\ No newline at end of file
diff --git a/idea/testData/checker/infos/SmartCasts.fir.kt b/idea/testData/checker/infos/SmartCasts.fir.kt
index 91c16c332fe..e7875925b4d 100644
--- a/idea/testData/checker/infos/SmartCasts.fir.kt
+++ b/idea/testData/checker/infos/SmartCasts.fir.kt
@@ -196,11 +196,11 @@ fun returnFunctionLiteral(a: Any?): Function0<Int> =
 
 fun mergeSmartCasts(a: Any?) {
   if (a is String || a is Int) {
-    a.<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): kotlin/Comparable.compareTo">compareTo</error>("")
+    a.compareTo(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but it(kotlin/String & kotlin/Int) was expected">""</error>)
     a.toString()
   }
   if (a is Int || a is String) {
-    a.<error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): kotlin/Comparable.compareTo">compareTo</error>("")
+    a.compareTo(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/String but it(kotlin/Int & kotlin/String) was expected">""</error>)
   }
   when (a) {
     is String, is Any -> a.<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: compareTo">compareTo</error>("")
diff --git a/idea/testData/checker/regression/CoercionToUnit.fir.kt b/idea/testData/checker/regression/CoercionToUnit.fir.kt
index af845e1537a..89c3aca5c0d 100644
--- a/idea/testData/checker/regression/CoercionToUnit.fir.kt
+++ b/idea/testData/checker/regression/CoercionToUnit.fir.kt
@@ -1,9 +1,9 @@
 fun foo(u : Unit) : Int = 1
 
 fun test() : Int {
-    <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /foo">foo</error>(1)
+    foo(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/Int but kotlin/Unit was expected">1</error>)
     val a : () -> Unit = {
-        <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /foo">foo</error>(1)
+        foo(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/Int but kotlin/Unit was expected">1</error>)
     }
     return 1
 }
diff --git a/idea/testData/checker/regression/DoubleDefine.fir.kt b/idea/testData/checker/regression/DoubleDefine.fir.kt
index 96b2383e0b6..f2e676d00a1 100644
--- a/idea/testData/checker/regression/DoubleDefine.fir.kt
+++ b/idea/testData/checker/regression/DoubleDefine.fir.kt
@@ -11,7 +11,7 @@ fun takeFirst(expr: StringBuilder): Char {
 
 fun evaluateArg(expr: CharSequence, numbers: ArrayList<Int>): Int {
   if (expr.length == 0) throw Exception("Syntax error: Character expected");
-  val c = <error descr="[INAPPLICABLE_CANDIDATE] Inapplicable candidate(s): /takeFirst">takeFirst</error>(expr)
+  val c = takeFirst(<error descr="[ARGUMENT_TYPE_MISMATCH] Argument type mismatch: actual type is kotlin/CharSequence but kotlin/text/StringBuilder was expected">expr</error>)
   if (c >= '0' && c <= '9') {
     val n = c - '0'
     if (!numbers.contains(n)) throw Exception("You used incorrect number: " + n)