[TD] Update test data after previous commit

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<!>("")<!>
 }

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)<!>
 }
 

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)
 }

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

@@ -2,4 +2,4 @@ fun test(
     val f: String.() -> Int = { length }
 ): Int {
     return "".f()
-}
+}

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

@@ -4,4 +4,4 @@ fun test() {
     foo {
         this + it
     }
-}
+}

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)

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)()
+fun testInvoke(): Int = My(13)()

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)
-}
+}

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) {}
-}
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!> {}<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>() {}<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(other = false) {}<!>
+}

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

@@ -20,4 +20,4 @@ fun test(ordinal: Int) {
             }
         }
     }
-}
+}

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 }
     )
-}
+}

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()
-    }
-}
+    }<!>
+}

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 }

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)
-}
+}

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

@@ -5,4 +5,4 @@ interface A {
 
 fun test(a: A) {
     a.foo { true }
-}
+}

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 = "")
-}
+    <!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 = "")<!>
+}

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

@@ -4,4 +4,4 @@ fun foo(s: String) {}
 
 fun test(a: A) {
     foo("$a")
-}
+}

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

@@ -10,4 +10,4 @@ fun test() {
             foo()
         }
     }
-}
+}

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)<!>
 }

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)
-}
+}