[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
@@ -6,20 +6,20 @@ val receiverAndReturnType = { Int.(<!SYNTAX!><!>)<!SYNTAX!>: Int ->  5<!> }
 val receiverAndReturnTypeWithParameter = { Int.(<!UNRESOLVED_REFERENCE!>a<!><!SYNTAX!><!SYNTAX!><!>: Int): Int ->  5<!> }

 val returnType = { (<!SYNTAX!><!>): Int -> 5 }
-val returnTypeWithParameter = { (<!COMPONENT_FUNCTION_MISSING!><!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>: Int<!>): Int -> 5 }
+val returnTypeWithParameter = { (<!COMPONENT_FUNCTION_MISSING!>b: Int<!>): Int -> 5 }

 val receiverWithFunctionType = { ((Int)<!SYNTAX!><!> <!SYNTAX!>-> Int).() -><!> }

-val parenthesizedParameters = { <!CANNOT_INFER_PARAMETER_TYPE!>(<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>: Int)<!> -> }
-val parenthesizedParameters2 = { <!CANNOT_INFER_PARAMETER_TYPE!>(<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>)<!> -> }
+val parenthesizedParameters = { <!CANNOT_INFER_PARAMETER_TYPE!>(a: Int)<!> -> }
+val parenthesizedParameters2 = { <!CANNOT_INFER_PARAMETER_TYPE!>(b)<!> -> }

 val none = { -> }


 val parameterWithFunctionType = { a: ((Int) -> Int) -> <!SYNTAX!><!>} // todo fix parser

-val newSyntax = { <!UNUSED_ANONYMOUS_PARAMETER!>a<!>: Int -> }
-val newSyntax1 = { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>a<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>b<!> -> }
-val newSyntax2 = { <!UNUSED_ANONYMOUS_PARAMETER!>a<!>: Int, <!UNUSED_ANONYMOUS_PARAMETER!>b<!>: Int -> }
-val newSyntax3 = { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>a<!>, <!UNUSED_ANONYMOUS_PARAMETER!>b<!>: Int -> }
-val newSyntax4 = { <!UNUSED_ANONYMOUS_PARAMETER!>a<!>: Int, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>b<!> -> }
+val newSyntax = { a: Int -> }
+val newSyntax1 = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!>, <!CANNOT_INFER_PARAMETER_TYPE!>b<!> -> }
+val newSyntax2 = { a: Int, b: Int -> }
+val newSyntax3 = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!>, b: Int -> }
+val newSyntax4 = { a: Int, <!CANNOT_INFER_PARAMETER_TYPE!>b<!> -> }
@@ -16,6 +16,6 @@ fun test(s: Sub) {
        t: Trait -> s
    }

-    foo(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>fun(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>t: Sub<!>) = s<!>)
+    foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>fun(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>t: Sub<!>) = s<!>)
    foo(<!TYPE_MISMATCH!>fun(t): Super = s<!>)
 }
@@ -10,36 +10,36 @@ fun test1() {
        ""
    }
    foo0 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>s<!>: String<!>-> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>s: String<!>-> ""
    }<!>
    foo0 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>y<!><!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
    }<!>

    foo1 {
        ""
    }
    foo1 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETER_TYPE_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>s<!>: String<!> -> ""
+        <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
    }<!>
    foo1 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>y<!><!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
    }<!>
    foo1 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH{NI}, CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>42<!>
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
    }<!>


-    foo2 <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
+    foo2 <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
        ""
    }<!>
    foo2 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>s<!>: String<!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
    }<!>
    foo2 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_ANONYMOUS_PARAMETER!>x<!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> ""
    }<!>
    foo2 <!TYPE_MISMATCH{NI}!>{
-         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH{NI}, CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>42<!>
+         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
    }<!>
 }
@@ -6,8 +6,8 @@ interface A
 interface B
 interface C: A, B

-fun <T> foo(<!UNUSED_PARAMETER!>a<!>: A, f: () -> T): T = f()
-fun <T> foo(<!UNUSED_PARAMETER!>b<!>: B, f: () -> T): T = f()
+fun <T> foo(a: A, f: () -> T): T = f()
+fun <T> foo(b: B, f: () -> T): T = f()

 fun test(c: C) {
    <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>foo<!>(c) f@ {
@@ -2,15 +2,15 @@
 fun test(bal: Array<Int>) {
    var bar = 4

-    val <!UNUSED_VARIABLE!>a<!>: () -> Unit = { bar += 4 }
+    val a: () -> Unit = { bar += 4 }

-    val <!UNUSED_VARIABLE!>b<!>: () -> Int = { <!EXPECTED_TYPE_MISMATCH!>bar = 4<!> }
+    val b: () -> Int = { <!EXPECTED_TYPE_MISMATCH!>bar = 4<!> }

-    val <!UNUSED_VARIABLE!>c<!>: () -> <!UNRESOLVED_REFERENCE!>UNRESOLVED<!> = { bal[2] = 3 }
+    val c: () -> <!UNRESOLVED_REFERENCE!>UNRESOLVED<!> = { bal[2] = 3 }

-    val <!UNUSED_VARIABLE!>d<!>: () -> Int = { <!ASSIGNMENT_TYPE_MISMATCH("Int")!>bar += 4<!> }
+    val d: () -> Int = { <!ASSIGNMENT_TYPE_MISMATCH("Int")!>bar += 4<!> }

-    val <!UNUSED_VARIABLE!>e<!>: Unit = run { bar += 4 }
+    val e: Unit = run { bar += 4 }

-    val <!UNUSED_VARIABLE!>f<!>: Int = <!TYPE_MISMATCH{NI}!>run { <!ASSIGNMENT_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>bar += 4<!> }<!>
+    val f: Int = <!TYPE_MISMATCH{NI}!>run { <!ASSIGNMENT_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>bar += 4<!> }<!>
 }
@@ -7,12 +7,12 @@ data class B(val u: Double, val w: Short)
 fun foo(block: (A, B) -> Unit) { }

 fun bar() {
-    foo { (<!REDECLARATION, UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>, <!REDECLARATION!>a<!>), b ->
+    foo { (<!REDECLARATION!>a<!>, <!REDECLARATION!>a<!>), b ->
        a checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Int>() }
        b checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String>() }
    }

-    foo { (<!REDECLARATION, UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>, b), <!REDECLARATION!>a<!> ->
+    foo { (<!REDECLARATION!>a<!>, b), <!REDECLARATION!>a<!> ->
        a checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Int>() }
        b checkType { _<String>() }
    }
@@ -22,7 +22,7 @@ fun bar() {
        b checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String>() }
    }

-    foo { (a, <!REDECLARATION, UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>), (c, <!REDECLARATION!>b<!>) ->
+    foo { (a, <!REDECLARATION!>b<!>), (c, <!REDECLARATION!>b<!>) ->
        a checkType { _<Int>() }
        b checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String>() }
        c checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><B>() }
@@ -47,7 +47,7 @@ fun bar() {
        _ checkType { _<String>() }
    }

-    foo { (<!REDECLARATION, UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>`_`<!>, <!REDECLARATION!>`_`<!>) ->
+    foo { (<!REDECLARATION!>`_`<!>, <!REDECLARATION!>`_`<!>) ->
        _ checkType { _<String>() }
    }

@@ -7,36 +7,36 @@ fun foo(block: (A) -> Unit) { }
 fun foobar(block: (A, B) -> Unit) { }

 fun bar() {
-    foo { (a, <!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>) ->
+    foo { (a, b) ->
        a checkType { _<Int>() }
    }

-    foo { (<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>, b) ->
+    foo { (a, b) ->
        b checkType { _<String>() }
    }

-    foo { (a: Int, <!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>: String) ->
+    foo { (a: Int, b: String) ->
        a checkType { _<Int>() }
    }

-    foo { (<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>: Int, b: String) ->
+    foo { (a: Int, b: String) ->
        b checkType { _<String>() }
    }

-    foobar { (a, <!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>), c ->
+    foobar { (a, b), c ->
        a checkType { _<Int>() }
    }

-    foobar { a, (<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>, c) ->
+    foobar { a, (b, c) ->
        c checkType { _<Short>() }
    }

-    foobar { (a, <!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>), (<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>c<!>, d) ->
+    foobar { (a, b), (c, d) ->
        a checkType { _<Int>() }
        d checkType { _<Short>() }
    }

-    foobar { (<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>, b), (c, <!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>d<!>) ->
+    foobar { (a, b), (c, d) ->
        b checkType { _<String>() }
        c checkType { _<Double>() }
    }
@@ -1,25 +0,0 @@
-class Log
-
-data class CalculatedVariable(
-    val idString: String,
-    val presentableName: String,
-    val units: String,
-    val function: (Log) -> ((TimeIndex) -> Any?)?,
-    val converter: (Any) -> Double
-) {
-    constructor(idString: String, presentableName: String, units: String, function: (Log) -> ((TimeIndex) -> Double?)?)
-            : this(idString, presentableName, units, function, { it as Double })
-}
-
-object CalculatedVariables {
-    val x = CalculatedVariable(
-        "A",
-        "B",
-        "C",
-        fun(log: Log): ((TimeIndex) -> Double?)? {
-            return { 0.0 }
-        }
-    )
-}
-
-class TimeIndex
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class Log

 data class CalculatedVariable(
@@ -16,10 +17,10 @@ object CalculatedVariables {
        "A",
        "B",
        "C",
-        fun(<!UNUSED_ANONYMOUS_PARAMETER!>log<!>: Log): ((TimeIndex) -> Double?)? {
+        fun(log: Log): ((TimeIndex) -> Double?)? {
            return { 0.0 }
        }
    )
 }

-class TimeIndex
+class TimeIndex
@@ -1,15 +0,0 @@
-// !CHECK_TYPE
-
-interface Predicate<T>
-
-fun <T> Predicate(x: (T?) -> Boolean): Predicate<T> = null!!
-
-fun foo() {
-    process(Predicate {
-        x -> x checkType { _<String?>() }
-
-        true
-    })
-}
-
-fun process(x: Predicate<String>) {}
@@ -1,8 +1,9 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 interface Predicate<T>

-fun <T> Predicate(<!UNUSED_PARAMETER!>x<!>: (T?) -> Boolean): Predicate<T> = null!!
+fun <T> Predicate(x: (T?) -> Boolean): Predicate<T> = null!!

 fun foo() {
    process(Predicate {
@@ -12,4 +13,4 @@ fun foo() {
    })
 }

-fun process(<!UNUSED_PARAMETER!>x<!>: Predicate<String>) {}
+fun process(x: Predicate<String>) {}
@@ -1,16 +0,0 @@
-// !CHECK_TYPE
-
-// FILE: Predicate.java
-import org.jetbrains.annotations.NotNull;
-
-public interface Predicate<T extends CharSequence> {
-    // Same effect with @Nullable here
-    boolean invoke(@NotNull T t);
-}
-// FILE: Main.kt
-fun process(x: Predicate<String>) {}
-fun main() {
-    process(Predicate { x -> x checkType { _<String>() }
-        true
-    })
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 // FILE: Predicate.java
@@ -8,7 +9,7 @@ public interface Predicate<T extends CharSequence> {
    boolean invoke(@NotNull T t);
 }
 // FILE: Main.kt
-fun process(<!UNUSED_PARAMETER!>x<!>: Predicate<String>) {}
+fun process(x: Predicate<String>) {}
 fun main() {
    process(Predicate { x -> x checkType { _<String>() }
        true
@@ -1,6 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
-val la = { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>a<!> -> }
-val las = { <!UNUSED_ANONYMOUS_PARAMETER!>a<!>: Int -> }
+val la = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!> -> }
+val las = { a: Int -> }

-val larg = { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>a<!> -> }(123)
-val twoarg = { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>a<!>, <!UNUSED_ANONYMOUS_PARAMETER!>b<!>: String, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>c<!> -> }(123, "asdf", 123)
+val larg = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!> -> }(123)
+val twoarg = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!>, b: String, <!CANNOT_INFER_PARAMETER_TYPE!>c<!> -> }(123, "asdf", 123)
@@ -1,25 +0,0 @@
-// KT-3343 Type mismatch when function literal consists of try-catch with Int returning call, and Unit is expected
-
-fun main() {
-    "hello world".prt{
-        try{
-            print(it)
-            log("we are printing")
-        }
-        catch(e : Exception){
-            log("Exception")
-        }
-    }
-}
-
-fun log(str : String) : Int{
-    print("logging $str")
-    return 0
-}
-
-fun print(obj: Any) {}
-
-
-fun String.prt(action : (String) -> Unit){
-    action(this)
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // KT-3343 Type mismatch when function literal consists of try-catch with Int returning call, and Unit is expected

 fun main() {
@@ -17,9 +18,9 @@ fun log(str : String) : Int{
    return 0
 }

-fun print(<!UNUSED_PARAMETER!>obj<!>: Any) {}
+fun print(obj: Any) {}


 fun String.prt(action : (String) -> Unit){
    action(this)
-}
+}
@@ -1,10 +0,0 @@
-fun main() {
-    var list = listOf(1)
-
-    val a: Int? = 2
-
-    a?.let { list += it }
-}
-
-operator fun <T> Iterable<T>.plus(element: T): List<T> = null!!
-fun <T> listOf(vararg values: T): List<T> = null!!
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun main() {
    var list = listOf(1)

@@ -6,5 +7,5 @@ fun main() {
    a?.let { list += it }
 }

-operator fun <T> Iterable<T>.plus(<!UNUSED_PARAMETER!>element<!>: T): List<T> = null!!
-fun <T> listOf(vararg <!UNUSED_PARAMETER!>values<!>: T): List<T> = null!!
+operator fun <T> Iterable<T>.plus(element: T): List<T> = null!!
+fun <T> listOf(vararg values: T): List<T> = null!!
@@ -18,5 +18,4 @@ fun f() {
    }
 }

-fun foo(<!UNUSED_PARAMETER!>a<!>: Any) {}
-
+fun foo(a: Any) {}
@@ -7,5 +7,5 @@ fun f() {
    }
 }

-fun foo(<!UNUSED_PARAMETER!>a<!>: Any) {}
-fun bar(<!UNUSED_PARAMETER!>a<!>: Any) {}
+fun foo(a: Any) {}
+fun bar(a: Any) {}
@@ -11,5 +11,5 @@ val b/*: () -> Int */ = l@ {
 }

 val c/*: () -> Unit */ = l@ {
-    if (flag) <!UNUSED_EXPRESSION!>4<!>
-}
+    if (flag) 4
+}
@@ -18,5 +18,5 @@ val d: () -> Int = l@ {
 }

 val e: () -> Int = l@ {
-    <!TYPE_MISMATCH!>if (flag) <!UNUSED_EXPRESSION!>4<!><!>
-}
+    <!TYPE_MISMATCH!>if (flag) 4<!>
+}
@@ -10,7 +10,7 @@ val a = run { // () -> Unit
 // Unit
 val b = run {
    if (flag) return@run
-    <!UNUSED_EXPRESSION!>5<!>
+    5
 }

 // Unit
@@ -18,4 +18,4 @@ val c = run {
    if (flag) return@run

    return@run <!RETURN_TYPE_MISMATCH!>4<!>
-}
+}
@@ -1,9 +0,0 @@
-fun <T> listOf(): List<T> = null!!
-fun <T> listOf(vararg values: T): List<T> = null!!
-
-val flag = true
-
-val a: () -> List<Int> = l@ {
-    if (flag) return@l listOf()
-    listOf(5)
-}
@@ -1,9 +1,10 @@
+// FIR_IDENTICAL
 fun <T> listOf(): List<T> = null!!
-fun <T> listOf(vararg <!UNUSED_PARAMETER!>values<!>: T): List<T> = null!!
+fun <T> listOf(vararg values: T): List<T> = null!!

 val flag = true

 val a: () -> List<Int> = l@ {
    if (flag) return@l listOf()
    listOf(5)
-}
+}
@@ -1,10 +1,10 @@
 // !WITH_NEW_INFERENCE
 fun test(a: Int) {
    run<Int>f@{
-      if (a > 0) return@f <!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>""<!>
+      if (a > 0) return@f <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
      return@f 1
    }

-    run<Int>{ <!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>""<!> }
+    run<Int>{ <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
    run<Int>{ 1 }
 }
@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
-fun <T, R> Iterable<T>.map(<!UNUSED_PARAMETER!>transform<!>: (T) -> R): List<R> = null!!
+fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> = null!!
 fun <T> listOf(): List<T> = null!!
-fun <T> listOf(vararg <!UNUSED_PARAMETER!>values<!>: T): List<T> = null!!
+fun <T> listOf(vararg values: T): List<T> = null!!

 fun commonSystemFailed(a: List<Int>) {
    a.map {
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
-// KT-6822 Smart cast doesn't work inside local returned expression in lambda 
+// KT-6822 Smart cast doesn't work inside local returned expression in lambda

 val a /* :(Int?) -> Int? */ = l@ { it: Int? -> // but must be (Int?) -> Int
    if (it != null) return@l it
@@ -1,13 +1,13 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
-// KT-6822 Smart cast doesn't work inside local returned expression in lambda 
+// KT-6822 Smart cast doesn't work inside local returned expression in lambda

 val a /* :(Int?) -> Int? */ = l@ { it: Int? -> // but must be (Int?) -> Int
    if (it != null) return@l it
    5
 }

-fun <R> let(<!UNUSED_PARAMETER!>f<!>: (Int?) -> R): R = null!!
+fun <R> let(f: (Int?) -> R): R = null!!

 val b /*: Int? */ = let { // but must be Int
    if (it != null) return@let <!DEBUG_INFO_SMARTCAST{NI}!>it<!>
@@ -5,7 +5,7 @@ val a : (Int?) -> Int = l@ {
    5
 }

-fun <R> let(<!UNUSED_PARAMETER!>f<!>: (Int?) -> R): R = null!!
+fun <R> let(f: (Int?) -> R): R = null!!

 val b: Int = let {
    if (it != null) return@let <!DEBUG_INFO_SMARTCAST!>it<!>
@@ -1,7 +1,7 @@
 // !CHECK_TYPE

-fun foo(<!UNUSED_PARAMETER!>block<!>: (Int, String) -> Unit) { }
-fun foobar(<!UNUSED_PARAMETER!>block<!>: (Double) -> Unit) { }
+fun foo(block: (Int, String) -> Unit) { }
+fun foobar(block: (Double) -> Unit) { }

 fun bar() {
    foo { _, b ->
@@ -40,9 +40,9 @@ fun bar() {
        _ checkType { _<String>() }
    }

-    foo { <!REDECLARATION, REDECLARATION, UNUSED_ANONYMOUS_PARAMETER!>`_`<!>, <!REDECLARATION, REDECLARATION!>`_`<!> ->
+    foo { <!REDECLARATION, REDECLARATION!>`_`<!>, <!REDECLARATION, REDECLARATION!>`_`<!> ->
        _ checkType { _<String>() }
    }

-    foo(fun(<!UNUSED_ANONYMOUS_PARAMETER!>x<!>: Int, _: String) {})
+    foo(fun(x: Int, _: String) {})
 }
@@ -1,3 +1,5 @@
+// !DIAGNOSTICS: +UNUSED_LAMBDA_EXPRESSION, +UNUSED_VARIABLE
+
 fun unusedLiteral(){
    { ->
        val i = 1
@@ -9,4 +11,4 @@ fun unusedLiteralInDoWhile(){
    do{ ->
            val i = 1
    } while(false)
-}
+}
@@ -1,4 +1,4 @@
-// !DIAGNOSICS: +UNUSED_LAMBDA_EXPRESSION, +UNUSED_VARIABLE
+// !DIAGNOSTICS: +UNUSED_LAMBDA_EXPRESSION, +UNUSED_VARIABLE

 fun unusedLiteral(){
    <!UNUSED_LAMBDA_EXPRESSION!>{ ->
@@ -1,4 +1,4 @@
-// !DIAGNOSICS: +UNUSED_LAMBDA_EXPRESSION
+// !DIAGNOSTICS: +UNUSED_LAMBDA_EXPRESSION

 fun main() {
    "".run {
@@ -1,4 +1,4 @@
-// !DIAGNOSICS: +UNUSED_LAMBDA_EXPRESSION
+// !DIAGNOSTICS: +UNUSED_LAMBDA_EXPRESSION

 fun main() {
    "".run {