FIR: implement LT positioning in diagnostic tests, fix LT strategies

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/ArrayEqualityCanBeReplacedWithEquals.kt

@@ -4,14 +4,14 @@ fun foo(p: Int) {
     val a = arrayOf(1, 2, 3)
     val b = arrayOf(3, 2, 1)
 
-    if (<!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{LT}!>a <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{PSI}!>==<!> b<!>) { }
+    if (a <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS!>==<!> b) { }
 }
 
 fun testsFromIdea() {
     val a = arrayOf("a")
     val b = a
     val c: Any? = null
-    <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{LT}!>a <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{PSI}!>==<!> b<!>
+    a <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS!>==<!> b
     a == c
-    <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{LT}!>a <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{PSI}!>!=<!> b<!>
+    a <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS!>!=<!> b
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/CanBeValChecker.kt

@@ -23,7 +23,7 @@ operator fun C.plusAssign(a: Any) {}
 fun testOperatorAssignment() {
     val c = C()
     c += ""
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> c1 = C()<!>
+    <!CAN_BE_VAL!>var<!> c1 = C()
     <!ASSIGN_OPERATOR_AMBIGUITY!>c1 += ""<!>
 
     var a = 1
@@ -33,7 +33,7 @@ fun testOperatorAssignment() {
 
 
 fun destructuringDeclaration() {
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> (v1, <!UNUSED_VARIABLE!>v2<!>) = getPair()<!>
+    <!CAN_BE_VAL!>var<!> (v1, <!UNUSED_VARIABLE!>v2<!>) = getPair()
     print(v1)
 
     var (v3, <!VARIABLE_NEVER_READ!>v4<!>) = getPair()
@@ -49,11 +49,11 @@ fun destructuringDeclaration() {
 
     val (<!UNUSED_VARIABLE!>a<!>, <!UNUSED_VARIABLE!>b<!>, <!UNUSED_VARIABLE!>c<!>) = Triple(1, 1, 1)
 
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> (<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>, <!UNUSED_VARIABLE!>z<!>) = Triple(1, 1, 1)<!>
+    <!CAN_BE_VAL!>var<!> (<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>, <!UNUSED_VARIABLE!>z<!>) = Triple(1, 1, 1)
 }
 
 fun stackOverflowBug() {
-    <!CAN_BE_VAL{LT}, VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL{PSI}!>var<!> <!VARIABLE_NEVER_READ{PSI}!>a<!>: Int<!>
+    <!VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL!>var<!> <!VARIABLE_NEVER_READ{PSI}!>a<!>: Int<!>
     <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = 1
     for (i in 1..10)
         print(i)
@@ -71,8 +71,8 @@ fun smth(flag: Boolean) {
 }
 
 fun withAnnotation(p: List<Any>) {
-    <!CAN_BE_VAL{LT}!>@Suppress("UNCHECKED_CAST")
-    <!CAN_BE_VAL{PSI}!>var<!> v = p as List<String><!>
+    @Suppress("UNCHECKED_CAST")
+    <!CAN_BE_VAL!>var<!> v = p as List<String>
     print(v)
 }
 
@@ -88,7 +88,7 @@ fun listReceiver(p: List<String>) {}
 fun withInitializer() {
     <!VARIABLE_NEVER_READ{LT}!>var <!VARIABLE_NEVER_READ{PSI}!>v1<!> = 1<!>
     var v2 = 2
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> v3 = 3<!>
+    <!CAN_BE_VAL!>var<!> v3 = 3
     <!ASSIGNED_VALUE_IS_NEVER_READ!>v1<!> = 1
     <!ASSIGNED_VALUE_IS_NEVER_READ!>v2<!>++ // todo mark this UNUSED_CHANGED_VALUES
     print(v3)
@@ -102,7 +102,7 @@ fun test() {
 }
 
 fun foo() {
-    <!CAN_BE_VAL{LT}, VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL{PSI}!>var<!> <!VARIABLE_NEVER_READ{PSI}!>a<!>: Int<!>
+    <!VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL!>var<!> <!VARIABLE_NEVER_READ{PSI}!>a<!>: Int<!>
     val bool = true
     if (bool) <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = 4 else <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = 42
     <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>b<!>: String<!>
@@ -130,7 +130,7 @@ fun assignedTwice(p: Int) {
 }
 
 fun main(args: Array<String?>) {
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> a: String?<!>
+    <!CAN_BE_VAL!>var<!> a: String?
     <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>unused<!> = 0<!>
 
     if (args.size == 1) {
@@ -153,7 +153,7 @@ fun lambda() {
 }
 
 fun lambdaInitialization() {
-    <!CAN_BE_VAL{LT}, VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL{PSI}!>var<!> <!VARIABLE_NEVER_READ{PSI}!>a<!>: Int<!>
+    <!VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL!>var<!> <!VARIABLE_NEVER_READ{PSI}!>a<!>: Int<!>
 
     run {
         <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = 20
@@ -161,7 +161,7 @@ fun lambdaInitialization() {
 }
 
 fun notAssignedWhenNotUsed(p: Int) {
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> v: Int<!>
+    <!CAN_BE_VAL!>var<!> v: Int
     if (p > 0) {
         v = 1
         print(v)

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantExplicitTypeChecker.kt

@@ -52,7 +52,7 @@ fun foo() {
     <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>piFloat<!>: <!REDUNDANT_EXPLICIT_TYPE!>Float<!> = 3.14f<!>
     <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>piDouble<!>: <!REDUNDANT_EXPLICIT_TYPE!>Double<!> = 3.14<!>
     <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>charZ<!>: <!REDUNDANT_EXPLICIT_TYPE!>Char<!> = 'z'<!>
-    <!CAN_BE_VAL{LT}, UNUSED_VARIABLE{LT}!><!CAN_BE_VAL{PSI}!>var<!> <!UNUSED_VARIABLE{PSI}!>alpha<!>: <!REDUNDANT_EXPLICIT_TYPE!>Int<!> = 0<!>
+    <!UNUSED_VARIABLE{LT}!><!CAN_BE_VAL!>var<!> <!UNUSED_VARIABLE{PSI}!>alpha<!>: <!REDUNDANT_EXPLICIT_TYPE!>Int<!> = 0<!>
 }
 
 fun test(boolean: Boolean) {

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantModalityModifierChecker.kt

@@ -4,23 +4,23 @@ object O {
 
 // Interface
 interface Interface {
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Questionable cuz compiler reports warning here in FE 1.0
-    <!REDUNDANT_MODALITY_MODIFIER{PSI}!>open<!> val gav: Int
-        get() = 42<!>
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant
-    <!REDUNDANT_MODALITY_MODIFIER{PSI}!>abstract<!> fun foo()<!>
-    <!PRIVATE_FUNCTION_WITH_NO_BODY{LT}!>// error
-    <!PRIVATE_FUNCTION_WITH_NO_BODY{PSI}!>private<!> final fun bar()<!>
+    // Questionable cuz compiler reports warning here in FE 1.0
+    <!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav: Int
+        get() = 42
+    // Redundant
+    <!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun foo()
+    // error
+    <!PRIVATE_FUNCTION_WITH_NO_BODY!>private<!> final fun bar()
 
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!><!REDUNDANT_MODALITY_MODIFIER{PSI}!>open<!> fun goo() {}<!>
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!><!REDUNDANT_MODALITY_MODIFIER{PSI}!>abstract<!> fun tar()<!>
+    <!REDUNDANT_MODALITY_MODIFIER!>open<!> fun goo() {}
+    <!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun tar()
 
-    <!ABSTRACT_FUNCTION_WITH_BODY{LT}!>// error
-    <!ABSTRACT_FUNCTION_WITH_BODY{PSI}!>abstract<!> fun too() {}<!>
+    // error
+    <!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun too() {}
 }
 interface B {
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!><!REDUNDANT_MODALITY_MODIFIER{PSI}!>abstract<!> var bar: Unit<!>
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!><!REDUNDANT_MODALITY_MODIFIER{PSI}!>abstract<!> fun foo()<!>
+    <!REDUNDANT_MODALITY_MODIFIER!>abstract<!> var bar: Unit
+    <!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun foo()
 }
 interface Foo
 
@@ -35,8 +35,8 @@ expect abstract class AbstractClass : Foo {
 
 // Abstract
 abstract class Base {
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant final
-    <!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> fun foo() {}<!>
+    // Redundant final
+    <!REDUNDANT_MODALITY_MODIFIER!>final<!> fun foo() {}
     // Abstract
     abstract fun bar()
     // Open
@@ -44,8 +44,8 @@ abstract class Base {
 }
 
 class FinalDerived : Base() {
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant final
-    override <!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> fun bar() {}<!>
+    // Redundant final
+    override <!REDUNDANT_MODALITY_MODIFIER!>final<!> fun bar() {}
     // Non-final member in final class
     override open val gav = 13
 }
@@ -53,33 +53,33 @@ class FinalDerived : Base() {
 open class OpenDerived : Base() {
     // Final
     override final fun bar() {}
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant open
-    override <!REDUNDANT_MODALITY_MODIFIER{PSI}!>open<!> val gav = 13<!>
+    // Redundant open
+    override <!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav = 13
 }
-<!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant final
-<!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> class Final<!>
+// Redundant final
+<!REDUNDANT_MODALITY_MODIFIER!>final<!> class Final
 // Derived interface
 interface Derived : Interface {
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant
-    override <!REDUNDANT_MODALITY_MODIFIER{PSI}!>open<!> fun foo() {}<!>
+    // Redundant
+    override <!REDUNDANT_MODALITY_MODIFIER!>open<!> fun foo() {}
     // error
     final class Nested
 }
 // Derived abstract class
 abstract class AbstractDerived1(override final val gav: Int) : Interface {
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant
-    override <!REDUNDANT_MODALITY_MODIFIER{PSI}!>open<!> fun foo() {}<!>
+    // Redundant
+    override <!REDUNDANT_MODALITY_MODIFIER!>open<!> fun foo() {}
 }
 // Derived abstract class
 abstract class AbstractDerived2 : Interface {
     // Final
     override final fun foo() {}
-    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant
-    override <!REDUNDANT_MODALITY_MODIFIER{PSI}!>open<!> val gav = 13<!>
+    // Redundant
+    override <!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav = 13
 }
 // Redundant abstract interface
 abstract interface AbstractInterface
-<!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant final object
-<!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> object FinalObject<!>
+// Redundant final object
+<!REDUNDANT_MODALITY_MODIFIER!>final<!> object FinalObject
 // Open interface
 open interface OpenInterface

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantVisibilityModifierChecker.kt

@@ -1,7 +1,7 @@
 fun f() {
-    <!CAN_BE_VAL{LT}, REDUNDANT_VISIBILITY_MODIFIER{LT}, UNUSED_VARIABLE{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> <!CAN_BE_VAL{PSI}!>var<!> <!UNUSED_VARIABLE{PSI}!>baz<!> = 0<!>
+    <!UNUSED_VARIABLE{LT}!><!REDUNDANT_VISIBILITY_MODIFIER!>public<!> <!CAN_BE_VAL!>var<!> <!UNUSED_VARIABLE{PSI}!>baz<!> = 0<!>
     class LocalClass {
-        <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>internal<!> var foo = 0<!>
+        <!REDUNDANT_VISIBILITY_MODIFIER!>internal<!> var foo = 0
     }
     LocalClass().foo = 1
 }
@@ -26,10 +26,10 @@ class Foo2<
     internal inner class B<T,T2,>
 }
 
-<!REDECLARATION, REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> class C {
-    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> val foo: Int = 0<!>
+<!REDECLARATION!><!REDUNDANT_VISIBILITY_MODIFIER!>public<!> class C {
+    <!REDUNDANT_VISIBILITY_MODIFIER!>public<!> val foo: Int = 0
 
-    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> fun bar() {}<!>
+    <!REDUNDANT_VISIBILITY_MODIFIER!>public<!> fun bar() {}
 
 }<!>
 
@@ -42,19 +42,19 @@ open class D {
 }
 
 class E : D() {
-    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>protected<!> override fun willRemainProtected() {
-    }<!>
+    <!REDUNDANT_VISIBILITY_MODIFIER!>protected<!> override fun willRemainProtected() {
+    }
 
     public override fun willBecomePublic() {
     }
 }
 
-enum class F <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>private<!> constructor(val x: Int)<!> {
+enum class F <!REDUNDANT_VISIBILITY_MODIFIER!>private<!> constructor(val x: Int) {
     FIRST(42)
 }
 
 sealed class G constructor(val y: Int) {
-    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>private<!> constructor(): this(42)<!>
+    <!REDUNDANT_VISIBILITY_MODIFIER!>private<!> constructor(): this(42)
 
     object H : G()
 }
@@ -63,16 +63,16 @@ interface I {
     fun bar()
 }
 
-<!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> var baz = 0<!>
+<!REDUNDANT_VISIBILITY_MODIFIER!>public<!> var baz = 0
 
 open class J {
     protected val baz = 0
-    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>protected<!> get() = field * 2<!>
+    <!REDUNDANT_VISIBILITY_MODIFIER!>protected<!> get() = field * 2
     var baf = 0
-    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> get() = 1<!>
-    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> set(value) {
+    <!REDUNDANT_VISIBILITY_MODIFIER!>public<!> get() = 1
+    <!REDUNDANT_VISIBILITY_MODIFIER!>public<!> set(value) {
         field = value
-    }<!>
+    }
 
     var buf = 0
         private get() = 42

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/BasicTest.kt

@@ -1,7 +1,7 @@
 fun goo() {
     var a = 2
     val b = 4
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!>a <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> a + 1 + b<!>
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!>a <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> (a + 1)<!>
+    a <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> a + 1 + b
+    a <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> (a + 1)
     <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = a * b + 1
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/multipleOperators.kt

@@ -1,5 +1,5 @@
 fun foo() {
     var x = 0
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> y = 0<!>
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!><!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> x + y + 5<!>
+    <!CAN_BE_VAL!>var<!> y = 0
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> x + y + 5
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/multipleOperatorsRightSideRepeat.kt

@@ -1,5 +1,5 @@
 fun foo() {
     var x = 0
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> y = 0<!>
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!><!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> y + x + 5<!>
+    <!CAN_BE_VAL!>var<!> y = 0
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> y + x + 5
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/nonCommutativeRepeat.kt

@@ -1,8 +1,8 @@
 fun foo() {
     var x = 0
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!>x <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> x - 1 - 1<!>
+    x <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> x - 1 - 1
 
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!>x <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> x / 1<!>
+    x <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> x / 1
     x = 1 / x
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!><!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> -1 + x<!>
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> -1 + x
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/rightSideRepeat.kt

@@ -1,4 +1,4 @@
 fun foo() {
     var x = 0
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!><!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> 1 + x<!>
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> 1 + x
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/simpleAssign.kt

@@ -1,5 +1,5 @@
 fun foo() {
     var y = 0
     val x = 0
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!><!ASSIGNED_VALUE_IS_NEVER_READ!>y<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> y + x<!>
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>y<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> y + x
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/validAddition.kt

@@ -1,4 +1,4 @@
 fun foo() {
     var x = 0
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!><!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> x + 1<!>
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> x + 1
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/validSubtraction.kt

@@ -1,4 +1,4 @@
 fun foo() {
     var x = 0
-    <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{LT}!><!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT{PSI}!>=<!> x - 1<!>
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>x<!> <!CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT!>=<!> x - 1
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/manyLocalVariables.kt

@@ -1,5 +1,5 @@
 fun foo() {
-    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> a = 1<!>
+    <!CAN_BE_VAL!>var<!> a = 1
     var b = <!VARIABLE_INITIALIZER_IS_REDUNDANT!>2<!>
     var c = 3