diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt
index 616ba08d947..ac36f03e9f6 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt
@@ -15,5 +15,5 @@ class B : A() {
 }
 
 fun test(b: B) {
-    b.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>("")<!>
+    b.<!HIDDEN!>foo<!>("")
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
index d9ac68a53ae..bf5a1904af2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
@@ -8,19 +8,19 @@ fun test() {
     foo(1, 2.0, true)
     foo(1, third = true)
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0, 0.0, false, "")<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>()
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "")
 
     bar(1, third = true)
     bar(1, 2.0, true)
     bar(1, 2.0, true, "my")
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(1, true)<!>
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(1, true)
 
     baz(1)
     baz(1, "my", "yours")
     baz(1, z = true)
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(0, "", false)<!>
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(0, "", false)
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt
index af4ff520d6b..6995c3c4d61 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt
@@ -15,8 +15,8 @@ fun foo(a: A) {
     a.foo()
     a.foo(1)
 
-    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!>
-    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>("")<!>
+    a.<!INAPPLICABLE_CANDIDATE!>bar<!>()
+    a.<!INAPPLICABLE_CANDIDATE!>bar<!>("")
     a.bar(y = 1)
     a.bar("", 2)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
index 59b75b27414..0aa726d7740 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(10000000000)<!>
+    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
     takeLong(10000000000)
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000)<!>
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
 }
 
 fun test_3() {
@@ -35,8 +35,8 @@ fun test_4() {
 }
 
 fun test_5() {
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(1)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(run { 1 })<!>
+    <!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
+    <!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
 }
 
 annotation class Ann(val x: Byte)
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
index b6916223877..5972c59efdb 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeA<!>(array)<!>
+    <!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
     takeOutA(array)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
index 99f98ae6f6c..efbfd0fe827 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
@@ -10,8 +10,8 @@ fun test() {
     foo({})
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1) {}<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(f = {}) {}<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1) {}
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {}
 
     // OK
     bar(1) {}
@@ -20,15 +20,15 @@ fun test() {
     bar(x = 1, f = {})
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!> {}<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>({})<!>
+    <!INAPPLICABLE_CANDIDATE!>bar<!> {}
+    <!INAPPLICABLE_CANDIDATE!>bar<!>({})
 
     // OK
     baz(other = false, f = {})
     baz({}, false)
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!> {}<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>() {}<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(other = false) {}<!>
+    <!INAPPLICABLE_CANDIDATE!>baz<!> {}
+    <!INAPPLICABLE_CANDIDATE!>baz<!>() {}
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(other = false) {}
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt
index f867a56997e..99ee3e6cfa0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt
@@ -1,14 +1,14 @@
 fun <R> materialize(): R = null!!
 
 fun test_1() {
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> {
+    <!UNRESOLVED_REFERENCE!>myRun<!> {
         val x = 1
         x * 2
-    }<!>
+    }
 }
 
 fun test_2() {
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> {
+    <!UNRESOLVED_REFERENCE!>myRun<!> {
         materialize()
-    }<!>
+    }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
index 445ecf3ff4d..242b333b0a0 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 1)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + 127)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 - 1)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(-100 - 100)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(10 * 10)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 * 100)<!>
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>taleByte<!>(10 / 10)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 % 10)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 % 10)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 and 100)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(128 and 511)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(100 or 100)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000 or 0)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(511 xor 511)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(512 xor 511)<!>
+    <!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)
+    <!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)
 }
 
 fun test_5() {
     takeByte(-1)
     takeByte(+1)
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1.inv())<!>
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
 }
 
 fun test_6() {
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(run { 127 + 1 })<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1 + run { 1 })<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(run { 1 + 1 })<!>
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
+    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(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 d669fd5ef8a..737e67d3b8e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
@@ -7,11 +7,11 @@ fun test() {
     foo(1, second = 3.14, third = false, fourth = "!?")
     foo(third = false, second = 2.71, fourth = "?!", first = 0)
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0.0, false, 0, "")<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>()
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
     foo(1, 2.0, third = true, "")
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(second = 0.0, first = 0, fourth = "")<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0, 0.0, false, foth = "")<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(second = 0.0, first = 0, fourth = "")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, foth = "")
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
index ecafa19ebb0..f42aee5067d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
@@ -7,11 +7,11 @@ fun test() {
     foo(1, "my", "yours")
     foo(1, *arrayOf("my", "yours"))
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1, 2)<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
 
     bar(1, z = true, y = *arrayOf("my", "yours"))
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, z = false, y = "", y = "other")<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, "", true)<!>
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(0, z = false, y = "", y = "other")
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(0, "", true)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/asImports.kt b/compiler/fir/analysis-tests/testData/resolve/asImports.kt
index 33826641a61..8847a4c7fc4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/asImports.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/asImports.kt
@@ -11,9 +11,9 @@ class A {
 import foo.A as B
 
 fun test_1() {
-    val a = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!>
+    val a = <!UNRESOLVED_REFERENCE!>A<!>()
     val b = B() // should be OK
-    val c: B = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!>
+    val c: B = <!UNRESOLVED_REFERENCE!>A<!>()
 }
 
 fun test_2(b: B) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
index 8ce85a18c6e..390901c0302 100644
--- a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
@@ -9,11 +9,11 @@ fun bar(x: B) {}
 
 fun test(c: C) {
     // Argument mapping error
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
 
     // Ambiguity
-    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>bar<!>(c)<!>
+    <!AMBIGUITY!>bar<!>(c)
 
     // Unresolved reference
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
+    <!UNRESOLVED_REFERENCE!>baz<!>()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt
index c6cc6917af0..543f908a55b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt
@@ -9,6 +9,6 @@ fun main1() {
 }
 
 fun main2() {
-    { "" }.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!>
+    { "" }.<!INAPPLICABLE_CANDIDATE!>bar<!>()
     "".bar()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
index be90f5a38d6..f91d92380d2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
@@ -19,7 +19,7 @@ fun test_2(x: Any, y: Any) {
     val a = select(
         id(
             run {
-                y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
+                y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
                 x as Int
             }
         ),
@@ -39,14 +39,14 @@ fun test_3(x: Any, y: Any) {
     val a = select(
         id(
             run {
-                y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
+                y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
                 x as Int
                 materialize()
             }
         ),
         run {
             y as Int
-            x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
+            x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
             y.inc() // OK
             1
         }
@@ -60,19 +60,19 @@ fun test_4(x: Any, y: Any) {
     val a = select(
         id(
             myRun {
-                y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
+                y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
                 x as Int
             }
         ),
         y as Int,
         myRun {
-            x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
+            x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
             y.inc() // OK
             1
         }
 
     )
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!> // Bad
+    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
     takeInt(y) // OK
     takeInt(a) // Bad
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt
index 18abcc097c6..4c7e16469db 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt
@@ -22,7 +22,7 @@ class B : A() {
     }
 
     fun g() {
-        super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!>
+        super.<!ABSTRACT_SUPER_CALL!>f<!>()
         super.t()
 
         super.x
@@ -32,7 +32,7 @@ class B : A() {
 
 abstract class J : A() {
     fun r() {
-        super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!>
+        super.<!ABSTRACT_SUPER_CALL!>f<!>()
         super.t()
 
         super.x
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt
index 9ad38609849..23e7fc1dfcb 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt
@@ -13,5 +13,5 @@ open class B {
 class A : IWithToString, B() {
     override fun toString(): String = super.toString() // resolve to Any.toString
     override fun foo(): String = super.foo() // resolve to B.foo()
-    override fun bar(): String = super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>bar<!>()<!> // should be an error
+    override fun bar(): String = super.<!ABSTRACT_SUPER_CALL!>bar<!>() // should be an error
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
index 3e0bcb593bf..120b6037dca 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
@@ -63,5 +63,5 @@ class M {
 }
 
 class U : M {
-    <!INAPPLICABLE_CANDIDATE!>constructor()<!>
+    constructor()<!INAPPLICABLE_CANDIDATE!><!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt
index 89391c3f554..2aa050d6cd7 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt
@@ -3,16 +3,16 @@ class A(x: Int) {
 }
 
 class B : A {
-    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!>
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!><!NONE_APPLICABLE!><!>
     constructor(z: String) : this()
 }
 
 <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>class C : A(20) {
-    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!>
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED!>constructor()<!><!NONE_APPLICABLE!><!>
     constructor(z: String) : this()
 }<!>
 
 class D() : A(20) {
-    <!NONE_APPLICABLE, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(x: Int)<!>
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(x: Int)<!><!NONE_APPLICABLE!><!>
     constructor(z: String) : this()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
index ecc452d60ca..bd69a862cac 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
@@ -1,5 +1,5 @@
 class A {
-    constructor(x: Int = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSomeInt<!>()<!>, other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {}
+    constructor(x: Int = <!UNRESOLVED_REFERENCE!>getSomeInt<!>(), other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {}
     fun getSomeInt() = 10
     var keker = "test"
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt
index 4e8a13c2ee7..7d5354dc497 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt
@@ -4,7 +4,7 @@ class A {
 
 class B : A {
     fun g() {
-        <!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>f<!>()<!>
+        <!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE!>f<!>()
         super<A>.f()
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
index f0f7d5dc473..c4717ff1394 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
@@ -1,3 +1,3 @@
 sealed class A
 
-val b = <!HIDDEN{LT}!><!HIDDEN{PSI}!>A<!>()<!>
+val b = <!HIDDEN!>A<!>()
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt
index 22f7caf5bcd..f41d78a6551 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt
@@ -4,7 +4,7 @@ class B: A() {
     fun act() {
         <!SUPER_IS_NOT_AN_EXPRESSION!>super<!>()
 
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invoke<!>()<!>
+        <!UNRESOLVED_REFERENCE!>invoke<!>()
 
         <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> {
             <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>(<!ILLEGAL_CONST_EXPRESSION!>'weird'<!>)<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt
index 1ca40411257..62de59fefa9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt
@@ -1,20 +1,20 @@
 fun String.f() {
-    <!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
-    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
+    <!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
+    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
 }
 
 fun foo() {
     <!SUPER_NOT_AVAILABLE!>super<!>
-    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-    <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE!>foo<!>()
 }
 
 class A {
     fun act() {
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Test")<!>
+        <!UNRESOLVED_REFERENCE!>println<!>("Test")
     }
 
     fun String.fact() {
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Fest")<!>
+        <!UNRESOLVED_REFERENCE!>println<!>("Fest")
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
index c01d19b07bc..796fdcbfc0d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
@@ -17,8 +17,8 @@ object Best {
 
 }
 
-val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!>
-val b = Best.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>MyClass<!><String><!>
+val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
+val b = Best.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
 
 class B<E>
 class C<F<!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!> <!SYNTAX{PSI}!>:<!> <!SYNTAX{PSI}!>B<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>F<!><!SYNTAX{PSI}!><<!><!SYNTAX{PSI}!>Boolean<!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>><!><!SYNTAX{PSI}!>(<!><!SYNTAX{PSI}!>)<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
index 9e0ce9dcbfc..82d44bb7e8b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
@@ -45,4 +45,4 @@ val test8 = NL<String>()
 
 class NumberPhile<T: Number>(x: T)
 val np1 = NumberPhile(10)
-val np2 = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>NumberPhile<!>("Test")<!>
+val np2 = <!INAPPLICABLE_CANDIDATE!>NumberPhile<!>("Test")
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_enumJava.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_enumJava.kt
index 463216e5e5f..07ab6b5a49d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_enumJava.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_enumJava.kt
@@ -10,13 +10,13 @@ fun test_1(e: JavaEnum) {
     val a = <!NO_ELSE_IN_WHEN!>when<!> (e) {
         JavaEnum.A -> 1
         JavaEnum.B -> 2
-    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
 
     val b = <!NO_ELSE_IN_WHEN!>when<!> (e) {
         JavaEnum.A -> 1
         JavaEnum.B -> 2
         is String -> 3
-    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
 
     val c = when (e) {
         JavaEnum.A -> 1
@@ -35,7 +35,7 @@ fun test_2(e: JavaEnum?) {
         JavaEnum.A -> 1
         JavaEnum.B -> 2
         JavaEnum.C -> 3
-    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
 
     val a = when (e) {
         JavaEnum.A -> 1
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedSubClass.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedSubClass.kt
index 9beeb8a7276..e7c9a2027b2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedSubClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedSubClass.kt
@@ -35,18 +35,18 @@ fun test_2(e: A) {
     val a = <!NO_ELSE_IN_WHEN!>when<!> (e) {
         is D -> 1
         is E -> 2
-    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
 
     val b = <!NO_ELSE_IN_WHEN!>when<!> (e) {
         is B -> 1
         is D -> 2
         is E -> 3
-    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
 
     val c = <!NO_ELSE_IN_WHEN!>when<!> (e) {
         is B -> 1
         is D -> 2
-    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
+    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
 
     val d = when (e) {
         is C -> 1
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
index 7fa0c9cc927..abb4cda0e57 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
@@ -14,27 +14,27 @@ class CallBasedInExpressionGenerator(
     val codegen: ExpressionCodegen,
     operatorReference: KtSimpleNameExpression
 ) : InExpressionGenerator {
-    private val resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)<!>
-    private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getReferencedNameElementType<!>()<!> == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!>
+    private val resolvedCall = operatorReference.<!UNRESOLVED_REFERENCE!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)
+    private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE!>getReferencedNameElementType<!>() == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!>
 
     override fun generate(argument: StackValue): BranchedValue =
-        gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Invert<!>(it)<!> else it }
+        gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE!>Invert<!>(it) else it }
 
     private fun gen(argument: StackValue): BranchedValue =
         object : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!>)<!> {
             override fun putSelector(type: Type, kotlinType: KotlinType?, v: InstructionAdapter) {
                 invokeFunction(v)
-                <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>coerceTo<!>(type, kotlinType, v)<!>
+                <!UNRESOLVED_REFERENCE!>coerceTo<!>(type, kotlinType, v)
             }
 
             override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
                 invokeFunction(v)
-                v.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!> else <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFNE<!>, jumpLabel)<!>
+                v.<!UNRESOLVED_REFERENCE!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!> else <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFNE<!>, jumpLabel)
             }
 
             private fun invokeFunction(v: InstructionAdapter) {
-                val result = codegen.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>none<!>()<!>)<!>
-                result.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v)<!>
+                val result = codegen.<!UNRESOLVED_REFERENCE!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE!>none<!>())
+                result.<!UNRESOLVED_REFERENCE!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v)
             }
         }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
index 88236e7ebc8..ead6b21eda9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
@@ -43,7 +43,7 @@ fun f() {
     val d = ""
     val c = <!UNRESOLVED_REFERENCE!>c<!>
 
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>abc<!>()<!>
+    <!UNRESOLVED_REFERENCE!>abc<!>()
 
     fun bcd() {}
 
@@ -57,7 +57,7 @@ fun f() {
         dcb()
     }
 
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>dcb<!>()<!>
+    <!UNRESOLVED_REFERENCE!>dcb<!>()
 
     abc()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt
index cbc2599b9f9..8df28862e89 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt
@@ -20,6 +20,6 @@ fun test() {
     JavaClass.bar()
 
     val errC = BB.<!UNRESOLVED_REFERENCE!>C<!>
-    val errBarViaBB = BB.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
-    val errBarViaAA = AA.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+    val errBarViaBB = BB.<!UNRESOLVED_REFERENCE!>bar<!>()
+    val errBarViaAA = AA.<!UNRESOLVED_REFERENCE!>bar<!>()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
index e20e2c8f8e4..a9d5bb7a440 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>useVararg<!>(1, 2, 3, 4, 5)<!>
+    <!INAPPLICABLE_CANDIDATE!>useVararg<!>(1, 2, 3, 4, 5)
 }
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 ad6516e7254..651ca4c1e6f 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(bar)<!>
+    val b = <!INAPPLICABLE_CANDIDATE!>foo<!>(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 a44c5a04324..f4bf4ac52f5 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!><FooImpl>(fooBarImpl)<!>
+    val a = <!INAPPLICABLE_CANDIDATE!>foo<!><FooImpl>(fooBarImpl)
     val b = foo<Foo>(fooImpl)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt
index 50171203e9a..e5081adbb98 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt
@@ -17,6 +17,6 @@ class Foo {
         // this@Foo is dispatch receiver of foobar
         // Foo/foobar is dispatch receiver of invoke
         // this@chk is extension receiver of invoke
-        buz.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foobar<!>()<!>
+        buz.<!UNRESOLVED_REFERENCE!>foobar<!>()
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
index cf10589374f..a90af6e1282 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
@@ -18,4 +18,4 @@ fun test() {
     B.foo()
 }
 
-val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt
index 960d7239e02..73ed9de9800 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt
@@ -11,8 +11,8 @@ open class Outer {
 
 class Derived : Outer() {
     fun foo() {
-        Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
-        super.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
+        Outer.<!HIDDEN!>PrivateNested<!>()
+        super.<!HIDDEN!>PrivateInner<!>()
 
         Outer.ProtectedNested()
         super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
 }
 
 fun foo() {
-    Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
-    Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
+    Outer.<!HIDDEN!>PrivateNested<!>()
+    Outer().<!HIDDEN!>PrivateInner<!>()
 
-    Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedNested<!>()<!>
-    Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedInner<!>()<!>
+    Outer.<!HIDDEN!>ProtectedNested<!>()
+    Outer().<!HIDDEN!>ProtectedInner<!>()
 
     Outer.PublicNested()
     Outer().PublicInner()
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt
index f1426b42391..c61aef1fbcf 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt
@@ -9,21 +9,21 @@ private class Private {
         bar()
         Nested()
         fromCompanion()
-        NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
+        NotCompanion.<!HIDDEN!>foo<!>() // hidden
     }
 
     inner class Inner {
         fun foo() {
             bar()
             fromCompanion()
-            NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
+            NotCompanion.<!HIDDEN!>foo<!>() // hidden
         }
     }
 
     private class Nested {
         fun foo() {
             fromCompanion()
-            NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
+            NotCompanion.<!HIDDEN!>foo<!>() // hidden
         }
     }
 
@@ -54,7 +54,7 @@ fun withLocals() {
 
     Local().baz()
 
-    Local().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
+    Local().<!HIDDEN!>bar<!>() // hidden
 }
 
 fun test() {
@@ -62,14 +62,14 @@ fun test() {
     Private().baz()
     Private().Inner()
 
-    Private().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
-    Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden
-    Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>fromCompanion<!>()<!> // hidden
+    Private().<!HIDDEN!>bar<!>() // hidden
+    Private.<!HIDDEN!>Nested<!>() // hidden
+    Private.<!HIDDEN!>fromCompanion<!>() // hidden
 }
 
 // FILE: second.kt
 
 fun secondTest() {
-    <!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
-    <!HIDDEN{LT}!><!HIDDEN{PSI}!>Private<!>()<!> // hidden
+    <!HIDDEN!>foo<!>() // hidden
+    <!HIDDEN!>Private<!>() // hidden
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt
index 537f0fd2009..f27cce779d2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt
@@ -31,7 +31,7 @@ class Derived : Protected() {
     fun foo() {
         bar()
         Nested().foo()
-        Nested().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
+        Nested().<!HIDDEN!>bar<!>() // hidden
 
         fromCompanion()
         protectedFromCompanion()
@@ -48,8 +48,8 @@ fun test() {
     Protected().baz()
     Protected().Inner()
 
-    Protected().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
-    Protected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden
+    Protected().<!HIDDEN!>bar<!>() // hidden
+    Protected.<!HIDDEN!>Nested<!>() // hidden
 }
 
 open class Generic<T>(val x: T) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt
index 86ab1c8ab94..e95a3e3bf6a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt
@@ -6,7 +6,7 @@ class C {
 
     class Nested {
         fun test() {
-            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!>
+            <!UNRESOLVED_REFERENCE!>err<!>()
         }
     }
 }
@@ -17,5 +17,5 @@ fun test() {
     c.bar()
 
     val err = C()
-    err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    err.<!UNRESOLVED_REFERENCE!>foo<!>()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt
index 0e6ac864eb4..b651fd02343 100644
--- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt
@@ -9,17 +9,17 @@ enum class Order {
 enum class Planet(val m: Double, internal val r: Double) {
     MERCURY(1.0, 2.0) {
         override fun sayHello() {
-            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Hello!!!")<!>
+            <!UNRESOLVED_REFERENCE!>println<!>("Hello!!!")
         }
     },
     VENERA(3.0, 4.0) {
         override fun sayHello() {
-            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Ola!!!")<!>
+            <!UNRESOLVED_REFERENCE!>println<!>("Ola!!!")
         }
     },
     EARTH(5.0, 6.0) {
         override fun sayHello() {
-            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Privet!!!")<!>
+            <!UNRESOLVED_REFERENCE!>println<!>("Privet!!!")
         }
     };
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt
index 50c694c5335..923a96486fc 100644
--- a/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt
@@ -15,7 +15,7 @@ class C : A, B() {
     override fun foo() {
         super.foo()
 
-        super.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> // should be ambiguity (NB: really we should have overridden bar in C)
+        super.<!UNRESOLVED_REFERENCE!>bar<!>() // should be ambiguity (NB: really we should have overridden bar in C)
 
         super.baz() // Ok
         baz()       // Ok
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
index 51b826f6b5a..14fcd4dd0ff 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!>
+    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
 }
 
 fun test_2(b: Boolean, y: Int) {
     val x = if (b) y else null
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!>
+    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt
index 281eb062606..0a52fd88247 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>updateD<!>(d)<!> // should fail
+    val x = resolvedCall.<!INAPPLICABLE_CANDIDATE!>updateD<!>(d) // should fail
 }
 
 fun test_2_2(resolvedCall: ResolvedCall<in CallableDescriptor>, d: CallableDescriptor) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt
index 1c6aaf68ba1..d6758a13e51 100644
--- a/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt
@@ -23,7 +23,7 @@ class Owner {
             o.foo()
             foo()
             this@Owner.foo()
-            this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!>
+            this.<!UNRESOLVED_REFERENCE!>err<!>()
         }
     }
 }
@@ -31,8 +31,8 @@ class Owner {
 fun test() {
     val o = Owner()
     o.foo()
-    val err = Owner.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Inner<!>()<!>
-    err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
+    val err = Owner.<!UNRESOLVED_REFERENCE!>Inner<!>()
+    err.<!UNRESOLVED_REFERENCE!>baz<!>()
     val i = o.Inner()
     i.gau()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
index 8c866732348..6e298256607 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<Int>().Inner<Int>())<!> // illegal
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<String>().Inner<String>())<!> // illegal
+    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<Int>().Inner<Int>()) // illegal
+    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
     accept(Outer<String>().Inner<Int>()) // ok
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Boxed<Int>().substitute())<!> // illegal
+    <!INAPPLICABLE_CANDIDATE!>accept<!>(Boxed<Int>().substitute()) // illegal
     accept(Boxed<String>().substitute()) // ok
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt
index 0046ca0b2b2..d10a2c4c0f0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt
@@ -22,8 +22,8 @@ class Owner {
         }
 
         fun err() {
-            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-            this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            this.<!UNRESOLVED_REFERENCE!>foo<!>()
         }
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/kt41984.kt b/compiler/fir/analysis-tests/testData/resolve/kt41984.kt
index 41180d7f030..e693f6acce1 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>take<!>(null)<!>
+    b.<!INAPPLICABLE_CANDIDATE!>take<!>(null)
     b.takeInv(inv)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt
index 6cbf919f1ec..16b0ad25478 100644
--- a/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt
@@ -21,7 +21,7 @@ fun case1(kotlinClass: KotlinClass?) {
         {it}
     }
 
-    lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Unit, KotlinClass?>>()<!> }
+    lambda.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Unit, KotlinClass?>>() }
 }
 // TESTCASE NUMBER: 2
 fun case2(kotlinClass: KotlinClass) {
@@ -36,5 +36,5 @@ fun case2(kotlinClass: KotlinClass) {
         {it}
     }
 
-    lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Unit, KotlinClass?>>()<!> }
+    lambda.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Unit, KotlinClass?>>() }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt
index 03ce460d5d4..8bae96c5e36 100644
--- a/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt
@@ -26,9 +26,9 @@ fun case1(javaClass: JavaClass?) {
 
     validType.checkType { _<Function1<JavaClass, Boolean>>() } //ok
 
-    invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!)
+    invalidType.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
 
-    Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!)
+    Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
 }
 
 class Case1(val javaClass: JavaClass?) {
@@ -55,9 +55,9 @@ fun case2(kotlinClass: KotlinClass?) {
 
     validType.checkType { _<Function1<KotlinClass, Boolean>>() } //ok
 
-    invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> }  //(!!!)
+    invalidType.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() }  //(!!!)
 
-    Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!)
+    Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
 }
 
 class Case2(val kotlinClass: KotlinClass?) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt b/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt
index 0f5bdbfd63e..076512e710a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt
@@ -17,7 +17,7 @@ class D : A.C() {
         val a = A()
         val ac = A.C()
 
-        val c = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>C<!>()<!> // shouldn't resolve
+        val c = <!UNRESOLVED_REFERENCE!>C<!>() // shouldn't resolve
     }
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt
index a956ba7e5e9..f87bf8fb820 100644
--- a/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt
@@ -14,7 +14,7 @@ class B : A() {
     fun test() {
         foo()
         bar()
-        <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>buz<!>()<!>
+        <!NONE_APPLICABLE!>buz<!>()
     }
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
index b7e5ab8f445..5fd73df0428 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>f<!>(s, list)<!>
+    C().<!INAPPLICABLE_CANDIDATE!>f<!>(s, list)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt b/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
index 384164d4d76..0230fdf919f 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeV<!>(value)<!>
+    <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt b/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt
index c7645a90525..44ef3776643 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt
@@ -20,7 +20,7 @@ class WrappedPropertyDescriptor : PropertyDescriptor {
 fun test() {
     val descriptor = WrappedPropertyDescriptor()
     val res1 = descriptor.setter
-    val res2 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSetter<!>()<!> // Should be error
+    val res2 = descriptor.<!UNRESOLVED_REFERENCE!>getSetter<!>() // Should be error
     val res3 = descriptor.isDelegated
-    val res4 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>isDelegated<!>()<!> // Should be error
+    val res4 = descriptor.<!UNRESOLVED_REFERENCE!>isDelegated<!>() // Should be error
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt b/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt
index 704db700550..1ba85216a6c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt
@@ -10,5 +10,5 @@ class Another {}
 
 fun test() {
     val some = Some()
-    val another = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Another<!>()<!>
+    val another = <!UNRESOLVED_REFERENCE!>Another<!>()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt b/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt
index 0c98ff8eb99..30c39006a34 100644
--- a/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt
@@ -10,5 +10,5 @@ public @interface Ann {
 
 fun test(ann: Ann) {
     ann.value
-    ann.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>value<!>()<!> // should be an error
+    ann.<!UNRESOLVED_REFERENCE!>value<!>() // should be an error
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt b/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
index 2316e66886c..dda848e2b85 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(MyFunction { x: Int ->
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(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 b3fa3fb01dc..d2426e224ed 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable { x ->
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable { x ->
         x > 1
-    })<!>
+    })
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable({ it > 1 }))<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable({ it > 1 }))
 
     val x = { x: Int -> x > 1 }
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable(x))<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(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 78977c1f58b..c4eac6be67d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
@@ -21,9 +21,9 @@ fun main() {
         x.toInt().toString()
     }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x: Int ->
+    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo2<!> { x: Int ->
         x.toString()
-    }<!>
+    }
 
     JavaUsage.foo3(
         { x ->
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt b/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
index cca6f7e9917..5fb027ccb83 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(f)<!>
+    <!INAPPLICABLE_CANDIDATE!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
 
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!>(f)<!>
+    <!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
+    <!INAPPLICABLE_CANDIDATE!>foo3<!>(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 da5d1c5b163..016843b8718 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!> {
+    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!> {
             x ->
         x <!UNRESOLVED_REFERENCE!>><!> 1
-    }<!>
+    }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })<!>
+    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })
 
     val x = { x: Int -> x > 1 }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(x)<!>
+    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt
index e45272656a6..4f293d49cd0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt
@@ -24,8 +24,8 @@ fun test_1(x: Any) {
 fun test_2(x: Any) {
     if (x is B || x is C) {
         x.foo()
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
+        x.<!UNRESOLVED_REFERENCE!>bar<!>()
+        x.<!UNRESOLVED_REFERENCE!>baz<!>()
     }
 }
 
@@ -59,26 +59,26 @@ fun test_6(x: Any) {
 fun test_7(x: Any) {
     if (x is A || false) {
         // TODO: should be smartcast
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        x.<!UNRESOLVED_REFERENCE!>foo<!>()
     }
 }
 
 fun test_8(x: Any) {
     if (false || x is A) {
         // TODO: should be smartcast
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        x.<!UNRESOLVED_REFERENCE!>foo<!>()
     }
 }
 
 fun test_9(x: Any) {
     if (x is A || true) {
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        x.<!UNRESOLVED_REFERENCE!>foo<!>()
     }
 }
 
 fun test_10(x: Any) {
     if (true || x is A) {
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        x.<!UNRESOLVED_REFERENCE!>foo<!>()
     }
 }
 
@@ -86,7 +86,7 @@ fun test_10(x: Any) {
 
 fun test_11(x: Any, b: Boolean) {
     if (false && x is A) {
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        x.<!UNRESOLVED_REFERENCE!>foo<!>()
     }
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt
index f6e34990a98..e7be4c1de50 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt
@@ -30,7 +30,7 @@ fun test_3(x: Any, y: Any) {
     }
     z = y
     if (y is B) {
-        z.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        z.<!UNRESOLVED_REFERENCE!>foo<!>()
         z.bar()
     }
 }
@@ -40,7 +40,7 @@ fun test_4(y: Any) {
     x as Int
     x.inc()
     x = y
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!>
+    x.<!UNRESOLVED_REFERENCE!>inc<!>()
     if (y is A) {
         x.foo()
         y.foo()
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt
index dfb08e48fb6..b8dadae553d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt
@@ -15,31 +15,31 @@ fun test_3(b: Boolean, x: Any?) {
     if (b && x as Boolean) {
         x.not()
     }
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+    x.<!UNRESOLVED_REFERENCE!>not<!>()
 
     if (b && x as Boolean == true) {
         x.not()
     }
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+    x.<!UNRESOLVED_REFERENCE!>not<!>()
 
     if (b || x as Boolean) {
-        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+        x.<!UNRESOLVED_REFERENCE!>not<!>()
     }
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+    x.<!UNRESOLVED_REFERENCE!>not<!>()
 }
 
 fun test_4(b: Any) {
     if (b as? Boolean != null) {
         b.not()
     } else {
-        b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+        b.<!UNRESOLVED_REFERENCE!>not<!>()
     }
-    b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+    b.<!UNRESOLVED_REFERENCE!>not<!>()
 
     if (b as? Boolean == null) {
-        b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+        b.<!UNRESOLVED_REFERENCE!>not<!>()
     } else {
         b.not()
     }
-    b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+    b.<!UNRESOLVED_REFERENCE!>not<!>()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt
index 58f167ec50d..cacf8dcd98e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt
@@ -36,8 +36,8 @@ fun test_2(x: Any) {
         else -> return
     }
     x.foo()
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
+    x.<!UNRESOLVED_REFERENCE!>bar<!>()
+    x.<!UNRESOLVED_REFERENCE!>baz<!>()
 }
 
 fun test_3(x: Any) {
@@ -45,9 +45,9 @@ fun test_3(x: Any) {
         x is B -> x.bar()
         x is C -> x.baz()
     }
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
+    x.<!UNRESOLVED_REFERENCE!>foo<!>()
+    x.<!UNRESOLVED_REFERENCE!>bar<!>()
+    x.<!UNRESOLVED_REFERENCE!>baz<!>()
 }
 
 fun <T> runHigherOrder(f: () -> T): T = f()
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt
index bc94abdb650..1776f00f971 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt
@@ -44,7 +44,7 @@ fun test_4(x: Any, b: Boolean) {
         }
         break
     }
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> // No smartcast
+    x.<!UNRESOLVED_REFERENCE!>foo<!>() // No smartcast
 }
 
 fun test_5(x: Any, b: Boolean) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
index 50a6d0cc510..36f096e22e1 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
@@ -4,19 +4,19 @@ fun String.foo() {}
 
 fun test_1(a: Any?) {
     when (a) {
-        is String, is Any -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
+        is String, is Any -> a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
     }
 }
 
 fun test_2(a: Any?) {
     if (a is String || a is Any) {
-        a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
+        a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
     }
 }
 
 fun test_3(a: Any?, b: Boolean) {
     when (a) {
-        is String, b -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
+        is String, b -> a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
     }
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt
index f13a9b24ca5..b1ddb729fcc 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt
@@ -14,23 +14,23 @@ fun Any?.test_1() {
         this.foo()
         foo()
     } else {
-        this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        this.<!UNRESOLVED_REFERENCE!>foo<!>()
+        <!UNRESOLVED_REFERENCE!>foo<!>()
     }
-    this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    this.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!UNRESOLVED_REFERENCE!>foo<!>()
 }
 
 fun Any?.test_2() {
     if (this !is A) {
-        this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        this.<!UNRESOLVED_REFERENCE!>foo<!>()
+        <!UNRESOLVED_REFERENCE!>foo<!>()
     } else {
         this.foo()
         foo()
     }
-    this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    this.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!UNRESOLVED_REFERENCE!>foo<!>()
 }
 
 fun test_3(a: Any, b: Any, c: Any) {
@@ -49,13 +49,13 @@ fun test_3(a: Any, b: Any, c: Any) {
 
 fun Any?.test_4() {
     if (this !is A) {
-        this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-        this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+        this.<!UNRESOLVED_REFERENCE!>foo<!>()
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        this.<!UNRESOLVED_REFERENCE!>bar<!>()
+        <!UNRESOLVED_REFERENCE!>bar<!>()
     } else if (this !is B) {
-        this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+        this.<!UNRESOLVED_REFERENCE!>bar<!>()
+        <!UNRESOLVED_REFERENCE!>bar<!>()
         this.foo()
         foo()
     } else {
@@ -64,10 +64,10 @@ fun Any?.test_4() {
         this.bar()
         bar()
     }
-    this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-    this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
-    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+    this.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!UNRESOLVED_REFERENCE!>foo<!>()
+    this.<!UNRESOLVED_REFERENCE!>bar<!>()
+    <!UNRESOLVED_REFERENCE!>bar<!>()
 }
 
 fun Any.test_5(): Int = when {
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt
index 83a74410769..3c681bde320 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt
@@ -22,7 +22,7 @@ fun test_3(x: Any) {
     (x as? A)?.bar(x)?.foo(x.bool())?.let {
         x.bool()
     }
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bool<!>()<!>
+    x.<!UNRESOLVED_REFERENCE!>bool<!>()
 }
 
 fun test_4(x: A?) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt b/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
index 997d46d1aaa..5a6f706a61e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
@@ -42,7 +42,7 @@ fun test_2(inv: Inv2<A, B>) {
 
 fun test_3(inv: Inv3<A, B, C>) {
     inv.k().foo()
-    inv.t().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+    inv.t().<!UNRESOLVED_REFERENCE!>bar<!>()
     inv.t().baz()
 }
 
@@ -74,21 +74,21 @@ typealias Invariant1<X> = Invariant<X>
 fun test_5(a: A, in1: In1<A>, in2: In1<in A>, in3: In1<out A>) {
     in1.take(a)
     in2.take(a)
-    in3.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>take<!>(a)<!>
+    in3.<!UNRESOLVED_REFERENCE!>take<!>(a)
 }
 
 fun test_6(a: A, out1: Out1<A>, out2: Out1<in A>, out3: Out1<out A>) {
     out1.value().foo()
-    out2.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>value<!>()<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    out2.<!UNRESOLVED_REFERENCE!>value<!>().<!UNRESOLVED_REFERENCE!>foo<!>()
     out3.value().foo()
 }
 
 fun test_7(a: A, inv1: Invariant1<A>, inv2: Invariant1<in A>, inv3: Invariant1<out A>) {
     inv1.value().foo()
-    inv2.value().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    inv2.value().<!UNRESOLVED_REFERENCE!>foo<!>()
     inv3.value().foo()
 
     inv1.take(a)
     inv2.take(a)
-    inv3.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>take<!>(a)<!>
+    inv3.<!INAPPLICABLE_CANDIDATE!>take<!>(a)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt
index 5fc9f86fa4d..51a43a129e8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt
@@ -2,12 +2,12 @@ class A {
     companion object Comp {}
 
     fun foo() {
-        <!HIDDEN{LT}!><!HIDDEN{PSI}!>Comp<!>()<!>
+        <!HIDDEN!>Comp<!>()
     }
 }
 
 object B {
-    private val x = <!HIDDEN{LT}!><!HIDDEN{PSI}!>B<!>()<!>
+    private val x = <!HIDDEN!>B<!>()
 }
 
 class D {
@@ -26,6 +26,6 @@ enum class E {
     };
 
     fun foo() {
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>X<!>()<!>
+        <!UNRESOLVED_REFERENCE!>X<!>()
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
index bb474ca35cb..17ef4ed5510 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt
@@ -31,16 +31,16 @@ fun main() {
     foo1(KotlinClass::baz)
     foo2(KotlinClass::baz)
     // Ambiguity (companion/class)
-    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo3<!>(KotlinClass::baz)<!>
+    <!AMBIGUITY!>foo3<!>(KotlinClass::baz)
 
     // Type mismatch
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)<!>
+    <!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)
     foo2(KotlinClass::bar)
     foo3(KotlinClass::bar)
 
     foo1(KotlinClass2::bar)
     // Type mismatch
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)<!>
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)
     foo3(KotlinClass2::bar)
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt
index 4c5cb7ea24d..b2332695285 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt
@@ -7,6 +7,6 @@ fun <T> bar(f: (T) -> Unit, e: T) {}
 fun <T> baz(e: T, f: (T) -> Unit) {}
 
 fun test(a: A, b: B) {
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)<!>
-    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)<!>
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt
index 3d563c207fd..189e45d3611 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt
@@ -3,5 +3,5 @@ fun <T, R> use(x: (T) -> R): (T) -> R = x
 fun foo() = use(::bar)
 fun bar(x: String) = 1
 
-fun loop1() = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)<!>
+fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)
 fun loop2() = loop1()
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/javaStatic.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/javaStatic.kt
index 04a617ff483..b3057626abe 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/javaStatic.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/javaStatic.kt
@@ -16,5 +16,5 @@ fun foo3(x: (String) -> Int) {}
 fun main() {
     foo1(JavaClass::bar)
     foo2(JavaClass::bar)
-    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo3<!>(JavaClass::bar)<!>
+    <!AMBIGUITY!>foo3<!>(JavaClass::bar)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt
index 3ba452fd246..10944f406ca 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt
@@ -6,5 +6,5 @@ fun bar(): Int = 1
 fun bar(x: String): Int = 1
 
 fun main() {
-    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)<!>
+    <!AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt
index 3029d26ca7b..e310196c7fe 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt
@@ -59,8 +59,8 @@ fun test_2(x: Any) {
 fun test_3(x: Any) {
     myRequireOr(x is B, x is C)
     x.foo() // OK
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> // Error
-    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> // Error
+    x.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
+    x.<!UNRESOLVED_REFERENCE!>baz<!>() // Error
 }
 
 fun test_4(x: Any) {
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaVisibility2.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaVisibility2.kt
index 32b967e2377..46bc2d36099 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaVisibility2.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaVisibility2.kt
@@ -27,8 +27,8 @@ class A {
     val p3 = JavaProtected().<!HIDDEN!>javaPProtectedPackage<!>
 
     fun test() {
-        JavaProtected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMProtectedStatic<!>()<!>
-        JavaPackageLocal.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMPackage<!>()<!>
+        JavaProtected.<!HIDDEN!>javaMProtectedStatic<!>()
+        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
     }
 }
 
@@ -39,7 +39,7 @@ class B : JavaProtected() {
 
     fun test() {
         JavaProtected.javaMProtectedStatic()
-        JavaPackageLocal.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMPackage<!>()<!>
+        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
     }
 }
 
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 99df059cf1c..e8c12d5cbf3 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>nestedI<!>(vInt)<!>
+    k.getImpl().<!INAPPLICABLE_CANDIDATE!>nestedI<!>(vInt)
     k.getNestedSubClass().nested("")
-    k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>nested<!>(1)<!>
+    k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE!>nested<!>(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 c9c89e70850..c2256f265e2 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>("")<!>
+    JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
 }
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 972831a8220..970b06ffc7e 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{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(KotlinClass<String>())<!>
-    JavaClass.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>("")<!>
+    JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>(KotlinClass<String>())
+    JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
 }
diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KJKComplexHierarchyNestedLoop.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KJKComplexHierarchyNestedLoop.kt
index a28bf427821..151031d03c9 100644
--- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KJKComplexHierarchyNestedLoop.kt
+++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KJKComplexHierarchyNestedLoop.kt
@@ -2,11 +2,11 @@
 class K2: J1() {
     class Q : <!UNRESOLVED_REFERENCE!>Nested<!>()
     fun bar() {
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        <!UNRESOLVED_REFERENCE!>baz<!>()
 
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superClass<!>()<!>
-        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superI<!>()<!>
+        <!UNRESOLVED_REFERENCE!>superClass<!>()
+        <!UNRESOLVED_REFERENCE!>superI<!>()
     }
 }
 
diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
index 6ca5292d888..0e24e36d23b 100644
--- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
+++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
@@ -43,6 +43,7 @@ enum class PositioningStrategy(private val strategy: String) {
     VARIANCE_MODIFIER("VARIANCE_MODIFIER"),
     LATEINIT_MODIFIER("LATEINIT_MODIFIER"),
     SELECTOR_BY_QUALIFIED("SELECTOR_BY_QUALIFIED"),
+    REFERENCE_BY_QUALIFIED("REFERENCE_BY_QUALIFIED"),
 
     ;
 
diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
index 3ca0d8635e2..a0b79fab942 100644
--- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
@@ -45,10 +45,10 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
     }
 
     val UNRESOLVED by object : DiagnosticGroup("Unresolved") {
-        val HIDDEN by error<FirSourceElement, PsiElement> {
+        val HIDDEN by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<AbstractFirBasedSymbol<*>>("hidden")
         }
-        val UNRESOLVED_REFERENCE by error<FirSourceElement, PsiElement> {
+        val UNRESOLVED_REFERENCE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<String>("reference")
         }
         val UNRESOLVED_LABEL by error<FirSourceElement, PsiElement>()
@@ -62,7 +62,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
     val SUPER by object : DiagnosticGroup("Super") {
         val SUPER_IS_NOT_AN_EXPRESSION by error<FirSourceElement, PsiElement>()
         val SUPER_NOT_AVAILABLE by error<FirSourceElement, PsiElement>()
-        val ABSTRACT_SUPER_CALL by error<FirSourceElement, PsiElement>()
+        val ABSTRACT_SUPER_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED)
         val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error<FirSourceElement, PsiElement> {
             parameter<String>("target")
         }
@@ -152,20 +152,21 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
     }
 
     val APPLICABILITY by object : DiagnosticGroup("Applicability") {
-        val NONE_APPLICABLE by error<FirSourceElement, PsiElement> {
+        val NONE_APPLICABLE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
         }
 
-        val INAPPLICABLE_CANDIDATE by error<FirSourceElement, PsiElement> {
+        val INAPPLICABLE_CANDIDATE by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<AbstractFirBasedSymbol<*>>("candidate")
         }
+
         val INAPPLICABLE_LATEINIT_MODIFIER by error<FirSourceElement, KtModifierListOwner>(PositioningStrategy.LATEINIT_MODIFIER) {
             parameter<String>("reason")
         }
     }
 
     val AMBIGUIRY by object : DiagnosticGroup("Ambiguity") {
-        val AMBIGUITY by error<FirSourceElement, PsiElement> {
+        val AMBIGUITY by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<Collection<AbstractFirBasedSymbol<*>>>("candidates")
         }
         val ASSIGN_OPERATOR_AMBIGUITY by error<FirSourceElement, PsiElement> {
@@ -364,7 +365,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
         val UNSAFE_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.DOT_BY_QUALIFIED) {
             parameter<ConeKotlinType>("receiverType")
         }
-        val UNSAFE_IMPLICIT_INVOKE_CALL by error<FirSourceElement, PsiElement> {
+        val UNSAFE_IMPLICIT_INVOKE_CALL by error<FirSourceElement, PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
             parameter<ConeKotlinType>("receiverType")
         }
         val UNSAFE_INFIX_CALL by error<FirSourceElement, KtExpression> {
diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
index 30eb6beba1e..0c04d5c6dcc 100644
--- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
@@ -63,8 +63,8 @@ object FirErrors {
     val DELEGATION_IN_INTERFACE by error0<FirSourceElement, PsiElement>()
 
     // Unresolved
-    val HIDDEN by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
-    val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String>()
+    val HIDDEN by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val UNRESOLVED_LABEL by error0<FirSourceElement, PsiElement>()
     val DESERIALIZATION_ERROR by error0<FirSourceElement, PsiElement>()
     val ERROR_FROM_JAVA_RESOLUTION by error0<FirSourceElement, PsiElement>()
@@ -75,7 +75,7 @@ object FirErrors {
     // Super
     val SUPER_IS_NOT_AN_EXPRESSION by error0<FirSourceElement, PsiElement>()
     val SUPER_NOT_AVAILABLE by error0<FirSourceElement, PsiElement>()
-    val ABSTRACT_SUPER_CALL by error0<FirSourceElement, PsiElement>()
+    val ABSTRACT_SUPER_CALL by error0<FirSourceElement, PsiElement>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val INSTANCE_ACCESS_BEFORE_SUPER_CALL by error1<FirSourceElement, PsiElement, String>()
 
     // Supertypes
@@ -139,12 +139,12 @@ object FirErrors {
     val REDUNDANT_OPEN_IN_INTERFACE by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)
 
     // Applicability
-    val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
-    val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
+    val NONE_APPLICABLE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val INAPPLICABLE_LATEINIT_MODIFIER by error1<FirSourceElement, KtModifierListOwner, String>(SourceElementPositioningStrategies.LATEINIT_MODIFIER)
 
     // Ambiguity
-    val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
+    val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
 
     // Types & type parameters
@@ -235,7 +235,7 @@ object FirErrors {
 
     // Nullability
     val UNSAFE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>(SourceElementPositioningStrategies.DOT_BY_QUALIFIED)
-    val UNSAFE_IMPLICIT_INVOKE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>()
+    val UNSAFE_IMPLICIT_INVOKE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val UNSAFE_INFIX_CALL by error3<FirSourceElement, KtExpression, FirExpression, String, FirExpression>()
     val UNSAFE_OPERATOR_CALL by error3<FirSourceElement, KtExpression, FirExpression, String, FirExpression>()
 
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
index d48905957ae..00b2921b796 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
@@ -347,6 +347,32 @@ object LightTreePositioningStrategies {
         }
     }
 
+    val REFERENCE_BY_QUALIFIED: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
+        override fun mark(
+            node: LighterASTNode,
+            startOffset: Int,
+            endOffset: Int,
+            tree: FlyweightCapableTreeStructure<LighterASTNode>
+        ): List<TextRange> {
+            if (node.tokenType == KtNodeTypes.CALL_EXPRESSION || node.tokenType == KtNodeTypes.CONSTRUCTOR_DELEGATION_CALL) {
+                return markElement(tree.referenceExpression(node) ?: node, startOffset, endOffset, tree, node)
+            }
+            if (node.tokenType != KtNodeTypes.DOT_QUALIFIED_EXPRESSION && node.tokenType != KtNodeTypes.SAFE_ACCESS_EXPRESSION) {
+                return super.mark(node, startOffset, endOffset, tree)
+            }
+            val selector = tree.selector(node)
+            if (selector != null) {
+                when (selector.tokenType) {
+                    KtNodeTypes.REFERENCE_EXPRESSION ->
+                        return markElement(selector, startOffset, endOffset, tree, node)
+                    KtNodeTypes.CALL_EXPRESSION, KtNodeTypes.CONSTRUCTOR_DELEGATION_CALL ->
+                        return markElement(tree.referenceExpression(selector) ?: selector, startOffset, endOffset, tree, node)
+                }
+            }
+            return super.mark(node, startOffset, endOffset, tree)
+        }
+    }
+
     val WHEN_EXPRESSION = object : LightTreePositioningStrategy() {
         override fun mark(
             node: LighterASTNode,
@@ -400,6 +426,14 @@ private fun FlyweightCapableTreeStructure<LighterASTNode>.nameIdentifier(node: L
 private fun FlyweightCapableTreeStructure<LighterASTNode>.operationReference(node: LighterASTNode): LighterASTNode? =
     findChildByType(node, KtNodeTypes.OPERATION_REFERENCE)
 
+private fun FlyweightCapableTreeStructure<LighterASTNode>.referenceExpression(node: LighterASTNode): LighterASTNode? {
+    val childrenRef = Ref<Array<LighterASTNode?>>()
+    getChildren(node, childrenRef)
+    return childrenRef.get()?.firstOrNull {
+        it?.tokenType == KtNodeTypes.REFERENCE_EXPRESSION || it?.tokenType == KtNodeTypes.CONSTRUCTOR_DELEGATION_REFERENCE
+    }
+}
+
 private fun FlyweightCapableTreeStructure<LighterASTNode>.rightParenthesis(node: LighterASTNode): LighterASTNode? =
     findChildByType(node, KtTokens.RPAR)
 
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
index 6e006527cb2..489dcb6b5d7 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
@@ -108,6 +108,11 @@ object SourceElementPositioningStrategies {
         PositioningStrategies.SELECTOR_BY_QUALIFIED
     )
 
+    val REFERENCE_BY_QUALIFIED = SourceElementPositioningStrategy(
+        LightTreePositioningStrategies.REFERENCE_BY_QUALIFIED,
+        PositioningStrategies.REFERENCE_BY_QUALIFIED
+    )
+
     val WHEN_EXPRESSION = SourceElementPositioningStrategy(
         LightTreePositioningStrategies.WHEN_EXPRESSION,
         PositioningStrategies.WHEN_EXPRESSION
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
index 3848d8afb95..2d1cdd07752 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
@@ -732,4 +732,20 @@ object PositioningStrategies {
             return super.mark(element)
         }
     }
+
+    val REFERENCE_BY_QUALIFIED: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
+        override fun mark(element: PsiElement): List<TextRange> {
+            when (element) {
+                is KtQualifiedExpression -> {
+                    when (val selectorExpression = element.selectorExpression) {
+                        is KtCallExpression -> return mark(selectorExpression.calleeExpression ?: selectorExpression)
+                        is KtReferenceExpression -> return mark(selectorExpression)
+                    }
+                }
+                is KtCallExpression -> return mark(element.calleeExpression ?: element)
+                is KtConstructorDelegationCall -> return mark(element.calleeExpression ?: element)
+            }
+            return super.mark(element)
+        }
+    }
 }
diff --git a/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt b/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
index c067f6bb367..2da4f2f2f99 100644
--- a/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
+++ b/compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
@@ -33,8 +33,8 @@ operator fun CustomDelegate3.setValue(thisRef: Any?, prop: KProperty<*>, value:
 
 class Example {
 
-    var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!>
-    val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!>
+    var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
+    val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
     var b by OkDelegate()
     var c by CustomDelegate2()
     var d by CustomDelegate3()
diff --git a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
index 6a62617d900..29bae925d54 100644
--- a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
+++ b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
@@ -28,20 +28,20 @@ fun <T> fooT2() : (t : T) -> T {
 
 fun main(args : Array<String>) {
     args.foo()()
-    <!INAPPLICABLE_CANDIDATE!>args.foo1()()<!>
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()()<!>
+    args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
+    <!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     args.foo1()(1)
-    <!INAPPLICABLE_CANDIDATE!>args.foo1()("1")<!>
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()("1")<!>
+    args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
+    <!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     foo2()({})
     <!INAPPLICABLE_CANDIDATE!>foo2<!>(){}
     (foo2()){}
-    <!INAPPLICABLE_CANDIDATE!>(foo2()){x -> }<!>
-    <!INAPPLICABLE_CANDIDATE!>foo2()({x -> })<!>
+    <!INAPPLICABLE_CANDIDATE!>(foo2())<!>{x -> }
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>()({x -> })
 
     val a = fooT1(1)()
     checkSubtype<Int>(a)
@@ -50,25 +50,25 @@ fun main(args : Array<String>) {
     checkSubtype<Int>(b)
     fooT2()(1) // : Any?
 
-    <!UNRESOLVED_REFERENCE!>1()<!>
-    <!UNRESOLVED_REFERENCE!>1{}<!>
-    <!UNRESOLVED_REFERENCE!>1(){}<!>
+    <!UNRESOLVED_REFERENCE!>1<!>()
+    <!UNRESOLVED_REFERENCE!>1<!>{}
+    <!UNRESOLVED_REFERENCE!>1<!>(){}
 }
 
 fun f() :  Int.() -> Unit = {}
 
 fun main1() {
-    1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>;
+    1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
     {1}();
     (fun (x : Int) = x)(1)
-    1.<!UNRESOLVED_REFERENCE!>(fun Int.(x : Int) = x)(1)<!>;
+    1.<!UNRESOLVED_REFERENCE!>(fun Int.(x : Int) = x)<!>(1);
     l@{1}()
-    1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))()<!>
-    1.<!UNRESOLVED_REFERENCE!>(f())()<!>
-    1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}()<!>
-    1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}()<!>
+    1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))<!>()
+    1.<!UNRESOLVED_REFERENCE!>(f())<!>()
+    1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}<!>()
+    1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}<!>()
 
-    1.<!UNRESOLVED_REFERENCE!>"sdf"()<!>
+    1.<!UNRESOLVED_REFERENCE!>"sdf"<!>()
 
     1."sdf"
     1.{}
@@ -76,12 +76,12 @@ fun main1() {
 }
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}()<!>;
-    <!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)()<!>
-    "sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>
+    <!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}<!>();
+    <!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)<!>()
+    "sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
     val i : Int? = null
-    i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>;
-    <!INAPPLICABLE_CANDIDATE!>{}<Int>()<!>
-    1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>
-    1.<!UNRESOLVED_REFERENCE!>{}()<!>
+    i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
+    <!INAPPLICABLE_CANDIDATE!>{}<!><Int>()
+    1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
+    1.<!UNRESOLVED_REFERENCE!>{}<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt
index f4bdfdadd4c..892c511bd7b 100644
--- a/compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt
+++ b/compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt
@@ -28,7 +28,7 @@ abstract class My(@Field arg: Int, @Field val w: Int) {
     fun foo() {}
 
     @Field
-    val v: Int by <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Delegates<!>.<!UNRESOLVED_REFERENCE!>lazy<!> { 42 }<!>
+    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>lazy<!> { 42 }
 }
 
 enum class Your {
diff --git a/compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt b/compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt
index 89bbbfa27c2..f2dac1b0c43 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.")<!>
+    <!INAPPLICABLE_CANDIDATE!>(B::hashCode)<!>("No.")
 }
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt
index 28cae30c997..9a21bc9308d 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt
@@ -29,7 +29,7 @@ private fun <T> lazy(init: () -> T): <!UNRESOLVED_REFERENCE!>kotlin.Lazy<T><!> {
 }
 
 object DefaultHttpClientWithBy : HttpClient by client {
-    val client by <!UNRESOLVED_REFERENCE!>lazy { HttpClientImpl() }<!>
+    val client by <!UNRESOLVED_REFERENCE!>lazy<!> { HttpClientImpl() }
 }
 
 object DefaultFqHttpClient : HttpClient by DefaultFqHttpClient.client {
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 5539b97ee64..7276f6c9207 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 <!INAPPLICABLE_CANDIDATE!>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 e86865131dd..8d09b2a5612 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 <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
 }
 
 class Delegate<F> {
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt
index 991fc0fe076..7ad3ec07b8b 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt
@@ -45,7 +45,7 @@ fun test() {
     x4 checkType { _<Function1<Int, Unit>>() }
 
     { y: Int -> fun named14(): Int {return 1} }
-    val b = <!UNRESOLVED_REFERENCE!>(<!EXPRESSION_REQUIRED!>fun named15(): Boolean { return true }<!>)()<!>
+    val b = <!UNRESOLVED_REFERENCE!>(<!EXPRESSION_REQUIRED!>fun named15(): Boolean { return true }<!>)<!>()
 
     baz(<!EXPRESSION_REQUIRED!>fun named16(){}<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.fir.kt
index 12ee9c9e9e1..36688c7fa71 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.fir.kt
@@ -5,10 +5,10 @@ import kotlin.reflect.KProperty
 class A
 
 class D {
-    val c: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<A>()<!>
+    val c: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<!><A>()
 }
 
-val cTopLevel: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<A>()<!>
+val cTopLevel: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<!><A>()
 
 class IncorrectThis<T> {
     fun <R> get(t: Any?, p: KProperty<*>): Int {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt
index a2b3d2a91a0..bbe1ab30618 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 <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
 }
 
-val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty()<!>
+val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
 
 val A.e: Int by MyProperty()
 
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt
index 6fc5a1d7f20..9039756c190 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt
@@ -5,7 +5,7 @@ package test
 import first.*
 import second.*
 
-val a12 by <!AMBIGUITY!>A()<!>
+val a12 by <!AMBIGUITY!>A<!>()
 
 // FILE: first.kt
 package first
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt
index beac5cea63f..fb962e9965d 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt
@@ -8,4 +8,4 @@ class ValueWrapper()
     fun setValue(v: Int) { backingValue = v }
 }
 
-val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper()<!>
+val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper<!>()
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.fir.kt
index 270badeb52d..2433947dafe 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.fir.kt
@@ -1,3 +1,3 @@
-val a: Int by <!UNRESOLVED_REFERENCE!>A()<!>
+val a: Int by <!UNRESOLVED_REFERENCE!>A<!>()
 
 class A
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt
index 7ad8d8e86df..90b54acd693 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 <!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)
 }
 
 class Delegate<T: Any>(val init: T) {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt
index 6fb1bd69fdd..840e8feb846 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 <!INAPPLICABLE_CANDIDATE!>delegate<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt
index 3a826e00878..a52285427e2 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 <!INAPPLICABLE_CANDIDATE!>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 405dee83558..69230fdcd4a 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 <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 }
 
-var aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+var aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 
 class Delegate {
   fun getValue(t: Nothing, p: KProperty<*>): Int {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.fir.kt
index d7a9c9067f1..b9cac34cd3c 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.fir.kt
@@ -3,7 +3,7 @@
 import kotlin.reflect.KProperty
 
 class A {
-    val c: Int by <!NONE_APPLICABLE!>Delegate()<!>
+    val c: Int by <!NONE_APPLICABLE!>Delegate<!>()
 }
 
 class Delegate {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.fir.kt
index fc65950992f..aa603f3f806 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 <!INAPPLICABLE_CANDIDATE!>Delegate<!><A>()
 }
 
-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<A>()<!>
+val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>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 8058a494f55..41ba3d5bafe 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 <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 }
 
-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 
 class A
 
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt
index 1a8e7d9ffb3..f9f35f93c16 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt
@@ -3,10 +3,10 @@
 import kotlin.reflect.KProperty
 
 class A {
-  val a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+  val a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 }
 
-val aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+val aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 
 class Delegate {
   fun getValue(t: Any?, p: KProperty<*>, a: Int): Int {
diff --git a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt b/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt
index 138db690973..5e36f04c40f 100644
--- a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt
+++ b/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt
@@ -35,7 +35,7 @@ fun test4() {
 // should be an error on receiver, shouldn't be thrown away
 
 fun test5() {
-    1.<!UNRESOLVED_REFERENCE!>(fun String.()=1)()<!>
+    1.<!UNRESOLVED_REFERENCE!>(fun String.()=1)<!>()
 }
 
 fun <R: Any> R?.sure() : R = this!!
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt
index 8111b18415b..85ce9597a68 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt
@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 val receiver = { Int.(<!SYNTAX!><!>) <!SYNTAX!>-><!> }
-val receiverWithParameter = { Int.(<!UNRESOLVED_REFERENCE!>a<!>) <!SYNTAX!>-><!> }
+val receiverWithParameter = { <!UNRESOLVED_REFERENCE!>Int.(a)<!> <!SYNTAX!>-><!> }
 
 val receiverAndReturnType = { Int.(<!SYNTAX!><!>)<!SYNTAX!>: Int ->  5<!> }
-val receiverAndReturnTypeWithParameter = { Int.(<!UNRESOLVED_REFERENCE!>a<!><!SYNTAX!><!SYNTAX!><!>: Int): Int ->  5<!> }
+val receiverAndReturnTypeWithParameter = { Int.(a<!SYNTAX!><!SYNTAX!><!>: Int): Int ->  5<!> }
 
 val returnType = { (<!SYNTAX!><!>): Int -> 5 }
 val returnTypeWithParameter = { <!COMPONENT_FUNCTION_MISSING!>(b: Int): Int<!> -> 5 }
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt
index db815efa470..64001baabe3 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<!> <!INAPPLICABLE_CANDIDATE!>{ } { }<!>
+val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> <!INAPPLICABLE_CANDIDATE!>{ }<!> { }
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt
index 26b87f01991..8d48bd43e6f 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt
+++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt
@@ -40,7 +40,7 @@ fun foo() {
     property1 = 1
 
     val
-    propertyWithBy by <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>lazy<!> { 1 }<!>
+    propertyWithBy by <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>lazy<!> { 1 }
 
     val
     propertyWithType: Int
diff --git a/compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt b/compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt
index 7d238420de8..89d7abf1986 100644
--- a/compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt
+++ b/compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt
@@ -2,6 +2,6 @@ fun test1(i: Int) = { i ->
     i
 }(i)
 
-fun test2() = <!INAPPLICABLE_CANDIDATE!>{ i -> i }()<!>
+fun test2() = <!INAPPLICABLE_CANDIDATE!>{ i -> i }<!>()
 
 fun test3() = { i -> i }(1)
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/kt435.fir.kt b/compiler/testData/diagnostics/tests/kt435.fir.kt
index aec09116fa8..c24f1f89f78 100644
--- a/compiler/testData/diagnostics/tests/kt435.fir.kt
+++ b/compiler/testData/diagnostics/tests/kt435.fir.kt
@@ -3,5 +3,5 @@ fun Any.foo1() : (i : Int) -> Unit {
 }
 
 fun test(a : Any) {
-    <!INAPPLICABLE_CANDIDATE!>a.foo1()()<!>
+    a.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/objects/Objects.fir.kt b/compiler/testData/diagnostics/tests/objects/Objects.fir.kt
index fcaee4376e2..2b8bb4061c0 100644
--- a/compiler/testData/diagnostics/tests/objects/Objects.fir.kt
+++ b/compiler/testData/diagnostics/tests/objects/Objects.fir.kt
@@ -6,13 +6,13 @@ package toplevelObjectDeclarations
 
   <!INAPPLICABLE_CANDIDATE!>class T : Foo {}<!>
 
-  <!INAPPLICABLE_CANDIDATE!>object A<!> : Foo {
+  <!INAPPLICABLE_CANDIDATE!>object A : Foo {
     val x : Int = 2
 
     fun test() : Int {
       return x + foo()
     }
-  }
+  }<!>
 
   object B : A {}
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.fir.kt
index 6b6b626d5a5..d8b760b83c7 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.fir.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.fir.kt
@@ -19,5 +19,5 @@ public class J {
 // FILE: k.kt
 
 var A by J.staticNN
-var B by <!UNSAFE_CALL!>J.staticN<!>
+var B by J<!UNSAFE_CALL!>.<!>staticN
 var C by J.staticJ
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt b/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt
index bcc9b5931bc..e1d94c8f043 100644
--- a/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt
+++ b/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt
@@ -1,2 +1,2 @@
 // !WITH_NEW_INFERENCE
-val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>sdf<!>()()<!><out Any><!>::unwrap<!>
+val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>sdf<!>()()<out Any>::unwrap<!>
diff --git a/compiler/testData/diagnostics/tests/regressions/kt26303.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt26303.fir.kt
index dbfa13fb0f5..39472371d47 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt26303.fir.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt26303.fir.kt
@@ -14,5 +14,5 @@ import foo.foo as invoke
 import foo.invoke
 
 fun main(args: Array<String>) {
-    <!AMBIGUITY!>42()<!>
+    <!AMBIGUITY!>42<!>()
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.fir.kt
index dd3251bb346..ab2ff938366 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.fir.kt
@@ -7,5 +7,5 @@ fun Int.invoke(a: Any, i: Int) {}
 fun foo(i: Int) {
     <!AMBIGUITY!>i<!>(1, 1)
 
-    <!AMBIGUITY!>5(1, 2)<!>
+    <!AMBIGUITY!>5<!>(1, 2)
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.fir.kt
index d11dc63cba4..46c0ce68894 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.fir.kt
@@ -6,5 +6,5 @@ class My {
 
 fun My.foo(i: Int) {
     <!HIDDEN!>i<!>("")
-    <!HIDDEN!>1("")<!>
+    <!HIDDEN!>1<!>("")
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt
index 107f01d0c61..e02acf7781b 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt
@@ -7,5 +7,5 @@ fun test1(f: String.() -> Unit) {
 fun test2(f: (Int) -> Int) {
     1.<!UNRESOLVED_REFERENCE!>f<!>(2)
 
-    2.(<!UNRESOLVED_REFERENCE!>f<!>)(2)
+    2.<!UNRESOLVED_REFERENCE!>(f)<!>(2)
 }
\ No newline at end of file
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 0874328e546..40954777dd8 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.fir.kt
@@ -10,5 +10,5 @@ fun foo(s: String, ai: A<Int>) {
 
     <!INAPPLICABLE_CANDIDATE!>s<!>(ai)
 
-    <!INAPPLICABLE_CANDIDATE!>""(ai)<!>
+    <!INAPPLICABLE_CANDIDATE!>""<!>(ai)
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.fir.kt
index 0874f5b7d95..c42be06db89 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.fir.kt
@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 fun foo(i: Int) {
     <!UNRESOLVED_REFERENCE!>i<!>()
-    <!UNRESOLVED_REFERENCE!>1()<!>
+    <!UNRESOLVED_REFERENCE!>1<!>()
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.fir.kt
index 27539cd2175..cde534b69f7 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.fir.kt
@@ -6,5 +6,5 @@ operator fun String.invoke(i: Int) {}
 fun foo(s: String?) {
     <!UNSAFE_IMPLICIT_INVOKE_CALL!>s<!>(1)
 
-    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(s ?: null)(1)<!>
+    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(s ?: null)<!>(1)
 }
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 85b8d534ef0..5a3559b9135 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt
@@ -1,17 +1,17 @@
 // !WITH_NEW_INFERENCE
 
 fun test1() {
-    1. <!UNRESOLVED_REFERENCE!>(fun String.(i: Int) = i )(1)<!>
-    1.<!UNRESOLVED_REFERENCE!>(label@ fun String.(i: Int) = i )(1)<!>
+    1. <!UNRESOLVED_REFERENCE!>(fun String.(i: Int) = i )<!>(1)
+    1.<!UNRESOLVED_REFERENCE!>(label@ fun String.(i: Int) = i )<!>(1)
 }
 
 fun test2(f: String.(Int) -> Unit) {
-    11.(<!INAPPLICABLE_CANDIDATE!>f<!>)(1)
-    11.(<!INAPPLICABLE_CANDIDATE!>f<!>)()
+    11.<!INAPPLICABLE_CANDIDATE!>(f)<!>(1)
+    11.<!INAPPLICABLE_CANDIDATE!>(f)<!>()
 }
 
 fun test3() {
     fun foo(): String.(Int) -> Unit = {}
 
-    1.<!UNRESOLVED_REFERENCE!>(foo())(1)<!>
+    1.<!UNRESOLVED_REFERENCE!>(foo())<!>(1)
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.fir.kt
index e99d2def1c2..e8d87240b9e 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.fir.kt
@@ -6,5 +6,5 @@ fun String.invoke(i: Int) {}
 fun foo(i: Int) {
     <!INAPPLICABLE_CANDIDATE!>i<!>(1)
 
-    <!INAPPLICABLE_CANDIDATE!>1(1)<!>
+    <!INAPPLICABLE_CANDIDATE!>1<!>(1)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt
index 41aeacd7829..8af8d45ccec 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt
@@ -2,17 +2,17 @@ class A(val x: (String.() -> Unit)?)
 
 fun test(a: A) {
     if (a.x != null) {
-        "".<!UNRESOLVED_REFERENCE!>(a.x)()<!>
+        "".<!UNRESOLVED_REFERENCE!>(a.x)<!>()
         a.x("") // todo
         (a.x)("")
     }
-    "".<!UNRESOLVED_REFERENCE!>(a.x)()<!>
+    "".<!UNRESOLVED_REFERENCE!>(a.x)<!>()
     a.<!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!>("")
-    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)("")<!>
+    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)<!>("")
 
     with("") {
         a.<!INAPPLICABLE_CANDIDATE!>x<!>()
-        <!INAPPLICABLE_CANDIDATE!>(a.x)()<!>
+        <!INAPPLICABLE_CANDIDATE!>(a.x)<!>()
         if (a.x != null) {
             a.<!INAPPLICABLE_CANDIDATE!>x<!>() // todo
             (a.x)()
diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
index 52919c92464..2ee6ca48bc2 100644
--- a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
+++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
@@ -8,7 +8,7 @@ class B
 val A.foo: B.() -> Unit get() = {}
 
 fun test(a: A, b: B) {
-    b.<!UNRESOLVED_REFERENCE!>(a.foo)()<!>
+    b.<!UNRESOLVED_REFERENCE!>(a.foo)<!>()
     (a.foo)(b)
     a.foo(b)
 
@@ -17,7 +17,7 @@ fun test(a: A, b: B) {
 
         b.(foo)()
 
-        <!INAPPLICABLE_CANDIDATE!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)()<!>
+        <!INAPPLICABLE_CANDIDATE!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)<!>()
 
         foo(b)
         (foo)(b)
@@ -25,7 +25,7 @@ fun test(a: A, b: B) {
 
     with(b) {
         a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.<!INAPPLICABLE_CANDIDATE!>(foo)<!>()
 
         (a.foo)()
 
@@ -50,7 +50,7 @@ class A {
 class B
 
 fun test(a: A, b: B) {
-    b.<!UNRESOLVED_REFERENCE!>(a.foo)()<!>
+    b.<!UNRESOLVED_REFERENCE!>(a.foo)<!>()
     (a.foo)(b)
     a.foo(b)
 
@@ -59,7 +59,7 @@ fun test(a: A, b: B) {
 
         b.(foo)()
 
-        <!UNRESOLVED_REFERENCE!>(b.<!UNRESOLVED_REFERENCE!>foo<!>)()<!>
+        <!UNRESOLVED_REFERENCE!>(b.<!UNRESOLVED_REFERENCE!>foo<!>)<!>()
 
         foo(b)
         (foo)(b)
@@ -67,7 +67,7 @@ fun test(a: A, b: B) {
 
     with(b) {
         a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.<!INAPPLICABLE_CANDIDATE!>(foo)<!>()
 
         (a.foo)()
 
diff --git a/compiler/testData/diagnostics/tests/safeCall.fir.kt b/compiler/testData/diagnostics/tests/safeCall.fir.kt
deleted file mode 100644
index 6e02bc3303b..00000000000
--- a/compiler/testData/diagnostics/tests/safeCall.fir.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-// !WITH_NEW_INFERENCE
-
-fun f(s: String, action: (String.() -> Unit)?) {
-    s.foo().bar().<!UNSAFE_IMPLICIT_INVOKE_CALL!>action<!>()
-}
-
-fun String.foo() = ""
-
-fun String.bar() = ""
-
-// --------------------------------------------------------
-
-val functions: Map<String, () -> Any> = TODO()
-
-fun run(name: String) = <!UNSAFE_IMPLICIT_INVOKE_CALL!>functions[name]()<!>
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/safeCall.kt b/compiler/testData/diagnostics/tests/safeCall.kt
index 66185463af1..3c822ca8f69 100644
--- a/compiler/testData/diagnostics/tests/safeCall.kt
+++ b/compiler/testData/diagnostics/tests/safeCall.kt
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 
 fun f(s: String, action: (String.() -> Unit)?) {
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.fir.kt
index 6f999a9d56c..dd21d05a845 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.fir.kt
@@ -5,7 +5,7 @@ class D : C {
             {
                 val s = ""
                 <!UNRESOLVED_REFERENCE!>s<!>()
-                <!UNRESOLVED_REFERENCE!>""()<!>
+                <!UNRESOLVED_REFERENCE!>""<!>()
                 42
             }())
 
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/implicitSuperCallErrorsIfPrimary.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/implicitSuperCallErrorsIfPrimary.fir.kt
index a91d28edfc5..dabba36c8a7 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/implicitSuperCallErrorsIfPrimary.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/implicitSuperCallErrorsIfPrimary.fir.kt
@@ -2,6 +2,6 @@
 open class A(p1: String)
 
 class B() : A("") {
-    <!INAPPLICABLE_CANDIDATE, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(s: String)<!> {
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(s: String)<!><!INAPPLICABLE_CANDIDATE!><!> {
     }
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/nestedExtendsInner.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/nestedExtendsInner.fir.kt
index c0ca6c46513..478b4d07216 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/nestedExtendsInner.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/nestedExtendsInner.fir.kt
@@ -2,6 +2,6 @@ class A {
     open inner class Inner
 
     class Nested : Inner {
-        <!UNRESOLVED_REFERENCE!>constructor()<!>
+        constructor()<!UNRESOLVED_REFERENCE!><!>
     }
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/reportResolutionErrorOnImplicitOnce.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/reportResolutionErrorOnImplicitOnce.fir.kt
index 6c9596db92b..f2ab1ac6ddf 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/reportResolutionErrorOnImplicitOnce.fir.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/reportResolutionErrorOnImplicitOnce.fir.kt
@@ -2,5 +2,5 @@
 open class A(p1: String, p2: String, p3: String, p4: String, p5: String)
 
 class B : A {
-    <!INAPPLICABLE_CANDIDATE!>constructor(s: String)<!>
+    constructor(s: String)<!INAPPLICABLE_CANDIDATE!><!>
 }
diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt
index 456fc81b1a0..1190f320a02 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.fir.kt
@@ -17,7 +17,7 @@ fun case1() {
 }
 
 class B() {
-    val p: String by <!INAPPLICABLE_CANDIDATE!>Delegate()<!> // DELEGATE_SPECIAL_FUNCTION_MISSING expected
+    val p: String by <!INAPPLICABLE_CANDIDATE!>Delegate<!>() // DELEGATE_SPECIAL_FUNCTION_MISSING expected
 }
 
 class Delegate {
@@ -42,7 +42,7 @@ fun case2() {
 }
 
 class B() {
-    var p: String by <!INAPPLICABLE_CANDIDATE!>Delegate()<!> // DELEGATE_SPECIAL_FUNCTION_MISSING expected
+    var p: String by <!INAPPLICABLE_CANDIDATE!>Delegate<!>() // DELEGATE_SPECIAL_FUNCTION_MISSING expected
 }
 
 class Delegate {
diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.1.fir.kt
index 4db6e3767ce..7df09612c75 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.1.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.1.fir.kt
@@ -17,7 +17,7 @@ operator fun I2.invoke(): String = TODO()
 fun case1(a: A) {
     a.<!AMBIGUITY!>invoke<!>()
     <!AMBIGUITY!>a<!>()
-    <!AMBIGUITY!>A()()<!>
+    <!AMBIGUITY!>A<!>()()
 }
 
 // FILE: TestCase2.kt
@@ -36,7 +36,7 @@ fun case1(a: I) {
     a.<!AMBIGUITY!>invoke<!>()
     <!AMBIGUITY!>a<!>()
 
-    val x  = <!AMBIGUITY!>object : I {} ()<!>
+    val x  = <!AMBIGUITY!>object : I {}<!> ()
 }
 
 // FILE: TestCase3.kt
@@ -56,5 +56,5 @@ fun case1(a: I) {
     a.<!AMBIGUITY!>invoke<!>{}
     <!AMBIGUITY!>a<!>{}
 
-    val x  = <!AMBIGUITY!>object : I {} {}<!>
+    val x  = <!AMBIGUITY!>object : I {}<!> {}
 }
diff --git a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.2.fir.kt
index d29f42599bf..9b65fd3866a 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.2.fir.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.2.fir.kt
@@ -17,7 +17,7 @@ operator fun <R>I2.invoke(): String = TODO()
 fun case1(a: A) {
     a.<!AMBIGUITY!>invoke<!>()
     <!AMBIGUITY!>a<!>()
-    <!AMBIGUITY!>A()()<!>
+    <!AMBIGUITY!>A<!>()()
 }
 
 // FILE: TestCase2.kt
@@ -36,7 +36,7 @@ fun case1(a: I) {
     a.<!AMBIGUITY!>invoke<!>()
     <!AMBIGUITY!>a<!>()
 
-    val x  = <!AMBIGUITY!>object : I {} ()<!>
+    val x  = <!AMBIGUITY!>object : I {}<!> ()
 }
 
 // FILE: TestCase3.kt
@@ -56,5 +56,5 @@ fun case1(a: I) {
     a.<!AMBIGUITY!>invoke<!>{}
     <!AMBIGUITY!>a<!>{}
 
-    val x  = <!AMBIGUITY!>object : I {} {}<!>
+    val x  = <!AMBIGUITY!>object : I {}<!> {}
 }