[FIR-TEST] Add new testdata generated after changes in previous commit

2019-12-11 16:16:22 +03:00
parent e9c02a1cca
commit 2536fa0cd5
4578 changed files with 104067 additions and 1 deletions
@@ -0,0 +1,19 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_DESTRUCTURED_PARAMETER_ENTRY, -UNUSED_ANONYMOUS_PARAMETER
+
+data class Foo1(val x: String, val y: String, val z: String = "")
+
+fun main() {
+    val (x1,y1,) = Pair(1,2)
+    val (x2, y2: Number,) = Pair(1,2)
+    val (x3,y3,z3,) = Foo1("", "", )
+    val (x4,y4: CharSequence,) = Foo1("", "", "",)
+    val (x41,y41: CharSequence,/**/) = Foo1("", "", "",)
+
+    val x5: (Pair<Int, Int>, Int) -> Unit = { (x,y,),z, -> }
+    val x6: (Foo1, Int) -> Any = { (x,y,z: CharSequence,), z1: Number, -> 1 }
+    val x61: (Foo1, Int) -> Any = { (x,y,z: CharSequence,/**/), z1: Number,/**/ -> 1 }
+
+    for ((i, j,) in listOf(Pair(1,2))) {}
+    for ((i: Any,) in listOf(Pair(1,2))) {}
+    for ((i: Any,/**/) in listOf(Pair(1,2))) {}
+}
@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_DESTRUCTURED_PARAMETER_ENTRY, -UNUSED_ANONYMOUS_PARAMETER
+// !LANGUAGE: +TrailingCommas
+
+data class Foo1(val x: String, val y: String, val z: String = "")
+
+fun main() {
+    val (x1,y1,) = Pair(1, 2)
+    val (x2, y2: Number,) = Pair(1,2)
+    val (x3,y3,z3,) = Foo1("", "",)
+    val (x4,y4: CharSequence,) = Foo1("", "", "",)
+    val (x41,y41: CharSequence,/**/) = Foo1("", "", "",)
+
+    val x5: (Pair<Int, Int>, Int) -> Unit = { (x,y,),z, -> }
+    val x6: (Foo1, Int) -> Any = { (x,y,z: CharSequence,), z2: Number, -> 1 }
+    val x61: (Foo1, Int) -> Any = { (x,y,z: CharSequence,/**/), z2: Number,/**/ -> 1 }
+
+    for ((i, j) in listOf(Pair(1,2))) {}
+    for ((i: Any,) in listOf(Pair(1,2))) {}
+    for ((i: Any,/**/) in listOf(Pair(1,2))) {}
+}
@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
+// !LANGUAGE: +TrailingCommas
+
+fun foo(vararg x: Int) = false
+fun foo() = true
+
+fun main() {
+    val x = foo()
+    val y = foo(<!SYNTAX!>,<!><!SYNTAX!><!>)
+}
@@ -0,0 +1,28 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_TYPEALIAS_PARAMETER, -CAST_NEVER_SUCCEEDS
+
+class Foo1<T1> {}
+
+interface Foo2<T1,>
+
+fun <T1, T2, T3>foo3() {}
+
+typealias Foo4<T1,T2,T3,T4> = Int
+
+class Foo5<T, K: T,>: Foo2<K,>
+
+fun <T> foo() {
+    val x1 = Foo1<Int,>()
+    val x2: Foo2<Int,>? = null
+    val x21: Foo2<Int,/**/>? = null
+    val x3 = foo3<
+            Int,
+            String,
+            Float,
+            >()
+    val x4: Foo4<Comparable<Int,>, Iterable<Comparable<Float,>,>, Double, T,
+            >? = null as Foo4<Comparable<Int,>, Iterable<Comparable<Float,>,>, Double, T,>
+    val x5: (Float,) -> Unit = {}
+    val x6: Pair<(Float, Comparable<T,>,) -> Unit, (Float,) -> Unit,>? = null
+    val x61: Pair<(Float, Comparable<T,/**/>,/**/) -> Unit, (Float,/**/) -> Unit,/**/>? = null
+}
+
@@ -0,0 +1,28 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_TYPEALIAS_PARAMETER, -CAST_NEVER_SUCCEEDS
+// !LANGUAGE: +TrailingCommas
+
+class Foo1<T1> {}
+
+interface Foo2<T1,>
+
+fun <T1, T2, T3>foo3() {}
+
+typealias Foo4<T1,T2,T3,T4> = Int
+
+class Foo5<T, K: T,>: Foo2<K,>
+
+fun <T>foo () {
+    val x1 = Foo1<Int,>()
+    val x2: Foo2<Int,>? = null
+    val x21: Foo2<Int,/**/>? = null
+    val x3 = foo3<
+            Int,
+            String,
+            Float,
+            >()
+    val x4: Foo4<Comparable<Int,>, Iterable<Comparable<Float,>,>, Double, T,
+            >? = null as Foo4<Comparable<Int,>, Iterable<Comparable<Float,>,>, Double, T,>
+    val x5: (Float,) -> Unit = {}
+    val x6: Pair<(Float, Comparable<T,>,) -> Unit, (Float,) -> Unit,>? = null
+    val x61: Pair<(Float, Comparable<T,/**/>,/**/) -> Unit, (Float,/**/) -> Unit,/**/>? = null
+}
@@ -0,0 +1,48 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_TYPEALIAS_PARAMETER
+
+@Target(AnnotationTarget.TYPE)
+annotation class Anno
+
+class Foo1<T1,>
+
+class Foo2<
+        T1,
+        T2: T1,
+        > {
+    fun <T1,
+            T2, > foo2() {}
+
+    internal inner class B<T,T2,>
+}
+
+interface A<T,>
+
+interface A1<T,/**/>
+
+fun <T,> foo1() {}
+
+fun <T,/**/> foo11() {}
+
+fun <T1,
+        T2,
+        > T2?.foo2() {}
+
+val <T,> T.bar1 get() = null
+
+var <
+        T4,
+        > T4?.bar2
+    get() = null
+    set(value) {
+
+    }
+
+typealias Foo3<T1, @Anno T2,> = List<T2>
+
+typealias Foo4<T1, @Anno T2,/**/> = List<T2>
+
+fun main() {
+    fun <T,> foo10() {
+        fun <T1,T2,T3,> foo10() {}
+    }
+}
@@ -0,0 +1,51 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_TYPEALIAS_PARAMETER
+// !LANGUAGE: +TrailingCommas
+
+@Target(AnnotationTarget.TYPE)
+annotation class Anno
+
+class Foo1<T1,>
+
+class Foo2<
+        T1,
+        T2: T1,
+        > {
+    fun <T1,
+            T2, > foo2() {}
+
+    internal inner class B<T,T2,>
+}
+
+interface A<T,>
+
+interface A1<T,/**/>
+
+fun <T,> foo1() {}
+
+fun <T,/**/> foo11() {}
+
+inline fun <reified T1, T2, reified T3,> foo2() {}
+
+fun <T1,
+        T2,
+        > T2?.foo3() {}
+
+val <T,> T.bar1 get() = null
+
+var <
+        T4,
+        > T4?.bar2
+    get() = null
+    set(value) {
+
+    }
+
+typealias Foo3<T1, @Anno T2,> = List<T2>
+
+typealias Foo4<T1, @Anno T2,/**/> = List<T2>
+
+fun main() {
+    fun <T,> foo10() {
+        fun <T1,T2,T3,> foo10() {}
+    }
+}
@@ -0,0 +1,73 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -UNUSED_ANONYMOUS_PARAMETER
+
+@Target(AnnotationTarget.TYPE)
+annotation class Anno1(val x: IntArray)
+
+@Target(AnnotationTarget.TYPEALIAS)
+annotation class Anno2(val x: DoubleArray)
+
+fun foo1(vararg x: Any) {}
+fun foo2(x: (Any, Any) -> Unit) {}
+fun foo3(x: Any, y: () -> Unit) {}
+
+open class A1(vararg x: Any) {
+    operator fun get(x: Any, y: Any) = 10
+}
+
+open class A2(x: Int, y: () -> Unit) {}
+
+class B(): A1({},) {
+
+}
+
+@Anno2(
+    [
+        0.4,
+        .1,
+    ]
+)
+typealias A3 = B
+
+fun main1() {
+    foo1(1, 2, 3,)
+    foo1({},)
+    foo3(10,) {}
+    foo3(10,/**/) {}
+
+    val x1 = A1(1, 2, 3,)
+    val y1 = A1({},)
+    val z1 = A2(10,) {}
+
+    foo2({ x, y -> kotlin.Unit },)
+    foo2({ x, y -> kotlin.Unit },/**/)
+
+    val foo = listOf(
+        println(1),
+        "foo bar something",
+        )
+
+    val x2 = x1[
+            1,
+            2,
+    ]
+
+    val x3 = x1[{},{},]
+    val x31 = x1[{},{},/**/]
+
+    val x4: @Anno1([
+                      1, 2,
+                  ]) Float = 0f
+
+    foo1(object {},)
+    foo1(object {},/**/)
+    foo1(fun () {},)
+    foo1(if (true) 1 else 2,)
+
+    foo1(return,)
+}
+
+fun main2(x: A1) {
+    val x1 = x[object {}, return, ]
+    val x2 = x[fun () {}, throw Exception(), ]
+    val x3 = x[fun () {}, throw Exception(),/**/ ]
+}
@@ -0,0 +1,69 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -UNUSED_ANONYMOUS_PARAMETER
+// !LANGUAGE: +TrailingCommas
+
+@Target(AnnotationTarget.TYPE)
+annotation class Anno1(val x: IntArray)
+
+@Target(AnnotationTarget.TYPEALIAS)
+annotation class Anno2(val x: DoubleArray)
+
+fun foo1(vararg x: Any) {}
+fun foo2(x: (Any, Any) -> Unit) {}
+fun foo3(x: Any, y: () -> Unit) {}
+
+open class A1(vararg x: Any) {
+    operator fun get(x: Any, y: Any) = 10
+}
+
+open class A2(x: Any, y: () -> Unit)
+
+class B(): A1({},) {
+
+}
+
+@Anno2(
+    [
+        0.4,
+        .1,
+    ]
+)
+typealias A3 = B
+
+fun main1() {
+    foo1(1, 2, 3,/**/)
+    foo1({},)
+    foo3(10,/**/) {}
+
+    val x1 = A1(1, 2, 3,)
+    val y1 = A1({},)
+    val z1 = A2(10,) {}
+
+    foo2({ x, y -> kotlin.Unit },/**/)
+
+    val foo = listOf(
+        println(1),
+        "foo bar something",
+    )
+
+    val x2 = x1[
+        1,
+        2,
+    ]
+
+    val x3 = x1[{},{},/**/]
+
+    val x4: @Anno1([
+                  1, 2,/**/
+                  ]) Float = 0f
+
+    foo1(object {},)
+    foo1(fun () {},)
+    foo1(if (true) 1 else 2,/**/)
+
+    foo1(return,)
+}
+
+fun main2(x: A1) {
+    val x1 = x[object {}, return, ]
+    val x2 = x[fun () {}, throw Exception(), /**/]
+}
@@ -0,0 +1,120 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_ANONYMOUS_PARAMETER -UNUSED_VARIABLE
+
+open class Foo1(x: Int = 10, y: Float = 0f,)
+
+class Foo2(
+    val x: Int = 10,
+    var y: Float,
+): Foo1(x, y,) {
+    constructor(
+        x: Float,
+        y: Int = 10,
+    ): this(1, 1f,) {}
+
+    var x1: Int
+        get() = 10
+        set(value,) {
+
+        }
+
+    var x2: Int
+        get() = 10
+        set(
+            x2,
+        ) {}
+
+    var x3: (Int) -> Unit
+        get() = {}
+        set(x2: (Int) -> Unit,) {}
+
+    var x4: (Int) -> Unit
+        get() = {}
+        set(x2: (Int) -> Unit,/**/) {}
+}
+
+enum class Foo3(x: Int, )
+
+fun foo4(x: Int, y: Comparable<Float>,) {}
+
+fun foo5(x: Int = 10,) {}
+
+fun foo6(vararg x: Int,) {}
+
+fun foo7(y: Float, vararg x: Int,) {}
+
+val foo8: (Int, Int,) -> Int = fun(
+    x,
+    y,
+    ): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int,) -> Int =
+    fun (x, y: Int, z,): Int {
+        return x + y
+    }
+
+open class Foo10(x: Int = 10, y: Float = 0f)
+
+class Foo11: Foo10 {
+    constructor(
+        x: Float
+    ): <!INAPPLICABLE_CANDIDATE!>super<!>(1, 1f,)
+}
+
+class Foo12: Foo10 {
+    constructor(
+        x: Float
+    ): <!INAPPLICABLE_CANDIDATE!>super<!>(1, 1f,/**/)
+}
+
+fun main() {
+    val x1 = {
+            x: Comparable<Comparable<Number>>,
+            y: Iterable<Iterable<Number>>,
+        ->
+        println("1")
+    }
+    val x2 = { x: Comparable<Comparable<Number>>,
+        -> println("1")
+    }
+    val x3: ((Int,) -> Int) -> Unit = { x: (Int,) -> Int, -> println("1") }
+    val x4: ((Int,) -> Int) -> Unit = { x, -> println("1") }
+
+    fun foo10(x:Int,y:Int,) {
+        fun foo10(x:Int,y:Int,) {}
+    }
+    fun foo101(x:Int,y:Int,/**/) {
+        fun foo10(x:Int,y:Int,/**/) {}
+    }
+
+    try {
+        println(1)
+    } catch (e: Exception,) {
+
+    }
+
+    try {
+        println(1)
+    } catch (e: Exception,) {
+
+    } catch (e: Exception,) {
+
+    }
+
+    try {
+        println(1)
+    } catch (e: Exception,) {
+
+    } finally {
+
+    }
+
+    try {
+        println(1)
+    } catch (e: Exception,/**/) {
+
+    } finally {
+
+    }
+}
@@ -0,0 +1,104 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_ANONYMOUS_PARAMETER, -UNUSED_VARIABLE
+// !LANGUAGE: +TrailingCommas
+
+open class Foo1(x: Int = 10, y: Float = 0f,)
+
+class Foo2(
+    val x: Int = 10,
+    var y: Float,
+): Foo1(x, y) {
+    constructor(
+        x: Float,
+        y: Int = 10,
+        ): this(1, 1f,) {
+
+    }
+}
+
+enum class Foo3(x: Int, )
+
+fun foo4(x: Int, y: Comparable<Float>,) {}
+
+fun foo5(x: Int = 10,) {}
+
+fun foo6(vararg x: Int,) {}
+
+fun foo61(vararg x: Int,/**/) {}
+
+fun foo7(y: Float, vararg x: Int,) {}
+
+val foo8: (Int, Int,) -> Int = fun(
+    x,
+    y,
+    ): Int {
+    return x + y
+}
+
+val foo9: (Int, Int, Int,) -> Int =
+    fun (x, y: Int, z,): Int {
+        return x + y
+    }
+
+open class Foo10(x: Int = 10, y: Float = 0f)
+
+class Foo11: Foo10 {
+    constructor(
+        x: Float
+    ): <!INAPPLICABLE_CANDIDATE!>super<!>(1, 1f,)
+}
+
+class Foo12: Foo10 {
+    constructor(
+        x: Float
+    ): <!INAPPLICABLE_CANDIDATE!>super<!>(1, 1f,/**/)
+}
+
+fun main() {
+    val x1 = {
+            x: Comparable<Comparable<Number>>,
+            y: Iterable<Iterable<Number>>,
+        ->
+        println("1")
+    }
+    val x11 = {
+            x: Comparable<Comparable<Number>>,
+            y: Iterable<Iterable<Number>>,/**/
+        ->
+        println("1")
+    }
+    val x2 = { x: Comparable<Comparable<Number>>,
+        -> println("1")
+    }
+    val x3: ((Int,) -> Int) -> Unit = { x: (Int,) -> Int, -> println("1") }
+    val x4: ((Int,) -> Int) -> Unit = { x, -> println("1") }
+
+    try {
+        println(1)
+    } catch (e: Exception,) {
+
+    }
+
+    try {
+        println(1)
+    } catch (e: Exception,) {
+
+    } catch (e: Exception,) {
+
+    }
+
+    try {
+        println(1)
+    } catch (e: Exception,) {
+
+    } finally {
+
+    }
+
+    try {
+        println(1)
+    } catch (e: Exception,/**/) {
+
+    } finally {
+
+    }
+}
@@ -0,0 +1,49 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_EXPRESSION -NAME_SHADOWING
+
+fun foo1(x: Any) = when (x) {
+    Comparable::class,
+    Iterable::class,
+    String::class,
+        -> println(1)
+    else -> println(3)
+}
+
+fun foo2(x: Any) {
+    val z = when (val y: Int = x as Int) {
+        1, -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo3(x: (Any) -> Any) {
+    val z = when (val y: (Any) -> Any = x) {
+        {x: Any, -> x}, {y: Any, -> y}, -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo4(x: Any) {
+    val z = when (x) {
+        is Int, is Double, -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo5(x: Int, y: IntArray, z: IntArray) {
+    val u = when (x) {
+        in y,
+        in z,
+            -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo6(x: Boolean?) = when (x) {
+    true, false, -> println(1)
+    null, -> println(1)
+}
+
+fun foo7(x: Boolean?) = when (x) {
+    true, false,/**/ -> println(1)
+    null,/**/ -> println(1)
+}
@@ -0,0 +1,50 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NAME_SHADOWING
+// !LANGUAGE: +TrailingCommas
+
+fun foo1(x: Any) = when (x) {
+    Comparable::class,
+    Iterable::class,
+    String::class,
+        -> println(1)
+    else -> println(3)
+}
+
+fun foo2(x: Any) {
+    val z = when (val y: Int = x as Int) {
+        1, -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo3(x: (Any) -> Any) {
+    val z = when (val y: (Any) -> Any = x) {
+        {x: Any, -> x}, {y: Any, -> y}, -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo4(x: Any) {
+    val z = when (x) {
+        is Int, is Double, -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo5(x: Int, y: IntArray, z: IntArray) {
+    val u = when (x) {
+        in y,
+        in z,
+            -> println(1)
+        else -> println(3)
+    }
+}
+
+fun foo6(x: Boolean?) = when (x) {
+    true, false, -> println(1)
+    null, -> println(1)
+}
+
+fun foo7(x: Boolean?) = when (x) {
+    true, false,/**/ -> println(1)
+    null,/**/ -> println(1)
+}