Report warning on unused entities that can be renamed to _

Currently it's all about lambda parameters/destructuring entries

 #KT-14347 In Progress

compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt

@@ -578,6 +578,7 @@ class ControlFlowInformationProvider private constructor(
                         }
                         else if (element is KtParameter) {
                             val owner = element.parent?.parent
+                            if (element.isSingleUnderscore) return@traverse
                             when (owner) {
                                 is KtPrimaryConstructor -> if (!element.hasValOrVar()) {
                                     val containingClass = owner.getContainingClassOrObject()
@@ -590,7 +591,6 @@ class ControlFlowInformationProvider private constructor(
                                 is KtFunction -> {
                                     val mainFunctionDetector = MainFunctionDetector(trace.bindingContext)
                                     val isMain = owner is KtNamedFunction && mainFunctionDetector.isMain(owner)
-                                    if (owner is KtFunctionLiteral) return@traverse
                                     val functionDescriptor =
                                             trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, owner) as? FunctionDescriptor
                                             ?: throw AssertionError(owner.text)

compiler/frontend/src/org/jetbrains/kotlin/psi/KtPsiUtil.java

@@ -42,7 +42,6 @@ import org.jetbrains.kotlin.parsing.KotlinExpressionParsing;
 import org.jetbrains.kotlin.psi.psiUtil.KtPsiUtilKt;
 import org.jetbrains.kotlin.resolve.StatementFilter;
 import org.jetbrains.kotlin.resolve.StatementFilterKt;
-import org.jetbrains.kotlin.types.expressions.OperatorConventions;
 
 import java.util.Collection;
 import java.util.HashSet;
@@ -280,9 +279,8 @@ public class KtPsiUtil {
         if (!(declaration instanceof KtVariableDeclaration)) return false;
         if (declaration instanceof KtProperty) return true;
         assert declaration instanceof KtDestructuringDeclarationEntry;
-        KtDestructuringDeclaration parentDeclaration = (KtDestructuringDeclaration) declaration.getParent();
+        // We can always replace destructuring entry with _
-        List<KtDestructuringDeclarationEntry> entries = parentDeclaration.getEntries();
+        return true;
-        return entries.size() > 1 && entries.get(entries.size() - 1) == declaration;
     }
 
     @Nullable

compiler/testData/diagnostics/tests/AutoCreatedIt.kt

@@ -4,7 +4,7 @@ fun text() {
     "direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
     bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}
     bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
-    bar {it, it1 -> it}
+    bar {it, <!UNUSED_PARAMETER!>it1<!> -> it}
 
     bar1 {1}
     bar1 {it + 1}

compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt

@@ -36,8 +36,8 @@ fun main(args : Array<String>) {
     foo2()({})
     foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
     (foo2()){}
-    (foo2()){<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE!>x<!> -> }
+    (foo2()){<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>x<!> -> }
-    foo2()({<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE!>x<!> -> })
+    foo2()({<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>x<!> -> })
 
     val a = fooT1(1)()
     checkSubtype<Int>(a)
@@ -72,7 +72,7 @@ fun main1() {
 }
 
 fun test() {
-    {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
+    {<!UNUSED_PARAMETER!>x<!> : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
     (fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
     <!TYPE_MISMATCH!>"sd"<!>.(fun Int.() = 1)()
     val i : Int? = null

compiler/testData/diagnostics/tests/Underscore.kt

@@ -23,7 +23,7 @@ fun <!UNDERSCORE_IS_RESERVED!>__<!>(<!UNDERSCORE_IS_RESERVED!>___<!>: Int, y: _<
 }
 
 // one underscore parameters for named function are still prohibited
-fun oneUnderscore(<!UNUSED_PARAMETER, UNDERSCORE_IS_RESERVED!>_<!>: Int) {}
+fun oneUnderscore(<!UNDERSCORE_IS_RESERVED!>_<!>: Int) {}
 
 fun doIt(f: (Any?) -> Any?) = f(null)
 

compiler/testData/diagnostics/tests/UnusedInDestructuring.kt

@@ -1,6 +1,6 @@
 data class D(val x: Int, val y: Int, val z: Int)
 fun foo(): Int {
-    val (x, y, z) = D(1, 2, 3)
+    val (<!UNUSED_VARIABLE!>x<!>, y, z) = D(1, 2, 3)
     return y + z // x is not used, but we cannot do anything with it
 }
 fun bar(): Int {

compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.kt

@@ -8,7 +8,7 @@ fun foo() {
     for (@Ann(1) i in 1..100) {}
     for (@Ann(2) i in 1..100) {}
 
-    for (<!WRONG_ANNOTATION_TARGET!>@Ann(3)<!> (x, @Ann(4) <!UNUSED_VARIABLE!>y<!>) in bar()) {}
+    for (<!WRONG_ANNOTATION_TARGET!>@Ann(3)<!> (<!UNUSED_VARIABLE!>x<!>, @Ann(4) <!UNUSED_VARIABLE!>y<!>) in bar()) {}
 
-    for (@<!UNRESOLVED_REFERENCE!>Err<!>() (x,<!UNUSED_VARIABLE!>y<!>) in bar()) {}
+    for (@<!UNRESOLVED_REFERENCE!>Err<!>() (<!UNUSED_VARIABLE!>x<!>,<!UNUSED_VARIABLE!>y<!>) in bar()) {}
 }

compiler/testData/diagnostics/tests/controlStructures/valVarLoopParameter.kt

@@ -22,11 +22,11 @@ fun f() {
 
     }
 
-    for (<!VAL_OR_VAR_ON_LOOP_PARAMETER!>val<!> (i,<!UNUSED_VARIABLE!>j<!>) in Coll()) {
+    for (<!VAL_OR_VAR_ON_LOOP_PARAMETER!>val<!> (<!UNUSED_VARIABLE!>i<!>,<!UNUSED_VARIABLE!>j<!>) in Coll()) {
 
     }
 
-    for (<!VAL_OR_VAR_ON_LOOP_PARAMETER!>var<!> (i,<!UNUSED_VARIABLE!>j<!>) in Coll()) {
+    for (<!VAL_OR_VAR_ON_LOOP_PARAMETER!>var<!> (<!UNUSED_VARIABLE!>i<!>,<!UNUSED_VARIABLE!>j<!>) in Coll()) {
 
     }
 }

compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt

@@ -4,5 +4,5 @@ class A {
 }
 
 fun a(aa : A) {
-    val (a: String, <!UNUSED_VARIABLE!>b1<!>: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
+    val (<!UNUSED_VARIABLE!>a<!>: String, <!UNUSED_VARIABLE!>b1<!>: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
 }

compiler/testData/diagnostics/tests/declarationChecks/DataFlowInMultiDeclInFor.kt

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

compiler/testData/diagnostics/tests/declarationChecks/DataFlowInfoInMultiDecl.kt

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

compiler/testData/diagnostics/tests/declarationChecks/RedeclarationsInMultiDecl.kt

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

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/DoubleDeclForLoop.kt

@@ -8,7 +8,7 @@ class C {
 }
 
 fun test() {
-    for ((x, <!UNUSED_VARIABLE!>y<!>) in C()) {
+    for ((<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>) in C()) {
 
     }
 }

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt

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

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.kt

@@ -9,7 +9,7 @@ class C {
 }
 
 fun test() {
-    for ((x, <!UNUSED_VARIABLE!>y<!>) in <!COMPONENT_FUNCTION_AMBIGUITY!>C()<!>) {
+    for ((<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>) in <!COMPONENT_FUNCTION_AMBIGUITY!>C()<!>) {
 
     }
 }

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.kt

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

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt

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

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopWithExtensions.kt

@@ -8,7 +8,7 @@ class C {
 }
 
 fun test() {
-    for ((x, <!UNUSED_VARIABLE!>y<!>) in C()) {
+    for ((<!UNUSED_VARIABLE!>x<!>, <!UNUSED_VARIABLE!>y<!>) in C()) {
 
     }
 }

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForWithExplicitTypes.kt

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

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/RedeclarationInForLoop.kt

@@ -8,7 +8,7 @@ class C {
 }
 
 fun test() {
-    for ((<!REDECLARATION!>x<!>, <!NAME_SHADOWING, REDECLARATION, UNUSED_VARIABLE!>x<!>) in C()) {
+    for ((<!REDECLARATION, UNUSED_VARIABLE!>x<!>, <!NAME_SHADOWING, REDECLARATION, UNUSED_VARIABLE!>x<!>) in C()) {
 
     }
 }

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/SingleDeclForLoop.kt

@@ -7,7 +7,7 @@ class C {
 }
 
 fun test() {
-    for ((x) in C()) {
+    for ((<!UNUSED_VARIABLE!>x<!>) in C()) {
 
     }
 }

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt

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

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt

@@ -5,7 +5,7 @@ fun useDeclaredVariables() {
 }
 
 fun checkersShouldRun() {
-    <!INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION!>val (@A a, _)<!>
+    <!INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION!>val (@A <!UNUSED_VARIABLE!>a<!>, _)<!>
 }
 
 annotation class A

compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt

@@ -43,6 +43,8 @@ fun test() {
     val (_, <!NAME_SHADOWING, REDECLARATION!>`_`<!>) = A()
 
     foo(<!TYPE_MISMATCH!>_<!>, y)
+
+    val (<!UNUSED_VARIABLE!>unused<!>, _) = A()
 }
 
 fun foo(<!UNUSED_PARAMETER!>x<!>: Int, <!UNUSED_PARAMETER!>y<!>: String) {}

compiler/testData/diagnostics/tests/declarationChecks/kt2643MultiDeclInControlFlow.kt

@@ -7,7 +7,7 @@ class C {
 }
 
 fun test1(c: C) {
-    val (a, <!UNUSED_VARIABLE!>b<!>) = c
+    val (<!UNUSED_VARIABLE!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
 }
 
 fun test2(c: C) {
@@ -16,7 +16,7 @@ fun test2(c: C) {
 }
 
 fun test3(c: C) {
-    var (a, <!UNUSED_VARIABLE!>b<!>) = c
+    var (<!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
     <!UNUSED_VALUE!>a =<!> 3
 }
 

compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.kt

@@ -17,8 +17,8 @@ val none = { -> }
 
 val parameterWithFunctionType = { a: ((Int) -> Int) -> <!SYNTAX!><!>} // todo fix parser
 
-val newSyntax = { a: Int -> }
+val newSyntax = { <!UNUSED_PARAMETER!>a<!>: Int -> }
-val newSyntax1 = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!>, <!CANNOT_INFER_PARAMETER_TYPE!>b<!> -> }
+val newSyntax1 = { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>a<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>b<!> -> }
-val newSyntax2 = { a: Int, b: Int -> }
+val newSyntax2 = { <!UNUSED_PARAMETER!>a<!>: Int, <!UNUSED_PARAMETER!>b<!>: Int -> }
-val newSyntax3 = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!>, b: Int -> }
+val newSyntax3 = { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>a<!>, <!UNUSED_PARAMETER!>b<!>: Int -> }
-val newSyntax4 = { a: Int, <!CANNOT_INFER_PARAMETER_TYPE!>b<!> -> }
+val newSyntax4 = { <!UNUSED_PARAMETER!>a<!>: Int, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>b<!> -> }

compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt

@@ -9,20 +9,20 @@ fun test1() {
         ""
     }
     foo0 {
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>s: String<!>-> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_PARAMETER!>s<!>: String<!>-> ""
     }
     foo0 {
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>y<!><!> -> ""
     }
 
     foo1 {
         ""
     }
     foo1 {
-        <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
+        <!EXPECTED_PARAMETER_TYPE_MISMATCH!><!UNUSED_PARAMETER!>s<!>: String<!> -> ""
     }
     foo1 {
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_PARAMETER!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>y<!><!> -> ""
     }
     foo1 {
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
@@ -33,10 +33,10 @@ fun test1() {
         ""
     }
     foo2 {
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!><!UNUSED_PARAMETER!>s<!>: String<!> -> ""
     }
     foo2 {
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_PARAMETER!>x<!> -> ""
     }
     foo2 {
          <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>

compiler/testData/diagnostics/tests/functionLiterals/underscopeParameters.kt

@@ -1,8 +1,7 @@
 // !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_PARAMETER
 
-fun foo(block: (Int, String) -> Unit) { }
+fun foo(<!UNUSED_PARAMETER!>block<!>: (Int, String) -> Unit) { }
-fun foobar(block: (Double) -> Unit) { }
+fun foobar(<!UNUSED_PARAMETER!>block<!>: (Double) -> Unit) { }
 
 fun bar() {
     foo { _, b ->
@@ -41,9 +40,9 @@ fun bar() {
         _ checkType { _<String>() }
     }
 
-    foo { <!REDECLARATION, REDECLARATION!>`_`<!>, <!REDECLARATION, REDECLARATION!>`_`<!> ->
+    foo { <!REDECLARATION, REDECLARATION, UNUSED_PARAMETER!>`_`<!>, <!REDECLARATION, REDECLARATION!>`_`<!> ->
         _ checkType { _<String>() }
     }
 
-    foo(fun(x: Int, _: String) {})
+    foo(fun(<!UNUSED_PARAMETER!>x<!>: Int, _: String) {})
 }

compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt

@@ -3,4 +3,4 @@ package f
 fun <R> h(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>a<!>: Any, <!UNUSED_PARAMETER!>r<!>: R, <!UNUSED_PARAMETER!>f<!>: (Boolean) -> Int) = 1
 fun <R> h(<!UNUSED_PARAMETER!>a<!>: Any, <!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>r<!>: R, <!UNUSED_PARAMETER!>f<!>: (Boolean) -> Int) = 1
 
-fun test() = <!CANNOT_COMPLETE_RESOLVE!>h<!>(1, 1, 1, { <!CANNOT_INFER_PARAMETER_TYPE!>b<!> -> 42 })
+fun test() = <!CANNOT_COMPLETE_RESOLVE!>h<!>(1, 1, 1, { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>b<!> -> 42 })

compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt

@@ -4,7 +4,7 @@ package f
 fun <R> h(<!UNUSED_PARAMETER!>f<!>: (Boolean) -> R) = 1
 fun <R> h(<!UNUSED_PARAMETER!>f<!>: (String) -> R) = 2
 
-fun test() = <!CANNOT_COMPLETE_RESOLVE!>h<!>{ <!CANNOT_INFER_PARAMETER_TYPE!>i<!> -> getAnswer() }
+fun test() = <!CANNOT_COMPLETE_RESOLVE!>h<!>{ <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>i<!> -> getAnswer() }
 
 fun getAnswer() = 42
 

compiler/testData/diagnostics/tests/inference/dependantOnVarianceNullable.kt

@@ -5,7 +5,7 @@ import java.util.*
 import java.util.Collections.*
 
 fun foo(list: List<String>) : String {
-    val w : String = max(list, comparator<String?> {o1, o2 -> 1
+    val w : String = max(list, comparator<String?> {<!UNUSED_PARAMETER!>o1<!>, <!UNUSED_PARAMETER!>o2<!> -> 1
     })
     return w
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt

@@ -9,5 +9,5 @@ fun <A, B> Foo<A>.map(<!UNUSED_PARAMETER!>f<!>: (A) -> B): Foo<B> = object : Foo
 
 fun foo() {
     val l: Foo<String> = object : Foo<String> {}
-    val <!UNUSED_VARIABLE!>m<!>: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>map { ppp -> 1 }<!>
+    val <!UNUSED_VARIABLE!>m<!>: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>map { <!UNUSED_PARAMETER!>ppp<!> -> 1 }<!>
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt

@@ -7,5 +7,5 @@ fun <T> _arrayList(vararg <!UNUSED_PARAMETER!>values<!>: T) : List<T> = throw Ex
 class _Pair<A>(val a: A)
 
 fun test() {
-    _arrayList(_Pair(1))._sortBy { it -> <!UNRESOLVED_REFERENCE!>xxx<!> }
+    _arrayList(_Pair(1))._sortBy { <!UNUSED_PARAMETER!>it<!> -> <!UNRESOLVED_REFERENCE!>xxx<!> }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2841.kt

@@ -9,7 +9,7 @@ public inline fun <T: Closeable, R> T.use1(block: (T)-> R) : R {
 
 fun main(args: Array<String>) {
     C().use1 {
-        w ->  // ERROR here
+        <!UNUSED_PARAMETER!>w<!> ->  // ERROR here
         <!UNRESOLVED_REFERENCE!>x<!>
     }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt3007.kt

@@ -8,7 +8,7 @@ enum class SomeEnum {
 
 // Doesn't work
 fun Iterable<Int>.some() {
-    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
+    this.fold(SomeEnum.FIRST, {res : SomeEnum, <!UNUSED_PARAMETER!>value<!> ->
         if (res == SomeEnum.FIRST) SomeEnum.FIRST else SomeEnum.SECOND
     })
 }
@@ -19,7 +19,7 @@ fun tempFun() : SomeEnum {
 
 // Doesn't work
 fun Iterable<Int>.someSimpleWithFun() {
-    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
+    this.fold(SomeEnum.FIRST, {<!UNUSED_PARAMETER!>res<!> : SomeEnum, <!UNUSED_PARAMETER!>value<!> ->
         tempFun()
     })
 }
@@ -27,14 +27,14 @@ fun Iterable<Int>.someSimpleWithFun() {
 
 // Works
 fun Iterable<Int>.someSimple() {
-    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
+    this.fold(SomeEnum.FIRST, {<!UNUSED_PARAMETER!>res<!> : SomeEnum, <!UNUSED_PARAMETER!>value<!> ->
         SomeEnum.FIRST
     })
 }
 
 // Works
 fun Iterable<Int>.someInt() {
-    this.fold(0, {res : Int, value ->
+    this.fold(0, {res : Int, <!UNUSED_PARAMETER!>value<!> ->
         if (res == 0) 1 else 0
     })
 }

compiler/testData/diagnostics/tests/inference/regressions/kt3150.kt

@@ -15,10 +15,10 @@ fun SomeTemplate.query(f: (i: Int) -> Unit) = f
 fun SomeTemplate.query1(f: (i: Int) -> Unit) = f
 
 fun test() {
-    val mapperFunction = { i: Int -> }
+    val mapperFunction = { <!UNUSED_PARAMETER!>i<!>: Int -> }
     SomeTemplate().query(mapperFunction)
 
     // TYPE_MISMATCH: Required Class<[ERROR: CANT_INFER]>, Found (kotlin.Int) -> Unit
-    SomeTemplate().query { i: Int -> }
+    SomeTemplate().query { <!UNUSED_PARAMETER!>i<!>: Int -> }
-    SomeTemplate().query1 { i: Int -> }
+    SomeTemplate().query1 { <!UNUSED_PARAMETER!>i<!>: Int -> }
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.kt

@@ -3,7 +3,7 @@ package a
 fun <T, R, S> foo(block: (T)-> R, <!UNUSED_PARAMETER!>second<!>: (T)-> S) = block
 
 fun main(args: Array<String>) {
-    val fff = { x: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
+    val fff = { <!UNUSED_PARAMETER!>x<!>: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
     foo(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fff<!>, { x -> x + 1 })
 }
 

compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.kt

@@ -9,7 +9,7 @@ fun <T: Closeable, R> T.foo(block: (T, T)-> R) = block
 
 fun main(args: Array<String>) {
     C().foo { // no ambiguity here
-        www ->
+        <!UNUSED_PARAMETER!>www<!> ->
         <!UNRESOLVED_REFERENCE!>xs<!>
     }
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt

@@ -4,7 +4,7 @@ fun <T, R> foo(block: (T)-> R) = block
 
 fun test1() {
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
-        <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->  // here we have 'cannot infer parameter type' error
+        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>x<!> ->  // here we have 'cannot infer parameter type' error
         43
     }
 }
@@ -12,5 +12,5 @@ fun test1() {
 fun bar(<!UNUSED_PARAMETER!>f<!>: (<!UNRESOLVED_REFERENCE!>A<!>)->Unit) {}
 
 fun test2() {
-    bar { a -> } // here we don't have 'cannot infer parameter type' error
+    bar { <!UNUSED_PARAMETER!>a<!> -> } // here we don't have 'cannot infer parameter type' error
 }

compiler/testData/diagnostics/tests/inline/kt4869.kt

@@ -1,6 +1,6 @@
 inline fun foo(f: () -> Unit) {
     val ff = { f: () -> Unit ->
-
+        f.invoke()
     }
     ff(<!USAGE_IS_NOT_INLINABLE!>f<!>)
 }

compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt

@@ -19,32 +19,32 @@ public class A {
 // FILE: main.kt
 fun main() {
     A().foo {
-        x -> 1
+        x -> x.hashCode()
     }
 
     A.bar {
-        x -> 1
+        x -> x.hashCode()
     }
 
 
     // baz
     A.baz {
-        x -> "" // OK
+        x -> x.toString() // OK
     }
 
     A.baz {
-        x -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
+        x -> <!TYPE_MISMATCH!>x.hashCode()<!>
     }
 
     val block: (String) -> Any? = {
-        x -> 1
+        x -> x.hashCode()
     }
 
     A().foo(block)
     A.bar(block)
 
     val block2: (String) -> CharSequence? = {
-        x -> ""
+        x -> x.toString()
     }
 
     A.<!NONE_APPLICABLE!>baz<!>(block)

compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt

@@ -16,12 +16,12 @@ public class A {
 // FILE: main.kt
 fun main() {
     A().foo <!TYPE_MISMATCH!>{
-        <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>x<!> ->
         ""
     }<!>
 
     A.bar <!TYPE_MISMATCH!>{
-        <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>x<!> ->
         ""
     }<!>
 }

compiler/testData/diagnostics/tests/j+k/samByProjectedType/starProjectionComplexUpperBound.kt

@@ -27,7 +27,7 @@ fun main() {
         ""
     }
 
-    val block: (Map<String, Int>) -> CharSequence = { x -> "" }
+    val block: (Map<String, Int>) -> CharSequence = { x -> x.toString() }
     A().foo(block)
     A.bar(block)
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt

@@ -23,5 +23,5 @@ fun main() {
     B().foo(<!TYPE_MISMATCH!>{ println() }<!>, B.bar())
     // So you should use SAM constructors when you want to use mix lambdas and Java objects
     B().foo(Runnable { println() }, B.bar())
-    B().foo({ println() }, { it: Any? -> true } )
+    B().foo({ println() }, { it: Any? -> it == null } )
 }

compiler/testData/diagnostics/tests/platformTypes/samAdapterInConstructor.kt

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: A.java
 import java.util.Comparator;

compiler/testData/diagnostics/tests/regressions/Jet124.kt

@@ -3,6 +3,6 @@ fun foo1() :  (Int) -> Int = { x: Int -> x }
 fun foo() {
   val h :  (Int) -> Int = foo1();
   h(1)
-  val m :  (Int) -> Int = {a : Int -> 1}//foo1()
+  val m :  (Int) -> Int = {<!UNUSED_PARAMETER!>a<!> : Int -> 1}//foo1()
   m(1)
 }

compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.kt

@@ -6,7 +6,7 @@ class A {
 fun foo(a: A, c: Int) {
     val (<!NAME_SHADOWING!>a<!>, b) = a
     val arr = Array(2) { A() }
-    for ((<!NAME_SHADOWING!>c<!>, <!UNUSED_VARIABLE!>d<!>) in arr)  {
+    for ((<!NAME_SHADOWING, UNUSED_VARIABLE!>c<!>, <!UNUSED_VARIABLE!>d<!>) in arr)  {
 
     }
 

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt

@@ -1,6 +1,6 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<String>): String {
-    return javaClass.doSomething("", 1) { s: String -> "" }
+    return javaClass.doSomething("", 1) { <!UNUSED_PARAMETER!>s<!>: String -> "" }
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt

@@ -12,13 +12,13 @@ val test2: (String) -> Boolean =
 
 val test3: (String) -> Boolean =
         when {
-            true -> { s -> true }
+            true -> { <!UNUSED_PARAMETER!>s<!> -> true }
             else -> null!!
         }
 
 val test4: (String) -> Boolean =
         when {
-            true -> { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>s1, <!CANNOT_INFER_PARAMETER_TYPE!>s2<!><!> -> true }
+            true -> { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_PARAMETER!>s1<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_PARAMETER!>s2<!><!> -> true }
             else -> null!!
         }
 

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCallsWithLambdas.kt

@@ -1,3 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
 // !CHECK_TYPE
 
 fun test(d: dynamic) {

compiler/testData/diagnostics/testsWithStdLib/annotations/JvmSyntheticOnDelegate.kt

@@ -1,3 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
 import kotlin.properties.Delegates
 
 class My {

compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt

@@ -1,3 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
 import kotlin.jvm.Volatile
 import kotlin.properties.Delegates
 

compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt

@@ -33,8 +33,8 @@ private val STRING = CompileTimeType<String>()
 private val ANY = CompileTimeType<Any>()
 
 
-private val emptyBinaryFun: Function2<BigInteger, BigInteger, BigInteger> = { a, b -> BigInteger("0") }
+private val emptyBinaryFun: Function2<BigInteger, BigInteger, BigInteger> = { <!UNUSED_PARAMETER!>a<!>, <!UNUSED_PARAMETER!>b<!> -> BigInteger("0") }
-private val emptyUnaryFun: Function1<Long, Long> = { a -> 1.toLong() }
+private val emptyUnaryFun: Function1<Long, Long> = { <!UNUSED_PARAMETER!>a<!> -> 1.toLong() }
 
 private val unaryOperations: HashMap<UnaryOperationKey<*>, Pair<Function1<Any?, Any>, Function1<Long, Long>>>
         = hashMapOf<UnaryOperationKey<*>, Pair<Function1<Any?, Any>, Function1<Long, Long>>>(

idea/testData/checker/Shadowing.kt

@@ -5,15 +5,15 @@ class A {
 
 fun arrayA(): Array<A> = null!!
 
-fun foo(a: A, <warning>c</warning>: Int) {
+fun foo(a: A, <warning descr="[UNUSED_PARAMETER] Parameter 'c' is never used">c</warning>: Int) {
-    val (<warning descr="[NAME_SHADOWING] Name shadowed: a">a</warning>, <warning>b</warning>) = a
+    val (<warning descr="[NAME_SHADOWING] Name shadowed: a"><warning descr="[UNUSED_VARIABLE] Variable 'a' is never used">a</warning></warning>, <warning descr="[UNUSED_VARIABLE] Variable 'b' is never used">b</warning>) = a
     val arr = arrayA()
-    for ((<warning descr="[NAME_SHADOWING] Name shadowed: c">c</warning>, <warning>d</warning>) in arr) {
+    for ((<warning descr="[NAME_SHADOWING] Name shadowed: c"><warning descr="[UNUSED_VARIABLE] Variable 'c' is never used">c</warning></warning>, <warning descr="[UNUSED_VARIABLE] Variable 'd' is never used">d</warning>) in arr) {
     }
 }
 
-fun f(<warning>p</warning>: Int): Int {
+fun f(<warning descr="[UNUSED_PARAMETER] Parameter 'p' is never used">p</warning>: Int): Int {
-    val <error>p</error> = 2
+    val <error descr="">p</error> = 2
-    val <error>p</error> = 3
+    val <error descr="">p</error> = 3
     return p
 }

idea/testData/checker/regression/DescructuringDeclarationInForLoop.kt

@@ -1,3 +1,3 @@
 fun main() {
-    for ((i, <warning>j</warning>)<error>)</error> {}
+    for ((<warning>i</warning>, <warning>j</warning>)<error>)</error> {}
 }

idea/testData/checker/regression/Jet124.kt

@@ -3,6 +3,6 @@ fun foo1() :  (Int) -> Int = { x: Int -> x }
 fun foo() {
   val h :  (Int) -> Int = foo1();
   h(1)
-  val m :  (Int) -> Int = {a : Int -> 1}//foo1()
+  val m :  (Int) -> Int = {<warning descr="[UNUSED_PARAMETER] Parameter 'a' is never used">a</warning> : Int -> 1}//foo1()
   m(1)
 }