Introduce UNUSED_ANONYMOUS_PARAMETER for anonymous functions

It is not reported for 1.0 language version because renaming to _ is not possible. It has weak warning severity So #KT-8813 Fixed So #KT-16875 Fixed
2017-03-30 17:42:46 +03:00
parent 110fc103de
commit 7a53b2f4c8
65 changed files with 130 additions and 90 deletions
@@ -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, UNUSED_PARAMETER!>b<!> -> 42 })
+fun test() = <!CANNOT_COMPLETE_RESOLVE!>h<!>(1, 1, 1, { <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>b<!> -> 42 })
@@ -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, UNUSED_PARAMETER!>i<!> -> getAnswer() }
+fun test() = <!CANNOT_COMPLETE_RESOLVE!>h<!>{ <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>i<!> -> getAnswer() }

 fun getAnswer() = 42

@@ -5,7 +5,7 @@ import java.util.*
 import java.util.Collections.*

 fun foo(list: List<String>) : String {
-    val w : String = max(list, comparator<String?> {<!UNUSED_PARAMETER!>o1<!>, <!UNUSED_PARAMETER!>o2<!> -> 1
+    val w : String = max(list, comparator<String?> {<!UNUSED_ANONYMOUS_PARAMETER!>o1<!>, <!UNUSED_ANONYMOUS_PARAMETER!>o2<!> -> 1
    })
    return w
 }
@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER

 fun <T, R : Any> foo(body: (R?) -> T): T = fail()

@@ -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 { <!UNUSED_PARAMETER!>ppp<!> -> 1 }<!>
+    val <!UNUSED_VARIABLE!>m<!>: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>map { <!UNUSED_ANONYMOUS_PARAMETER!>ppp<!> -> 1 }<!>
 }
@@ -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 { <!UNUSED_PARAMETER!>it<!> -> <!UNRESOLVED_REFERENCE!>xxx<!> }
+    _arrayList(_Pair(1))._sortBy { <!UNUSED_ANONYMOUS_PARAMETER!>it<!> -> <!UNRESOLVED_REFERENCE!>xxx<!> }
 }
@@ -9,7 +9,7 @@ public inline fun <T: Closeable, R> T.use1(block: (T)-> R) : R {

 fun main(args: Array<String>) {
    C().use1 {
-        <!UNUSED_PARAMETER!>w<!> ->  // ERROR here
+        <!UNUSED_ANONYMOUS_PARAMETER!>w<!> ->  // ERROR here
        <!UNRESOLVED_REFERENCE!>x<!>
    }
 }
@@ -8,7 +8,7 @@ enum class SomeEnum {

 // Doesn't work
 fun Iterable<Int>.some() {
-    this.fold(SomeEnum.FIRST, {res : SomeEnum, <!UNUSED_PARAMETER!>value<!> ->
+    this.fold(SomeEnum.FIRST, {res : SomeEnum, <!UNUSED_ANONYMOUS_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, {<!UNUSED_PARAMETER!>res<!> : SomeEnum, <!UNUSED_PARAMETER!>value<!> ->
+    this.fold(SomeEnum.FIRST, {<!UNUSED_ANONYMOUS_PARAMETER!>res<!> : SomeEnum, <!UNUSED_ANONYMOUS_PARAMETER!>value<!> ->
        tempFun()
    })
 }
@@ -27,14 +27,14 @@ fun Iterable<Int>.someSimpleWithFun() {

 // Works
 fun Iterable<Int>.someSimple() {
-    this.fold(SomeEnum.FIRST, {<!UNUSED_PARAMETER!>res<!> : SomeEnum, <!UNUSED_PARAMETER!>value<!> ->
+    this.fold(SomeEnum.FIRST, {<!UNUSED_ANONYMOUS_PARAMETER!>res<!> : SomeEnum, <!UNUSED_ANONYMOUS_PARAMETER!>value<!> ->
        SomeEnum.FIRST
    })
 }

 // Works
 fun Iterable<Int>.someInt() {
-    this.fold(0, {res : Int, <!UNUSED_PARAMETER!>value<!> ->
+    this.fold(0, {res : Int, <!UNUSED_ANONYMOUS_PARAMETER!>value<!> ->
        if (res == 0) 1 else 0
    })
 }
@@ -15,10 +15,10 @@ fun SomeTemplate.query(f: (i: Int) -> Unit) = f
 fun SomeTemplate.query1(f: (i: Int) -> Unit) = f

 fun test() {
-    val mapperFunction = { <!UNUSED_PARAMETER!>i<!>: Int -> }
+    val mapperFunction = { <!UNUSED_ANONYMOUS_PARAMETER!>i<!>: Int -> }
    SomeTemplate().query(mapperFunction)

    // TYPE_MISMATCH: Required Class<[ERROR: CANT_INFER]>, Found (kotlin.Int) -> Unit
-    SomeTemplate().query { <!UNUSED_PARAMETER!>i<!>: Int -> }
-    SomeTemplate().query1 { <!UNUSED_PARAMETER!>i<!>: Int -> }
+    SomeTemplate().query { <!UNUSED_ANONYMOUS_PARAMETER!>i<!>: Int -> }
+    SomeTemplate().query1 { <!UNUSED_ANONYMOUS_PARAMETER!>i<!>: Int -> }
 }
@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER
 // KT-8132 Can't omit lambda parameter types

 fun <T> test(foo: List<T>): T {
@@ -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 = { <!UNUSED_PARAMETER!>x<!>: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
+    val fff = { <!UNUSED_ANONYMOUS_PARAMETER!>x<!>: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
    foo(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fff<!>, { x -> x + 1 })
 }

@@ -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
-        <!UNUSED_PARAMETER!>www<!> ->
+        <!UNUSED_ANONYMOUS_PARAMETER!>www<!> ->
        <!UNRESOLVED_REFERENCE!>xs<!>
    }
 }
@@ -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, UNUSED_PARAMETER!>x<!> ->  // here we have 'cannot infer parameter type' error
+        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_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 { <!UNUSED_PARAMETER!>a<!> -> } // here we don't have 'cannot infer parameter type' error
+    bar { <!UNUSED_ANONYMOUS_PARAMETER!>a<!> -> } // here we don't have 'cannot infer parameter type' error
 }