[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,25 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B(open val parentProp: Int)
+val global: Int = 1
+class A : B {
+    val myProp: Int = 1
+    override val parentProp = 1
+
+    constructor(x: Int, y: Int = global): <!INAPPLICABLE_CANDIDATE!>super<!>(x + y + global) {
+        foo(x, y, myProp)
+        x + y + myProp + parentProp + super.parentProp
+    }
+    constructor(x: Double, y: Int): this(x.toInt() + y, x.toInt() * y) {
+        foo(x.toInt(), y, myProp)
+        x + y + myProp + parentProp + super.parentProp
+    }
+    constructor(x: String, y: Int): <!INAPPLICABLE_CANDIDATE!>super<!>(x) {
+        <!INAPPLICABLE_CANDIDATE!>foo<!>(x, y, myProp)
+        x + y + myProp + parentProp + super.parentProp
+    }
+    constructor(x: B, y: Int = <!UNRESOLVED_REFERENCE!>global2<!>): <!INAPPLICABLE_CANDIDATE!>this<!>("", x) {
+        x.parentProp + y + myProp + parentProp + super.parentProp
+    }
+
+    fun foo(x: Int, y: Int, z: Int) = x
+}
@@ -0,0 +1,4 @@
+class A {
+    constructor()
+    init {}
+}
@@ -0,0 +1,17 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    companion object {
+        fun foo(): Int = 1
+        val prop = 2
+        val C = 3
+    }
+    object B {
+        fun bar(): Int = 4
+        val prop = 5
+    }
+    object C {
+    }
+
+    constructor(x: Int)
+    constructor() : this(foo() + prop + B.bar() + B.prop <!INAPPLICABLE_CANDIDATE!>+<!> C)
+}
@@ -0,0 +1,28 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// NI_EXPECTED_FILE
+class A(x: Int) {
+    constructor(x: Double): this(1)
+    constructor(x: String): this(1)
+}
+val x1: A = A(1)
+val x2: A = A(1.0)
+val x3: A = A("abc")
+
+class B<R> {
+    constructor(x: String)
+    constructor(x: R)
+}
+
+val y1: B<Int> = B(1)
+val y2: B<Int> = B("")
+val y3: B<Int> = B<Int>(1)
+val y4: B<Int> = B<Int>("")
+
+val y5: B<String> = <!INAPPLICABLE_CANDIDATE!>B<!><String>(1)
+val y6: B<String> = B<String>("")
+val y7: B<String> = B(1)
+val y8: B<String> = B("")
+
+val y9 = B(1)
+val y10 = B("")
@@ -0,0 +1,20 @@
+object A {
+    constructor()
+    init {}
+}
+
+enum class B {
+    X() {
+        constructor()
+    }
+}
+
+class C {
+    companion object {
+        constructor()
+    }
+}
+
+val anonObject = object {
+    <!CONSTRUCTOR_IN_OBJECT!>constructor()<!>
+}
@@ -0,0 +1,3 @@
+interface A {
+    constructor()
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+annotation class Ann1
+annotation class Ann2(val x: Int)
+
+class A {
+    @Ann1
+    constructor()
+    @Ann2
+    constructor(x1: Int)
+    @Ann2(2)
+    constructor(x1: Int, x2: Int)
+}
@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A1 {
+    constructor(): this()
+}
+
+class A2(x: Byte) {
+    constructor(x1: Int): this(x1, 1)
+    constructor(x1: Int, x2: Int): this(x1, x2, 2)
+    constructor(x1: Int, x2: Int, x3: Int): this(x1)
+
+    // delegating to previously declared cycle
+    constructor(x1: Double): this(1)
+
+
+    // delegating to cycle declared after
+    constructor(x1: String): this(1L)
+
+    constructor(x1: Long): this(x1, 1L)
+    constructor(x1: Long, x2: Long): this(x1, x2, 2L)
+    constructor(x1: Long, x2: Long, x3: Long): this(x1)
+
+    // no cycle, just call to primary constuctor
+    constructor(x1: Double, x2: Double): this(x1, x2, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double): this(x1, x2, x3, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double, x4: Double): this(1.toByte())
+
+    constructor(): this("x", "y")
+
+    constructor(x1: String, x2: String): this(x1, x2, "")
+    constructor(x1: String, x2: String, x3: String): this(x1, x2)
+}
+
+open class B(x: Byte)
+class A : B {
+    // no cycle, just call to super constuctor
+    constructor(x1: Double, x2: Double): this(x1, x2, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double): this(x1, x2, x3, 1.0)
+    constructor(x1: Double, x2: Double, x3: Double, x4: Double): <!INAPPLICABLE_CANDIDATE!>super<!>(1.toByte())
+}
@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+data class A1(val x: String) {
+    constructor(): this("")
+}
+
+data class A2(val y: String, val z: Int) {
+    constructor(x: String): this(x, 0)
+}
+
+data class A3 {
+    constructor()
+}
+
+data class A4 internal constructor()
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    constructor(x: Any, y: Any, z: Any)
+    constructor(x: String?, y: String?): this(x!!, x.length.toString() + y!!, "") {
+        x.length + y.length
+    }
+}
@@ -0,0 +1,6 @@
+interface A
+class AImpl : A
+
+class B : A by AImpl() {
+    constructor()
+}
@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+enum class A {
+    W(1), X(1, 2), Y(3.0), Z(""), E();
+
+    constructor()
+    constructor(x: Int)
+    constructor(x: Int, y: Int): this(x+y)
+    constructor(x: Double): this(x.toInt(), 1)
+    constructor(x: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, 1)
+}
+
+enum class B(x: Int) {
+    W(1), X(1, 2), Y(3.0), Z("");
+
+    constructor(x: Int, y: Int): this(x+y)
+    constructor(x: Double): this(x.toInt(), 1)
+    constructor(x: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, 1)
+}
+
+enum class C {
+    EMPTY(); // may be we should avoid explicit call here
+    constructor()
+}
+
+enum class D(val prop: Int) {
+    X(123) {
+        override fun f() = 1
+    },
+    Y() {
+        override fun f() = prop
+    },
+    Z("abc") {
+        override fun f() = prop
+    };
+
+    constructor(): this(1)
+    constructor(x: String): this(x.length)
+
+    abstract fun f(): Int
+}
@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B0(x: Int)
+
+class A0 : B0 {
+    constructor()
+    constructor(x: Int) : super()
+}
+
+// --------------------------
+
+open class B1 {
+    constructor(x: Int = 1)
+    constructor()
+}
+
+class A1 : B1 {
+    constructor()
+    constructor(x: Int) : super()
+}
+
+// --------------------------
+
+open class B2 {
+    constructor(x: Int)
+    constructor(x: String)
+}
+
+class A2 : B2 {
+    constructor()
+    constructor(x: Int) : super()
+}
+
+// --------------------------
+
+open class B3 {
+    private constructor()
+}
+
+class A3 : B3 {
+    constructor()
+    constructor(x: Int) : super()
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A(x: Int) {
+    constructor()
+}
+open class B(x: Int)
+class C(x: Int) : B(x) {
+    constructor(): super(1)
+}
@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNREACHABLE_CODE
+open class B<T>(x: T, y: T) {
+    constructor(x: T): this(x, x)
+    constructor(): this(null!!, null!!)
+}
+
+class A0 : B<String?> {
+    constructor()
+    constructor(x: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x)
+    constructor(x: String, y: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+}
+
+class A1<R> : B<R> {
+    constructor()
+    constructor(x: R): <!INAPPLICABLE_CANDIDATE!>super<!>(x)
+    constructor(x: R, y: R): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+}
+
+class A2<R> {
+    constructor(t: R, i: Int) : this(i, 1)
+}
@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+open class B<R1, R2>(x: R1, y: R2)
+
+class A0<T1, T2> {
+    constructor(x: T1, y: T2): this(x, y)
+
+    constructor(x: T1, y: T2, z: T2): this(x, 1) // ok, delegates to constructor(x: T1, y: Int)
+
+    constructor(x: T1, y: Int): this(x, "")
+    constructor(x: T1): this(x, 1)
+    constructor(x: T1, y: T2, z: String): this(y, x)
+}
+
+class A1<T1, T2> : B<T1, T2> {
+    constructor(x: T1, y: T2): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T1, y: Int): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T1, y: T1, z: T1): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+}
+
+class A2<T1, T2> : B<T1, Int> {
+    constructor(x: T1, y: T2): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T1, y: Int): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T1, y: T1, z: T1): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T1, y: T2, z: String): <!INAPPLICABLE_CANDIDATE!>super<!>(y, 1)
+}
+
@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B<X, Y : X> {
+    constructor(x: X, y: Y)
+    constructor(x: X, s: String)
+    constructor(y: Y, i: Int) : this(y, "")
+}
+
+class A<T1, T2 : T1> : B<T1, T2> {
+    constructor(x: T1, y: T2): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+    constructor(x: T2, y: T2, z: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, y)
+
+    constructor(x: T2, z: String, z1: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, "")
+    constructor(x: T2, z: String, z1: String, z2: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, 1)
+    constructor(x: T1, z: String, z1: String, z2: String, z3: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, "")
+    constructor(x: T1, z: String, z1: String, z2: String, z3: String, z4: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, 1)
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+open class Base<T>(p: Any?) {
+    fun foo1(t: T) {}
+}
+
+class D: Base<Int>("") {
+    inner class B : Base<String> {
+        constructor() : <!INAPPLICABLE_CANDIDATE!>super<!>(foo1(""))
+        constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(foo1(1))
+    }
+}
@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+open class Base<T>(p: Any?) {
+    fun foo1(t: T) {}
+}
+
+class D: Base<Int>(1) {
+    inner class B : Base<Int> {
+        constructor() : <!INAPPLICABLE_CANDIDATE!>super<!>(foo1(1))
+        constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(this@B.foo1(1))
+        constructor(x: Int, y: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(this@D.foo1(1))
+    }
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class Base(p: Any?) {
+    fun foo1() {}
+}
+
+fun Base.foo() {
+    class B : Base {
+        constructor() : <!INAPPLICABLE_CANDIDATE!>super<!>(foo1())
+        constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(this@foo.foo1())
+        constructor(x: Int, y: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(this@B.foo1())
+    }
+}
@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class Base<T>(p: Any?) {
+    fun foo1(t: T) {}
+}
+
+fun Base<Int>.foo() {
+    class B : Base<String> {
+        constructor() : <!INAPPLICABLE_CANDIDATE!>super<!>(foo1(""))
+        constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(foo1(1))
+        constructor(x: Int, y: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(this@foo.foo1(12))
+        constructor(x: Int, y: Int, z: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>(this@B.foo1(""))
+    }
+}
@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+fun foo(x: Outer) = 1
+class Outer {
+    inner class Inner {
+        val prop = 1
+    }
+
+    constructor(x: Int)
+    constructor(x: Int, y: Int, z: Int = x + Inner().prop + this.Inner().prop) :
+        this(x + Inner().prop + this.Inner().prop)
+}
@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun A.foobar() = 3
+
+class A {
+    fun foo() = 1
+    constructor(x: () -> Int)
+    constructor() : this(
+            {
+                foo() +
+                this.foo() +
+                this@A.foo() +
+                foobar()
+            })
+}
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    fun foo() = 1
+    constructor(x: Int)
+    constructor(x: Int, y: Int, z: Int = x + foo() + this.foo()) :
+        this(x + foo() + this.foo())
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun A.foobar() = 3
+
+class A {
+    fun foo() = 1
+    constructor(x: Any?)
+    constructor() : this(object {
+        fun bar() = foo() + this@A.foo() +
+                    foobar() + super@A.hashCode()
+    })
+}
@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun A.foobar() = 3
+
+class A {
+    fun foo() = 1
+    constructor( x: Any = object {
+        fun bar() = foo() + this@A.foo() +
+                    foobar()
+    })
+}
@@ -0,0 +1,13 @@
+open class C(val x: Int)
+
+class D : C {
+    constructor() : <!INAPPLICABLE_CANDIDATE!>super<!>(
+            {
+                val s = ""
+                s()
+                ""()
+                42
+            }())
+
+    operator fun String.invoke() { }
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+fun foo(x: A) = 1
+
+class A {
+    constructor(x: Int)
+    constructor(x: Int, y: Int, z: Int = x + foo(this) + foo(this@A)) :
+        this(x + foo(this) + foo(this@A))
+}
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    val prop = 1
+    constructor(x: Int)
+    constructor(x: Int, y: Int, z: Int = x + prop + this.prop) :
+        this(x + prop + this.prop)
+}
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B(x: Int)
+class A : B {
+    val prop = 1
+    constructor(x: Int, y: Int = x + prop + this.prop) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x + prop + this.prop)
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B(x: Int) {
+    fun foo() = 1
+}
+class A : B {
+    constructor(x: Int, y: Int = x + foo() + this.foo() + super.foo()) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x + foo() + this.foo() + super.foo())
+}
@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B(x: Int) {
+    open fun foo() = 1
+}
+class A : B {
+    override fun foo() = 2
+    constructor(x: Int, y: Int = x + foo() + this.foo() + super.foo()) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x + foo() + this.foo() + super.foo())
+}
@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B(val prop: Int)
+class A : B {
+    constructor(x: Int, y: Int = x + prop + this.prop + super.prop) :
+        <!INAPPLICABLE_CANDIDATE!>super<!>(x + prop + this.prop + super.prop)
+}
@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun A.foobar() = 1
+val A.prop: Int get() = 2
+
+class A {
+    constructor(x: Int)
+    constructor() : this(
+            foobar() +
+            this.foobar() +
+            prop +
+            this.prop +
+            this@A.prop
+    )
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+fun foo(x: Outer) = 1
+class Outer {
+    inner class Inner {
+        constructor(x: Int)
+        constructor(x: Int, y: Int, z: Int = x + foo(this@Outer)) : this(x + foo(this@Outer))
+    }
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class Outer {
+    val prop = 1
+    inner class Inner {
+        constructor(x: Int)
+        constructor(x: Int, y: Int, z: Int = x + prop + this@Outer.prop) : this(x + prop + this@Outer.prop)
+    }
+}
@@ -0,0 +1,5 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B(x: Int)
+class A : B(1) {
+    constructor(): super(1)
+}
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class A(p1: String)
+
+class B() : A("") {
+    constructor(s: String) {
+    }
+}
@@ -0,0 +1,15 @@
+class A {
+    val x: Int
+    val y: Int
+    constructor(x: Int, y: Int) {
+        this.x = x
+        this.y = y
+    }
+    constructor(other: A) {
+        x = other.x
+        y = other.y
+    }
+}
+class A1(val x: Int, val y: Int) {
+    constructor(other: A1): this(other.x, other.y)
+}
@@ -0,0 +1,3 @@
+class X<T>(val t: T) {
+    constructor(t: String): this(t)
+}
@@ -0,0 +1,5 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+class X<T>(val t: T) {
+    constructor(t: T, i: Int) : this(i)
+}
@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class X<T> {
+    constructor(t: T, i: Int): this(i, 1)
+}
@@ -0,0 +1,5 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A<T1, T2> {
+    constructor(block: (T1) -> T2)
+    constructor(x: T2): this({ x })
+}
@@ -0,0 +1,7 @@
+class A {
+    open inner class Inner
+
+    class Nested : Inner {
+        constructor()
+    }
+}
@@ -0,0 +1,4 @@
+// do not report generate empty synthetic constructor by primary as it leads to CONFLICTING_JVM_DECLARATIONS
+class A(val x: Int = 1, val y: Int = 2) {
+    constructor(): this(0, 0)
+}
@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    constructor(x: Int)
+}
+
+val x = <!INAPPLICABLE_CANDIDATE!>A<!>()
@@ -0,0 +1,6 @@
+open class B
+interface C
+interface D
+class A : C, B, D {
+    constructor()
+}
@@ -0,0 +1,33 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A(val w: Char) {
+    val x: Int
+    var y: Int
+    val z: Int
+    val v = -1
+
+    val uninitialized: Int
+    val overinitialized: Int
+
+    constructor(): this('a') {
+        y = 1
+
+        overinitialized = 2
+        uninitialized = 3
+    }
+
+    // anonymous
+    init {
+        x = 4
+        z = 5
+        overinitialized = 6
+    }
+
+    constructor(a: Int): this('b') {
+        y = 7
+    }
+
+    // anonymous
+    init {
+        y = 8
+    }
+}
@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    val x: Int
+    var y: Int
+    val z: Int
+    val v = -1
+
+    val uninitialized: Int
+    val overinitialized: Int
+
+    constructor() {
+        x = 1
+        y = 2
+
+        overinitialized = 3
+        uninitialized = 4
+    }
+
+    constructor(a: Int): super() {
+        x = 5
+        y = 6
+    }
+
+    constructor(x: String): this() {
+        y = 7
+        uninitialized = 8
+    }
+
+    //anonymous
+    init {
+        z = 9
+        overinitialized = 10
+    }
+
+    // anonymous
+    init {
+        y = 12
+    }
+}
@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A(x: String = "", y: String = "") {
+    constructor(x: String, y: String): this(x, y)
+    constructor(): this("", "")
+    constructor(): this("", "")
+}
+
+class B {
+    constructor(x: Int)
+}
+
+fun B(x: Int) {}
+
+class Outer {
+    class A(x: String = "", y: String = "") {
+        constructor(x: String, y: String): this(x, y)
+        constructor(): this("", "")
+        constructor(): this("", "")
+    }
+
+    class B {
+        constructor(x: Int)
+    }
+
+    fun B(x: Int) {}
+}
@@ -0,0 +1,11 @@
+class A
+class A {
+    constructor()
+}
+
+class B
+class Outer {
+    class B {
+        constructor()
+    }
+}
@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class A(p1: String, p2: String, p3: String, p4: String, p5: String)
+
+class B : A {
+    constructor(s: String)
+}
@@ -0,0 +1,4 @@
+class A {
+    val prop: Int = ""
+    constructor()
+}
@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+class A {
+    init {
+        return
+        return 1
+    }
+    constructor() {
+        if (1 == 1) {
+            return
+            return 1
+        }
+        return
+        return foo()
+    }
+
+    fun foo(): Int = 1
+}
@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    constructor(): <!INAPPLICABLE_CANDIDATE!>super<!>(1)
+}
@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+open class B(x: Double) {
+    constructor(x: Int): this(1.0)
+    constructor(x: String): this(1.0)
+}
+interface C
+class A : B, C {
+    constructor(): <!INAPPLICABLE_CANDIDATE!>super<!>(' ')
+    constructor(x: Int)
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+class A {
+    constructor(x: Int) {}
+    constructor(x: String) {}
+    constructor(): <!INAPPLICABLE_CANDIDATE!>this<!>('a') {}
+}
@@ -0,0 +1,38 @@
+class A0 {
+    val x: Int
+    constructor() {
+        if (1 == 1) {
+            return
+        }
+        x = 1
+    }
+    constructor(arg: Int) {
+        x = arg
+    }
+}
+
+class A1 {
+    val x: Int
+    constructor() {
+        if (1 == 1) {
+            return
+        } else null!!
+        x = 1
+    }
+}
+
+class A2 {
+    val x: Int
+    constructor() {
+        if (1 == 1) {
+            x = 1
+            return
+        }
+        else {
+            x = 2
+        }
+    }
+    constructor(arg: Int) {
+        x = arg
+    }
+}
@@ -0,0 +1,30 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A(val w: Int) {
+    val x: Int
+    val useUnitialized = x +
+                         y +
+                         v
+    var y: Int
+    val v = -1
+    val useInitialized = useUnitialized + v + w
+
+    val uninitialized: Int
+
+    constructor(): this(1) {
+        x + y + v + uninitialized + w
+    }
+
+    // anonymous
+    init {
+        x + y + v + uninitialized + w
+        x = 1
+        x + y + v + uninitialized + w
+    }
+
+    // anonymous
+    init {
+        x + y + v + uninitialized + w
+        y = 7
+        x + y + v + uninitialized + w
+    }
+}
@@ -0,0 +1,46 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    val x: Int
+    val useUnitialized = x + // reported on each secondary constructor
+                         y +
+                         v
+    var y: Int
+    val v = -1
+
+    val useInitialized = useUnitialized + v
+
+    val uninitialized: Int
+
+    constructor() {
+        x = 1
+        y = 2
+
+        x + y + v + uninitialized
+
+        uninitialized = 3
+
+        x + y + v + uninitialized
+    }
+
+    constructor(a: Int): super() {
+        x + y + v + uninitialized
+        x = 4
+        y = 5
+
+        x + y + v + uninitialized
+    }
+
+    constructor(x: String): this() {
+        x + y + v + uninitialized
+    }
+
+    //anonymous
+    init {
+        y
+    }
+
+    // anonymous
+    init {
+        y = 9
+    }
+}
@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class A {
+    constructor(
+        val x: Int, y: Int,
+        var z: Int,
+        public a: Int)
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+fun <T> array(vararg x: T): Array<T> = null!!
+
+open class B(vararg y: String) {
+    constructor(x: Int): <!INAPPLICABLE_CANDIDATE!>this<!>(x.toString(), *array("1"), "2")
+}
+
+class A : B {
+    constructor(x: String, y: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, *array("3"), y)
+    constructor(x: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x)
+    constructor(): super()
+}
@@ -0,0 +1,17 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+fun <T> array(vararg x: T): Array<T> = null!!
+
+open class B(x: Int) {
+    constructor(vararg y: String): this(y[0].length)
+}
+
+class A : B {
+    constructor(x: String, y: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x, *array("q"), y)
+    constructor(x: String): <!INAPPLICABLE_CANDIDATE!>super<!>(x)
+    constructor(): super()
+}
+
+val b1 = B()
+val b2 = B("1", "2", "3")
+val b3 = <!INAPPLICABLE_CANDIDATE!>B<!>("1", *array("2", "3"), "4")
+val b4 = B(1)