FIR: run diagnostic "with stdlib" tests also in light tree mode

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/beyoundCalls.kt

-<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>fun bar(x: String): Int<!> = 1<!>
-<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>fun bar(x: String): Double<!> = 1<!>
+<!CONFLICTING_OVERLOADS!>fun bar(x: String): Int<!> = 1
+<!CONFLICTING_OVERLOADS!>fun bar(x: String): Double<!> = 1
 
 fun baz(x: String): Int = 1
 fun <T, R> foobaz(x: T): R = TODO()

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt

@@ -31,16 +31,16 @@ fun main() {
     foo1(KotlinClass::baz)
     foo2(KotlinClass::baz)
     // Ambiguity (companion/class)
-    <!AMBIGUITY!>foo3<!>(KotlinClass::baz)
+    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo3<!>(KotlinClass::baz)<!>
 
     // Type mismatch
-    <!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo1<!>(<!UNRESOLVED_REFERENCE!>KotlinClass::bar<!>)<!>
     foo2(KotlinClass::bar)
     foo3(KotlinClass::bar)
 
     foo1(KotlinClass2::bar)
     // Type mismatch
-    <!INAPPLICABLE_CANDIDATE!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo2<!>(<!UNRESOLVED_REFERENCE!>KotlinClass2::bar<!>)<!>
     foo3(KotlinClass2::bar)
 }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt

@@ -7,6 +7,6 @@ fun <T> bar(f: (T) -> Unit, e: T) {}
 fun <T> baz(e: T, f: (T) -> Unit) {}
 
 fun test(a: A, b: B) {
-    <!INAPPLICABLE_CANDIDATE!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>baz<!>(a, <!UNRESOLVED_REFERENCE!>::fooB<!>)<!>
+    <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>bar<!>(<!UNRESOLVED_REFERENCE!>::fooB<!>, a)<!>
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt

@@ -3,5 +3,5 @@ fun <T, R> use(x: (T) -> R): (T) -> R = x
 fun foo() = use(::bar)
 fun bar(x: String) = 1
 
-fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)
+fun loop1() = <!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>use<!>(<!UNRESOLVED_REFERENCE!>::loop2<!>)<!>
 fun loop2() = loop1()

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/javaStatic.kt

@@ -16,5 +16,5 @@ fun foo3(x: (String) -> Int) {}
 fun main() {
     foo1(JavaClass::bar)
     foo2(JavaClass::bar)
-    <!AMBIGUITY!>foo3<!>(JavaClass::bar)
+    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo3<!>(JavaClass::bar)<!>
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt

@@ -6,5 +6,5 @@ fun bar(): Int = 1
 fun bar(x: String): Int = 1
 
 fun main() {
-    <!AMBIGUITY!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)
+    <!AMBIGUITY{LT}!><!AMBIGUITY{PSI}!>foo<!>(<!UNRESOLVED_REFERENCE!>::bar<!>)<!>
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt

@@ -59,8 +59,8 @@ fun test_2(x: Any) {
 fun test_3(x: Any) {
     myRequireOr(x is B, x is C)
     x.foo() // OK
-    x.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
-    x.<!UNRESOLVED_REFERENCE!>baz<!>() // Error
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>bar<!>()<!> // Error
+    x.<!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!> // Error
 }
 
 fun test_4(x: Any) {

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

@@ -27,8 +27,8 @@ class A {
     val p3 = JavaProtected().<!HIDDEN!>javaPProtectedPackage<!>
 
     fun test() {
-        JavaProtected.<!HIDDEN!>javaMProtectedStatic<!>()
-        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
+        JavaProtected.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMProtectedStatic<!>()<!>
+        JavaPackageLocal.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMPackage<!>()<!>
     }
 }
 
@@ -39,7 +39,7 @@ class B : JavaProtected() {
 
     fun test() {
         JavaProtected.javaMProtectedStatic()
-        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
+        JavaPackageLocal.<!HIDDEN{LT}!><!HIDDEN{PSI}!>javaMPackage<!>()<!>
     }
 }
 

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

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

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

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

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

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

compiler/fir/analysis-tests/testData/resolveWithStdlib/listPlusAssign.kt

 fun List<String>.modify() {
-    <!VARIABLE_EXPECTED!>this<!> += "Alpha"
-    <!VARIABLE_EXPECTED!>this<!> += "Omega"
+    <!VARIABLE_EXPECTED{PSI}!>this<!> += "Alpha"
+    <!VARIABLE_EXPECTED{PSI}!>this<!> += "Omega"
 }
 
 fun Any.modify() {

compiler/fir/analysis-tests/testData/resolveWithStdlib/lowPriorityInResolution.kt

-<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+<!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 <!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
-fun foo(): Int<!> = 1<!>
+fun foo(): Int<!> = 1
 
-<!CONFLICTING_OVERLOADS{LT}!><!CONFLICTING_OVERLOADS!>fun foo(): String<!> = ""<!>
+<!CONFLICTING_OVERLOADS!>fun foo(): String<!> = ""
 
 fun test() {
     val s = foo()

compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KJKComplexHierarchyNestedLoop.kt

@@ -2,11 +2,11 @@
 class K2: J1() {
     class Q : <!UNRESOLVED_REFERENCE!>Nested<!>()
     fun bar() {
-        <!UNRESOLVED_REFERENCE!>foo<!>()
-        <!UNRESOLVED_REFERENCE!>baz<!>()
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>foo<!>()<!>
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>baz<!>()<!>
 
-        <!UNRESOLVED_REFERENCE!>superClass<!>()
-        <!UNRESOLVED_REFERENCE!>superI<!>()
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superClass<!>()<!>
+        <!UNRESOLVED_REFERENCE{LT}!><!UNRESOLVED_REFERENCE{PSI}!>superI<!>()<!>
     }
 }
 

compiler/tests-for-compiler-generator/tests/org/jetbrains/kotlin/test/generators/GenerateJUnit5CompilerTests.kt

@@ -104,6 +104,7 @@ fun generateJUnit5CompilerTests(args: Array<String>) {
                 annotations = listOf(annotation(Execution::class.java, ExecutionMode.SAME_THREAD))
             ) {
                 model("resolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME)
+                model("resolveWithStdlib", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME)
             }
         }