[Test] Migrate AbstractExtendedFirDiagnosticsTest to new infrastructure

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

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

compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod/nullable.kt

@@ -1,5 +0,0 @@
-// WITH_RUNTIME
-// IS_APPLICABLE: false
-fun foo(s: String?) {
-    val <!UNUSED_VARIABLE!>t<!>: String = s.toString()
-}

compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod/safeString2.kt

@@ -1,6 +0,0 @@
-// WITH_RUNTIME
-data class Foo(val name: String)
-
-fun test(foo: Foo?) {
-    val <!UNUSED_VARIABLE!>s<!>: String? = foo?.name?.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toString()<!>
-}

compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod/uByte.kt

@@ -1,4 +0,0 @@
-// WITH_RUNTIME
-fun test(i: UByte) {
-    val <!UNUSED_VARIABLE!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toUByte()<!>
-}

compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod/uInt.kt

@@ -1,4 +0,0 @@
-// WITH_RUNTIME
-fun test(i: UInt) {
-    val <!UNUSED_VARIABLE!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toUInt()<!>
-}

compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod/uLong.kt

@@ -1,4 +0,0 @@
-// WITH_RUNTIME
-fun test(i: ULong) {
-    val <!UNUSED_VARIABLE!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toULong()<!>
-}

compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod/uShort.kt

@@ -1,4 +0,0 @@
-// WITH_RUNTIME
-fun test(i: UShort) {
-    val <!UNUSED_VARIABLE!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toUShort()<!>
-}

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

@@ -1,76 +0,0 @@
-import kotlin.reflect.KClass
-
-@Target(AnnotationTarget.TYPE)
-annotation class A
-
-fun annotated() {
-    val <!UNUSED_VARIABLE!>x<!>: @A Int /* NOT redundant */ = 1
-}
-
-object SomeObj
-fun fer() {
-    val <!UNUSED_VARIABLE!>x<!>: Any /* NOT redundant */ = SomeObj
-}
-
-fun f2(y: String?): String {
-    val <!UNUSED_VARIABLE!>f<!>: KClass<*> = (y ?: return "")::class
-    return ""
-}
-
-object Obj {}
-
-interface IA
-interface IB : IA
-
-fun IA.extFun(x: IB) {}
-
-fun testWithExpectedType() {
-    val <!UNUSED_VARIABLE!>extFun_AB_A<!>: IA.(IB) -> Unit = IA::extFun
-}
-
-interface Point {
-    val x: Int
-    val y: Int
-}
-
-class PointImpl(override val x: Int, override val y: Int) : Point
-
-fun foo() {
-    val <!UNUSED_VARIABLE!>s<!>: <!REDUNDANT_EXPLICIT_TYPE!>String<!> = "Hello ${10+1}"
-    val <!UNUSED_VARIABLE!>str<!>: String? = ""
-
-    val <!UNUSED_VARIABLE!>o<!>: <!REDUNDANT_EXPLICIT_TYPE!>Obj<!> = Obj
-
-    val <!UNUSED_VARIABLE!>p<!>: Point = PointImpl(1, 2)
-    val <!UNUSED_VARIABLE!>a<!>: <!REDUNDANT_EXPLICIT_TYPE!>Boolean<!> = true
-    val <!UNUSED_VARIABLE!>i<!>: Int = 2 * 2
-    val <!UNUSED_VARIABLE!>l<!>: <!REDUNDANT_EXPLICIT_TYPE!>Long<!> = 1234567890123L
-    val <!UNUSED_VARIABLE!>s<!>: String? = null
-    val <!UNUSED_VARIABLE!>sh<!>: Short = 42
-
-    val <!UNUSED_VARIABLE!>integer<!>: <!REDUNDANT_EXPLICIT_TYPE!>Int<!> = 42
-    val <!UNUSED_VARIABLE!>piFloat<!>: <!REDUNDANT_EXPLICIT_TYPE!>Float<!> = 3.14f
-    val <!UNUSED_VARIABLE!>piDouble<!>: <!REDUNDANT_EXPLICIT_TYPE!>Double<!> = 3.14
-    val <!UNUSED_VARIABLE!>charZ<!>: <!REDUNDANT_EXPLICIT_TYPE!>Char<!> = 'z'
-    <!CAN_BE_VAL!>var<!> <!UNUSED_VARIABLE!>alpha<!>: <!REDUNDANT_EXPLICIT_TYPE!>Int<!> = 0
-}
-
-fun test(boolean: Boolean) {
-    val <!UNUSED_VARIABLE!>expectedLong<!>: Long = if (boolean) {
-        42
-    } else {
-        return
-    }
-}
-
-class My {
-    val x: Int = 1
-}
-
-val ZERO: Int = 0
-
-fun main() {
-    val <!UNUSED_VARIABLE!>id<!>: Id = 11
-}
-
-typealias Id = Int

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

@@ -1,85 +0,0 @@
-object O {
-    fun foo() {}
-}
-
-// Interface
-interface Interface {
-    // 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 final fun bar() {}
-
-    <!REDUNDANT_MODALITY_MODIFIER!>open<!> fun goo() {}
-    <!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun tar()
-
-    // error
-    abstract fun too() {}
-}
-interface B {
-    <!REDUNDANT_MODALITY_MODIFIER!>abstract<!> var bar: Unit
-    <!REDUNDANT_MODALITY_MODIFIER!>abstract<!> fun foo()
-}
-interface Foo
-
-expect abstract class AbstractClass : Foo {
-    abstract override fun foo()
-
-    abstract fun bar()
-
-    abstract val baz: Int
-}
-
-
-// Abstract
-abstract class Base {
-    // Redundant final
-    <!REDUNDANT_MODALITY_MODIFIER!>final<!> fun foo() {}
-    // Abstract
-    abstract fun bar()
-    // Open
-    open val gav = 42
-}
-
-class FinalDerived : Base() {
-    // Redundant final
-    override <!REDUNDANT_MODALITY_MODIFIER!>final<!> fun bar() {}
-    // Non-final member in final class
-    override open val gav = 13
-}
-// Open
-open class OpenDerived : Base() {
-    // Final
-    override final fun bar() {}
-    // Redundant open
-    override <!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav = 13
-}
-// Redundant final
-<!REDUNDANT_MODALITY_MODIFIER!>final<!> class Final
-// Derived interface
-interface Derived : Interface {
-    // 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
-    override <!REDUNDANT_MODALITY_MODIFIER!>open<!> fun foo() {}
-}
-// Derived abstract class
-abstract class AbstractDerived2 : Interface {
-    // Final
-    override final fun foo() {}
-    // Redundant
-    override <!REDUNDANT_MODALITY_MODIFIER!>open<!> val gav = 13
-}
-// Redundant abstract interface
-abstract interface AbstractInterface
-// Redundant final object
-<!REDUNDANT_MODALITY_MODIFIER!>final<!> object FinalObject
-// Open interface
-open interface OpenInterface

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

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

compiler/fir/analysis-tests/testData/extendedCheckers/UselessCallOnNotNullChecker/Sequence.kt

@@ -1,5 +0,0 @@
-// WITH_RUNTIME
-
-fun test(s: Sequence<Int>) {
-    val <!UNUSED_VARIABLE!>foo<!> = s.<!USELESS_CALL_ON_NOT_NULL!>orEmpty()<!>
-}

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

@@ -1,7 +0,0 @@
-fun goo() {
-    var a = 2
-    val b = 4
-    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/extendedCheckers/canBeReplacedWithOperatorAssignment/multipleOperators.kt

@@ -1,5 +0,0 @@
-fun foo() {
-    var x = 0
-    <!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/extendedCheckers/canBeReplacedWithOperatorAssignment/multipleOperatorsRightSideRepeat.kt

@@ -1,5 +0,0 @@
-fun foo() {
-    var x = 0
-    <!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/extendedCheckers/canBeReplacedWithOperatorAssignment/nonCommutativeRepeat.kt

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+// WITH_RUNTIME
+
+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<!>) { }
+}
+
+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 == c
+    <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{LT}!>a <!ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS{PSI}!>!=<!> b<!>
+}

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

@@ -4,8 +4,8 @@ import kotlin.reflect.KProperty
 import kotlin.properties.Delegates
 
 fun testDelegator() {
-    var <!UNUSED_VARIABLE!>x<!>: Boolean by LocalFreezableVar(true)
-    var <!UNUSED_VARIABLE!>y<!> by LocalFreezableVar("")
+    <!UNUSED_VARIABLE{LT}!>var <!UNUSED_VARIABLE{PSI}!>x<!>: Boolean by LocalFreezableVar(true)<!>
+    <!UNUSED_VARIABLE{LT}!>var <!UNUSED_VARIABLE{PSI}!>y<!> by LocalFreezableVar("")<!>
 }
 
 class LocalFreezableVar<T>(private var value: T)  {
@@ -23,7 +23,7 @@ operator fun C.plusAssign(a: Any) {}
 fun testOperatorAssignment() {
     val c = C()
     c += ""
-    <!CAN_BE_VAL!>var<!> c1 = C()
+    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> c1 = C()<!>
     <!ASSIGN_OPERATOR_AMBIGUITY!>c1 += ""<!>
 
     var a = 1
@@ -33,7 +33,7 @@ fun testOperatorAssignment() {
 
 
 fun destructuringDeclaration() {
-    <!CAN_BE_VAL!>var<!> (v1, <!UNUSED_VARIABLE!>v2<!>) = getPair()
+    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>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!>var<!> (<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>, <!UNUSED_VARIABLE!>z<!>) = 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)<!>
 }
 
 fun stackOverflowBug() {
-    <!CAN_BE_VAL!>var<!> <!VARIABLE_NEVER_READ!>a<!>: Int
+    <!CAN_BE_VAL{LT}, VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL{PSI}!>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>) {
-    @Suppress("UNCHECKED_CAST")
-    <!CAN_BE_VAL!>var<!> v = p as List<String>
+    <!CAN_BE_VAL{LT}!>@Suppress("UNCHECKED_CAST")
+    <!CAN_BE_VAL{PSI}!>var<!> v = p as List<String><!>
     print(v)
 }
 
@@ -86,9 +86,9 @@ fun getPair(): Pair<Int, String> = Pair(1, "1")
 fun listReceiver(p: List<String>) {}
 
 fun withInitializer() {
-    var <!VARIABLE_NEVER_READ!>v1<!> = 1
+    <!VARIABLE_NEVER_READ{LT}!>var <!VARIABLE_NEVER_READ{PSI}!>v1<!> = 1<!>
     var v2 = 2
-    <!CAN_BE_VAL!>var<!> v3 = 3
+    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>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,10 +102,10 @@ fun test() {
 }
 
 fun foo() {
-    <!CAN_BE_VAL!>var<!> <!VARIABLE_NEVER_READ!>a<!>: Int
+    <!CAN_BE_VAL{LT}, VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL{PSI}!>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
-    val <!UNUSED_VARIABLE!>b<!>: String
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>b<!>: String<!>
 
     <!ASSIGNED_VALUE_IS_NEVER_READ!>bool<!> = false
 }
@@ -116,7 +116,7 @@ fun cycles() {
         a--
     }
 
-    var <!VARIABLE_NEVER_READ!>b<!>: Int
+    <!VARIABLE_NEVER_READ{LT}!>var <!VARIABLE_NEVER_READ{PSI}!>b<!>: Int<!>
     while (a < 10) {
         a++
         <!ASSIGNED_VALUE_IS_NEVER_READ!>b<!> = a
@@ -124,14 +124,14 @@ fun cycles() {
 }
 
 fun assignedTwice(p: Int) {
-    var <!VARIABLE_NEVER_READ!>v<!>: Int
+    <!VARIABLE_NEVER_READ{LT}!>var <!VARIABLE_NEVER_READ{PSI}!>v<!>: Int<!>
     <!ASSIGNED_VALUE_IS_NEVER_READ!>v<!> = 0
     if (p > 0) <!ASSIGNED_VALUE_IS_NEVER_READ!>v<!> = 1
 }
 
 fun main(args: Array<String?>) {
-    <!CAN_BE_VAL!>var<!> a: String?
-    val <!UNUSED_VARIABLE!>unused<!> = 0
+    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> a: String?<!>
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>unused<!> = 0<!>
 
     if (args.size == 1) {
         <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = args[0]
@@ -144,7 +144,7 @@ fun main(args: Array<String?>) {
 fun run(f: () -> Unit) = f()
 
 fun lambda() {
-    var <!VARIABLE_NEVER_READ!>a<!>: Int
+    <!VARIABLE_NEVER_READ{LT}!>var <!VARIABLE_NEVER_READ{PSI}!>a<!>: Int<!>
     <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = 10
 
     run {
@@ -153,7 +153,7 @@ fun lambda() {
 }
 
 fun lambdaInitialization() {
-    <!CAN_BE_VAL!>var<!> <!VARIABLE_NEVER_READ!>a<!>: Int
+    <!CAN_BE_VAL{LT}, VARIABLE_NEVER_READ{LT}!><!CAN_BE_VAL{PSI}!>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!>var<!> v: Int
+    <!CAN_BE_VAL{LT}!><!CAN_BE_VAL{PSI}!>var<!> v: Int<!>
     if (p > 0) {
         v = 1
         print(v)
@@ -180,6 +180,6 @@ class C {
 }
 
 fun withDelegate() {
-    var <!VARIABLE_NEVER_READ!>s<!>: String by Delegates.notNull()
+    <!VARIABLE_NEVER_READ{LT}!>var <!VARIABLE_NEVER_READ{PSI}!>s<!>: String by Delegates.notNull()<!>
     <!ASSIGNED_VALUE_IS_NEVER_READ!>s<!> = ""
 }

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/nullable.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+// IS_APPLICABLE: false
+fun foo(s: String?) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>t<!>: String = s.toString()<!>
+}

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/nullable2.kt

@@ -3,5 +3,5 @@
 data class Foo(val name: String)
 
 fun nullable2(foo: Foo?) {
-    val <!UNUSED_VARIABLE!>s<!>: String = foo?.name.toString()
-}
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>s<!>: String = foo?.name.toString()<!>
+}

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/safeString2.kt

@@ -0,0 +1,6 @@
+// WITH_RUNTIME
+data class Foo(val name: String)
+
+fun test(foo: Foo?) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>s<!>: String? = foo?.name?.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toString()<!><!>
+}

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uByte.kt

@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun test(i: UByte) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toUByte()<!><!>
+}

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uInt.kt

@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun test(i: UInt) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toUInt()<!><!>
+}

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uLong.kt

@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun test(i: ULong) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toULong()<!><!>
+}

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uShort.kt

@@ -0,0 +1,4 @@
+// WITH_RUNTIME
+fun test(i: UShort) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>foo<!> = i.<!REDUNDANT_CALL_OF_CONVERSION_METHOD!>toUShort()<!><!>
+}

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

@@ -0,0 +1,76 @@
+import kotlin.reflect.KClass
+
+@Target(AnnotationTarget.TYPE)
+annotation class A
+
+fun annotated() {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>x<!>: @A Int /* NOT redundant */ = 1<!>
+}
+
+object SomeObj
+fun fer() {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>x<!>: Any /* NOT redundant */ = SomeObj<!>
+}
+
+fun f2(y: String?): String {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>f<!>: KClass<*> = (y ?: return "")::class<!>
+    return ""
+}
+
+object Obj {}
+
+interface IA
+interface IB : IA
+
+fun IA.extFun(x: IB) {}
+
+fun testWithExpectedType() {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>extFun_AB_A<!>: IA.(IB) -> Unit = IA::extFun<!>
+}
+
+interface Point {
+    val x: Int
+    val y: Int
+}
+
+class PointImpl(override val x: Int, override val y: Int) : Point
+
+fun foo() {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>s<!>: <!REDUNDANT_EXPLICIT_TYPE!>String<!> = "Hello ${10+1}"<!>
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>str<!>: String? = ""<!>
+
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>o<!>: <!REDUNDANT_EXPLICIT_TYPE!>Obj<!> = Obj<!>
+
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>p<!>: Point = PointImpl(1, 2)<!>
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>a<!>: <!REDUNDANT_EXPLICIT_TYPE!>Boolean<!> = true<!>
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>i<!>: Int = 2 * 2<!>
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>l<!>: <!REDUNDANT_EXPLICIT_TYPE!>Long<!> = 1234567890123L<!>
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>s<!>: String? = null<!>
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>sh<!>: Short = 42<!>
+
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>integer<!>: <!REDUNDANT_EXPLICIT_TYPE!>Int<!> = 42<!>
+    <!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<!>
+}
+
+fun test(boolean: Boolean) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>expectedLong<!>: Long = if (boolean) {
+        42
+    } else {
+        return
+    }<!>
+}
+
+class My {
+    val x: Int = 1
+}
+
+val ZERO: Int = 0
+
+fun main() {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>id<!>: Id = 11<!>
+}
+
+typealias Id = Int

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

@@ -0,0 +1,85 @@
+object O {
+    fun foo() {}
+}
+
+// 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()<!>
+    // error
+    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()<!>
+
+    // error
+    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()<!>
+}
+interface Foo
+
+expect abstract class AbstractClass : Foo {
+    abstract override fun foo()
+
+    abstract fun bar()
+
+    abstract val baz: Int
+}
+
+
+// Abstract
+abstract class Base {
+    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant final
+    <!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> fun foo() {}<!>
+    // Abstract
+    abstract fun bar()
+    // Open
+    open val gav = 42
+}
+
+class FinalDerived : Base() {
+    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant final
+    override <!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> fun bar() {}<!>
+    // Non-final member in final class
+    override open val gav = 13
+}
+// Open
+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_MODALITY_MODIFIER{LT}!>// Redundant final
+<!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> class Final<!>
+// Derived interface
+interface Derived : Interface {
+    <!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant
+    override <!REDUNDANT_MODALITY_MODIFIER{PSI}!>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() {}<!>
+}
+// 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 abstract interface
+abstract interface AbstractInterface
+<!REDUNDANT_MODALITY_MODIFIER{LT}!>// Redundant final object
+<!REDUNDANT_MODALITY_MODIFIER{PSI}!>final<!> object FinalObject<!>
+// Open interface
+open interface OpenInterface

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

@@ -0,0 +1,86 @@
+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<!>
+    class LocalClass {
+        <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>internal<!> var foo = 0<!>
+    }
+    LocalClass().foo = 1
+}
+
+internal inline fun internal() {
+    f()
+}
+
+<!REDECLARATION!>class C {
+    internal val z = object {
+        fun foo() = 13
+    }
+}<!>
+
+class Foo2<
+        T1,
+        T2: T1,
+        > {
+    fun <T1,
+            T2, > 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<!>
+
+    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> fun bar() {}<!>
+
+}<!>
+
+open class D {
+    protected open fun willRemainProtected() {
+    }
+
+    protected open fun willBecomePublic() {
+    }
+}
+
+class E : D() {
+    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>protected<!> override fun willRemainProtected() {
+    }<!>
+
+    public override fun willBecomePublic() {
+    }
+}
+
+enum class F <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>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)<!>
+
+    object H : G()
+}
+
+interface I {
+    fun bar()
+}
+
+<!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>public<!> var baz = 0<!>
+
+open class J {
+    protected val baz = 0
+    <!REDUNDANT_VISIBILITY_MODIFIER{LT}!><!REDUNDANT_VISIBILITY_MODIFIER{PSI}!>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) {
+        field = value
+    }<!>
+
+    var buf = 0
+        private get() = 42
+        protected set(value) {
+            field = value
+        }
+
+    var bar = 0
+        get() = 3.1415926535
+        set(value) {}
+}

compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/Sequence.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(s: Sequence<Int>) {
+    <!UNUSED_VARIABLE{LT}!>val <!UNUSED_VARIABLE{PSI}!>foo<!> = s.<!USELESS_CALL_ON_NOT_NULL!>orEmpty()<!><!>
+}

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

@@ -0,0 +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)<!>
+    <!ASSIGNED_VALUE_IS_NEVER_READ!>a<!> = a * b + 1
+}