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

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