[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
@@ -1,9 +0,0 @@
-// !ALLOW_RESULT_RETURN_TYPE
-// !LANGUAGE: -AllowNullOperatorsForResult
-
-fun result(): Result<Int> = TODO()
-val resultP: Result<Int> = result()
-
-fun f(r1: Result<Int>?) {
-    r1 ?: 0
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !ALLOW_RESULT_RETURN_TYPE
 // !LANGUAGE: -AllowNullOperatorsForResult

@@ -5,5 +6,5 @@ fun result(): Result<Int> = TODO()
 val resultP: Result<Int> = result()

 fun f(r1: Result<Int>?) {
-    r1 ?: <!UNUSED_EXPRESSION!>0<!>
-}
+    r1 ?: 0
+}
@@ -5,7 +5,7 @@ class Impl : Inv

 class Scope<InterfaceT, ImplementationT : InterfaceT>(private val implClass: <!UNRESOLVED_REFERENCE!>j<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>Class<!><ImplementationT>) {
    fun foo(c: Collection<InterfaceT>) {
-        val <!UNUSED_VARIABLE!>hm<!> = c.asSequence()
+        val hm = c.asSequence()
            .filter(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>implClass<!>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>isInstance<!>)
            .<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>map<!>(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>implClass<!>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>cast<!>)
            .<!DEBUG_INFO_MISSING_UNRESOLVED!>toSet<!>()
@@ -10,25 +10,25 @@ class Controller<T> {
 fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()

 val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>apply<!> {
-        <!DEBUG_INFO_MISSING_UNRESOLVED, NI;DEBUG_INFO_MISSING_UNRESOLVED{OI}!>yield<!>(4)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>apply<!> {
+        <!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>yield<!>(4)
    }
 }

 val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
    yield(B)
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>apply<!> {
-        <!DEBUG_INFO_MISSING_UNRESOLVED, NI;DEBUG_INFO_MISSING_UNRESOLVED{OI}!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED, NI;DEBUG_INFO_MISSING_UNRESOLVED{OI}!>C<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>apply<!> {
+        <!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>C<!>)
    }
 }

-val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
-    this.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>let<!> {
+val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
+    this.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>let<!> {
        yield(B)
    }

-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>apply<!> {
-        <!DEBUG_INFO_MISSING_UNRESOLVED, NI;DEBUG_INFO_MISSING_UNRESOLVED{OI}!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED, NI;DEBUG_INFO_MISSING_UNRESOLVED{OI}!>C<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>apply<!> {
+        <!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>yield<!>(<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>C<!>)
    }
 }

@@ -4,7 +4,7 @@ class StateMachine<Q> internal constructor() {
    fun getInputStub(): Q = null <!UNCHECKED_CAST!>as Q<!>
 }

-fun <T> stateMachine(<!UNUSED_PARAMETER!>block<!>: suspend StateMachine<T>.() -> Unit): StateMachine<T> {
+fun <T> stateMachine(block: suspend StateMachine<T>.() -> Unit): StateMachine<T> {
    return StateMachine<T>()
 }

@@ -16,7 +16,7 @@ fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit):
@BuilderInference
 suspend fun <S> GenericController<List<S>>.yieldGenerate(g: suspend GenericController<S>.() -> Unit): Unit = TODO()

-val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
+val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>generate<!> {
    // TODO: KT-15185
    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}, TYPE_MISMATCH{OI}!>yieldGenerate<!> {
        yield(4)
@@ -8,7 +8,7 @@ interface Job : CoroutineContext.Element {}
 interface Deferred<out T> : Job {
    suspend fun await(): T
 }
-fun <T> async(<!UNUSED_PARAMETER!>block<!>: suspend () -> T): Deferred<T> = TODO()
+fun <T> async(block: suspend () -> T): Deferred<T> = TODO()

 suspend fun fib(n: Long) =
    async {
@@ -29,22 +29,22 @@ fun foo() {
    i = genericBuilder { 1 }
    genericBuilder { 1 }
    genericBuilder<Int> { 1 }
-    genericBuilder<Int> { <!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>""<!> }
+    genericBuilder<Int> { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }

    val y = { 1 }
    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>genericBuilder<!>(<!TYPE_MISMATCH{OI}, UNSUPPORTED_FEATURE{NI}!>y<!>)

    unitBuilder {}
-    unitBuilder { <!UNUSED_EXPRESSION!>1<!> }
+    unitBuilder { 1 }
    unitBuilder({})
-    unitBuilder({ <!UNUSED_EXPRESSION!>1<!> })
+    unitBuilder({ 1 })

    manyArgumentsBuilder({}, { "" }) { 1 }

    val s: String = manyArgumentsBuilder({}, { "" }) { 1 }

    manyArgumentsBuilder<String>({}, { "" }, { 1 })
-    manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>1<!> }, { 2 })
+    manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })

    severalParamsInLambda { <!NAME_SHADOWING!>x<!>, <!NAME_SHADOWING!>y<!> ->
        x checkType { _<String>() }
@@ -34,7 +34,7 @@ fun bar() {
        println()
    }

-    val <!UNUSED_VARIABLE!>w<!>: (suspend () -> Int) -> Any? = ::suspend
+    val w: (suspend () -> Int) -> Any? = ::suspend

    A().<!MODIFIER_FORM_FOR_NON_BUILT_IN_SUSPEND!>suspend<!> {
        println()
@@ -36,7 +36,7 @@ fun bar() {

    suspend<Nothing?>(null)

-    val <!UNUSED_VARIABLE!>w<!>: (Any?) -> Any? = ::suspend
+    val w: (Any?) -> Any? = ::suspend

    A().<!MODIFIER_FORM_FOR_NON_BUILT_IN_SUSPEND!>suspend<!> {
        println()
@@ -1,7 +1,7 @@
 // FILE: 1.kt
-fun test(<!UNUSED_PARAMETER!>c<!>: <!UNRESOLVED_REFERENCE!>Continuation<!><Unit>) {}
+fun test(c: <!UNRESOLVED_REFERENCE!>Continuation<!><Unit>) {}

 // FILE: 2.kt
 import kotlin.coroutines.*

-fun test2(<!UNUSED_PARAMETER!>c<!>: Continuation<Unit>) {}
+fun test2(c: Continuation<Unit>) {}
@@ -28,7 +28,7 @@ fun bar() {
        println()
    }

-    val <!UNUSED_VARIABLE!>w<!>: (suspend () -> Int) -> Any? = ::<!NON_MODIFIER_FORM_FOR_BUILT_IN_SUSPEND!>suspend<!>
+    val w: (suspend () -> Int) -> Any? = ::<!NON_MODIFIER_FORM_FOR_BUILT_IN_SUSPEND!>suspend<!>
 }

@Target(AnnotationTarget.EXPRESSION)
@@ -41,5 +41,5 @@ fun main(suspend: WLambdaInvoke) {
 }

 class WLambdaInvoke {
-    operator fun invoke(<!UNUSED_PARAMETER!>l<!>: () -> Unit) {}
+    operator fun invoke(l: () -> Unit) {}
 }
@@ -26,5 +26,5 @@ fun bar() {
        println()
    }

-    val <!UNUSED_VARIABLE!>w<!>: (suspend () -> Int) -> Any? = ::<!NON_MODIFIER_FORM_FOR_BUILT_IN_SUSPEND!>suspendLambda<!>
+    val w: (suspend () -> Int) -> Any? = ::<!NON_MODIFIER_FORM_FOR_BUILT_IN_SUSPEND!>suspendLambda<!>
 }
@@ -20,9 +20,9 @@ suspend fun RestrictedController.ext() {
    memberExt()
 }

-fun generate(<!UNUSED_PARAMETER!>c<!>: suspend RestrictedController.() -> Unit) {}
+fun generate(c: suspend RestrictedController.() -> Unit) {}

-fun runBlocking(<!UNUSED_PARAMETER!>x<!>: suspend () -> Unit) {}
+fun runBlocking(x: suspend () -> Unit) {}

 fun test() {
    generate a@{
@@ -8,7 +8,7 @@ import kotlin.experimental.ExperimentalTypeInference

@kotlin.coroutines.RestrictsSuspension
 class RestrictedController<T> {
-    suspend fun yield(<!UNUSED_PARAMETER!>x<!>: T) {}
+    suspend fun yield(x: T) {}

    suspend fun anotherYield(x: T) {
        yield(x)
@@ -27,10 +27,10 @@ class RestrictedController<T> {
    }
 }

-fun <T> buildSequence(@BuilderInference <!UNUSED_PARAMETER!>c<!>: suspend RestrictedController<T>.() -> Unit) {}
+fun <T> buildSequence(@BuilderInference c: suspend RestrictedController<T>.() -> Unit) {}

@BuilderInference
-suspend fun <T> RestrictedController<T>.yield2(<!UNUSED_PARAMETER!>x<!>: T) {}
+suspend fun <T> RestrictedController<T>.yield2(x: T) {}

 fun test() {
    buildSequence<Int> a@{
@@ -4,7 +4,7 @@ class RestrictedController
 suspend fun Any?.extFun() {}
 suspend fun suspendFun() {}

-fun generate(<!UNUSED_PARAMETER!>c<!>: suspend RestrictedController.() -> Unit) {}
+fun generate(c: suspend RestrictedController.() -> Unit) {}

 fun test() {
    generate {
@@ -4,9 +4,9 @@ class RestrictedController {
    suspend fun yield() {}
 }

-fun generate(<!UNUSED_PARAMETER!>c<!>: suspend RestrictedController.() -> Unit) {}
+fun generate(c: suspend RestrictedController.() -> Unit) {}

-fun runBlocking(<!UNUSED_PARAMETER!>x<!>: suspend () -> Unit) {}
+fun runBlocking(x: suspend () -> Unit) {}

 fun test() {
    generate {
@@ -18,7 +18,7 @@ fun bar() {
        return@suspend
    }

-    val <!UNUSED_VARIABLE!>x<!> = suspend@{
+    val x = suspend@{
        suspend {
            // Might be resolved to outer lambda, but doesn't make sense because suspend-lambdas here is noinline
            <!RETURN_FOR_BUILT_IN_SUSPEND!>return<!LABEL_NAME_CLASH!>@suspend<!><!>
@@ -25,7 +25,7 @@ class K3 : JavaClass() {
    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: Int, y: Continuation<String>): Any? = null
 }

-fun builder(<!UNUSED_PARAMETER!>block<!>: suspend () -> Unit) {}
+fun builder(block: suspend () -> Unit) {}

 fun main(x: Continuation<String>) {
    JavaClass().<!ILLEGAL_SUSPEND_FUNCTION_CALL!>foo<!>(5, <!TOO_MANY_ARGUMENTS!>x<!>)
@@ -1,13 +0,0 @@
-// SKIP_TXT
-class A {
-    suspend operator fun component1(): String = "K"
-}
-
-fun foo(c: suspend (A) -> Unit) {}
-
-fun bar() {
-    foo {
-        (x) ->
-        x.length
-    }
-}
@@ -1,9 +1,10 @@
+// FIR_IDENTICAL
 // SKIP_TXT
 class A {
    suspend operator fun component1(): String = "K"
 }

-fun foo(<!UNUSED_PARAMETER!>c<!>: suspend (A) -> Unit) {}
+fun foo(c: suspend (A) -> Unit) {}

 fun bar() {
    foo {
@@ -37,7 +37,7 @@ fun test() {
        severalParams("", 89) checkType { _<Double>() }

        // TODO: should we allow somehow to call with passing continuation explicitly?
-        severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!DEBUG_INFO_UNRESOLVED_WITH_TARGET{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Unit>() }
-        severalParams("", 89, <!TOO_MANY_ARGUMENTS!>this <!CAST_NEVER_SUCCEEDS!>as<!> Continuation<Double><!>) checkType { <!DEBUG_INFO_UNRESOLVED_WITH_TARGET{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Unit>() }
+        severalParams("", 89, <!TOO_MANY_ARGUMENTS!>6.9<!>) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Unit>() }
+        severalParams("", 89, <!TOO_MANY_ARGUMENTS!>this <!CAST_NEVER_SUCCEEDS!>as<!> Continuation<Double><!>) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Unit>() }
    }
 }
@@ -28,7 +28,7 @@ class K3 : JavaClass() {
    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: Int, y: Continuation<String>): Any? = null
 }

-fun builder(<!UNUSED_PARAMETER!>block<!>: suspend () -> Unit) {}
+fun builder(block: suspend () -> Unit) {}

 fun main(x: Continuation<String>) {
    JavaClass().<!ILLEGAL_SUSPEND_FUNCTION_CALL!>foo<!>(5, <!TOO_MANY_ARGUMENTS!>x<!>)
@@ -25,7 +25,7 @@ class K3 : JavaClass() {
    <!NOTHING_TO_OVERRIDE!>override<!> fun foo(x: Int, y: Continuation<String>): Any? = null
 }

-fun builder(<!UNUSED_PARAMETER!>block<!>: suspend () -> Unit) {}
+fun builder(block: suspend () -> Unit) {}

 fun main(x: Continuation<String>) {
    JavaClass().<!ILLEGAL_SUSPEND_FUNCTION_CALL!>foo<!>(5, <!TOO_MANY_ARGUMENTS!>x<!>)