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

compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.fir.kt

@@ -0,0 +1,41 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+interface A {
+    companion object {
+        fun foo() {}
+
+        class A_
+    }
+}
+
+open class B {
+    companion object {
+        fun bar() {}
+
+        class B_
+    }
+}
+
+class C: B(), A {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        A.foo()
+        A.Companion.foo()
+        C.<!UNRESOLVED_REFERENCE!>foo<!>()
+
+        <!UNRESOLVED_REFERENCE!>A_<!>()
+        A.A_()
+        A.Companion.A_()
+        C.<!UNRESOLVED_REFERENCE!>A_<!>()
+
+        bar()
+        B.bar()
+        B.Companion.bar()
+        C.<!UNRESOLVED_REFERENCE!>bar<!>()
+
+        B_()
+        B.B_()
+        B.Companion.B_()
+        C.<!UNRESOLVED_REFERENCE!>B_<!>()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.fir.kt

@@ -0,0 +1,52 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+// FILE: 1.kt
+interface A {
+    companion object {
+        fun foo() {}
+
+        class A_
+    }
+}
+
+open class B {
+    companion object {
+        fun bar() {}
+
+        class B_
+    }
+}
+
+// FILE: C.java
+public class C extends B implements A {
+
+}
+
+// FILE: 2.kt
+class D: C() {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        A.foo()
+        A.Companion.foo()
+        C.<!UNRESOLVED_REFERENCE!>foo<!>()
+        D.<!UNRESOLVED_REFERENCE!>foo<!>()
+
+        <!UNRESOLVED_REFERENCE!>A_<!>()
+        A.A_()
+        A.Companion.A_()
+        C.<!UNRESOLVED_REFERENCE!>A_<!>()
+        D.<!UNRESOLVED_REFERENCE!>A_<!>()
+
+        bar()
+        B.bar()
+        B.Companion.bar()
+        C.<!UNRESOLVED_REFERENCE!>bar<!>()
+        D.<!UNRESOLVED_REFERENCE!>bar<!>()
+
+        B_()
+        B.B_()
+        B.Companion.B_()
+        C.<!UNRESOLVED_REFERENCE!>B_<!>()
+        D.<!UNRESOLVED_REFERENCE!>B_<!>()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.fir.kt

@@ -0,0 +1,37 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+open class A {
+    companion object {
+        fun bar() = 1
+    }
+    init {
+        val a: Int = <!INAPPLICABLE_CANDIDATE!>foo<!>()
+        val b: Int = bar()
+    }
+}
+
+open class B: A() {
+    companion object {
+        fun bar() = ""
+    }
+    init {
+        val a: String = <!INAPPLICABLE_CANDIDATE!>foo<!>()
+        val b: String = bar()
+    }
+}
+
+fun A.Companion.foo() = 1
+fun B.Companion.foo() = ""
+
+class C: A() {
+    init {
+        val a: Int = <!INAPPLICABLE_CANDIDATE!>foo<!>()
+        val b: Int = bar()
+    }
+}
+
+class D: B() {
+    init {
+        val a: String = <!INAPPLICABLE_CANDIDATE!>foo<!>()
+        val b: String = bar()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.fir.kt

@@ -0,0 +1,66 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+open class A {
+    inner class B {
+        fun foo() {}
+    }
+
+    inner class D
+
+    companion object {
+        class B {
+            fun bar() {}
+        }
+
+        class C
+    }
+
+    init {
+        B().foo()
+        B().<!UNRESOLVED_REFERENCE!>bar<!>()
+
+        D()
+        C()
+    }
+}
+
+class E: A() {
+    init {
+        B().foo()
+        B().<!UNRESOLVED_REFERENCE!>bar<!>()
+
+        D()
+        C()
+    }
+
+    object Z {
+        init {
+            B().foo()
+            B().<!UNRESOLVED_REFERENCE!>bar<!>()
+
+            D()
+            C()
+        }
+    }
+}
+
+class F: A() {
+    class B {
+        fun fas() {}
+    }
+    inner class D {
+        fun f() {}
+    }
+
+    init {
+        B().fas()
+        D().f()
+    }
+
+    companion object {
+        init {
+            B().fas()
+            D().f()
+        }
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.fir.kt

@@ -0,0 +1,33 @@
+fun foo(init: A.() -> Unit) { }
+
+class A {
+    var x: Int = 0
+    companion object {
+        val f = foo() {
+            x = 1
+        }
+    }
+}
+
+class B(val a: String) {
+    fun f() = 0
+    companion object   {
+        fun B.bar() = a + f()
+    }
+}
+
+open class C {
+    fun bar() {}
+}
+
+class E: C() {
+
+    class D {
+        init {
+            with(C()) {
+                bar()
+                this.bar()
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt

@@ -0,0 +1,34 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: A.java
+public class A {
+    int foo() {return 1;}
+}
+
+// FILE: 1.kt
+
+fun foo() = ""
+
+open class B: A() {
+    init {
+        val a: Int = foo()
+    }
+}
+
+fun test() {
+    fun foo() = ""
+
+    class B: A() {
+        init {
+            val a: Int = foo() // todo
+        }
+    }
+}
+
+class E: A() {
+    fun foo() = A()
+
+    init {
+        val a: A = foo() // todo: discuss
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.fir.kt

@@ -0,0 +1,27 @@
+// FILE: A.java
+public interface A {
+    public class A_ {}
+}
+
+// FILE: 1.kt
+interface B {
+    class B_
+}
+
+class X: A {
+    val a: A_ = A_()
+    val b: A.A_ = A.A_()
+
+    companion object {
+        val a: A_ = A_()
+    }
+}
+
+class Y: B {
+    val a: B_ = B_()
+    val b: B.B_ = B.B_()
+
+    companion object {
+        val b: B_ = B_()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.fir.kt

@@ -0,0 +1,39 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+open class A {
+    companion object {
+        class B
+    }
+}
+
+class C: A() {
+    val b: B = null!!
+
+    init {
+        B()
+    }
+
+    object O {
+        val b: B = null!!
+
+        init {
+            B()
+        }
+    }
+
+    class K {
+        val b: B = null!!
+
+        init {
+            B()
+        }
+    }
+
+    inner class I {
+        val b: B = null!!
+
+        init {
+            B()
+        }
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.fir.kt

@@ -0,0 +1,95 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+open class A {
+    class X {
+        fun A_X() {}
+    }
+
+    class Y {
+        fun A_Y() {}
+    }
+
+    companion object {
+        class X {
+            fun A_C_X() {}
+        }
+
+        class Z {
+            fun A_C_Z() {}
+        }
+    }
+
+    init {
+        X().A_X()
+        X().<!UNRESOLVED_REFERENCE!>A_C_X<!>()
+    }
+}
+
+class Simple: A() {
+    init {
+        Y().A_Y()
+        Z().A_C_Z()
+    }
+}
+
+class B: A() {
+    class Y {
+        fun B_Y() {}
+    }
+
+    class Z {
+        fun B_Z() {}
+    }
+
+    init {
+        X().A_X()
+        X().<!UNRESOLVED_REFERENCE!>A_C_X<!>()
+
+        Y().B_Y()
+        Y().<!UNRESOLVED_REFERENCE!>A_Y<!>()
+
+        Z().B_Z()
+        Z().<!UNRESOLVED_REFERENCE!>A_C_Z<!>()
+    }
+
+    companion object {
+        init {
+            X().A_X()
+            X().<!UNRESOLVED_REFERENCE!>A_C_X<!>()
+
+            Y().B_Y()
+            Y().<!UNRESOLVED_REFERENCE!>A_Y<!>()
+
+            Z().B_Z()
+            Z().<!UNRESOLVED_REFERENCE!>A_C_Z<!>()
+        }
+    }
+}
+
+class C: A() {
+    companion object {
+        class Y {
+            fun C_C_Y() {}
+        }
+
+        class Z {
+            fun C_C_Z() {}
+        }
+
+        init {
+            Y().C_C_Y()
+            Y().<!UNRESOLVED_REFERENCE!>A_Y<!>()
+
+            Z().C_C_Z()
+            Z().<!UNRESOLVED_REFERENCE!>A_C_Z<!>()
+        }
+    }
+
+    init {
+        Y().<!UNRESOLVED_REFERENCE!>C_C_Y<!>()
+        Y().A_Y()
+
+        Z().C_C_Z()
+        Z().<!UNRESOLVED_REFERENCE!>A_C_Z<!>()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.fir.kt

@@ -0,0 +1,47 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+// FILE: 1.kt
+open class A {
+    class Y {
+        fun A_Y() {}
+    }
+
+    companion object {
+        class Z {
+            fun A_C_Z() {}
+        }
+    }
+}
+
+// FILE: B.java
+public class B extends A {
+    class Y {
+        void B_Y() {}
+    }
+
+    class Z {
+        void B_Z() {}
+    }
+}
+
+// FILE: C.java
+public class C extends A {}
+
+// FILE: 2.kt
+class E: B() {
+    init {
+        Y().B_Y()
+        Y().<!UNRESOLVED_REFERENCE!>A_Y<!>()
+
+        Z().B_Z()
+        Z().<!UNRESOLVED_REFERENCE!>A_C_Z<!>()
+    }
+}
+
+class Y: C() {
+    init {
+        Y().A_Y()
+
+        Z().A_C_Z()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.fir.kt

@@ -0,0 +1,90 @@
+// FILE: A.java
+public interface A {
+    public class A_S { // static
+
+    }
+}
+
+// FILE: B.java
+public class B {
+    public static class B_S {
+
+    }
+    public class B_ {
+
+    }
+}
+
+// FILE: C.java
+public class C extends B implements A {
+
+}
+
+// FILE: 1.kt
+
+class X: A {
+    val a_s: A_S = null!!
+
+    init {
+        A_S()
+        A.A_S()
+        X.A_S()
+    }
+
+    object xD {
+        val a_: A_S = null!!
+
+        init {
+            A_S()
+        }
+    }
+}
+
+class Y: B() {
+    val b_: B_ = null!!
+    val b_s: B_S = null!!
+
+    init {
+        B_()
+        B.<!UNRESOLVED_REFERENCE!>B_<!>()
+        Y.<!UNRESOLVED_REFERENCE!>B_<!>()
+
+        B_S()
+        B.B_S()
+        Y.B_S()
+    }
+
+    object X {
+        val b_: B_ = null!!
+        val b_s: B_S = null!!
+
+        init {
+            B_()
+            B_S()
+        }
+    }
+}
+
+class Z: C() {
+    val a_s: A_S = null!!
+    val b_: B_ = null!!
+    val b_s: B_S = null!!
+
+    init {
+        A_S()
+        B_()
+        B_S()
+    }
+
+    object X {
+        val a_s: A_S = null!!
+        val b_: B_ = null!!
+        val b_s: B_S = null!!
+
+        init {
+            A_S()
+            B_()
+            B_S()
+        }
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.fir.kt

@@ -0,0 +1,82 @@
+// FILE: A.java
+public interface A {
+    class A_S {
+
+    }
+}
+
+// FILE: B.java
+public class B {
+    static class B_S {
+
+    }
+    class B_ {
+
+    }
+}
+
+// FILE: C.java
+public class C extends B implements A {
+
+}
+
+// FILE: 1.kt
+interface E {
+    class E_S
+}
+
+open class D: C(), E
+
+// FILE: F.java
+public class F extends D {
+
+}
+
+// FILE: 2.kt
+class X: D() {
+    init {
+        B_()
+        B.<!UNRESOLVED_REFERENCE!>B_<!>()
+        C.<!UNRESOLVED_REFERENCE!>B_<!>()
+        D.<!UNRESOLVED_REFERENCE!>B_<!>()
+        X.<!UNRESOLVED_REFERENCE!>B_<!>()
+
+        A_S()
+        A.A_S()
+        C.A_S()
+        D.A_S()
+        X.A_S()
+
+        B_S()
+        B.B_S()
+        C.B_S()
+        D.B_S()
+        X.B_S()
+
+        E_S()
+        E.E_S()
+        D.E_S()
+        X.E_S()
+    }
+}
+
+class Y: F() {
+    init {
+
+        B_()
+        F.<!UNRESOLVED_REFERENCE!>B_<!>()
+        Y.<!UNRESOLVED_REFERENCE!>B_<!>()
+
+        A_S()
+        F.A_S()
+        Y.A_S()
+
+        B_S()
+        F.B_S()
+        Y.B_S()
+
+        E_S()
+        F.E_S()
+        Y.E_S()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.fir.kt

@@ -0,0 +1,38 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+class X {
+    fun T_X() {}
+}
+
+class Y {
+    fun T_Y() {}
+}
+
+open class A {
+    class X {
+        fun A_X() {}
+    }
+    companion object {
+        class Y {
+            fun A_C_Y() {}
+        }
+    }
+
+    init {
+        X().A_X()
+        X().<!UNRESOLVED_REFERENCE!>T_X<!>()
+
+        Y().A_C_Y()
+        Y().<!UNRESOLVED_REFERENCE!>T_Y<!>()
+    }
+}
+
+class B: A() {
+    init {
+        X().A_X()
+        X().<!UNRESOLVED_REFERENCE!>T_X<!>()
+
+        Y().A_C_Y()
+        Y().<!UNRESOLVED_REFERENCE!>T_Y<!>()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.fir.kt

@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+open class A {
+    companion object {
+        fun foo() = 1
+        fun bar(a: String) = a
+    }
+}
+
+open class B: A() {
+    companion object {
+        fun foo() = ""
+        fun bar(a: Int) = a
+    }
+}
+
+class C: B() {
+    init {
+        val a: String = foo()
+        val b: Int = bar(1)
+        val c: String = bar("")
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_after.fir.kt

@@ -0,0 +1,55 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: J2.java
+public class J2 extends A {
+    public static void boo() {}
+}
+
+// FILE: test.kt
+open class A {
+    companion object : J() {
+        fun bar() {}
+    }
+}
+
+class B : J2() {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        boo()
+    }
+
+    fun test2() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        boo()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>boo<!>()
+        }
+    }
+
+    companion object {
+        init {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>boo<!>()
+        }
+
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>boo<!>()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.fir.kt

@@ -0,0 +1,55 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: J2.java
+public class J2 extends A {
+    public static void boo() {}
+}
+
+// FILE: test.kt
+open class A {
+    companion object : J() {
+        fun bar() {}
+    }
+}
+
+class B : J2() {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        boo()
+    }
+
+    fun test2() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        boo()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>boo<!>()
+        }
+    }
+
+    companion object {
+        init {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>boo<!>()
+        }
+
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>boo<!>()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_after.fir.kt

@@ -0,0 +1,46 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+open class A {
+    companion object : J() {
+        fun bar() {}
+    }
+}
+
+class B : A() {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    fun test2() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+    }
+
+    companion object {
+        init {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+
+        fun bar() {}
+    }
+}
+

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.fir.kt

@@ -0,0 +1,46 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+open class A {
+    companion object : J() {
+        fun bar() {}
+    }
+}
+
+class B : A() {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    fun test2() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+    }
+
+    companion object {
+        init {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+
+        fun bar() {}
+    }
+}
+

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt

@@ -0,0 +1,54 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+open class A<T> : J() {
+    init {
+        foo()
+        bar()
+        val a: Int = baz()
+        val b: T = baz()
+    }
+
+    fun test1() {
+        foo()
+        bar()
+        val a: Int = baz()
+        val b: T = baz()
+    }
+
+    fun baz(): T = null!!
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            val a: Int = <!UNRESOLVED_REFERENCE!>baz<!>()
+            val b: T = <!UNRESOLVED_REFERENCE!>baz<!>()
+        }
+    }
+
+    companion object : A<Int>() {
+        init {
+            foo()
+            bar()
+            val a: Int = baz()
+            val b: T = baz()
+        }
+
+        fun test() {
+            foo()
+            bar()
+            val a: Int = baz()
+            val b: T = baz()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt

@@ -0,0 +1,54 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+open class A<T> : J() {
+    init {
+        foo()
+        bar()
+        val a: Int = baz()
+        val b: T = baz()
+    }
+
+    fun test1() {
+        foo()
+        bar()
+        val a: Int = baz()
+        val b: T = baz()
+    }
+
+    fun baz(): T = null!!
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            val a: Int = <!UNRESOLVED_REFERENCE!>baz<!>()
+            val b: T = <!UNRESOLVED_REFERENCE!>baz<!>()
+        }
+    }
+
+    companion object : A<Int>() {
+        init {
+            foo()
+            bar()
+            val a: Int = baz()
+            val b: T = baz()
+        }
+
+        fun test() {
+            foo()
+            bar()
+            val a: Int = baz()
+            val b: T = baz()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_after.fir.kt

@@ -0,0 +1,50 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+
+open class B : J() {
+    fun baz() {}
+}
+
+class A {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        <!UNRESOLVED_REFERENCE!>baz<!>()
+    }
+
+    fun test1() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        <!UNRESOLVED_REFERENCE!>baz<!>()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>baz<!>()
+        }
+    }
+
+
+    companion object : B() {
+        init {
+            foo()
+            bar()
+            baz()
+        }
+
+        fun test() {
+            foo()
+            bar()
+            baz()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.fir.kt

@@ -0,0 +1,50 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+
+open class B : J() {
+    fun baz() {}
+}
+
+class A {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        <!UNRESOLVED_REFERENCE!>baz<!>()
+    }
+
+    fun test1() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+        <!UNRESOLVED_REFERENCE!>baz<!>()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+            <!UNRESOLVED_REFERENCE!>baz<!>()
+        }
+    }
+
+
+    companion object : B() {
+        init {
+            foo()
+            bar()
+            baz()
+        }
+
+        fun test() {
+            foo()
+            bar()
+            baz()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_after.fir.kt

@@ -0,0 +1,39 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+class A {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    fun test1() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+    }
+
+    companion object : J() {
+        init {
+            foo()
+            bar()
+        }
+
+        fun test() {
+            foo()
+            bar()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.fir.kt

@@ -0,0 +1,39 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// FILE: J.java
+public class J {
+    public static void foo() {}
+}
+
+// FILE: test.kt
+class A {
+    init {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    fun test1() {
+        <!UNRESOLVED_REFERENCE!>foo<!>()
+        bar()
+    }
+
+    object O {
+        fun test() {
+            <!UNRESOLVED_REFERENCE!>foo<!>()
+            bar()
+        }
+    }
+
+    companion object : J() {
+        init {
+            foo()
+            bar()
+        }
+
+        fun test() {
+            foo()
+            bar()
+        }
+
+        fun bar() {}
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.fir.kt

@@ -0,0 +1,36 @@
+// FILE: A.java
+
+class A {
+    private static int a = 1;
+    private static void foo() {}
+
+    protected static int b = 1;
+    protected static void bar() {}
+}
+
+// FILE: B.java
+
+class B extends A {
+    public static int a = 1;
+    public static void foo() {}
+    public static void foo(int i) {}
+
+    public static int b = 1;
+    public static void bar() {}
+    public static void bar(int i) {}
+}
+
+// FILE: test.kt
+
+fun test() {
+    A.<!INAPPLICABLE_CANDIDATE!>a<!>
+    A.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    A.b
+    A.bar()
+    B.a
+    B.foo()
+    B.foo(1)
+    B.<!AMBIGUITY!>b<!>
+    B.bar()
+    B.bar(1)
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/jjkj.fir.kt

@@ -0,0 +1,43 @@
+// FILE: I.java
+
+public interface I {
+    int a = 1;
+}
+
+// FILE: C.java
+
+public class C implements I {
+    static int b = 1;
+    static void bar() {}
+}
+
+// FILE: K.kt
+
+open class K : C()
+
+// FILE: D.java
+
+public class D extends K {
+    static int c = 1;
+    static void baz() {}
+}
+
+// FILE: test.kt
+
+fun test() {
+    I.a
+
+    C.a
+    C.b
+    C.bar()
+
+    K.a
+    K.b
+    K.bar()
+
+    D.a
+    D.b
+    D.c
+    D.bar()
+    D.baz()
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.fir.kt

@@ -0,0 +1,37 @@
+// FILE: K.kt
+
+open class K {
+    companion object {
+        fun foo() {}
+    }
+}
+
+// FILE: D.java
+
+class D extends K {
+    static int b = 1;
+    static void bar() {}
+}
+
+// FILE: K.kt
+
+class K2 {
+    companion object {
+        fun baz() {}
+    }
+}
+
+// FILE: test.kt
+
+fun test() {
+    K.foo()
+
+    D.b
+    D.bar()
+    D.<!UNRESOLVED_REFERENCE!>foo<!>()
+
+    K2.<!UNRESOLVED_REFERENCE!>b<!>
+    K2.<!UNRESOLVED_REFERENCE!>bar<!>()
+    K2.<!UNRESOLVED_REFERENCE!>foo<!>()
+    K2.baz()
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt

@@ -0,0 +1,27 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: A.java
+public class A {
+    public static int foo() {return 1;}
+}
+
+// FILE: 1.kt
+
+fun foo() = ""
+
+class B: A() {
+    init {
+        val a: Int = foo()
+    }
+}
+
+// FILE: 2.kt
+fun test() {
+    fun foo() = ""
+
+    class B: A() {
+        init {
+            val a: Int = foo() // todo
+        }
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.fir.kt

@@ -0,0 +1,32 @@
+// FILE: A.java
+
+public interface A {
+    int field = 1;
+}
+
+// FILE: B.java
+
+public interface B {
+    String field = 1;
+}
+
+// FILE: E.java
+
+public class E implements A, B {
+}
+
+// FILE: O.java
+
+public class O implements A, B {
+    public static double field = 1;
+}
+
+// FILE: test.kt
+
+fun test() {
+    A.field
+    B.field
+
+    E.<!AMBIGUITY!>field<!>
+    O.<!AMBIGUITY!>field<!>
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.fir.kt

@@ -0,0 +1,32 @@
+// FILE: A.java
+
+public interface A {
+    int field = 1;
+}
+
+// FILE: B.java
+
+public interface B extends A {
+    String field = 1;
+}
+
+// FILE: E.java
+
+public class E implements A, B {
+}
+
+// FILE: O.java
+
+public class O implements A, B {
+    public static double field = 1;
+}
+
+// FILE: test.kt
+
+fun test() {
+    A.field
+    B.<!AMBIGUITY!>field<!>
+
+    E.<!AMBIGUITY!>field<!>
+    O.<!AMBIGUITY!>field<!>
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.fir.kt

@@ -0,0 +1,66 @@
+// FILE: A.java
+
+public interface A {
+    int field = 1;
+}
+
+// FILE: B.java
+
+public interface B {
+    String field = 1;
+}
+
+// FILE: C.java
+
+public interface C extends A {
+}
+
+// FILE: D.java
+
+public interface D extends B {
+}
+
+// FILE: E.java
+
+public class E implements C, D {
+}
+
+// FILE: EE.java
+
+public class EE extends E {
+}
+
+// FILE: EO.java
+
+public class EO extends E {
+    public static double field = 1;
+}
+
+// FILE: O.java
+
+public class O implements C, D {
+    public static double field = 1;
+}
+
+// FILE: OO.java
+
+public class OO extends O {
+}
+
+// FILE: test.kt
+
+fun test() {
+    A.field
+    B.field
+
+    C.field
+    D.field
+
+    E.<!AMBIGUITY!>field<!>
+    O.<!AMBIGUITY!>field<!>
+
+    EE.<!AMBIGUITY!>field<!>
+    EO.<!AMBIGUITY!>field<!>
+
+    OO.<!AMBIGUITY!>field<!>
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.fir.kt

@@ -0,0 +1,55 @@
+// FILE: I.java
+
+public interface I {
+    int a = 1;
+}
+
+// FILE: C.java
+
+public class C implements I {
+    static int b = 1;
+    static void bar() {}
+}
+
+// FILE: K.kt
+
+open class K : C(), I
+
+// FILE: D.java
+
+public class D extends K implements I {
+    static int c = 1;
+    static void baz() {}
+}
+
+// FILE: E.java
+
+public class E extends D implements I {
+    static int a = 1;
+}
+
+// FILE: test.kt
+
+fun test() {
+    I.a
+
+    C.a
+    C.b
+    C.bar()
+
+    K.a
+    K.b
+    K.bar()
+
+    D.a
+    D.b
+    D.c
+    D.bar()
+    D.baz()
+
+    E.<!AMBIGUITY!>a<!>
+    E.b
+    E.c
+    E.bar()
+    E.baz()
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.fir.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: A.java
+public class A {
+    static void foo() {}
+    static int bar() { return 1; }
+}
+
+// FILE: B.java
+public class B extends A {
+    static void foo() {}
+    static long bar() { return 1; }
+}
+
+// FILE: 1.kt
+class E: B() {
+    init {
+        foo()
+        val a: Long = bar()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.fir.kt

@@ -0,0 +1,50 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: A.java
+public class A {
+    static void foo() {}
+    static int bar() {return 1;}
+}
+
+// FILE: B.java
+public class B extends A {}
+
+// FILE: C.java
+public class C {
+    static void bar() {}
+}
+
+// FILE: 1.kt
+import A.foo
+import B.bar
+
+class E: A() {
+    init {
+        foo()
+        bar()
+    }
+}
+
+class F: B() {
+    init {
+        foo()
+        bar()
+    }
+}
+
+// FILE: 2.kt
+import C.bar
+
+class Z: A() {
+    init {
+        val a: Int = bar()
+    }
+}
+
+// FILE: 3.kt
+import C.*
+
+class Q: A() {
+    init {
+        val a: Int = bar()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.fir.kt

@@ -0,0 +1,59 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: A.java
+public class A {
+    static byte foo = 1;
+    static int bar = 2;
+}
+
+// FILE: B.java
+public class B extends A {}
+
+// FILE: C.java
+public class C {
+    static long bar = 3;
+}
+
+// FILE: 1.kt
+import A.foo
+import B.bar
+
+class E: A() {
+    init {
+        foo
+        bar
+    }
+}
+
+class F: B() {
+    init {
+        foo
+        bar
+    }
+}
+
+// FILE: 2.kt
+import C.bar
+
+class Z: A() {
+    init {
+        val a: Int = bar
+    }
+}
+
+// FILE: 3.kt
+import C.*
+
+class Q: A() {
+    init {
+        val a: Int = bar
+    }
+}
+
+// FILE: 4.kt
+val bar = ""
+
+class W: A() {
+    init {
+        val a: Int = bar
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.fir.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: A.java
+public class A {
+    static void foo() {}
+}
+
+// FILE: 1.kt
+open class B : A() {
+    companion object {
+        fun foo() = 1
+    }
+
+    init {
+        val a: Int = foo()
+    }
+}
+
+class C: B() {
+    init {
+        val a: Int = foo()
+    }
+}
+
+// FILE: X.java
+public class X extends B {
+    static double foo() {
+        return 1.0;
+    }
+}
+
+// FILE: 2.kt
+class Y: X() {
+    init {
+        val a: Double = foo()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.fir.kt

@@ -0,0 +1,69 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: A.java
+public class A {
+    public static int foo() { return 1; }
+    public static int bar = 1;
+}
+
+// FILE: 1.kt
+
+class B: A() {
+    companion object {
+        init {
+            val a: Int = <!UNRESOLVED_REFERENCE!>foo<!>()
+            val b: Int = <!UNRESOLVED_REFERENCE!>bar<!>
+        }
+    }
+
+    init {
+        val a: Int = foo()
+        val b: Int = bar
+    }
+}
+
+open class C: A() {
+    val bar = ""
+    fun foo() = ""
+
+    init {
+        val a: String = foo()
+        val b: String = <!AMBIGUITY!>bar<!>
+    }
+}
+
+class E: C() {
+    init {
+        val a: String = foo()
+        val b: String = <!AMBIGUITY!>bar<!>
+    }
+}
+
+open class F: A() {
+    companion object {
+        val bar = ""
+        fun foo() = ""
+
+        init {
+            val a: String = foo()
+            val b: String = bar
+        }
+    }
+    init {
+        val a: String = foo()
+        val b: String = bar
+    }
+}
+
+class G: F() {
+    companion object {
+        init {
+            val a: String = foo()
+            val b: String = bar
+        }
+    }
+
+    init {
+        val a: String = foo()
+        val b: String = bar
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.fir.kt

@@ -0,0 +1,19 @@
+// FILE: A.java
+public class A {
+    public static int foo() {return 1;}
+}
+
+// FILE: B.java
+public class B extends A {
+    public static int foo() {return 1;}
+}
+
+// FILE: 1.kt
+
+fun foo() = ""
+
+class C: B() {
+    init {
+        val a: Int = foo()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.fir.kt

@@ -0,0 +1,51 @@
+// FILE: A.java
+public class A {
+    public static void foo() {}
+}
+
+// FILE: B.java
+public class B extends A {
+    public static void bar() {}
+}
+
+// FILE: 1.kt
+open class X: A() {
+    init {
+        foo()
+        A.foo()
+    }
+}
+
+open class Y: B() {
+    init {
+        foo()
+        A.foo()
+        B.foo()
+
+        bar()
+        B.bar()
+    }
+}
+
+class XN: X() {
+    init {
+        foo()
+        A.foo()
+        X.foo()
+        XN.foo()
+    }
+}
+
+class YN: Y() {
+    init {
+        foo()
+        A.foo()
+        Y.foo()
+        YN.foo()
+
+        bar()
+        B.bar()
+        Y.bar()
+        YN.bar()
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.fir.kt

@@ -0,0 +1,27 @@
+// FILE: A.java
+public class A {
+    public static void foo() {}
+}
+
+// FILE: 1.kt
+open class B: A()
+
+// FILE: C.java
+public class C extends B {
+    public static void bar() {}
+}
+
+// FILE: 2.kt
+class D: C() {
+    init {
+        foo()
+        A.foo()
+        B.foo()
+        C.foo()
+        D.foo()
+
+        bar()
+        C.bar()
+        D.bar()
+    }
+}