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

2021-03-29 12:14:16 +03:00
parent 85949b387e
commit cd890d5833
758 changed files with 1832 additions and 3745 deletions
@@ -5,5 +5,5 @@ class A {
 }

 fun a(aa : A) {
-    val (<!UNUSED_VARIABLE!>a<!>: String, <!UNUSED_VARIABLE!>b1<!>: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
+    val (a: String, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
 }
@@ -3,18 +3,18 @@ class Out<out T>
 class Inv<T>
 class X

-fun f1(<!UNUSED_PARAMETER!>p<!>: In<<!REDUNDANT_PROJECTION!>in<!> X>) {}
-fun f2(<!UNUSED_PARAMETER!>p<!>: In<<!CONFLICTING_PROJECTION!>out<!> X>) {}
-fun f3(<!UNUSED_PARAMETER!>p<!>: In<X>) {}
+fun f1(p: In<<!REDUNDANT_PROJECTION!>in<!> X>) {}
+fun f2(p: In<<!CONFLICTING_PROJECTION!>out<!> X>) {}
+fun f3(p: In<X>) {}

-fun f4(<!UNUSED_PARAMETER!>p<!>: Out<<!REDUNDANT_PROJECTION!>out<!> X>) {}
-fun f5(<!UNUSED_PARAMETER!>p<!>: Out<<!CONFLICTING_PROJECTION!>in<!> X>) {}
-fun f6(<!UNUSED_PARAMETER!>p<!>: Out<X>) {}
+fun f4(p: Out<<!REDUNDANT_PROJECTION!>out<!> X>) {}
+fun f5(p: Out<<!CONFLICTING_PROJECTION!>in<!> X>) {}
+fun f6(p: Out<X>) {}

-fun f6(<!UNUSED_PARAMETER!>p<!>: Inv<X>) {}
-fun f7(<!UNUSED_PARAMETER!>p<!>: Inv<in X>) {}
-fun f8(<!UNUSED_PARAMETER!>p<!>: Inv<out X>) {}
+fun f6(p: Inv<X>) {}
+fun f7(p: Inv<in X>) {}
+fun f8(p: Inv<out X>) {}

-fun f9(<!UNUSED_PARAMETER!>p<!>: In<*>) {}
-fun f10(<!UNUSED_PARAMETER!>p<!>: Out<*>) {}
-fun f11(<!UNUSED_PARAMETER!>p<!>: Inv<*>) {}
+fun f9(p: In<*>) {}
+fun f10(p: Out<*>) {}
+fun f11(p: Inv<*>) {}
@@ -8,8 +8,8 @@ class A {
 }

 fun foo(list: List<A>) {
-    for (<!VAL_OR_VAR_ON_LOOP_PARAMETER!>var<!> (<!UNUSED_VARIABLE!>c1<!>, <!UNUSED_VARIABLE!>c2<!>, c3) in list) {
-        <!UNUSED_VALUE!><!VAL_REASSIGNMENT!>c1<!> =<!> 1
+    for (<!VAL_OR_VAR_ON_LOOP_PARAMETER!>var<!> (c1, c2, c3) in list) {
+        <!VAL_REASSIGNMENT!>c1<!> = 1
        c3 + 1
    }
 }
@@ -5,10 +5,10 @@ class A {

 fun a(aa : A?, b : Any) {
    if (aa != null) {
-        val (<!UNUSED_VARIABLE!>a1<!>, <!UNUSED_VARIABLE!>b1<!>) = <!DEBUG_INFO_SMARTCAST!>aa<!>;
+        val (a1, b1) = <!DEBUG_INFO_SMARTCAST!>aa<!>;
    }

    if (b is A) {
-        val (<!UNUSED_VARIABLE!>a1<!>, <!UNUSED_VARIABLE!>b1<!>) = <!DEBUG_INFO_SMARTCAST!>b<!>;
+        val (a1, b1) = <!DEBUG_INFO_SMARTCAST!>b<!>;
    }
 }
@@ -18,9 +18,9 @@ class Outer {
 }

 fun outerFun() {
-    <!UNUSED_EXPRESSION!>fun () {}<!>
-    <!UNUSED_EXPRESSION!>fun B.() {}<!>
+    fun () {}
+    fun B.() {}

-    <!UNUSED_EXPRESSION!>@a fun () {}<!>
-    <!UNUSED_EXPRESSION!>fun @a A.() {}<!>
-}
+    @a fun () {}
+    fun @a A.() {}
+}
@@ -1,3 +1,3 @@
 fun test() {
-    val <!UNUSED_VARIABLE, VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>a<!>
+    val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>a<!>
 }
@@ -2,7 +2,7 @@
 package a

 class MyClass {
-    fun component1(<!UNUSED_PARAMETER!>i<!>: Int) {}
+    fun component1(i: Int) {}
 }

 class MyClass2 {}
@@ -4,11 +4,11 @@ class A {
 }

 fun a() {
-    val (<!REDECLARATION, UNUSED_VARIABLE!>a<!>, <!NAME_SHADOWING, REDECLARATION, UNUSED_VARIABLE!>a<!>) = A()
-    val (<!UNUSED_VARIABLE!>x<!>, <!REDECLARATION, UNUSED_VARIABLE!>y<!>) = A();
+    val (<!REDECLARATION!>a<!>, <!NAME_SHADOWING, REDECLARATION!>a<!>) = A()
+    val (x, <!REDECLARATION!>y<!>) = A();
    val <!REDECLARATION!>b<!> = 1
    use(b)
-    val (<!NAME_SHADOWING, REDECLARATION, UNUSED_VARIABLE!>b<!>, <!NAME_SHADOWING, REDECLARATION, UNUSED_VARIABLE!>y<!>) = A();
+    val (<!NAME_SHADOWING, REDECLARATION!>b<!>, <!NAME_SHADOWING, REDECLARATION!>y<!>) = A();
 }


@@ -1,43 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER -UNUSED_VARIABLE
-// !CHECK_TYPE
-fun foo(block: () -> (() -> Int)) {}
-
-fun test() {
-    foo { fun(): Int {return 1} }
-    foo({ fun() = 1 })
-
-    val x1 =
-        if (1 == 1)
-            fun(): Int {return 1}
-        else
-            fun() = 1
-
-    val x2 =
-            if (1 == 1) {
-                fun(): Int {
-                    return 1
-                }
-            }
-            else
-                fun() = 1
-
-    val x3 = when (1) {
-        0 -> fun(): Int {return 1}
-        else -> fun() = 1
-    }
-
-    val x31 = when (1) {
-        0 -> {
-            fun(): Int {return 1}
-        }
-        else -> fun() = 1
-    }
-
-    val x4 = {
-        y: Int -> fun(): Int {return 1}
-    }
-
-    x4 checkType { _<Function1<Int, Function0<Int>>>() }
-
-    { y: Int -> fun(): Int {return 1} }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER -UNUSED_VARIABLE
 // !CHECK_TYPE
 fun foo(block: () -> (() -> Int)) {}
@@ -39,5 +40,5 @@ fun test() {

    x4 checkType { _<Function1<Int, Function0<Int>>>() }

-    <!UNUSED_LAMBDA_EXPRESSION!>{ y: Int -> fun(): Int {return 1} }<!>
+    { y: Int -> fun(): Int {return 1} }
 }
@@ -1,14 +0,0 @@
-class A {
-    operator fun component1() = 1
-    operator fun component2() = 1
-}
-
-class C {
-    operator fun iterator(): Iterator<A> = null!!
-}
-
-fun test() {
-    for ((x, y) in C()) {
-
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
    operator fun component1() = 1
    operator fun component2() = 1
@@ -8,7 +9,7 @@ class C {
 }

 fun test() {
-    for ((<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>) in C()) {
+    for ((x, y) in C()) {

    }
 }
@@ -9,7 +9,7 @@ class C {
 }

 fun test() {
-    for ((<!UNUSED_VARIABLE!>x<!>: Double, <!UNUSED_VARIABLE!>y<!>: Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
+    for ((x: Double, y: Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {

    }
 }
@@ -1,15 +0,0 @@
-class A {
-    <!CONFLICTING_OVERLOADS!>operator fun component1()<!> = 1
-    <!CONFLICTING_OVERLOADS!>operator fun component1()<!> = 1
-    operator fun component2() = 1
-}
-
-class C {
-    operator fun iterator(): Iterator<A> = null!!
-}
-
-fun test() {
-    for ((x, y) in <!COMPONENT_FUNCTION_AMBIGUITY!>C()<!>) {
-
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
    <!CONFLICTING_OVERLOADS!>operator fun component1()<!> = 1
    <!CONFLICTING_OVERLOADS!>operator fun component1()<!> = 1
@@ -9,7 +10,7 @@ class C {
 }

 fun test() {
-    for ((<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>) in <!COMPONENT_FUNCTION_AMBIGUITY!>C()<!>) {
+    for ((x, y) in <!COMPONENT_FUNCTION_AMBIGUITY!>C()<!>) {

    }
 }
@@ -1,13 +0,0 @@
-class A {
-    operator fun component1() = 1
-}
-
-class C {
-    operator fun iterator(): Iterator<A> = null!!
-}
-
-fun test() {
-    for ((x, y) in <!COMPONENT_FUNCTION_MISSING!>C()<!>) {
-
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
    operator fun component1() = 1
 }
@@ -7,7 +8,7 @@ class C {
 }

 fun test() {
-    for ((<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>) in <!COMPONENT_FUNCTION_MISSING!>C()<!>) {
+    for ((x, y) in <!COMPONENT_FUNCTION_MISSING!>C()<!>) {

    }
 }
@@ -1,13 +1,13 @@
 // !WITH_NEW_INFERENCE
 fun useDeclaredVariables() {
    for ((a, b)<!SYNTAX!><!>) {
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
    }
 }

 fun checkersShouldRun() {
-    for ((@A <!UNUSED_VARIABLE!>a<!>, _)<!SYNTAX!><!>) {
+    for ((@A a, _)<!SYNTAX!><!>) {

    }
 }
@@ -1,14 +0,0 @@
-class A {
-}
-operator fun A.component1() = 1
-operator fun A.component2() = 1
-
-class C {
-    operator fun iterator(): Iterator<A> = null!!
-}
-
-fun test() {
-    for ((x, y) in C()) {
-
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
 }
 operator fun A.component1() = 1
@@ -8,7 +9,7 @@ class C {
 }

 fun test() {
-    for ((<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>) in C()) {
+    for ((x, y) in C()) {

    }
 }
@@ -1,14 +0,0 @@
-class A {
-    operator fun component1() = 1
-    operator fun component2() = 1.0
-}
-
-class C {
-    operator fun iterator(): Iterator<A> = null!!
-}
-
-fun test() {
-    for ((x: Int, y: Double) in C()) {
-
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
    operator fun component1() = 1
    operator fun component2() = 1.0
@@ -8,7 +9,7 @@ class C {
 }

 fun test() {
-    for ((<!UNUSED_VARIABLE!>x<!>: Int, <!UNUSED_VARIABLE!>y<!>: Double) in C()) {
+    for ((x: Int, y: Double) in C()) {

    }
 }
@@ -8,7 +8,7 @@ class C {
 }

 fun test() {
-    for ((<!REDECLARATION, UNUSED_VARIABLE!>x<!>, <!NAME_SHADOWING, REDECLARATION, UNUSED_VARIABLE!>x<!>) in C()) {
+    for ((<!REDECLARATION!>x<!>, <!NAME_SHADOWING, REDECLARATION!>x<!>) in C()) {

    }
 }
@@ -1,13 +0,0 @@
-class A {
-    operator fun component1() = 1
-}
-
-class C {
-    operator fun iterator(): Iterator<A> = null!!
-}
-
-fun test() {
-    for ((x) in C()) {
-
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
    operator fun component1() = 1
 }
@@ -7,7 +8,7 @@ class C {
 }

 fun test() {
-    for ((<!UNUSED_VARIABLE!>x<!>) in C()) {
+    for ((x) in C()) {

    }
 }
@@ -1,11 +1,11 @@
 fun useDeclaredVariables() {
    val (a, b) = <!UNRESOLVED_REFERENCE!>unresolved<!>
-    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
-    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
 }

 fun checkersShouldRun() {
-    val (@A <!UNUSED_VARIABLE!>a<!>, _) = <!UNRESOLVED_REFERENCE!>unresolved<!>
+    val (@A a, _) = <!UNRESOLVED_REFERENCE!>unresolved<!>
 }

 annotation class A
@@ -1,11 +1,11 @@
 fun useDeclaredVariables() {
    <!INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION!>val (a, b)<!>
-    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
-    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
 }

 fun checkersShouldRun() {
-    <!INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION!>val (@A <!UNUSED_VARIABLE!>a<!>, _)<!>
+    <!INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION!>val (@A a, _)<!>
 }

 annotation class A
@@ -45,7 +45,7 @@ fun test() {

    foo(<!TYPE_MISMATCH, UNDERSCORE_USAGE_WITHOUT_BACKTICKS!>_<!>, y)

-    val (<!UNUSED_VARIABLE!>unused<!>, _) = A()
+    val (unused, _) = A()
 }

-fun foo(<!UNUSED_PARAMETER!>x<!>: Int, <!UNUSED_PARAMETER!>y<!>: String) {}
+fun foo(x: Int, y: String) {}
@@ -1,21 +0,0 @@
-//KT-1141 No check that object in 'object expression' implements all abstract members of supertype
-
-package kt1141
-
-public interface SomeTrait {
-    fun foo()
-}
-
-fun foo() {
-    val x = <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : SomeTrait {
-    }
-    x.foo()
-}
-
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object Rr<!> : SomeTrait {}
-
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C<!> : SomeTrait {}
-
-fun foo2() {
-    val r = <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : Runnable {} //no error
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-1141 No check that object in 'object expression' implements all abstract members of supertype

 package kt1141
@@ -17,5 +18,5 @@ fun foo() {
 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C<!> : SomeTrait {}

 fun foo2() {
-    val <!UNUSED_VARIABLE!>r<!> = <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : Runnable {} //no error
+    val r = <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : Runnable {} //no error
 }
@@ -7,21 +7,21 @@ class C {
 }

 fun test1(c: C) {
-    val (<!UNUSED_VARIABLE!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
+    val (a, b) = c
 }

 fun test2(c: C) {
-    val (a, <!UNUSED_VARIABLE!>b<!>) = c
+    val (a, b) = c
    a + 3
 }

 fun test3(c: C) {
-    var (<!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
-    <!UNUSED_VALUE!>a =<!> 3
+    var (<!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>a<!>, b) = c
+    a = 3
 }

 fun test4(c: C) {
-    var (<!VARIABLE_WITH_REDUNDANT_INITIALIZER!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
+    var (<!VARIABLE_WITH_REDUNDANT_INITIALIZER!>a<!>, b) = c
    a = 3
    a + 1
 }
@@ -5,8 +5,8 @@ class T {
 }

 fun foo() {
-    <!WRONG_MODIFIER_TARGET!>public<!> val <!UNUSED_VARIABLE!>i<!> = 11
-    <!WRONG_MODIFIER_TARGET!>abstract<!> val <!UNUSED_VARIABLE, VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>j<!>
+    <!WRONG_MODIFIER_TARGET!>public<!> val i = 11
+    <!WRONG_MODIFIER_TARGET!>abstract<!> val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>j<!>
    <!WRONG_MODIFIER_TARGET!>override<!> fun T.<!EXTENSION_SHADOWED_BY_MEMBER!>baz<!>() = 2
    <!WRONG_MODIFIER_TARGET!>private<!> fun bar() = 2
-}
+}
@@ -44,7 +44,7 @@ fun test() {

    x4 checkType { _<Function1<Int, Unit>>() }

-    <!UNUSED_LAMBDA_EXPRESSION!>{ y: Int -> fun named14(): Int {return 1} }<!>
+    { y: Int -> fun named14(): Int {return 1} }
    val b = (fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named15<!>(): Boolean { return true })()

    baz(fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named16<!>(){})
@@ -7,4 +7,4 @@ fun test() {
 }

 var g: Int = 1
-    <!WRONG_MODIFIER_CONTAINING_DECLARATION!>protected<!> set(<!UNUSED_PARAMETER!>i<!>: Int) {}
+    <!WRONG_MODIFIER_CONTAINING_DECLARATION!>protected<!> set(i: Int) {}