[Test] Disable UNUSED_* diagnostics in tests which are not belong to contolFlowAnalysis suite

compiler/testData/diagnostics/tests/generics/Projections.kt

@@ -2,9 +2,9 @@
 // !CHECK_TYPE
 
 class In<in T>() {
-    fun f(<!UNUSED_PARAMETER!>t<!> : T) : Unit {}
-    fun f(<!UNUSED_PARAMETER!>t<!> : Int) : Int = 1
-    fun f1(<!UNUSED_PARAMETER!>t<!> : T) : Unit {}
+    fun f(t : T) : Unit {}
+    fun f(t : Int) : Int = 1
+    fun f1(t : T) : Unit {}
 }
 
 class Out<out T>() {
@@ -14,7 +14,7 @@ class Out<out T>() {
 
 class Inv<T>() {
     fun f(t : T) : T = t
-    fun inf(<!UNUSED_PARAMETER!>t<!> : T) : Unit {}
+    fun inf(t : T) : Unit {}
     fun outf() : T {throw IllegalStateException()}
 }
 

compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.kt

@@ -1,4 +1,4 @@
-public fun foo(a: Any, <!UNUSED_PARAMETER!>b<!>: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
+public fun foo(a: Any, b: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Map<!>) {
     when (a) {
         is Map<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> -> {}
         is <!NO_TYPE_ARGUMENTS_ON_RHS!>Map<!> -> {}
@@ -10,4 +10,4 @@ public fun foo(a: Any, <!UNUSED_PARAMETER!>b<!>: <!WRONG_NUMBER_OF_TYPE_ARGUMENT
         is Int -> {}
         else -> {}
     }
-}
+}

compiler/testData/diagnostics/tests/generics/genericsInType.kt

@@ -32,5 +32,5 @@ fun test() {
 fun <T: Foo<String.<!UNRESOLVED_REFERENCE!>Bar<!>>> x() {}
 fun Foo<String>.<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Bar<!>.ext() {}
 
-fun ex1(<!UNUSED_PARAMETER!>a<!>: Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar<String>): Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar<String> {
-<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+fun ex1(a: Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar<String>): Foo<!TYPE_ARGUMENTS_FOR_OUTER_CLASS_WHEN_NESTED_REFERENCED!><String><!>.Bar<String> {
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt

@@ -45,7 +45,7 @@ fun test() {
     x().foo().a() checkType { _<A<String, Double, Short, Long>>() }
     x().bar() checkType { _<A<String, Double, Short, Char>>() }
 
-    x = <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH!>foobar<Int>()<!>
+    x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
 
     var y = noParameters()
     y = noParameters()

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt

@@ -46,7 +46,7 @@ class Outer<T> {
             x().foo().a() checkType { _<A<T, F, String, Double, Short, Long>>() }
             x().bar() checkType { _<A<T, F, String, Double, Short, Char>>() }
 
-            x = <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH!>foobar<Int>()<!>
+            x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
             x = <!TYPE_MISMATCH!>z.<!TYPE_MISMATCH{NI}!>foobar<String>()<!><!>
 
             var y = noParameters()

compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt

@@ -32,7 +32,7 @@ fun main() {
     checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
 
     checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.bar()<!>)
-    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>outer.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>Inner()<!><!>)
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>outer.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>Inner()<!><!>)
 
     outer.set(outer.bar())
     outer.set(outer.Inner())

compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt

@@ -14,14 +14,14 @@ class A<E> {
 fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
     a.foo {
         val x: String = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> // Should be no TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS
-        <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH!>""<!>
+        <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
     }
-    a.bar { <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH!>Out<CharSequence>()<!> }
+    a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
     a.bar { Out() }
-    a.bar { <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH!>z.id()<!> }
+    a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
 
     a.foo {
-        z.foobar(if (1 > 2) return@foo <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH!>""<!> else "")
-        <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH!>""<!>
+        z.foobar(if (1 > 2) return@foo <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
+        <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
     }
 }

compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt

@@ -6,10 +6,10 @@ fun <T> id(p: T): T = p
 fun <A> main() {
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>C<!>()
 
-    val <!UNUSED_VARIABLE!>a<!>: C<A> = <!TYPE_PARAMETER_AS_REIFIED!>C<!>()
+    val a: C<A> = <!TYPE_PARAMETER_AS_REIFIED!>C<!>()
     C<<!TYPE_PARAMETER_AS_REIFIED!>A<!>>()
 
-    val <!UNUSED_VARIABLE!>b<!>: C<Int> = C()
+    val b: C<Int> = C()
     C<Int>()
 
     // TODO svtk, uncomment when extensions are called for nested calls!

compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt

@@ -12,11 +12,11 @@ fun <T> id(p: T): T = p
 fun <A> main() {
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>f<!>()
 
-    val <!UNUSED_VARIABLE!>a<!>: A = <!TYPE_PARAMETER_AS_REIFIED!>f<!>()
+    val a: A = <!TYPE_PARAMETER_AS_REIFIED!>f<!>()
     f<<!TYPE_PARAMETER_AS_REIFIED!>A<!>>()
 
-    val <!UNUSED_VARIABLE!>b<!>: Int = f()
+    val b: Int = f()
     f<Int>()
 
-    val <!UNUSED_VARIABLE!>с<!>: A = id(<!TYPE_PARAMETER_AS_REIFIED!>f<!>())
+    val с: A = id(<!TYPE_PARAMETER_AS_REIFIED!>f<!>())
 }

compiler/testData/diagnostics/tests/generics/tpAsReified/InType.kt

@@ -1,4 +1,4 @@
 class C<<!REIFIED_TYPE_PARAMETER_NO_INLINE!>reified<!> T>
 
-fun <A> main(<!UNUSED_PARAMETER!>p1<!>: C<A>, <!UNUSED_PARAMETER!>p2<!>: C<Int>) {
-}
+fun <A> main(p1: C<A>, p2: C<Int>) {
+}

compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutPlusAssignDefined.fir.kt

@@ -1,13 +0,0 @@
-// !DIAGNOSTICS: -UNREACHABLE_CODE
-interface Tr<T> {
-    var v: T
-}
-
-class C {
-    operator fun plusAssign(c: C) {}
-}
-
-fun test(t: Tr<out C>) {
-    // No error because no real assignment happens
-    t.v += null!!
-}

compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutPlusAssignDefined.kt

@@ -1,13 +1,14 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNREACHABLE_CODE
 interface Tr<T> {
     var v: T
 }
 
 class C {
-    operator fun plusAssign(<!UNUSED_PARAMETER!>c<!>: C) {}
+    operator fun plusAssign(c: C) {}
 }
 
 fun test(t: Tr<out C>) {
     // No error because no real assignment happens
     t.v += null!!
-}
+}