diff --git a/compiler/fir/analysis-tests/testData/resolve/F.kt b/compiler/fir/analysis-tests/testData/resolve/F.kt
index ea56d48e954..a95e7c700ef 100644
--- a/compiler/fir/analysis-tests/testData/resolve/F.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/F.kt
@@ -1,4 +1,4 @@
 open class A
 
 
-class B : A()
\ No newline at end of file
+class B : A()
diff --git a/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt b/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt
index 2af76b328d1..2fd0590d384 100644
--- a/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt
@@ -6,4 +6,4 @@ typealias TA = A
 
 class B : TA() {
     class NestedInB : Nested()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt b/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt
index ca28a0dc3dd..613c2c4de8c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt
@@ -10,4 +10,4 @@ abstract class My {
 
 class Your : My() {
     class NestedThree : NestedOne()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt b/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt
index 030f50027df..fa5281064a6 100644
--- a/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt
@@ -3,4 +3,4 @@ package p
 
 open class A
 
-class B : A()
\ No newline at end of file
+class B : A()
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt
index ac36f03e9f6..616ba08d947 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!>foo<!>("")
+    b.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>("")<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
index bf5a1904af2..d9ac68a53ae 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!>foo<!>()
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "")
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0, 0.0, false, "")<!>
 
     bar(1, third = true)
     bar(1, 2.0, true)
     bar(1, 2.0, true, "my")
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(1, true)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(1, true)<!>
 
     baz(1)
     baz(1, "my", "yours")
     baz(1, z = true)
 
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(0, "", false)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 6995c3c4d61..af4ff520d6b 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!>bar<!>()
-    a.<!INAPPLICABLE_CANDIDATE!>bar<!>("")
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!>
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>("")<!>
     a.bar(y = 1)
     a.bar("", 2)
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt
index 9ecc8487742..cb6d3aa922c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt
@@ -2,4 +2,4 @@ fun test(
     val f: String.() -> Int = { length }
 ): Int {
     return "".f()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt
index 3d8b49c348c..94e5a0d0a5f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt
@@ -4,4 +4,4 @@ fun test() {
     foo {
         this + it
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
index 0aa726d7740..59b75b27414 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
@@ -17,9 +17,9 @@ fun test_1() {
 }
 
 fun test_2() {
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(10000000000)<!>
     takeLong(10000000000)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1000)<!>
 }
 
 fun test_3() {
@@ -35,8 +35,8 @@ fun test_4() {
 }
 
 fun test_5() {
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
-    <!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(1)<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeString<!>(run { 1 })<!>
 }
 
 annotation class Ann(val x: Byte)
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt
index c9392ab0068..523198288aa 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt
@@ -6,4 +6,4 @@ class My(var x: Int) {
     fun copy() = My(x)
 }
 
-fun testInvoke(): Int = My(13)()
\ No newline at end of file
+fun testInvoke(): Int = My(13)()
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
index 4ead42a36c3..b6916223877 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
@@ -13,6 +13,6 @@ fun takeOutA(array: Array<out A>) {}
 
 fun test(array: Array<B>) {
     A.take(array)
-    <!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeA<!>(array)<!>
     takeOutA(array)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
index d593651712a..99f98ae6f6c 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!>foo<!>(1) {}
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {}
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1) {}<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(f = {}) {}<!>
 
     // OK
     bar(1) {}
@@ -20,15 +20,15 @@ fun test() {
     bar(x = 1, f = {})
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>bar<!> {}
-    <!INAPPLICABLE_CANDIDATE!>bar<!>({})
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!> {}<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>({})<!>
 
     // OK
     baz(other = false, f = {})
     baz({}, false)
 
     // Bad
-    <!INAPPLICABLE_CANDIDATE!>baz<!> {}
-    <!INAPPLICABLE_CANDIDATE!>baz<!>() {}
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(other = false) {}
-}
\ No newline at end of file
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!> {}<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>() {}<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(other = false) {}<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt
index 8b73579af58..4c565c751eb 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt
@@ -20,4 +20,4 @@ fun test(ordinal: Int) {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt
index eb13dc322f5..f98e070fc4a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt
@@ -25,4 +25,4 @@ fun test() {
     val processor = AdapterProcessor<PsiMethod, PsiClass>(
         Function { method: PsiMethod? -> method?.containingClass }
     )
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt
index 26f6d8f3b0d..f867a56997e 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!>myRun<!> {
+    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> {
         val x = 1
         x * 2
-    }
+    }<!>
 }
 
 fun test_2() {
-    <!UNRESOLVED_REFERENCE!>myRun<!> {
+    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>myRun<!> {
         materialize()
-    }
-}
\ No newline at end of file
+    }<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
index 5309319fed2..4e6622f6fcc 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
@@ -31,33 +31,33 @@ fun test_3() {
 fun takeByte(b: Byte) {}
 
 fun test_4() {
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
-    <!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)
+    <!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)<!>
 }
 
 fun test_5() {
     takeByte(-1)
     takeByte(+1)
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeByte<!>(1.inv())<!>
 }
 
 fun test_6() {
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
-    <!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
+    <!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 })<!>
     1 + 1
     run { 1 }
     1 + run { 1 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt
index f8b42bbf33f..dc03b8952a4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt
@@ -14,4 +14,4 @@ fun takeInt(x: Int) {}
 fun test(d: D) {
     val x = d.foo()
     takeInt(x)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt
index bbe5dd311eb..617fad9626b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt
@@ -5,4 +5,4 @@ interface A {
 
 fun test(a: A) {
     a.foo { true }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
index c043e7a8ca1..d669fd5ef8a 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!>foo<!>()
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(0.0, false, 0, "")<!>
     foo(1, 2.0, third = true, "")
-    <!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 = "")
-}
\ No newline at end of file
+    <!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 = "")<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt
index a863ad03614..6f8a2d62b33 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt
@@ -4,4 +4,4 @@ fun foo(s: String) {}
 
 fun test(a: A) {
     foo("$a")
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt
index 0cb52a8116b..48f800e3549 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt
@@ -10,4 +10,4 @@ fun test() {
             foo()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
index f42aee5067d..ecafa19ebb0 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!>foo<!>("")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(1, 2)<!>
 
     bar(1, z = true, y = *arrayOf("my", "yours"))
 
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(0, z = false, y = "", y = "other")
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(0, "", true)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, z = false, y = "", y = "other")<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(0, "", true)<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt
index 5f7aae988c3..f51ce1bd32e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt
@@ -6,4 +6,4 @@ fun foo(vararg arg: Base) {}
 fun bar(base: Array<Base>, sub: Array<Sub>) {
     foo(*base)
     foo(*sub)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt
index ed31f6b10c4..7ee2af2cb3f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt
@@ -28,4 +28,4 @@ fun test_2(a: A<C>) {
 
 fun test_3(a: A<D>) {
     a[0] = D() // set
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt
index 3a96512472a..a1a92464668 100644
--- a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt
@@ -33,4 +33,4 @@ fun test_3(a: A<D>) {
 
 fun test_4(b: B) {
     <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>b[0]<!> += B()<!> // unresolved
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/asImports.kt b/compiler/fir/analysis-tests/testData/resolve/asImports.kt
index cf61f45b05c..33826641a61 100644
--- a/compiler/fir/analysis-tests/testData/resolve/asImports.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/asImports.kt
@@ -11,11 +11,11 @@ class A {
 import foo.A as B
 
 fun test_1() {
-    val a = <!UNRESOLVED_REFERENCE!>A<!>()
+    val a = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!>
     val b = B() // should be OK
-    val c: B = <!UNRESOLVED_REFERENCE!>A<!>()
+    val c: B = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>A<!>()<!>
 }
 
 fun test_2(b: B) {
     b.foo()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt b/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt
index 8eb5d168b34..88229fac48d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt
@@ -2,4 +2,4 @@ abstract class MyStringList : List<String>
 abstract class MyMutableStringList : MutableList<String>
 
 fun List<String>.convert(): MyStringList = this as MyStringList
-fun ret(l: MutableList<String>): MyMutableStringList = l as MyMutableStringList
\ No newline at end of file
+fun ret(l: MutableList<String>): MyMutableStringList = l as MyMutableStringList
diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
index 6989a80856a..8ce85a18c6e 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!>foo<!>("")
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>("")<!>
 
     // Ambiguity
-    <!AMBIGUITY!>bar<!>(c)
+    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>bar<!>(c)<!>
 
     // Unresolved reference
-    <!UNRESOLVED_REFERENCE!>baz<!>()
-}
\ No newline at end of file
+    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt
index 29e27786a03..56aeefc56fd 100644
--- a/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt
@@ -26,4 +26,4 @@ class Outer<E> {
     }
 
     fun bar(i: Inner) {}
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt
index 543f908a55b..c6cc6917af0 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!>bar<!>()
+    { "" }.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>()<!>
     "".bar()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/cast.kt b/compiler/fir/analysis-tests/testData/resolve/cast.kt
index eb1c8be7d0b..25782fdfc86 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cast.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cast.kt
@@ -4,4 +4,4 @@ val y = 2 as Any
 val f = fun() = 3 as Any
 val g = {}
 val h: (String) -> Boolean = { _ -> false }
-val hError = { _ -> true }
\ No newline at end of file
+val hError = { _ -> true }
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt
index 75a77b82182..794013aabe4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt
@@ -13,4 +13,4 @@ fun foo(b: Boolean) {
     bar()
 }
 
-fun bar() {}
\ No newline at end of file
+fun bar() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt
index 7d264eb9f7a..e5ba0f3a228 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt
@@ -45,4 +45,4 @@ fun test_8(b: Boolean) {
     if (true && b) {
         1
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt
index 3da982bef9a..ec9eac70bc4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt
@@ -19,4 +19,4 @@ internal fun AutoCloseable?.closeFinally(cause: Throwable?) = when {
 inline fun <reified T : Any> List<*>.firstIsInstanceOrNull(): T? {
     for (element in this) if (element is T) return element
     return null
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt
index 31a170b91f0..13609cffc29 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt
@@ -9,4 +9,4 @@ fun test_2(x: Int) {
 
 fun test_3(x: Int) {
     when (val y = x) {}
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
index d965d81be19..be90f5a38d6 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!>inc<!>() // Bad
+                y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
                 x as Int
             }
         ),
@@ -39,14 +39,14 @@ fun test_3(x: Any, y: Any) {
     val a = select(
         id(
             run {
-                y.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
+                y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
                 x as Int
                 materialize()
             }
         ),
         run {
             y as Int
-            x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
+            x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>inc<!>() // Bad
+                y.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
                 x as Int
             }
         ),
         y as Int,
         myRun {
-            x.<!UNRESOLVED_REFERENCE!>inc<!>() // Bad
+            x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!> // Bad
             y.inc() // OK
             1
         }
 
     )
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!> // Bad
     takeInt(y) // OK
     takeInt(a) // Bad
 }
@@ -90,4 +90,4 @@ fun test_6() {
             }
         }
     )
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt
index 9b01e0cfee0..53799431123 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt
@@ -11,4 +11,4 @@ class Bar {
         throw Exception()
         val y = 2
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt
index 41ef10d358a..06f6dffba56 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt
@@ -11,4 +11,4 @@ class C(a: A, b: B) {
             C(a, it)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt
index 126031fbd59..a5dc4b78cb6 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt
@@ -15,7 +15,7 @@ fun test_2(x: Int?) {
     } else {
         x
     }
-    y.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 }
 
 fun test_3(x: Int?) {
@@ -50,4 +50,4 @@ fun test_6() {
     run {
         return@run
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt
index f46fd20a6a4..510a2bcdc7a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt
@@ -65,4 +65,4 @@ fun testDoWhileFalse() {
         1
     } while (false)
     1
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt
index 8aaf470465e..302d1b95bf8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt
@@ -6,4 +6,4 @@ class B(val s: String) : A(s.let { { it } }) {
     fun foo() {
         foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt
index 50bb00666ea..ac29eec136d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt
@@ -3,4 +3,4 @@ inline fun foo(vararg x: Any) {}
 
 fun test(a: Any, b: Any, c: Any) {
     foo(a, { "" }, b)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt
index 8f9f0dd5234..31055eb1267 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt
@@ -40,4 +40,4 @@ val x4 = try {
     2
 } finally {
     0
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt
index a8a716d7145..e0d1b079569 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt
@@ -19,4 +19,4 @@ fun test_2() {
 
 fun test_3() {
     val x = run { return }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt
index b15a7ff84a5..b6ad6aa9b12 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt
@@ -5,4 +5,4 @@ fun test() {
     val x = 1
     val y = x + 1
     foo()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt
index 753b04f5373..3fa5da9b4a8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt
@@ -31,4 +31,4 @@ fun test_3(b: Boolean) {
         val y = 2
     }
     val z = 3
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt
index fc052120c6d..fe5b1fcfbb7 100644
--- a/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt
@@ -15,4 +15,4 @@ fun test_2(x: Any?) {
     if (x is A && x is B) {
         x is A
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/companion.kt b/compiler/fir/analysis-tests/testData/resolve/companion.kt
index 4c6c0c970f1..03bcb9c51c7 100644
--- a/compiler/fir/analysis-tests/testData/resolve/companion.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/companion.kt
@@ -14,4 +14,4 @@ abstract class Another {
     }
 
     abstract val x: InCompanion
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt b/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt
index af3ba0912f6..b8ab9e19eed 100644
--- a/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt
@@ -15,4 +15,4 @@ class Derived : Base() {
             val dd: DerivedNested = DerivedNested()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt b/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt
index 57224d8d01f..61f4f92d0dd 100644
--- a/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt
@@ -24,4 +24,4 @@ typealias DDD = C
 
 class CKt : QQQ, DDD {
     constructor(s: String) : super(s)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/copy.kt b/compiler/fir/analysis-tests/testData/resolve/copy.kt
index c4fe1712a7d..1c8e94975c2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/copy.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/copy.kt
@@ -5,4 +5,4 @@ fun test(some: Some) {
     val another = some.copy(x = 123)
     val same = some.copy()
     val different = some.copy(456, "456")
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt
index a343b108e55..15af25df94b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt
@@ -20,4 +20,4 @@ fun foo(element: PsiElement, usages: Array<UsageInfo>) {
     val adjusted = if (element is KtParameter) usages.filterNot {
         it.usage is KtLightMethod
     } else usages.toList()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt b/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt
index 35b8e7b5702..99ab71bd47a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt
@@ -6,4 +6,4 @@ class B : A {
     override fun foo() {}
 }
 
-class C(val b: B) : A by b
\ No newline at end of file
+class C(val b: B) : A by b
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt
index d4cb4c7154c..2d5c01f4b2b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt
@@ -24,4 +24,4 @@ class Test {
 fun test() {
     var x: Boolean by LocalFreezableVar(true)
     var y by LocalFreezableVar("")
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt
index 6f9052fd8a7..d704ff136e5 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt
@@ -13,4 +13,4 @@ class Test {
         val y = getAny() as? String ?: ""
         y
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt
index f2a8127487f..aed7168156c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt
@@ -5,4 +5,4 @@ inline fun <L> runLogged(action: () -> L): L {
 operator fun <V> V.getValue(receiver: Any?, p: Any): V =
     runLogged { this }
 
-val testK by runLogged { "K" }
\ No newline at end of file
+val testK by runLogged { "K" }
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt
index e23ee0e8868..4a046e9ab8b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt
@@ -5,4 +5,4 @@ inline fun <L> runLogged(action: () -> L): L {
 operator fun String.getValue(receiver: Any?, p: Any): String =
     runLogged { this }
 
-val testK by runLogged { "K" }
\ No newline at end of file
+val testK by runLogged { "K" }
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt
index 68c31000880..f493571c259 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt
@@ -16,4 +16,4 @@ fun <T> delegate(value: T): DelegateProvider<T> = DelegateProvider(value)
 
 class A {
     val x by delegate(1)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
index 5d6d63eb1a1..74b8f919ea8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
@@ -10,18 +10,18 @@ open class A3(x: String, y: String = "") {
     constructor(x: String, b: Boolean = true) : this(x, x)
 }
 
-class B3_1 : <!AMBIGUITY!>A3<!>("")
+class B3_1 : <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>A3<!>("")<!>
 class B3_2 : A3("", "asas")
 class B3_3 : A3("", true)
-class B3_4 : <!NONE_APPLICABLE!>A3<!>("", Unit)
+class B3_4 : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>A3<!>("", Unit)<!>
 
 open class A4(val x: Byte)
-class B4 : <!INAPPLICABLE_CANDIDATE!>A4<!>( 1 + 1)
+class B4 : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>A4<!>( 1 + 1)<!>
 
 open class A5 {
     constructor(x: Byte)
     constructor(x: Short)
 }
 
-class B5_1 : <!NONE_APPLICABLE!>A5<!>(1 + 1)
-class B5_2 : <!NONE_APPLICABLE!>A5<!>(100 * 2)
+class B5_1 : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>A5<!>(1 + 1)<!>
+class B5_2 : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>A5<!>(100 * 2)<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt
index 79789e1554b..8d43415b854 100644
--- a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt
@@ -2,4 +2,4 @@ open class Inv<T, R>(x: T, r: R)
 
 typealias Alias<X> = Inv<X, Inv<X, X>>
 
-class InvImpl : Alias<String>("", Inv("", ""))
\ No newline at end of file
+class InvImpl : Alias<String>("", Inv("", ""))
diff --git a/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt b/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt
index 0ef313b2750..1fd145ab255 100644
--- a/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt
@@ -2,4 +2,4 @@ open class Base<T1>(val x: T1)
 
 class Derived<T2 : Any>(x: T2) : Base<T2>(x)
 
-fun <T3 : Any> create(x: T3) /* Derived<T3> */ = Derived(x)
\ No newline at end of file
+fun <T3 : Any> create(x: T3) /* Derived<T3> */ = Derived(x)
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt
index 4c7e16469db..18abcc097c6 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!>f<!>()
+        super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>f<!>()<!>
         super.t()
 
         super.x
@@ -32,7 +32,7 @@ class B : A() {
 
 abstract class J : A() {
     fun r() {
-        super.<!ABSTRACT_SUPER_CALL!>f<!>()
+        super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>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 23e7fc1dfcb..9ad38609849 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!>bar<!>() // should be an error
+    override fun bar(): String = super.<!ABSTRACT_SUPER_CALL{LT}!><!ABSTRACT_SUPER_CALL{PSI}!>bar<!>()<!> // should be an error
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt
index ff628194b16..86984c64a8d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt
@@ -28,4 +28,4 @@ class Class {
     )<!>
 )
 @Ann3(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arr<!>)
-fun test() {}
\ No newline at end of file
+fun test() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt
index 18506224a43..684f7d0029e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt
@@ -8,4 +8,4 @@ val foo = TestEnum.Foo
 var bar = TestEnum.Foo
 
 @Ann(<!ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST!>foo<!>, <!ANNOTATION_ARGUMENT_MUST_BE_ENUM_CONST!>bar<!>)
-fun test() {}
\ No newline at end of file
+fun test() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt
index e04ed99f525..f32955807db 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt
@@ -21,4 +21,4 @@ fun bar() = Foo::class
         <!ANNOTATION_ARGUMENT_MUST_BE_KCLASS_LITERAL!>bar()<!>
     ]
 )
-fun test1() {}
\ No newline at end of file
+fun test1() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt
index 2e12e471c7a..99c7f132257 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt
@@ -1,7 +1,7 @@
 annotation class A() {
-    <!ANNOTATION_CLASS_MEMBER!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(s: Nothing?)<!> {}<!>
+    <!ANNOTATION_CLASS_MEMBER!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(s: Nothing?)<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}<!>
     <!ANNOTATION_CLASS_MEMBER!>init {}<!>
     <!ANNOTATION_CLASS_MEMBER!>fun foo() {}<!>
     <!ANNOTATION_CLASS_MEMBER!>val bar: Nothing?<!>
     <!ANNOTATION_CLASS_MEMBER!>val baz get() = Unit<!>
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt
index f635f85286c..dda522b47e4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt
@@ -14,4 +14,4 @@ fun A.test_2() {
     object : B by b {}
 }
 
-class D(val x: String, val y: String = <!NO_THIS!>this<!>.<!UNRESOLVED_REFERENCE!>x<!>) {}
\ No newline at end of file
+class D(val x: String, val y: String = <!NO_THIS!>this<!>.<!UNRESOLVED_REFERENCE!>x<!>) {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt
index e504994e2c4..10fe8fcbc68 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt
@@ -2,4 +2,4 @@ class A
 
 interface C
 
-enum class B : C, <!CLASS_IN_SUPERTYPE_FOR_ENUM!>A<!>(), Any()
\ No newline at end of file
+enum class B : C, <!CLASS_IN_SUPERTYPE_FOR_ENUM!>A<!>(), Any()
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt
index 18944e0d232..a5e75c40091 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt
@@ -49,7 +49,7 @@ fun lol(a: Array<Boolean>) {}
 <!CONFLICTING_OVERLOADS!>fun <T> mem(t: T) where T : String, T : () -> Boolean {}<!>
 
 class M {
-    companion <!REDECLARATION!>object<!> {}
+    <!REDECLARATION{LT}!>companion <!REDECLARATION{PSI}!>object<!> {}<!>
     <!REDECLARATION!>val Companion = object : Any {}<!>
 }
 
@@ -65,4 +65,4 @@ class mest
 
 fun() {}
 
-private fun() {}
\ No newline at end of file
+private fun() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt
index 44f0ef1703d..fed72540136 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt
@@ -1,7 +1,7 @@
-interface <!CONSTRUCTOR_IN_INTERFACE!>A(val s: String)<!>
+<!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>A(val s: String)<!><!>
 
-interface <!CONSTRUCTOR_IN_INTERFACE!>B constructor(val s: String)<!>
+<!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>B constructor(val s: String)<!><!>
 
 interface C {
-    <!CONSTRUCTOR_IN_INTERFACE!>constructor(val s: String)<!> {}
-}
\ No newline at end of file
+    <!CONSTRUCTOR_IN_INTERFACE{LT}!><!CONSTRUCTOR_IN_INTERFACE{PSI}!>constructor(val s: String)<!> {}<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
index 3e0bcb593bf..6af1dea3d24 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
@@ -2,14 +2,14 @@ class B
 class C
 
 class A() {
-    constructor(a: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>("test") {}
-    constructor(a: String) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(10) {}
+    constructor(a: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>("test")<!> {}
+    constructor(a: String) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(10)<!> {}
 
-    constructor(a: Boolean) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>('\n') {}
-    constructor(a: Char) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(0.0) {}
-    constructor(a: Double) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(false) {}
+    constructor(a: Boolean) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>('\n')<!> {}
+    constructor(a: Char) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(0.0)<!> {}
+    constructor(a: Double) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(false)<!> {}
 
-    constructor(b: B) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3.14159265) {}
+    constructor(b: B) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3.14159265)<!> {}
 
     constructor(c: C) : this() {}
     constructor(a: List<Int>) : this(C()) {}
@@ -17,7 +17,7 @@ class A() {
 
 class D {
     constructor(i: Boolean) {}
-    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3) {}
+    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3)<!> {}
 }
 
 class E<T> {
@@ -25,7 +25,7 @@ class E<T> {
     // selection of the proper constructor
     // but a type mismatch for the first
     // argument
-    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10) {}
+    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>(i, 10)<!> {}
 }
 
 class I<T> {
@@ -33,7 +33,7 @@ class I<T> {
     // selection of the proper constructor
     // but a type mismatch for the first
     // argument
-    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10)
+    constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>(i, 10)<!>
 }
 
 class J<T> {
@@ -42,20 +42,20 @@ class J<T> {
 }
 
 class F(s: String) {
-    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(i: Boolean)<!> {}
-    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>(3) {}
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(i: Boolean)<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}
+    constructor(i: Int) : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>(3)<!> {}
 }
 
 class G(x: Int) {
-    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor()<!> {}
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor()<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!> {}
 }
 
 class H(x: Int) {
-    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor()<!>
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor()<!><!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!>
 }
 
 class K(x: Int) {
-    constructor() : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL!>this<!>() {}
+    constructor() : <!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{LT}!><!CYCLIC_CONSTRUCTOR_DELEGATION_CALL{PSI}!>this<!>()<!> {}
 }
 
 class M {
@@ -63,5 +63,5 @@ class M {
 }
 
 class U : M {
-    <!INAPPLICABLE_CANDIDATE!>constructor()<!>
+    <!INAPPLICABLE_CANDIDATE{PSI}!>constructor()<!><!INAPPLICABLE_CANDIDATE{LT}!><!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt
index 07010f92307..b212a508b3c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt
@@ -6,4 +6,4 @@ interface B : <!DELEGATION_IN_INTERFACE, INTERFACE_WITH_SUPERCLASS!>A<!> by a {
 
 val test = A()
 
-interface C : <!DELEGATION_IN_INTERFACE, INTERFACE_WITH_SUPERCLASS!>A<!> by test
\ No newline at end of file
+interface C : <!DELEGATION_IN_INTERFACE, INTERFACE_WITH_SUPERCLASS!>A<!> by test
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt
index 8ac7aeef381..de3e2fca1f5 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt
@@ -1,6 +1,6 @@
 enum class A {
     A(1), B(2), C("test");
 
-    constructor(x: Int) : <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR!>super<!>()
+    constructor(x: Int) : <!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR{LT}!><!DELEGATION_SUPER_CALL_IN_ENUM_CONSTRUCTOR{PSI}!>super<!>()<!>
     constructor(t: String) : this(10)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt
index 467e4dd41d1..8a943818747 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, NONE_APPLICABLE{PSI}!>constructor()<!><!NONE_APPLICABLE{LT}!><!>
     constructor(z: String) : this()
 }
 
 <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>class C : A(20) {
-    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE!>constructor()<!>
+    <!EXPLICIT_DELEGATION_CALL_REQUIRED, NONE_APPLICABLE{PSI}!>constructor()<!><!NONE_APPLICABLE{LT}!><!>
     constructor(z: String) : this()
 }<!>
 
 class D() : A(20) {
-    <!NONE_APPLICABLE, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(x: Int)<!>
+    <!NONE_APPLICABLE{PSI}, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{PSI}!>constructor(x: Int)<!><!NONE_APPLICABLE{LT}, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED{LT}!><!>
     constructor(z: String) : this()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt
index 4479b9b9485..e5cdcc75457 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt
@@ -35,4 +35,4 @@ fun rest() {
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit var i: Int<!>
     lateinit var a: A
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit var b: B<String> = B()<!>
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt
index f450767bb03..930e025ca9c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt
@@ -28,4 +28,4 @@ private abstract class M : K()
 class X {
     <!INCOMPATIBLE_MODIFIERS!>inner<!> <!INCOMPATIBLE_MODIFIERS!>data<!> class Y(val i: Int)
     <!INCOMPATIBLE_MODIFIERS!>sealed<!> <!INCOMPATIBLE_MODIFIERS!>inner<!> class Z
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
index bd69a862cac..5af0cecc5ce 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!>getSomeInt<!>(), other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {}
+    constructor(x: Int = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSomeInt<!>()<!>, other: A = <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>, header: String = <!UNRESOLVED_REFERENCE!>keker<!>) {}
     fun getSomeInt() = 10
     var keker = "test"
 }
@@ -7,10 +7,10 @@ class A {
 class B(other: B = <!NO_THIS!>this<!>)
 
 class C() {
-    constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>({
+    constructor(x: Int) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>this<!>({
         val a = 10
         <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
-    }) {}
+    })<!> {}
 }
 
 class D {
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt
index 718ea6c5312..8142f7c3420 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt
@@ -5,4 +5,4 @@ interface B : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A
 interface C
 class D
 
-interface E : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A<!>(), C, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>D<!>()
\ No newline at end of file
+interface E : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A<!>(), C, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>D<!>()
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt
index 9ee1d8fe997..ac1d02a2347 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt
@@ -2,7 +2,7 @@ fun foo() {
     <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Ann<!>
 
     @Ann class Local {
-        // There should also be NESTED_CLASS_NOT_ALLOWED report here.
-        <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Nested<!>
+        <!LOCAL_ANNOTATION_CLASS_ERROR{LT}!>// There should also be NESTED_CLASS_NOT_ALLOWED report here.
+        <!LOCAL_ANNOTATION_CLASS_ERROR{PSI}!>annotation class Nested<!><!>
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt
index 064c23e4eae..93261d8df5c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt
@@ -6,19 +6,19 @@ object A {
     interface X
 
     val a = object : Any() {
-        <!LOCAL_OBJECT_NOT_ALLOWED!>object D<!> {
+        <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object D<!> {
             <!LOCAL_OBJECT_NOT_ALLOWED!>object G<!>
             <!LOCAL_INTERFACE_NOT_ALLOWED!>interface Z<!>
-        }
+        }<!>
 
         <!LOCAL_INTERFACE_NOT_ALLOWED!>interface Y<!>
     }
 
     fun b() {
-        <!LOCAL_OBJECT_NOT_ALLOWED!>object E<!> {
+        <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object E<!> {
             <!LOCAL_OBJECT_NOT_ALLOWED!>object F<!>
             <!LOCAL_INTERFACE_NOT_ALLOWED!>interface M<!>
-        }
+        }<!>
 
         <!LOCAL_INTERFACE_NOT_ALLOWED!>interface N<!>
 
@@ -28,4 +28,4 @@ object A {
             <!LOCAL_INTERFACE_NOT_ALLOWED!>interface U<!>
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt
index 165d3911fc2..0b81df7cd10 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt
@@ -1,11 +1,11 @@
 class A {
-    companion <!REDECLARATION!>object<!> {
+    <!REDECLARATION{LT}!>companion <!REDECLARATION{PSI}!>object<!> {
 
-    }
+    }<!>
 
-    companion <!MANY_COMPANION_OBJECTS, REDECLARATION!>object<!> {
+    <!MANY_COMPANION_OBJECTS{LT}, REDECLARATION{LT}!>companion <!MANY_COMPANION_OBJECTS{PSI}, REDECLARATION{PSI}!>object<!> {
 
-    }
+    }<!>
 }
 
 class B {
@@ -13,7 +13,7 @@ class B {
 
     }
 
-    companion <!MANY_COMPANION_OBJECTS!>object B<!> {
+    <!MANY_COMPANION_OBJECTS{LT}!>companion <!MANY_COMPANION_OBJECTS{PSI}!>object B<!> {
 
-    }
-}
\ No newline at end of file
+    }<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt
index 44051de762b..411419ce10c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt
@@ -22,4 +22,4 @@ interface D {
     override operator fun toString(): String
     override operator fun equals(other: Any?): Boolean
     override operator fun hashCode(): Int
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt
index ed82693076a..ae88b8599f9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt
@@ -10,4 +10,4 @@ const val cnst = 2
         <!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>foo + cnst.toString()<!>
     )<!>
 )
-fun test() {}
\ No newline at end of file
+fun test() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt
index 014517dd296..4e8a13c2ee7 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!>f<!>()
+        <!NOT_A_SUPERTYPE!>super<String><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>f<!>()<!>
         super<A>.f()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt
index 74cf32556d9..b2792655a77 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt
@@ -6,4 +6,4 @@ data class A {}
 
 <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>data class C {
     constructor(x: Int)
-}<!>
\ No newline at end of file
+}<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
index 1ad1c48926d..5c5c24fb52e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
@@ -26,7 +26,7 @@ class G<E : Double>(val balue: E) : F<E>(balue) {
     override var rest: E = balue
 }
 
-class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
+class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>F<E><!>(balue)<!> {
     override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt
index 946667303a7..81edcb0ef35 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt
@@ -31,4 +31,4 @@ class Test2 : IDerived<String>, AliasedIBase {
         super<IDerived>.bar()
         super<IDerived>.qux()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt
index 184d9b91e71..79f48016693 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt
@@ -1,2 +1,2 @@
 <!REDUNDANT_MODIFIER!>open<!> abstract class A
-<!REDUNDANT_MODIFIER!>abstract<!> sealed class B
\ No newline at end of file
+<!REDUNDANT_MODIFIER!>abstract<!> sealed class B
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt
index 6095c967cc3..adbb0b1c8a3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt
@@ -14,4 +14,4 @@ enum <!REPEATED_MODIFIER!>enum<!> class C {
 
 open class E(private <!REPEATED_MODIFIER!>private<!> val int: Int = 5) {
     protected <!REPEATED_MODIFIER!>protected<!> var double = int + 8.0
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
index d5d6c933864..12775ff02b0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
@@ -27,7 +27,7 @@ class G<E : Double>(val balue: E) : F<E>(balue) {
     override fun rest(): E = balue
 }
 
-class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
+class H<E : String>(val balue: E) : <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>F<E><!>(balue)<!> {
     override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE
 }
 
@@ -66,4 +66,4 @@ open class GoodDerrived : Base<Y, W>() {
 
 open class BadDerrived : Base<Y, W>() {
     override fun kek(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>String<!> = "test"
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt
index ff7559e24dc..ae002614d51 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 = <!SEALED_CLASS_CONSTRUCTOR_CALL!>A<!>()
\ No newline at end of file
+val b = <!SEALED_CLASS_CONSTRUCTOR_CALL{LT}!><!SEALED_CLASS_CONSTRUCTOR_CALL{PSI}!>A<!>()<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt
index 4bbe7624aa3..63562f91132 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt
@@ -28,13 +28,13 @@ sealed class P {
 
 class K : P()
 
-<!REDECLARATION!>object B<!> {
+<!REDECLARATION{LT}!><!REDECLARATION{PSI}!>object B<!> {
     class I : <!SEALED_SUPERTYPE!>P<!>()
-}
+}<!>
 
 fun test() {
     class L : <!SEALED_SUPERTYPE_IN_LOCAL_CLASS!>P<!>()
     val a = object : <!SEALED_SUPERTYPE_IN_LOCAL_CLASS!>P<!>() {
 
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt
index 3b434d4f2f4..17772e48f74 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt
@@ -9,4 +9,4 @@ class C(a: A) : B(a) {
         // Should be resolved to delegated B.foo (no error)
         super.foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt
index d47496e516f..ad4f40fa5f2 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!>invoke<!>()
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>invoke<!>()<!>
 
         <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> {
             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 d3767bc0fa7..1ca40411257 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!>compareTo<!>("")
-    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
+    <!SUPER_NOT_AVAILABLE!>super@f<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
+    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>compareTo<!>("")<!>
 }
 
 fun foo() {
     <!SUPER_NOT_AVAILABLE!>super<!>
-    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
-    <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+    <!SUPER_NOT_AVAILABLE!>super<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    <!SUPER_NOT_AVAILABLE!>super<Nothing><!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
 }
 
 class A {
     fun act() {
-        <!UNRESOLVED_REFERENCE!>println<!>("Test")
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Test")<!>
     }
 
     fun String.fact() {
-        <!UNRESOLVED_REFERENCE!>println<!>("Fest")
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Fest")<!>
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt
index 602afe19d25..f18b3dfb777 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt
@@ -6,4 +6,4 @@ interface ATrait : <!INTERFACE_WITH_SUPERCLASS!>A<!> {
     override fun foo() {
         <!SUPERCLASS_NOT_ACCESSIBLE_FROM_INTERFACE!>super<A><!>.foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt
index c0c3ad4c722..2b50b9f867d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt
@@ -10,4 +10,4 @@ interface E : <!INTERFACE_WITH_SUPERCLASS, SUPERTYPE_INITIALIZED_IN_INTERFACE!>A
 
 interface F : A, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>B<!>(), <!INTERFACE_WITH_SUPERCLASS!>C<!>, <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>D<!>(), <!SUPERTYPE_INITIALIZED_IN_INTERFACE!>Any<!>() {
 
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt
index 30d66077a9b..40a8a7036d4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt
@@ -8,4 +8,4 @@ class F() : C(10)
 
 <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>class G : C(10) {
     constructor() : super(1)
-}<!>
\ No newline at end of file
+}<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt
index 20fc13b1970..2c91b6ebf20 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt
@@ -19,4 +19,4 @@ package simulation
 )
 class KotlinImporterComponent {
     class State(var directories: List<String> = ArrayList())
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
index 2763a3e4dd2..c01d19b07bc 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt
@@ -17,11 +17,11 @@ object Best {
 
 }
 
-val a = <!TYPE_ARGUMENTS_NOT_ALLOWED!>rest<Int><!>.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
-val b = Best.<!UNRESOLVED_REFERENCE!>MyClass<!><String>
+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><!>
 
 class B<E>
-class C<F<!SYNTAX!><<!><!SYNTAX!>Boolean<!><!SYNTAX!>><!><!SYNTAX!>><!> <!SYNTAX!>:<!> <!SYNTAX!>B<!><!SYNTAX!><<!><!SYNTAX!>F<!><!SYNTAX!><<!><!SYNTAX!>Boolean<!><!SYNTAX!>><!><!SYNTAX!>><!><!SYNTAX!>(<!><!SYNTAX!>)<!>
+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}!>)<!>
 
 fun <G> gest() {}
 
@@ -31,4 +31,4 @@ fun <T> fest() {
     gest<T>()
     val c: List<List<List<<!TYPE_ARGUMENTS_NOT_ALLOWED!>T<String><!>>>>
     gest<List<List<<!TYPE_ARGUMENTS_NOT_ALLOWED!>T<Boolean><!>>>>()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt
index 75dc16cd3dc..85691a21134 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt
@@ -20,4 +20,4 @@ annotation class Ann2(
     val p4: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Array<Int>?<!>,
     val p5: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Ann1?<!>,
     val p6: <!NULLABLE_TYPE_OF_ANNOTATION_MEMBER!>Enum?<!>
-)
\ No newline at end of file
+)
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt
index 9d9a934ae47..355cca493c3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt
@@ -1,3 +1,3 @@
 enum class A<<!TYPE_PARAMETERS_IN_ENUM!>B<!>, C : B, D>
 
-enum class B
\ No newline at end of file
+enum class B
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt
index b2600d87a4f..53e38a047bc 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt
@@ -1,15 +1,15 @@
-<!TYPE_PARAMETERS_IN_OBJECT!>object A<!><T, K : T> {
-    <!TYPE_PARAMETERS_IN_OBJECT!>object B<!><L>
-}
+<!TYPE_PARAMETERS_IN_OBJECT{LT}!><!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object A<!><T, K : T> {
+    <!TYPE_PARAMETERS_IN_OBJECT{LT}!><!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object B<!><L><!>
+}<!>
 
 class N {
-    companion <!TYPE_PARAMETERS_IN_OBJECT!>object<!><T> {
+    <!TYPE_PARAMETERS_IN_OBJECT{LT}!>companion <!TYPE_PARAMETERS_IN_OBJECT{PSI}!>object<!><T> {
 
-    }
+    }<!>
 }
 
 fun test() {
-    <!LOCAL_OBJECT_NOT_ALLOWED, TYPE_PARAMETERS_IN_OBJECT!>object M<!><H> {
+    <!LOCAL_OBJECT_NOT_ALLOWED{LT}, TYPE_PARAMETERS_IN_OBJECT{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}, TYPE_PARAMETERS_IN_OBJECT{PSI}!>object M<!><H> {
 
-    }
-}
\ No newline at end of file
+    }<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
index b4fd2d58a74..d1596c5afda 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!>NumberPhile<!>("Test")
+val np2 = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>NumberPhile<!>("Test")<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt
index 7cc5b967fa4..03c8a353964 100644
--- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt
@@ -1,4 +1,4 @@
 annotation class A(
-    <!VAR_ANNOTATION_PARAMETER!>var<!> a: Int,
+    <!VAR_ANNOTATION_PARAMETER{LT}!><!VAR_ANNOTATION_PARAMETER{PSI}!>var<!> a: Int<!>,
     <!MISSING_VAL_ON_ANNOTATION_PARAMETER!>b: String<!>
-)
\ No newline at end of file
+)
diff --git a/compiler/fir/analysis-tests/testData/resolve/enum.kt b/compiler/fir/analysis-tests/testData/resolve/enum.kt
index ff83577c41e..300bdf1464a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/enum.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/enum.kt
@@ -34,4 +34,4 @@ enum class EnumClass {
 
     abstract fun foo(): Int
     abstract val bar: String
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt
index 19010ea6a55..b2fb14b0bf3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt
@@ -35,4 +35,4 @@ fun test_3() {
         SomeEnum.A2 -> B()
     }
     takeB(b) // should be OK
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt
index 1c7013b0ba0..ca517f63c3d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt
@@ -22,4 +22,4 @@ fun test_2(b: Boolean?) {
         false -> 2
         null -> 3
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt
index da4c4b24aa6..c502f35e046 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt
@@ -53,4 +53,4 @@ fun test_3(e: Enum) {
         Enum.A, Enum.B -> 1
         Enum.C -> 2
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt
index 7e428a3fb2e..ab00bc6dab8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt
@@ -10,13 +10,13 @@ fun test_1(e: JavaEnum) {
     val a = when (e) {
         JavaEnum.A -> 1
         JavaEnum.B -> 2
-    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
 
     val b = when (e) {
         JavaEnum.A -> 1
         JavaEnum.B -> 2
         is String -> 3
-    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>plus<!>(0)
+    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
 
     val a = when (e) {
         JavaEnum.A -> 1
@@ -57,4 +57,4 @@ fun test_3(e: JavaEnum) {
         JavaEnum.A, JavaEnum.B -> 1
         JavaEnum.C -> 2
     }.plus(0)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt
index 8ab05066465..78547c73258 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt
@@ -57,4 +57,4 @@ fun test_3(e: Base) {
         is Base.A, is Base.A.B -> 1
         is C -> 2
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt
index c3752fb9187..fcf93835019 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt
@@ -21,4 +21,4 @@ fun test_2(a: A) {
         C -> ""
     }
     takeString(s)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt
index 8633767fdfc..523b7eca50a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt
@@ -35,20 +35,20 @@ fun test_2(e: A) {
     val a = when (e) {
         is D -> 1
         is E -> 2
-    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
 
     val b = when (e) {
         is B -> 1
         is D -> 2
         is E -> 3
-    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
 
     val c = when (e) {
         is B -> 1
         is D -> 2
-    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
 
     val d = when (e) {
         is C -> 1
-    }.<!UNRESOLVED_REFERENCE!>plus<!>(0)
+    }.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>plus<!>(0)<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
index 1843aa9905b..7fa0c9cc927 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!>getResolvedCallWithAssert<!>(codegen.<!UNRESOLVED_REFERENCE!>bindingContext<!>)
-    private val isInverted = operatorReference.<!UNRESOLVED_REFERENCE!>getReferencedNameElementType<!>() == <!UNRESOLVED_REFERENCE!>KtTokens<!>.<!UNRESOLVED_REFERENCE!>NOT_IN<!>
+    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<!>
 
     override fun generate(argument: StackValue): BranchedValue =
-        gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE!>Invert<!>(it) else it }
+        gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Invert<!>(it)<!> else it }
 
     private fun gen(argument: StackValue): BranchedValue =
-        object : <!INAPPLICABLE_CANDIDATE!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!>) {
+        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!>coerceTo<!>(type, kotlinType, v)
+                <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>coerceTo<!>(type, kotlinType, v)<!>
             }
 
             override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) {
                 invokeFunction(v)
-                v.<!UNRESOLVED_REFERENCE!>visitJumpInsn<!>(if (jumpIfFalse) <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFEQ<!> else <!UNRESOLVED_REFERENCE!>Opcodes<!>.<!UNRESOLVED_REFERENCE!>IFNE<!>, jumpLabel)
+                v.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>invokeFunction<!>(resolvedCall.<!UNRESOLVED_REFERENCE!>call<!>, resolvedCall, <!UNRESOLVED_REFERENCE!>none<!>())
-                result.<!UNRESOLVED_REFERENCE!>put<!>(result.<!UNRESOLVED_REFERENCE!>type<!>, result.<!UNRESOLVED_REFERENCE!>kotlinType<!>, v)
+                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)<!>
             }
         }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
index 43487deca83..88236e7ebc8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt
@@ -21,7 +21,7 @@ class Bar {
     }
 
     // NB! abc() here is resolved to member Foo.abc(), and not to extension member of Bar
-    fun Foo.check() = abc() <!NONE_APPLICABLE!>+<!> bar()
+    fun Foo.check() = <!NONE_APPLICABLE{LT}!>abc() <!NONE_APPLICABLE{PSI}!>+<!> bar()<!>
 
     // NB! + here is resolved to member String.plus (not to extension member above)
     fun Foo.check2() = "" + bar()
@@ -43,7 +43,7 @@ fun f() {
     val d = ""
     val c = <!UNRESOLVED_REFERENCE!>c<!>
 
-    <!UNRESOLVED_REFERENCE!>abc<!>()
+    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>abc<!>()<!>
 
     fun bcd() {}
 
@@ -57,7 +57,7 @@ fun f() {
         dcb()
     }
 
-    <!UNRESOLVED_REFERENCE!>dcb<!>()
+    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>dcb<!>()<!>
 
     abc()
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt
index 4c6a3a5c7b7..9bdb75ab1c0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt
@@ -3,4 +3,4 @@
 
 const val x = 42
 
-annotation class Some(val value: Int)
\ No newline at end of file
+annotation class Some(val value: Int)
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt
index 4f4d9b5dc1e..d0e10bef1e9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt
@@ -16,4 +16,4 @@ fun foo() {
     } catch (t: Throwable) {
         0
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt
index e4fb0a8d56c..cbc2599b9f9 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!>bar<!>()
-    val errBarViaAA = AA.<!UNRESOLVED_REFERENCE!>bar<!>()
-}
\ No newline at end of file
+    val errBarViaBB = BB.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+    val errBarViaAA = AA.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt
index 862f3f6f243..05dd484ed41 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt
@@ -13,4 +13,4 @@ fun foo() {
     val ra = bar(a)
     val rb = bar(b)
     val rc = bar(c)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt
index 3f73c6112e9..014b17a2021 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt
@@ -7,4 +7,4 @@ class Factory {
         val f = Function
         val x = Function.Default
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt
index 8bc9fa378a3..f58c33c8511 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt
@@ -23,4 +23,4 @@ fun test() {
     val x = A.D
     val y = B.C
     val z = B.<!UNRESOLVED_REFERENCE!>D<!>
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt
index 331a2640158..7a1b6473417 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt
@@ -6,4 +6,4 @@ class My {
     fun test() {
         foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt
index e7b117928a4..fe22f0b1048 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt
@@ -4,4 +4,4 @@ class C {
 }
 
 fun foo() = C()
-fun bar() = foo().create()
\ No newline at end of file
+fun bar() = foo().create()
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt
index 3a7fd610c2f..1c5a715977e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt
@@ -7,4 +7,4 @@
      lateinit var delegate: Base
 
      fun check() = delegate.check() // Should not resolve
- }
\ No newline at end of file
+ }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
index 8adb7774b67..e20e2c8f8e4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
@@ -18,5 +18,5 @@ fun test() {
     useEnum(TestEnum.THIRD)
 
     useVararg(TestEnum.FIRST, TestEnum.SECOND)
-    <!INAPPLICABLE_CANDIDATE!>useVararg<!>(1, 2, 3, 4, 5)
-}
\ No newline at end of file
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>useVararg<!>(1, 2, 3, 4, 5)<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt
index 73fa12fc982..c82ce6a6a40 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt
@@ -15,4 +15,4 @@ fun foo() {
 
     val first = MyEnum.valueOf("FIRST")
     val last = MyEnum.valueOf("LAST")
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt
index 4ac3e2c8aa0..b637a3cbbaf 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt
@@ -10,4 +10,4 @@ class My {
 
 fun Your.foo() {
     val x = <!UNRESOLVED_REFERENCE!>::Nested<!> // Still should be error
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt
index 198eb9cbab5..739558408e4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt
@@ -11,4 +11,4 @@ fun use(f: () -> String) {}
 fun test1() {
     use { C("abc").y }
     use(C("abc")::y)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt
index 98958c167f4..4bfa21deb37 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt
@@ -16,4 +16,4 @@ public abstract class Decorator<T extends LookupElement> extends LookupElement {
 
 class MyDecorator : Decorator<LookupElement> {
     override fun getLookupString(): String = delegate.lookupString
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt
index 1c089007e2b..4f8e72981ba 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt
@@ -38,4 +38,4 @@ fun <D : Descriptor> test(call: Call<D>, resolvedCall: ResolvedCall<D>) {
 fun otherTest(call: Call<*>, resolvedCall: ResolvedCall<*>) {
     call.resultingDescriptor.name
     resolvedCall.resultingDescriptor.name
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt
index 9a1cfd6472b..607833a6d85 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt
@@ -4,4 +4,4 @@ abstract class Base<T>(val x: T) {
 
 class Derived<T>(x: T) : Base<T>(x) {
     override fun foo(): T = x
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt
index eac7488d220..6e3687fef46 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt
@@ -6,4 +6,4 @@ fun test(arg: Generic<String>) {
     val value = arg.value
     val foo = arg.foo()
     val length = foo.length + value.length
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt
index 6b4bae77c7d..74f1a947dba 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt
@@ -28,4 +28,4 @@ fun test() {
     true.gau()
     wat()
     false.watwat()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt
index 5a54aba8bd7..aa5b3c0cb4d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt
@@ -5,4 +5,4 @@ fun main() {
     val a = id("string")
     val b = id(null)
     val c = id(id(a))
-}
\ No newline at end of file
+}
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 e73ddbe3285..ad6516e7254 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt
@@ -7,5 +7,5 @@ fun <T : Foo> foo(t: T) = t
 
 fun main(fooImpl: FooImpl, bar: Bar) {
     val a = foo(fooImpl)
-    val b = <!INAPPLICABLE_CANDIDATE!>foo<!>(bar)
-}
\ No newline at end of file
+    val b = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 931964e572c..a44c5a04324 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt
@@ -6,6 +6,6 @@ fun <T : Foo> foo(t: T) = t
 
 
 fun main(fooImpl: FooImpl, fooBarImpl: FooBarImpl) {
-    val a = <!INAPPLICABLE_CANDIDATE!>foo<!><FooImpl>(fooBarImpl)
+    val a = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!><FooImpl>(fooBarImpl)<!>
     val b = foo<Foo>(fooImpl)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt
index ccb941f6afa..4a642b8b735 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt
@@ -3,4 +3,4 @@ class Outer {
 }
 
 val x = Outer.Inner
-val klass = Outer.Inner::class
\ No newline at end of file
+val klass = Outer.Inner::class
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt
index a5ba70cba68..350fb2479e7 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt
@@ -10,4 +10,4 @@ class Outer {
     inner class Inner : Base() {
         val c = codegen
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt
index 2c1c336f3d3..b1054a23a14 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt
@@ -1,3 +1,3 @@
 fun String.k(): () -> String = { -> this }
 
-fun test() = "hello".k()()
\ No newline at end of file
+fun test() = "hello".k()()
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt
index 5d11ba36d9c..b883f8a2b02 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt
@@ -22,4 +22,4 @@ class Bar {
     fun baz() {
         x() // Should resolve to fun x()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt
index d45f7fd022c..501707e377a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt
@@ -16,4 +16,4 @@ class Foo {
     val x: Bar = Bar()
 
     fun bar() = x() // Should resolve to invoke (1)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt
index ebe97fbd7af..72f1f3a9072 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt
@@ -8,4 +8,4 @@ class Foo {
     val x = 0
 
     fun foo() = x() // should resolve to invoke
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt
index a983627d6a8..b969d1f9984 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt
@@ -7,4 +7,4 @@ class Y {
         val x = X
         x.op()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt
index 5518db20fad..928cbaf7235 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt
@@ -9,4 +9,4 @@ class Foo {
     val x = 0
 
     fun foo() = x() // should resolve to fun x
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt
index 81e849c5254..713e35a3dda 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt
@@ -7,4 +7,4 @@ class A {
 
 fun create() = A()
 
-val foo = create()
\ No newline at end of file
+val foo = create()
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt
index 363c262ad17..27d60c91a8f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt
@@ -1,4 +1,4 @@
 fun test(e: Int.() -> String) {
     val s = 3.e()
     val ss = 3.(e)()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt
index 26d938dd8d8..7c2478fbae3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt
@@ -7,4 +7,4 @@ fun sss() {
     // Should be resolved to top-level some,
     // because with local some invoke isn't applicable
     some()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt
index f49645188e6..bb1e61c9a92 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt
@@ -1,3 +1,3 @@
 class Bar(name: () -> String) {
     val name = name()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt
index e9d5bb869a8..a149327774a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt
@@ -7,4 +7,4 @@ fun test(a: A) {
     }
     val c = a.y
     val d = "".c()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt
index 187ebd5f683..3e33715adf4 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt
@@ -4,4 +4,4 @@ class Simple {
 
 fun test(s: Simple) {
     val result = s()
-}
\ No newline at end of file
+}
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 e5081adbb98..50171203e9a 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!>foobar<!>()
+        buz.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foobar<!>()<!>
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt
index 5435fe4042c..ef830e069ec 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt
@@ -10,4 +10,4 @@ public class JavaClass {
 fun test() {
     val staticReference = JavaClass::staticField
     val nonStaticReference = JavaClass::nonStaticField
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt
index d38dbf0d514..737e97a3f13 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt
@@ -38,4 +38,4 @@ fun test_4() {
         this.inc()
         it.length
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt
index a5c288b6127..10978ba49c7 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt
@@ -8,4 +8,4 @@ class Outer {
     }
 
     val y = ""
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt
index 2844400f9f0..3563f42d167 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt
@@ -2,4 +2,4 @@ fun test() {
     class Local
 
     val l = Local()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt
index fbb385a688f..0c33cadb7f2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt
@@ -3,4 +3,4 @@
          fun Foo.bar() {}
          bar()
      }
- }
\ No newline at end of file
+ }
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt
index 5d937d62e08..1f41ad9eb6f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt
@@ -4,4 +4,4 @@ fun foo() {
         fun abc() = 1
     }
     val g = x.sss()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt
index 05d0b6813c8..f0e9415d985 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt
@@ -8,4 +8,4 @@ fun bar() {
 
         inner class Derived(val x: Int) : Foo
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
index a90af6e1282..f82f0ba51de 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt
@@ -12,10 +12,10 @@ fun test() {
     }
     b.foo()
 
-    <!LOCAL_OBJECT_NOT_ALLOWED!>object B<!> {
+    <!LOCAL_OBJECT_NOT_ALLOWED{LT}!><!LOCAL_OBJECT_NOT_ALLOWED{PSI}!>object B<!> {
         fun foo() {}
-    }
+    }<!>
     B.foo()
 }
 
-val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE!>foo<!>()
+val bb = <!UNRESOLVED_REFERENCE!>B<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt
index 568c3628cc5..d73e41b378a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt
@@ -25,4 +25,4 @@ fun test() {
     derived.gau()
     derived.baz()
     derived.foo()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt
index 725ceddcf86..ee7b0351efe 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt
@@ -11,4 +11,4 @@ fun foo() {
         val Boolean.w: Char get() = ' '
         fun <T : Foo> id(arg: T): T = arg
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt
index f3b9673fcce..510b26194aa 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt
@@ -20,4 +20,4 @@ fun foo(): Boolean {
 
     val some = true
     return !some
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt
index 9b4f207b9d9..8642f8fbb11 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt
@@ -12,4 +12,4 @@ class Bar {
     fun bar(arg: Foo) {
         arg.foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt
index 6cb0aa1b602..d6981017de0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt
@@ -5,4 +5,4 @@ class A {
         val x = ::Nested
         val y = A::Nested
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt
index 139732c1e6d..9708e898074 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt
@@ -7,4 +7,4 @@ object A {
 object B
 
 val err = B.<!UNRESOLVED_REFERENCE!>A<!>.<!UNRESOLVED_REFERENCE!>B<!>
-val correct = A.B.A
\ No newline at end of file
+val correct = A.B.A
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt
index 73ed9de9800..960d7239e02 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!>PrivateNested<!>()
-        super.<!HIDDEN!>PrivateInner<!>()
+        Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
+        super.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
 
         Outer.ProtectedNested()
         super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
 }
 
 fun foo() {
-    Outer.<!HIDDEN!>PrivateNested<!>()
-    Outer().<!HIDDEN!>PrivateInner<!>()
+    Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateNested<!>()<!>
+    Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>PrivateInner<!>()<!>
 
-    Outer.<!HIDDEN!>ProtectedNested<!>()
-    Outer().<!HIDDEN!>ProtectedInner<!>()
+    Outer.<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedNested<!>()<!>
+    Outer().<!HIDDEN{LT}!><!HIDDEN{PSI}!>ProtectedInner<!>()<!>
 
     Outer.PublicNested()
     Outer().PublicInner()
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt
index 9462e12290d..20af0363ac0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt
@@ -9,4 +9,4 @@ object Derived : Base
 fun test() {
     // See KT-35730
     foo() // Derived.foo is more correct here
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt
index 0926d75e203..97345c4f1ee 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt
@@ -3,4 +3,4 @@ object A {
 }
 
 fun use() = A
-fun bar() = A.foo()
\ No newline at end of file
+fun bar() = A.foo()
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt
index 10a0bb25702..87197a0c125 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt
@@ -11,4 +11,4 @@ fun test_1() {
 fun test_2() {
     var f = Foo()
     f += Foo()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt
index c89e1843cd2..10dd9c63aab 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt
@@ -6,4 +6,4 @@ class Foo {
 fun test() {
     var f = Foo()
     <!ASSIGN_OPERATOR_AMBIGUITY!>f += f<!>
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt
index b2084548df9..235e861ef18 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt
@@ -7,7 +7,7 @@ class Foo {
 
 fun test_1() {
     val f = Foo()
-    f <!UNRESOLVED_REFERENCE!>+<!> f
+    <!UNRESOLVED_REFERENCE{LT}!>f <!UNRESOLVED_REFERENCE{PSI}!>+<!> f<!>
 }
 
 fun test_2() {
@@ -19,4 +19,4 @@ fun test_3(f: Foo) {
     f += f
     f += ""
     f += 1
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt
index 4ada07d50e5..19e65397ac2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt
@@ -42,4 +42,4 @@ class Generator(val codegen: Any) {
                 val cc = codegen.hashCode()
             }
         }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt
index f950fbe0355..4a60595acfa 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt
@@ -16,4 +16,4 @@ fun test() {
     val d = Derived()
     val res1 = d.something // Should be Ok
     val res2 = d.getSomething() // Should be Ok
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt
index 9cd32f8032f..67188d0d0fe 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt
@@ -10,4 +10,4 @@ class C {
     }
 
     val w = z.foo() // ERROR!
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt
index a7a9a682290..54a9235fef8 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!>foo<!>() // hidden
+        NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
     }
 
     inner class Inner {
         fun foo() {
             bar()
             fromCompanion()
-            NotCompanion.<!HIDDEN!>foo<!>() // hidden
+            NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
         }
     }
 
     private class Nested {
         fun foo() {
             fromCompanion()
-            NotCompanion.<!HIDDEN!>foo<!>() // hidden
+            NotCompanion.<!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
         }
     }
 
@@ -54,7 +54,7 @@ fun withLocals() {
 
     Local().baz()
 
-    Local().<!HIDDEN!>bar<!>() // hidden
+    Local().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
 }
 
 fun test() {
@@ -62,14 +62,14 @@ fun test() {
     Private().baz()
     Private().Inner()
 
-    Private().<!HIDDEN!>bar<!>() // hidden
-    Private.<!HIDDEN!>Nested<!>() // hidden
-    Private.<!HIDDEN!>fromCompanion<!>() // hidden
+    Private().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
+    Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden
+    Private.<!HIDDEN{LT}!><!HIDDEN{PSI}!>fromCompanion<!>()<!> // hidden
 }
 
 // FILE: second.kt
 
 fun secondTest() {
-    <!HIDDEN!>foo<!>() // hidden
-    <!HIDDEN!>Private<!>() // hidden
+    <!HIDDEN{LT}!><!HIDDEN{PSI}!>foo<!>()<!> // hidden
+    <!HIDDEN{LT}!><!HIDDEN{PSI}!>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 f27cce779d2..537f0fd2009 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!>bar<!>() // hidden
+        Nested().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
 
         fromCompanion()
         protectedFromCompanion()
@@ -48,8 +48,8 @@ fun test() {
     Protected().baz()
     Protected().Inner()
 
-    Protected().<!HIDDEN!>bar<!>() // hidden
-    Protected.<!HIDDEN!>Nested<!>() // hidden
+    Protected().<!HIDDEN{LT}!><!HIDDEN{PSI}!>bar<!>()<!> // hidden
+    Protected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>Nested<!>()<!> // hidden
 }
 
 open class Generic<T>(val x: T) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt
index 8917d08e900..9da704f0ba3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt
@@ -30,4 +30,4 @@ fun main() {
     C().foo()
     val e = a.b.E.entry
     val e1 = E.entry
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt
index 714ba2fcbc1..86ab1c8ab94 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!>err<!>()
+            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!>
         }
     }
 }
@@ -17,5 +17,5 @@ fun test() {
     c.bar()
 
     val err = C()
-    err.<!UNRESOLVED_REFERENCE!>foo<!>()
-}
\ No newline at end of file
+    err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt
index dfdbecf2746..44116bf518d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt
@@ -4,4 +4,4 @@ class Foo {
     fun test() {
         bar()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt
index 9b1486d66f6..b6c2a77ebde 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt
@@ -6,4 +6,4 @@ val bar = ""
 
 val n = null
 
-val g: String? = null
\ No newline at end of file
+val g: String? = null
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt
index 51fab0e4ff2..5fa24511973 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt
@@ -12,4 +12,4 @@ class User : Owner() {
     fun foo() = text
 
     override fun getText() = ""
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt
index 4975a819e8e..be3c84777bf 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt
@@ -6,4 +6,4 @@ class Foo {
     fun Bar.buz() = this
     fun Bar.foo() = this@Foo
     fun Bar.foobar() = this@foobar
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt
index 6daf0e510c1..877ef026d97 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt
@@ -7,4 +7,4 @@ class Outer {
     inner class Inner {
         val x = foo() // Should be Int
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt
index 0f3aae11065..6560aa1243c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt
@@ -5,4 +5,4 @@ fun foo() {}
 fun main() {
     foo()
     foo("!")
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt
index 38f66b94736..9947275b9b9 100644
--- a/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt
@@ -3,4 +3,4 @@ fun foo() = if (true) 1 else 0
 fun bar(arg: Any?) = when (arg) {
     is Int -> arg as Int
     else -> 42
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/extension.kt b/compiler/fir/analysis-tests/testData/resolve/extension.kt
index cbe661d5b0d..83502b09540 100644
--- a/compiler/fir/analysis-tests/testData/resolve/extension.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/extension.kt
@@ -10,4 +10,4 @@ class My {
     }
 }
 
-fun My.foo() {}
\ No newline at end of file
+fun My.foo() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt
index 6735d03f171..564a212f32f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt
@@ -4,4 +4,4 @@ class My : <!OTHER_ERROR!>My<!>()
 
 class Your : His()
 
-class His : <!OTHER_ERROR!>Your<!>()
\ No newline at end of file
+class His : <!OTHER_ERROR!>Your<!>()
diff --git a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt
index 7abe15c411b..66b45a20144 100644
--- a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt
@@ -2,4 +2,4 @@ import incorrect.directory.Your
 
 typealias My = <!UNRESOLVED_REFERENCE!>incorrect.directory.My<!>
 
-typealias Your = <!OTHER_ERROR!>Your<!>
\ No newline at end of file
+typealias Your = <!OTHER_ERROR!>Your<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/fib.kt b/compiler/fir/analysis-tests/testData/resolve/fib.kt
index d3bf182815c..0a734c9e323 100644
--- a/compiler/fir/analysis-tests/testData/resolve/fib.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/fib.kt
@@ -8,4 +8,4 @@ fun fibIterative(n: Int): Int {
         prev = temp
     }
     return current
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt
index 4ff9238e2a4..7f91a4dc5db 100644
--- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt
@@ -8,4 +8,4 @@ class C<T, out S> {
 
 interface Test {
     val x: a.b.C<out CharSequence, *>.D<in List<*>, *>
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt
index 627ab90dfe2..0e6ac864eb4 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!>println<!>("Hello!!!")
+            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Hello!!!")<!>
         }
     },
     VENERA(3.0, 4.0) {
         override fun sayHello() {
-            <!UNRESOLVED_REFERENCE!>println<!>("Ola!!!")
+            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Ola!!!")<!>
         }
     },
     EARTH(5.0, 6.0) {
         override fun sayHello() {
-            <!UNRESOLVED_REFERENCE!>println<!>("Privet!!!")
+            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>println<!>("Privet!!!")<!>
         }
     };
 
@@ -30,4 +30,4 @@ enum class Planet(val m: Double, internal val r: Double) {
     companion object {
         const val G = 6.67e-11
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt
index fbd6b4e236e..5f0a3dcd069 100644
--- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt
@@ -6,4 +6,4 @@ class NoPrimary {
     }
 
     constructor(): this("")
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt
index b35d86be327..d6e91bf884b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt
@@ -18,4 +18,4 @@ class SomeClass : SomeInterface {
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit var fau: Double<!>
 }
 
-inline class InlineClass
\ No newline at end of file
+inline class InlineClass
diff --git a/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt b/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt
index a88e9c41a82..b1978fe2dbb 100644
--- a/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt
@@ -4,4 +4,4 @@ inline fun <reified T : Any> Any.safeAs(): T? = this as? T
 
 abstract class Summator {
     abstract fun <T> plus(first: T, second: T): T
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt b/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt
index 74b6bed41ef..093387b3e5d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt
@@ -12,4 +12,4 @@ class C : B() {
     fun foo(x: Inv<String>) {
         x.phasedFir
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt
index 923a96486fc..50c694c5335 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!>bar<!>() // should be ambiguity (NB: really we should have overridden bar in C)
+        super.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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/callableReferencesAndDefaultParameters.kt b/compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt
index d42b9a85ddd..e52df037663 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt
@@ -6,4 +6,4 @@ inline fun <T> T.myLet(block: (T) -> Unit) {}
 
 fun test(a: A, s: String) {
     s.myLet(a::foo)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt b/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt
index cde99fc41b9..1739ea41199 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt
@@ -16,4 +16,4 @@ fun main(x: A?) {
 
     // lambda has a type (() -> Unit?)
     foo(lambda)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt b/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt
index 59cef711f34..93f08e7d9d5 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt
@@ -11,4 +11,4 @@ class K<T : Comparable<T>>(t: T)
 fun main() {
     K(0)
     JavaClass(0)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt
index a27f1e46c48..f30007d46af 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt
@@ -16,4 +16,4 @@ fun test_2(a: A, vararg zs: A.() -> Unit) {
     for (z in zs) {
         a.z()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
index 2bfbe8fa5ea..51b826f6b5a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
@@ -4,10 +4,10 @@ fun takeInt(x: Int) {}
 
 fun test_1(b: Boolean) {
     val x = if (b) 1 else null
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>takeInt<!>(x)<!>
 }
 
 fun test_2(b: Boolean, y: Int) {
     val x = if (b) y else null
-    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
-}
\ No newline at end of file
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 0a52fd88247..281eb062606 100644
--- a/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt
@@ -24,7 +24,7 @@ fun test_1_3(resolvedCall: ResolvedCall<CallableDescriptor>) {
 }
 
 fun test_2_1(resolvedCall: ResolvedCall<out CallableDescriptor>, d: CallableDescriptor) {
-    val x = resolvedCall.<!INAPPLICABLE_CANDIDATE!>updateD<!>(d) // should fail
+    val x = resolvedCall.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 8e1ca1419a8..1c6aaf68ba1 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!>err<!>()
+            this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>err<!>()<!>
         }
     }
 }
@@ -31,8 +31,8 @@ class Owner {
 fun test() {
     val o = Owner()
     o.foo()
-    val err = Owner.<!UNRESOLVED_REFERENCE!>Inner<!>()
-    err.<!UNRESOLVED_REFERENCE!>baz<!>()
+    val err = Owner.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Inner<!>()<!>
+    err.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
     val i = o.Inner()
     i.gau()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
index 797f42d4a2e..8c866732348 100644
--- a/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
@@ -12,10 +12,10 @@ val rr = Outer<String>().Inner<Int>()
 val rrq = Boxed<String>().substitute()
 
 fun check() {
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<Int>().Inner<Int>()) // illegal
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<Int>().Inner<Int>())<!> // illegal
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Outer<String>().Inner<String>())<!> // illegal
     accept(Outer<String>().Inner<Int>()) // ok
 
-    <!INAPPLICABLE_CANDIDATE!>accept<!>(Boxed<Int>().substitute()) // illegal
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>accept<!>(Boxed<Int>().substitute())<!> // illegal
     accept(Boxed<String>().substitute()) // ok
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt
index a42556effec..0046ca0b2b2 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!>foo<!>()
-            this.<!UNRESOLVED_REFERENCE!>foo<!>()
+            <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+            this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
         }
     }
 }
@@ -33,4 +33,4 @@ fun test() {
     o.foo()
     val n = Owner.Nested()
     n.baz()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt b/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt
index 96ce7df60d9..961cd6bacff 100644
--- a/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt
@@ -11,4 +11,4 @@ fun test() = select(Clazz1(), Clazz2())
 
 fun <T> makeNull(x: T): T? = null
 
-fun testNull() = makeNull(select(Clazz1(), Clazz2()))
\ No newline at end of file
+fun testNull() = makeNull(select(Clazz1(), Clazz2()))
diff --git a/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt
index 0d96614457c..e114b6e6421 100644
--- a/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt
@@ -14,4 +14,4 @@ class C {
     fun anotherTest(block: C.() -> Int) {
         block()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt b/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt
index 5c568c02749..c4dba658f87 100644
--- a/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt
@@ -13,4 +13,4 @@ public class A {
 fun test(a: A) {
     val int = a.x // <- should be int
     val string = a.getX()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/kt41984.kt b/compiler/fir/analysis-tests/testData/resolve/kt41984.kt
index e693f6acce1..41180d7f030 100644
--- a/compiler/fir/analysis-tests/testData/resolve/kt41984.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/kt41984.kt
@@ -26,6 +26,6 @@ open class B<V> : A<Any, V>() {
 
 fun test_1(b: B<Int>, x: Int, inv: Inv<Int>) {
     b.take(x)
-    b.<!INAPPLICABLE_CANDIDATE!>take<!>(null)
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 af380eaa627..6cbf919f1ec 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!>_<!><Function1<Unit, KotlinClass?>>() }
+    lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Unit, KotlinClass?>>()<!> }
 }
 // TESTCASE NUMBER: 2
 fun case2(kotlinClass: KotlinClass) {
@@ -36,5 +36,5 @@ fun case2(kotlinClass: KotlinClass) {
         {it}
     }
 
-    lambda.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Unit, KotlinClass?>>() }
-}
\ No newline at end of file
+    lambda.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Unit, KotlinClass?>>()<!> }
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt
index a27703b45d7..02044811550 100644
--- a/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt
@@ -14,4 +14,4 @@ fun test_2(s: String) {
 
 class B<out K, V>(val k: K, val v: V)
 
-fun <X, R, V> B<X, V>.myMap(transform: (B<X, V>) -> R): B<R, V> = TODO()
\ No newline at end of file
+fun <X, R, V> B<X, V>.myMap(transform: (B<X, V>) -> R): B<R, V> = TODO()
diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt
index 8bae96c5e36..03ce460d5d4 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!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
+    invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!)
 
-    Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
+    Case1(javaClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><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!>_<!><Function1<Nothing, Boolean>>() }  //(!!!)
+    invalidType.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> }  //(!!!)
 
-    Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Nothing, Boolean>>() } //(!!!)
+    Case2(kotlinClass).x.checkType { <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>_<!><Function1<Nothing, Boolean>>()<!> } //(!!!)
 }
 
 class Case2(val kotlinClass: KotlinClass?) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt b/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt
index 985defd6e30..e6bb627b045 100644
--- a/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt
@@ -20,4 +20,4 @@ fun test_2() {
 
     val y = 1
     y.transform()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/localObject.kt b/compiler/fir/analysis-tests/testData/resolve/localObject.kt
index ff144f1d776..bdc52f69238 100644
--- a/compiler/fir/analysis-tests/testData/resolve/localObject.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/localObject.kt
@@ -44,4 +44,4 @@ class TestProperty {
         }
         2
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt
index ef01d9fd690..721194e5944 100644
--- a/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt
@@ -43,4 +43,4 @@ class Second(val y: Char) : @WithInt(0) First() {
 
 @WithInt(24)
 @VeryComplex(3.14f, 6.67e-11, false, 123456789012345L, null)
-typealias Third = @Simple Second
\ No newline at end of file
+typealias Third = @Simple Second
diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt
index 6ff526b84b2..9fdcc9342e2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt
@@ -15,4 +15,4 @@ import test.*
 interface My {
     // Should be kotlin.ByteArray
     val array: ByteArray
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt
index b01d0b6f983..bc36c906394 100644
--- a/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt
@@ -25,4 +25,4 @@ import b.B
 class A : B() {
     class NestedInA1 : NestedInB()
     class NestedInA2 : NestedInC()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt
index b062b6db320..4387c1c29b3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt
@@ -20,4 +20,4 @@ abstract class Factory {
     abstract fun createObj(): O
 
     abstract fun createExtra(): Extra
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt
index a5ee84d5f39..2c1053f889b 100644
--- a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt
@@ -12,4 +12,4 @@ package b
 
 import a.MyClass.MyNested
 
-class YourClass : MyNested()
\ No newline at end of file
+class YourClass : MyNested()
diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt
index 877b0420088..f248ee6f7fb 100644
--- a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt
@@ -12,4 +12,4 @@ package b
 
 import a.Outer
 
-class My : Outer.Nested()
\ No newline at end of file
+class My : Outer.Nested()
diff --git a/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt b/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt
index 076512e710a..0f5bdbfd63e 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!>C<!>() // shouldn't resolve
+        val c = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>C<!>()<!> // shouldn't resolve
     }
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt b/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt
index b1df40b3da8..72370905cfa 100644
--- a/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt
@@ -38,4 +38,4 @@ class Foo {
     private fun saveResult(result: Result) {}
 
     class Result
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt b/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt
index 5cda845d32d..347c0ba1358 100644
--- a/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt
@@ -4,4 +4,4 @@ class Some {
     fun foo(): Nested {
         return Nested()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt b/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt
index e62a32ee691..df02cad8938 100644
--- a/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt
@@ -146,4 +146,4 @@ class Case3() {
 }
 
 interface A {}
-class B() {}
\ No newline at end of file
+class B() {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt b/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt
index e0de3d4d18c..7fca3d6ad6a 100644
--- a/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt
@@ -44,4 +44,4 @@ fun callJava(derived: Test.Derived, derivedRaw: Test.DerivedRaw, v: Test.I123) {
 
 fun callKotlin(derived: KDerived) {
     derived.foo<KI12>()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt
index c827bacb73a..916f320e75f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt
@@ -12,4 +12,4 @@ interface Some {
         set(value) {
             field = value
         }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt
index b6c7d6d1d3a..de6e5d2f399 100644
--- a/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt
@@ -12,4 +12,4 @@ class C : Base(), I
 
 fun f(list: List<Int>) {
     C().f(list)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt
index f87bf8fb820..a956ba7e5e9 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!>buz<!>()
+        <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>buz<!>()<!>
     }
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
index 5fd73df0428..b7e5ab8f445 100644
--- a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
@@ -10,5 +10,5 @@ class C : Base<CharSequence>()
 
 fun f(list: MutableList<X>, s: MutableList<CharSequence>) {
     C().f(list, s)
-    C().<!INAPPLICABLE_CANDIDATE!>f<!>(s, list)
+    C().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>f<!>(s, list)<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt
index c904e1f9c2e..b0b95c5fd31 100644
--- a/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt
@@ -19,4 +19,4 @@ class C : B() {
         bar()
         baz()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt b/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt
index cc1de920011..fca09a36613 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt
@@ -3,4 +3,4 @@ fun <K> select(x: K, y: K): K = TODO()
 
 fun test() {
     select(id { it.inv() }, id<(Int) -> Unit> { })
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt b/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
index 0230fdf919f..384164d4d76 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
@@ -11,5 +11,5 @@ public interface SLRUMap<V> {
 // FILE: main.kt
 
 fun <V> SLRUMap<V>.getOrPut(value: V) {
-    <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 1d4e92d91fb..c7645a90525 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!>getSetter<!>() // Should be error
+    val res2 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>getSetter<!>()<!> // Should be error
     val res3 = descriptor.isDelegated
-    val res4 = descriptor.<!UNRESOLVED_REFERENCE!>isDelegated<!>() // Should be error
-}
\ No newline at end of file
+    val res4 = descriptor.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>isDelegated<!>()<!> // Should be error
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt b/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt
index 711f14d1426..d679c8e4bad 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt
@@ -22,4 +22,4 @@ open class A(val s: String) {
     inner class F : E()
 }
 
-fun box(): String = A("Fail").F().s
\ No newline at end of file
+fun box(): String = A("Fail").F().s
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt b/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt
index a16bfa160e3..704db700550 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!>Another<!>()
-}
\ No newline at end of file
+    val another = <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Another<!>()<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt b/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt
index b44d753dd3d..9f0e79eaeed 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt
@@ -1,4 +1,4 @@
 class Outer { inner class Inner }
 fun test() {
-    val x = object : <!UNRESOLVED_REFERENCE!>Outer.Inner<!>() { }
-}
\ No newline at end of file
+    val x = object : <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>Outer.Inner<!>()<!> { }
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt b/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt
index db5f72a53cd..c1060e44fdd 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt
@@ -10,4 +10,4 @@ class B(p0: String) {
         p1 = p0.length
         p3 = ""
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/problems2.kt b/compiler/fir/analysis-tests/testData/resolve/problems2.kt
index 7477479399d..7f27ac53f9f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/problems2.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/problems2.kt
@@ -27,4 +27,4 @@ val KonanTarget.presetName
 // Exhaustive when expressions give Any result type
 // Substitution for field declared in Java super-type does not work (KotlinStringLiteralTextEscaper.myHost)
 // Super is not resolved in anonymous object
-// TypeParameterDescriptor.name is not resolved
\ No newline at end of file
+// TypeParameterDescriptor.name is not resolved
diff --git a/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt b/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt
index 30c39006a34..0c98ff8eb99 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!>value<!>() // should be an error
+    ann.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>value<!>()<!> // should be an error
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt b/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt
index bd8a257c737..0c5076aecc8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt
@@ -19,4 +19,4 @@ public class B {
 
 fun test(b: B) {
     b.text += ""
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt b/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt
index a777ee49e24..102fe6387d2 100644
--- a/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt
@@ -16,4 +16,4 @@ fun test() {
     fun A.invoke() {}
 
     my.xx()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt b/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt
index cb39869714a..72e0b814a6c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt
@@ -6,4 +6,4 @@ fun testRef(f: () -> Int) {}
 fun test() {
     // should resolve to Int.foo
     testRef(1::foo)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/references/simple.kt b/compiler/fir/analysis-tests/testData/resolve/references/simple.kt
index 01c56edc69c..0fa2c1a7555 100644
--- a/compiler/fir/analysis-tests/testData/resolve/references/simple.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/references/simple.kt
@@ -1,3 +1,3 @@
 fun foo() = 1
 
-fun bar() = foo()
\ No newline at end of file
+fun bar() = foo()
diff --git a/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt b/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt
index 1dfabd7727c..ae890509710 100644
--- a/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt
@@ -6,4 +6,4 @@ class B : A() {
     fun bar() {
         foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt b/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
index dda848e2b85..2316e66886c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
@@ -18,9 +18,9 @@ fun main() {
         x.toInt().toString()
     })
 
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(MyFunction { x: Int ->
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 d2426e224ed..b3fa3fb01dc 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt
@@ -10,13 +10,13 @@ fun foo(m: MyRunnable) {}
 fun MyRunnable(x: (Int) -> Boolean) = 1
 
 fun main() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable { x ->
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable { x ->
         x > 1
-    })
+    })<!>
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable({ it > 1 }))
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(MyRunnable({ it > 1 }))<!>
 
     val x = { x: Int -> x > 1 }
 
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable(x))
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 c4eac6be67d..78977c1f58b 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!>foo2<!> { x: Int ->
+    JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 5fb027ccb83..cca6f7e9917 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
@@ -29,11 +29,11 @@ fun main() {
     foo1 { x -> x > 1 }
     foo1(f)
 
-    <!INAPPLICABLE_CANDIDATE!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(f)<!>
 
-    <!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
-    <!INAPPLICABLE_CANDIDATE!>foo3<!>(f)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 016843b8718..da5d1c5b163 100644
--- a/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt
@@ -18,14 +18,14 @@ public class JavaUsage {
 fun foo(m: MyRunnable) {}
 
 fun main() {
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!> {
+    JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!> {
             x ->
         x <!UNRESOLVED_REFERENCE!>><!> 1
-    }
+    }<!>
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })
+    JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNRESOLVED_REFERENCE!>><!> 1 })<!>
 
     val x = { x: Int -> x > 1 }
 
-    JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
+    JavaUsage.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>(x)<!>
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt b/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt
index 071205181ae..76cc50ceb00 100644
--- a/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt
@@ -6,5 +6,5 @@ sealed class WithPrivateConstructor private constructor(val x: Int) {
     private constructor() : this(42)
 }
 
-object First : <!NONE_APPLICABLE!>WithPrivateConstructor<!>() // error
-object Second : <!NONE_APPLICABLE!>WithPrivateConstructor<!>(0) // error
+object First : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>WithPrivateConstructor<!>()<!> // error
+object Second : <!NONE_APPLICABLE{LT}!><!NONE_APPLICABLE{PSI}!>WithPrivateConstructor<!>(0)<!> // error
diff --git a/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt b/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt
index 851f3c6f289..e78036d2670 100644
--- a/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt
@@ -16,4 +16,4 @@ class SomeClass : SomeInterface {
         set(value) {}
 
     var fau: Double
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt b/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt
index 00b88d1bd87..34a18758304 100644
--- a/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt
@@ -2,4 +2,4 @@ interface B
 
 typealias C = B
 
-class D : C
\ No newline at end of file
+class D : C
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt
index 6c778107ba5..b861d37433d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt
@@ -26,7 +26,7 @@ fun test_3(a: A?, b: Boolean) {
     if (b && a!!.foo()) {
         a.foo() // OK
     }
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Bad
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Bad
 }
 
 fun test_4(a: A?, b: Boolean) {
@@ -38,9 +38,9 @@ fun test_4(a: A?, b: Boolean) {
 
 fun test_5(a: A?, b: Boolean) {
     if (b || a!!.foo()) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
     }
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
 }
 
 fun <X : A?> test_6(x: X) {
@@ -49,4 +49,4 @@ fun <X : A?> test_6(x: X) {
 
 fun <X : A> test_7(x: X?) {
     x!!.foo()
-}
\ No newline at end of file
+}
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 4f293d49cd0..e45272656a6 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!>bar<!>()
-        x.<!UNRESOLVED_REFERENCE!>baz<!>()
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>()
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
     }
 }
 
 fun test_8(x: Any) {
     if (false || x is A) {
         // TODO: should be smartcast
-        x.<!UNRESOLVED_REFERENCE!>foo<!>()
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
     }
 }
 
 fun test_9(x: Any) {
     if (x is A || true) {
-        x.<!UNRESOLVED_REFERENCE!>foo<!>()
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
     }
 }
 
 fun test_10(x: Any) {
     if (true || x is A) {
-        x.<!UNRESOLVED_REFERENCE!>foo<!>()
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>()
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
     }
 }
 
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt
index 045d3fa1779..97732d845cd 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt
@@ -8,13 +8,13 @@ fun test_1(b: Boolean?) {
     if ((b == true) == true) {
         b.not() // OK
     } else {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     }
 }
 
 fun test_2(b: Boolean?) {
     if ((b == true) != true) {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     } else {
         b.not() // OK
     }
@@ -22,7 +22,7 @@ fun test_2(b: Boolean?) {
 
 fun test_3(b: Boolean?) {
     if ((b == true) == false) {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     } else {
         b.not() // OK
     }
@@ -32,13 +32,13 @@ fun test_4(b: Boolean?) {
     if ((b == true) != false) {
         b.not() // OK
     } else {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     }
 }
 
 fun test_5(b: Boolean?) {
     if ((b != true) == true) {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     } else {
         b.not() // OK
     }
@@ -48,7 +48,7 @@ fun test_6(b: Boolean?) {
     if ((b != true) != true) {
         b.not() // OK
     } else {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     }
 }
 
@@ -56,14 +56,14 @@ fun test_7(b: Boolean?) {
     if ((b != true) == false) {
         b.not() // OK
     } else {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     }
 }
 
 fun test_8(b: Boolean?) {
     if ((b != true) != false) {
-        b.<!INAPPLICABLE_CANDIDATE!>not<!>() // Bad
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
     } else {
         b.not() // OK
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt
index b425f917c26..be91a791bed 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt
@@ -34,24 +34,24 @@ fun test_4(a: A?) {
 
 fun test_5(a: A?) {
     a == null || throw Exception()
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
 }
 
 fun teat_6(a: A?) {
     a != null && throw Exception()
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
 }
 
 fun test_7(a: A?) {
     if (a == null || throw Exception()) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
     }
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
 }
 
 fun test_8(a: A?) {
     if (a != null && throw Exception()) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
     }
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>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 2642e666098..f6e34990a98 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!>foo<!>()
+        z.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
         z.bar()
     }
 }
@@ -40,7 +40,7 @@ fun test_4(y: Any) {
     x as Int
     x.inc()
     x = y
-    x.<!UNRESOLVED_REFERENCE!>inc<!>()
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>inc<!>()<!>
     if (y is A) {
         x.foo()
         y.foo()
@@ -75,4 +75,4 @@ fun test_7(d1: D, d2: D) {
     a.foo() // should be OK
     b as B
     b.bar() // should be OK
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt
index 33e8f4b3cb4..88992851c5c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt
@@ -118,4 +118,4 @@ fun test_7() {
         y.<!INAPPLICABLE_CANDIDATE!>length<!> // Bad
         z.length // OK
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt
index 75224175da3..dfb08e48fb6 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!>not<!>()
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
 
     if (b && x as Boolean == true) {
         x.not()
     }
-    x.<!UNRESOLVED_REFERENCE!>not<!>()
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
 
     if (b || x as Boolean) {
-        x.<!UNRESOLVED_REFERENCE!>not<!>()
+        x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
     }
-    x.<!UNRESOLVED_REFERENCE!>not<!>()
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
 }
 
 fun test_4(b: Any) {
     if (b as? Boolean != null) {
         b.not()
     } else {
-        b.<!UNRESOLVED_REFERENCE!>not<!>()
+        b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
     }
-    b.<!UNRESOLVED_REFERENCE!>not<!>()
+    b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
 
     if (b as? Boolean == null) {
-        b.<!UNRESOLVED_REFERENCE!>not<!>()
+        b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
     } else {
         b.not()
     }
-    b.<!UNRESOLVED_REFERENCE!>not<!>()
-}
\ No newline at end of file
+    b.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>not<!>()<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt
index cdcbaa5f77c..8891abd774d 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt
@@ -14,4 +14,4 @@ fun test2(a: Any?, b: Any?): String {
     if (b !is String) return ""
     if (a !is String?) return ""
     return a ?: b
-}
\ No newline at end of file
+}
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 71d27f73d39..58f167ec50d 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!>bar<!>()
-    x.<!UNRESOLVED_REFERENCE!>baz<!>()
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>()
-    x.<!UNRESOLVED_REFERENCE!>bar<!>()
-    x.<!UNRESOLVED_REFERENCE!>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<!>()<!>
 }
 
 fun <T> runHigherOrder(f: () -> T): T = f()
@@ -60,4 +60,4 @@ fun test_4(a: Any?) {
     runHigherOrder {
         s.length // Should be OK
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt
index bbe6b2244b2..04653ca4545 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt
@@ -23,4 +23,4 @@ fun test_3(x: Any) {
             x.inc()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt
index 07d628f7306..3ce26ed8eea 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt
@@ -9,4 +9,4 @@ fun test(a: Any) {
     if (takeA(a as? A ?: return)) {
         a.foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt
index b5a9a67bab0..a5e84e1accd 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt
@@ -89,4 +89,4 @@ fun test_4(x: Any) {
         1 -> x.inc()
     }
     x.inc()
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt
index 18289e801d8..e54a97ef7fd 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt
@@ -16,12 +16,12 @@ fun test_1(x: A, y: A?) {
 
 fun test_2(x: A?, y: A?) {
     if (x == y) {
-        x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        y.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
+        y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
     }
     if (x === y) {
-        x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        y.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
+        y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
     }
 }
 
@@ -35,4 +35,4 @@ fun test_3(x: A?, y: A?) {
         x.foo()
         y.foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt
index afaf177ac05..4a2b7373d0f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt
@@ -33,4 +33,4 @@ fun d() {
             koko = null
         }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt
index dd476fa0e59..dcf4cbfcec8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt
@@ -11,4 +11,4 @@ fun Q.foo() {
     when (this) {
         is B -> x // unresolved
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt
index f2a6e828f2f..f314cbcdf87 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt
@@ -9,4 +9,4 @@ fun main(a: A) {
     if (a === X) {
         foo(a)
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt
index 311e0c240e4..abc7a141b50 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt
@@ -30,4 +30,4 @@ fun test_3(x: Any?) {
         }
         x.bar()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt
index 7c551a3deeb..908142c83af 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt
@@ -20,4 +20,4 @@ private fun foo(p: Sealed) {
         is SubClass1 -> p.t
         is SubClass2 -> "2"
     }.length // should be resolved, but when is not considered as sealed because type of p is not a sealed class
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt
index 0ee6af5b03c..c8d3d037e35 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt
@@ -3,4 +3,4 @@ fun test(func: (() -> Unit)?) {
     if (func != null) {
         func()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt
index fe66111c930..7008375bcb0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt
@@ -10,4 +10,4 @@ fun test() {
     while (a is B || a is C) {
         a.foo()
     }
-}
\ No newline at end of file
+}
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 1776f00f971..bc94abdb650 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!>foo<!>() // No smartcast
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!> // No smartcast
 }
 
 fun test_5(x: Any, b: Boolean) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt
index d264337c942..c9b0b837694 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt
@@ -26,4 +26,4 @@ fun test_1() {
         a.foo()
         b.foo()
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt
index 35b4d6f8b97..a0f9eb98439 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt
@@ -39,18 +39,18 @@ fun test_1(x: A?) {
     if (x != null) {
         x.foo()
     } else {
-        x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
     }
-    x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
 }
 
 fun test_2(x: A?) {
     if (x == null) {
-        x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
     } else {
         x.foo()
     }
-    x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
 }
 
 fun test_3(x: A?) {
@@ -83,8 +83,8 @@ fun test_6(q: Q?) {
 fun test_7(q: Q?) {
     if (q?.fdata()?.fs()?.inc() != null) {
         q.fdata() // good
-        q.fdata().<!INAPPLICABLE_CANDIDATE!>fs<!>() // bad
-        q.fdata().<!INAPPLICABLE_CANDIDATE!>fs<!>().inc() // bad
+        q.fdata().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>fs<!>()<!> // bad
+        q.fdata().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>fs<!>()<!>.inc() // bad
     }
 }
 
@@ -98,44 +98,44 @@ fun test_9(a: Int, b: Int?) {
     if (a == b) {
         b.inc()
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 
     if (a === b) {
         b.inc()
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 
     if (b == a) {
         b.inc()
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 
     if (b === a) {
         b.inc()
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 }
 
 fun test_10(a: Int?, b: Int?) {
     if (a == b) {
-        b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 
     if (a === b) {
-        b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 
     if (b == a) {
-        b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 
     if (b === a) {
-        b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+        b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
     }
-    b.<!INAPPLICABLE_CANDIDATE!>inc<!>()
+    b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
 }
 
 fun test_11(q: QImpl?, q2: QImpl) {
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
index c681c1b2959..9b2ad3bab6f 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt
@@ -4,24 +4,24 @@ fun String.foo() {}
 
 fun test_1(a: Any?) {
     when (a) {
-        is String, is Any -> a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
+        is String, is Any -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
     }
 }
 
 fun test_2(a: Any?) {
     if (a is String || a is Any) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
+        a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
     }
 }
 
 fun test_3(a: Any?, b: Boolean) {
     when (a) {
-        is String, b -> a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
+        is String, b -> a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
     }
 }
 
 fun test_4(a: Any?, b: Boolean) {
     if (a is String || b) {
-        a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // Should be Bad
+        a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt
index a06e2fa03a1..6fc7ae837a3 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt
@@ -15,4 +15,4 @@ fun Any.test_2(): Int = when (val x = this) {
         length
     }
     else -> 0
-}
\ No newline at end of file
+}
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 23e50af2cc2..f13a9b24ca5 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!>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<!>()
+    this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
 }
 
 fun Any?.test_2() {
     if (this !is A) {
-        this.<!UNRESOLVED_REFERENCE!>foo<!>()
-        <!UNRESOLVED_REFERENCE!>foo<!>()
+        this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
     } else {
         this.foo()
         foo()
     }
-    this.<!UNRESOLVED_REFERENCE!>foo<!>()
-    <!UNRESOLVED_REFERENCE!>foo<!>()
+    this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+    <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>()
-        <!UNRESOLVED_REFERENCE!>foo<!>()
-        this.<!UNRESOLVED_REFERENCE!>bar<!>()
-        <!UNRESOLVED_REFERENCE!>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<!>()<!>
     } else if (this !is B) {
-        this.<!UNRESOLVED_REFERENCE!>bar<!>()
-        <!UNRESOLVED_REFERENCE!>bar<!>()
+        this.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!>
         this.foo()
         foo()
     } else {
@@ -64,10 +64,10 @@ fun Any?.test_4() {
         this.bar()
         bar()
     }
-    this.<!UNRESOLVED_REFERENCE!>foo<!>()
-    <!UNRESOLVED_REFERENCE!>foo<!>()
-    this.<!UNRESOLVED_REFERENCE!>bar<!>()
-    <!UNRESOLVED_REFERENCE!>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<!>()<!>
 }
 
 fun Any.test_5(): Int = when {
@@ -81,4 +81,4 @@ fun Any.test_6() {
     size
     this as String
     length
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt
index 025700d52e9..ca70aec69ce 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt
@@ -11,4 +11,4 @@ class Wrapper(val s: String?) {
     }
 }
 
-<!CONFLICTING_OVERLOADS!>fun takeString(s: String) {}<!>
\ No newline at end of file
+<!CONFLICTING_OVERLOADS!>fun takeString(s: String) {}<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt
index f0cefdea95a..2ab10f63a19 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt
@@ -57,4 +57,4 @@ fun test_2(a: B?) {
     val a = x as? B ?: return
     a.foo() // Should be OK
     x.foo() // Should be OK
-}<!>
\ No newline at end of file
+}<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt
index 741000c7541..293db6f24d0 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt
@@ -31,4 +31,4 @@ fun test_4(s: String?) {
     } else {
         s.length // Should be OK
     }
-}
\ No newline at end of file
+}
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 51413298fbf..455c59ab709 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt
@@ -22,17 +22,17 @@ fun test_3(x: Any) {
     (x as? A)?.bar(x)?.foo(x.bool())?.let {
         x.bool()
     }
-    x.<!UNRESOLVED_REFERENCE!>bool<!>()
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bool<!>()<!>
 }
 
 fun test_4(x: A?) {
     x?.id()?.bool()
-    x.<!INAPPLICABLE_CANDIDATE!>id<!>()
+    x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>id<!>()<!>
 }
 
 fun Any?.boo(b: Boolean) {}
 
 fun test_5(x: A?) {
     x?.let { return }?.boo(x.bool())
-    x.<!INAPPLICABLE_CANDIDATE!>id<!>()
-}
\ No newline at end of file
+    x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>id<!>()<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt
index 8742262e919..98b6ef64964 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt
@@ -13,4 +13,4 @@ fun test_2(b: B) {
     if (b.x is String) {
         b.x.length
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt
index 6bf18a7dd07..c911291afd8 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt
@@ -11,5 +11,5 @@ fun test(b: Boolean) {
     } else {
         a = null
     }
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-}
\ No newline at end of file
+    a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt
index b24f2f6b05d..056a5620c9c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt
@@ -19,4 +19,4 @@ fun test_3() {
     x.length
     x = null
     x.<!INAPPLICABLE_CANDIDATE!>length<!>
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt b/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt
index df9adc970ad..ca85a5cc842 100644
--- a/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt
@@ -25,4 +25,4 @@ fun testFromJava() {
     val values = Utils.getStrings()
     val list = myListOf(*values)
     takeStrings(list)
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/treeSet.kt b/compiler/fir/analysis-tests/testData/resolve/treeSet.kt
index 06a7a6516b1..695882645ec 100644
--- a/compiler/fir/analysis-tests/testData/resolve/treeSet.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/treeSet.kt
@@ -1,3 +1,3 @@
 import java.util.*
 
-val x: SortedSet<Int> = TreeSet()
\ No newline at end of file
+val x: SortedSet<Int> = TreeSet()
diff --git a/compiler/fir/analysis-tests/testData/resolve/tryInference.kt b/compiler/fir/analysis-tests/testData/resolve/tryInference.kt
index e6d14b02757..4ee09058718 100644
--- a/compiler/fir/analysis-tests/testData/resolve/tryInference.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/tryInference.kt
@@ -14,4 +14,4 @@ fun test() {
             materialize() // Should be an errror
         }
     )
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt b/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
index baaee1fb118..065f9741152 100644
--- a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
@@ -10,10 +10,10 @@ interface C {
     fun baz()
 }
 
-interface <!CONSTRUCTOR_IN_INTERFACE!>Inv<K, T>()<!> {
+<!CONSTRUCTOR_IN_INTERFACE{LT}!>interface <!CONSTRUCTOR_IN_INTERFACE{PSI}!>Inv<K, T>()<!> {
     fun k(): K
     fun t(): T
-}
+}<!>
 
 typealias Inv0 = Inv<A, B>
 typealias Inv1<X> = Inv<A, X>
@@ -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!>bar<!>()
+    inv.t().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>take<!>(a)
+    in3.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>take<!>(a)<!>
 }
 
 fun test_6(a: A, out1: Out1<A>, out2: Out1<in A>, out3: Out1<out A>) {
     out1.value().foo()
-    out2.<!UNRESOLVED_REFERENCE!>value<!>().<!UNRESOLVED_REFERENCE!>foo<!>()
+    out2.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>value<!>()<!>.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>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!>foo<!>()
+    inv2.value().<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
     inv3.value().foo()
 
     inv1.take(a)
     inv2.take(a)
-    inv3.<!INAPPLICABLE_CANDIDATE!>take<!>(a)
-}
\ No newline at end of file
+    inv3.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>take<!>(a)<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt b/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt
index 035f9be3c88..b796778f5bf 100644
--- a/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt
@@ -9,4 +9,4 @@ val w: Int get(): Int = 1
 
 interface Some {
     val bar: Int get() = 1
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt
index e1a220fb529..5181ec7b24e 100644
--- a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt
@@ -13,7 +13,7 @@ abstract class My<T : Some> {
 
     abstract val z: test.My.T
 
-    class Some : <!OTHER_ERROR, UNRESOLVED_REFERENCE!>T<!>()
+    class Some : <!UNRESOLVED_REFERENCE{LT}!><!OTHER_ERROR, UNRESOLVED_REFERENCE{PSI}!>T<!>()<!>
 }
 
 abstract class Your<T : Some> : <!OTHER_ERROR!>T<!>
diff --git a/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt b/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt
index f78eb42830c..a6e88678f95 100644
--- a/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt
@@ -10,4 +10,4 @@ class A<T1, T2> {
 
 fun <R1, R2, R3> foo(c: A<R1, R1>.B<R2, R2>.C<R3, R3>) {}
 
-fun <R3> foo(c: A.B.C<R3, R3>) {}
\ No newline at end of file
+fun <R3> foo(c: A.B.C<R3, R3>) {}
diff --git a/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt b/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt
index 943cf93e42d..2dbee247b04 100644
--- a/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt
@@ -7,4 +7,4 @@ fun foo(): () -> Boolean {
     } else {
         return { true }
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt
index 8e80e8fcbe6..b7581351fc1 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt
@@ -6,4 +6,4 @@ class B {
     fun foo(<!EXPOSED_PARAMETER_TYPE!>value: A.AInner<!>) {
 
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt
index 58c4c104ae8..49c79e79ccd 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt
@@ -5,7 +5,7 @@ class A {
 }
 
 abstract class B {
-    fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(str: String): A.InnerA
+    <!EXPOSED_FUNCTION_RETURN_TYPE{LT}!>fun <!EXPOSED_FUNCTION_RETURN_TYPE{PSI}!>foo<!>(str: String): A.InnerA<!>
 }
 
 private enum class Some {
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt
index b464599d35a..e3aef127280 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt
@@ -17,7 +17,7 @@ class Property {
     var var1: String
     var var2: String
     var var3: Int
-    var <!EXPOSED_PROPERTY_TYPE!>var4<!>: A.AInnerPrivate
+    <!EXPOSED_PROPERTY_TYPE{LT}!>var <!EXPOSED_PROPERTY_TYPE{PSI}!>var4<!>: A.AInnerPrivate<!>
     var var5: A.AInnerPublic
-    var <!EXPOSED_PROPERTY_TYPE!>var6<!>: A.AInnerProtectedEnum
-}
\ No newline at end of file
+    <!EXPOSED_PROPERTY_TYPE{LT}!>var <!EXPOSED_PROPERTY_TYPE{PSI}!>var6<!>: A.AInnerProtectedEnum<!>
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt
index 7fc4f2897e9..168e52b8dfc 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt
@@ -38,7 +38,7 @@ interface E {
 
 }
 
-class Test2 : A.APublicI, <!UNRESOLVED_REFERENCE!>B.BInner<!>() {
+class Test2 : A.APublicI, <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>B.BInner<!>()<!> {
 
 }
 
@@ -50,7 +50,7 @@ class Test4 : E, A.AProtectedI {
 
 }
 
-class Test5 : C.CPublicI, <!UNRESOLVED_REFERENCE!>B.BInner<!>() {
+class Test5 : C.CPublicI, <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>B.BInner<!>()<!> {
 
 }
 
@@ -60,4 +60,4 @@ class Test6 : E, <!EXPOSED_SUPER_CLASS!>C.CPublic<!> {
 
 class Test7 : <!UNRESOLVED_REFERENCE!>D.PublicButProtected<!> {
 
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt
index 4296207e024..9c51b28bf8c 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt
@@ -2,7 +2,7 @@ class A {
     private inner class Inner
 }
 class B {
-    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>AInner<!> = A.Inner
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE{LT}!>typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE{PSI}!>AInner<!> = A.Inner<!>
     inner class Inner
 }
 
@@ -10,9 +10,9 @@ class C {
     typealias BInner = B.Inner
 }
 
-typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>AInner0<!> = A.Inner
+<!EXPOSED_TYPEALIAS_EXPANDED_TYPE{LT}!>typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE{PSI}!>AInner0<!> = A.Inner<!>
 typealias BInner0 = B.Inner
 
 private typealias MyString = String
 
-fun foo(): MyString = ""
\ No newline at end of file
+fun foo(): MyString = ""
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt
index aac91cbe755..eda6bd86bc6 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt
@@ -32,4 +32,4 @@ public class Container : C {
 }
 
 // invalid, A is private, B is internal, D is protected
-public interface Test8<T: <!EXPOSED_TYPE_PARAMETER_BOUND!>A<!>, P: <!EXPOSED_TYPE_PARAMETER_BOUND!>B<!>, F: C, N: <!EXPOSED_TYPE_PARAMETER_BOUND!>C.D<!>, M: E>
\ No newline at end of file
+public interface Test8<T: <!EXPOSED_TYPE_PARAMETER_BOUND!>A<!>, P: <!EXPOSED_TYPE_PARAMETER_BOUND!>B<!>, F: C, N: <!EXPOSED_TYPE_PARAMETER_BOUND!>C.D<!>, M: E>
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt
index 51a43a129e8..5fc9f86fa4d 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!>Comp<!>()
+        <!HIDDEN{LT}!><!HIDDEN{PSI}!>Comp<!>()<!>
     }
 }
 
 object B {
-    private val x = <!HIDDEN!>B<!>()
+    private val x = <!HIDDEN{LT}!><!HIDDEN{PSI}!>B<!>()<!>
 }
 
 class D {
@@ -26,6 +26,6 @@ enum class E {
     };
 
     fun foo() {
-        <!UNRESOLVED_REFERENCE!>X<!>()
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>X<!>()<!>
     }
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt
index 9e5875af43c..768d1052b24 100644
--- a/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt
@@ -19,5 +19,5 @@ abstract class A {
 // FILE: main.kt
 
 fun test(b: B): String {
-    return b <!HIDDEN!>foo<!> "hello" // should be an error
+    return <!HIDDEN{LT}!>b <!HIDDEN{PSI}!>foo<!> "hello"<!> // should be an error
 }
diff --git a/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt
index f6078dd1139..caf0dccad90 100644
--- a/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt
@@ -9,4 +9,4 @@ fun foo(b: Boolean, a: Int) {
     }?.also {
         1
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/whenElse.kt b/compiler/fir/analysis-tests/testData/resolve/whenElse.kt
index 82295985eea..d217e230760 100644
--- a/compiler/fir/analysis-tests/testData/resolve/whenElse.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/whenElse.kt
@@ -53,4 +53,4 @@ fun case3() {
         A.A1 -> B() //should be INCOMPATIBLE_TYPES
         A.A2 -> B() //should be INCOMPATIBLE_TYPES
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/fir/analysis-tests/testData/resolve/whenInference.kt b/compiler/fir/analysis-tests/testData/resolve/whenInference.kt
index 5cf6db722d0..9dfd1cd2988 100644
--- a/compiler/fir/analysis-tests/testData/resolve/whenInference.kt
+++ b/compiler/fir/analysis-tests/testData/resolve/whenInference.kt
@@ -6,4 +6,4 @@ fun takeA(a: A) {}
 
 fun test() {
     takeA(if(true) materialize() else materialize())
-}
\ No newline at end of file
+}