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

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.fir.kt

@@ -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))
+    }
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase2.fir.kt

@@ -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))
+    }
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseWithSameExtension.fir.kt

@@ -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())
+    }
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.fir.kt

@@ -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(""))
+    }
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/innerInstanceCreation.fir.kt

@@ -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)
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/lambdaAsArgument.fir.kt

@@ -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()
+            })
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt

@@ -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())
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsArgument.fir.kt

@@ -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()
+    })
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsDefaultValueParameter.fir.kt

@@ -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()
+    })
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.fir.kt

@@ -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() { }
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/passingInstance.fir.kt

@@ -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))
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt

@@ -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)
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt

@@ -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)
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt

@@ -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())
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt

@@ -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())
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt

@@ -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)
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.fir.kt

@@ -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
+    )
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterInstance.fir.kt

@@ -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))
+    }
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterProperty.fir.kt

@@ -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)
+    }
+}