From 7d98103c0c2c296541981002ff5fb25e2043e57e Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 8 Feb 2016 19:04:18 +0300 Subject: [PATCH] overriddenDescriptors is empty for java static property and function declarations Fake overrides are still created for java static with non-empty overriddenDescriptors Add tests for inheriting visibility for java static members Add test: check that java static declarations that shadow deprecated declarations should not be deprecated Add test for corner case where "overriding" java static constant led to incorrect type in inheritor Fix test data for existing tests --- .../codegen/CollectionStubMethodGenerator.kt | 2 +- .../lazy/descriptors/LazyClassMemberScope.kt | 2 +- .../deprecated/javaDeprecatedInheritance.kt | 53 +++++++++++++++++++ .../deprecated/javaDeprecatedInheritance.txt | 39 ++++++++++++++ .../j+k/StaticMembersFromSuperclasses.txt | 2 +- .../j+k/shadowingPrimitiveStaticField.kt | 24 +++++++++ .../j+k/shadowingPrimitiveStaticField.txt | 3 ++ .../statics/hidePrivateByPublic.txt | 4 +- .../scopes/inheritance/statics/nameClash0.txt | 2 +- .../scopes/inheritance/statics/nameClash1.txt | 4 +- .../scopes/inheritance/statics/nameClash2.txt | 4 +- .../statics/oneInterfaceManyTimes.txt | 2 +- .../inheritance/statics/overloadStatic.txt | 4 +- .../inheritance/statics/staticVsCompanion.txt | 2 +- .../inheritance/statics/staticVsOuter.txt | 2 +- .../static/StaticMembersFromParentClass.txt | 4 +- ...taticMembersFromParentClassVisibility.java | 11 ++++ ...StaticMembersFromParentClassVisibility.txt | 21 ++++++++ .../StaticMembersFromParentInterface.txt | 4 +- .../static/StaticMembersInEnumFromParents.txt | 4 +- .../checkers/DiagnosticsTestGenerated.java | 12 +++++ .../jvm/compiler/LoadJavaTestGenerated.java | 6 +++ ...mRuntimeDescriptorLoaderTestGenerated.java | 6 +++ .../components/DescriptorResolverUtils.java | 32 ++++++++++- .../descriptors/LazyJavaClassMemberScope.kt | 11 ++-- .../descriptors/LazyJavaStaticClassScope.kt | 8 +-- .../builtins/functions/FunctionClassScope.kt | 2 +- .../kotlin/resolve/OverridingStrategy.kt | 10 ++-- .../kotlin/resolve/OverridingUtil.java | 6 ++- .../DeserializedClassDescriptor.kt | 2 +- 30 files changed, 249 insertions(+), 39 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt create mode 100644 compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.txt create mode 100644 compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt create mode 100644 compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java create mode 100644 compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.txt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt index fac58b412fa..243eb1f5989 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CollectionStubMethodGenerator.kt @@ -191,7 +191,7 @@ class CollectionStubMethodGenerator( ): List { val result = ArrayList() - OverrideResolver.generateOverridesInAClass(klass, listOf(), object : OverridingStrategy { + OverrideResolver.generateOverridesInAClass(klass, listOf(), object : OverridingStrategy() { override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) { if (fakeOverride !is FunctionDescriptor) return if (fakeOverride.findOverriddenFromDirectSuperClass(mutableCollectionClass)?.kind == DECLARATION) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index 0bfe7a8cabb..26e2739369b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -99,7 +99,7 @@ open class LazyClassMemberScope( } private fun generateFakeOverrides(name: Name, fromSupertypes: Collection, result: MutableCollection, exactDescriptorClass: Class) { - OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, ArrayList(result), thisDescriptor, object : OverridingStrategy { + OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, ArrayList(result), thisDescriptor, object : OverridingStrategy() { override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) { assert(exactDescriptorClass.isInstance(fakeOverride)) { "Wrong descriptor type in an override: " + fakeOverride + " while expecting " + exactDescriptorClass.simpleName } @Suppress("UNCHECKED_CAST") diff --git a/compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt b/compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt new file mode 100644 index 00000000000..88ad9036ccc --- /dev/null +++ b/compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt @@ -0,0 +1,53 @@ +// FILE: A.java + +public class A { + + @Deprecated + public static final String D = "d"; + + @Deprecated + public void f() { + return text; + } + + @Deprecated + public static void bar() { + } +} + +// FILE: B.java + +public class B extends A { + + public static final String D = "d"; + + @Override + public void f() { + return text; + } + + public static void bar() { + } +} + + +// FILE: C.java + +public class C extends A { +} + +// FILE: use.kt + +fun use(a: A, b: B, c: C) { + a.f() + b.f() + c.f() + + A.D + B.D + C.D + + A.bar() + B.bar() + C.bar() +} diff --git a/compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.txt b/compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.txt new file mode 100644 index 00000000000..44977b88ee3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.txt @@ -0,0 +1,39 @@ +package + +public fun use(/*0*/ a: A, /*1*/ b: B, /*2*/ c: C): kotlin.Unit + +public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open fun f(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + @kotlin.Deprecated(message = "Deprecated in Java") public const final val D: kotlin.String = "d" + @kotlin.Deprecated(message = "Deprecated in Java") public open fun bar(): kotlin.Unit +} + +public open class B : A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override() public open override /*1*/ fun f(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public const final val D: kotlin.String = "d" + public open fun bar(): kotlin.Unit +} + +public open class C : A { + public constructor C() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun f(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + @kotlin.Deprecated(message = "Deprecated in Java") public const final override /*1*/ /*fake_override*/ val D: kotlin.String + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun bar(): kotlin.Unit +} diff --git a/compiler/testData/diagnostics/tests/j+k/StaticMembersFromSuperclasses.txt b/compiler/testData/diagnostics/tests/j+k/StaticMembersFromSuperclasses.txt index 98a1816a6ac..8e3658fdfdf 100644 --- a/compiler/testData/diagnostics/tests/j+k/StaticMembersFromSuperclasses.txt +++ b/compiler/testData/diagnostics/tests/j+k/StaticMembersFromSuperclasses.txt @@ -19,5 +19,5 @@ public open class Bbb : Aaa { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public const final override /*1*/ val i: kotlin.String = "s" + public const final val i: kotlin.String = "s" } diff --git a/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt b/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt new file mode 100644 index 00000000000..e5d912fd599 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt @@ -0,0 +1,24 @@ +// FILE: B.kt + +import aa.B + +fun use() { + // checking that CONST is of platform type + B.CONST = null + B.CONST?.length + B.CONST.length +} + +// FILE: aa/A.java +package aa; + +public class A { + public static int CONST = 3; +} + +// FILE: aa/B.java +package aa; + +public class B extends A { + public static String CONST = null; +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt b/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt new file mode 100644 index 00000000000..e6c54b067c5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt @@ -0,0 +1,3 @@ +package + +public fun use(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.txt index 21d239ec1a6..3ffe5041ae4 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.txt @@ -23,8 +23,8 @@ public/*package*/ open class B : A { // Static members public final var a: kotlin.Int - public final override /*1*/ var b: kotlin.Int - public open override /*1*/ fun bar(): kotlin.Unit + public final var b: kotlin.Int + public open fun bar(): kotlin.Unit public open fun bar(/*0*/ i: kotlin.Int): kotlin.Unit public open fun foo(): kotlin.Unit public open fun foo(/*0*/ i: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.txt index 72e351f10fe..c0ce3daf90a 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.txt @@ -38,5 +38,5 @@ public open class O : A, B { public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public final override /*2*/ var field: kotlin.Double + public final var field: kotlin.Double } diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.txt index ac11490056b..2ad2714ee8b 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.txt @@ -17,7 +17,7 @@ public interface B : A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public const final override /*1*/ val field: kotlin.String + public const final val field: kotlin.String } public open class E : A, B { @@ -38,5 +38,5 @@ public open class O : A, B { public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public final override /*2*/ var field: kotlin.Double + public final var field: kotlin.Double } diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.txt index 4c1fbf3bfa2..2f165a7545e 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.txt @@ -67,7 +67,7 @@ public open class EO : E { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public final override /*2*/ var field: kotlin.Double + public final var field: kotlin.Double } public open class O : C, D { @@ -77,7 +77,7 @@ public open class O : C, D { public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public final override /*2*/ var field: kotlin.Double + public final var field: kotlin.Double } public open class OO : O { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.txt index 5ead921c7d5..588fa9e4f66 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.txt @@ -35,7 +35,7 @@ public open class E : D, I { public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public/*package*/ final override /*2*/ var a: kotlin.Int + public/*package*/ final var a: kotlin.Int public/*package*/ final override /*1*/ /*fake_override*/ var b: kotlin.Int public/*package*/ final override /*1*/ /*fake_override*/ var c: kotlin.Int public/*package*/ open override /*1*/ /*fake_override*/ fun bar(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.txt index a4acbd15388..df621310cf4 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.txt @@ -18,8 +18,8 @@ public open class B : A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public/*package*/ open override /*1*/ fun bar(): kotlin.Long - public/*package*/ open override /*1*/ fun foo(): kotlin.Unit + public/*package*/ open fun bar(): kotlin.Long + public/*package*/ open fun foo(): kotlin.Unit } public final class E : B { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.txt index 11c8e2510aa..dc08fd6a001 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.txt @@ -39,7 +39,7 @@ public open class X : B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public/*package*/ open override /*1*/ fun foo(): kotlin.Double + public/*package*/ open fun foo(): kotlin.Double } public final class Y : X { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.txt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.txt index 854dc61dc78..42574f87c08 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.txt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.txt @@ -19,7 +19,7 @@ public open class B : A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String // Static members - public open override /*1*/ fun foo(): kotlin.Int + public open fun foo(): kotlin.Int } public final class C : B { diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.txt b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.txt index c499397f9e6..611c9ba0c0c 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.txt +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.txt @@ -5,11 +5,11 @@ public/*package*/ open class Child : test.Parent { // Static members public final override /*1*/ /*fake_override*/ var a: kotlin.Int - public final override /*1*/ var b: kotlin.String + public final var b: kotlin.String! public final var c: kotlin.Int public open fun bar(): kotlin.Unit public open fun bar(/*0*/ p0: kotlin.Int): kotlin.Unit - public open override /*1*/ fun baz(): kotlin.Unit + public open fun baz(): kotlin.Unit public open fun baz(/*0*/ p0: kotlin.Int): kotlin.Unit public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit public open fun foo(/*0*/ p0: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java new file mode 100644 index 00000000000..3196e6a0aeb --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java @@ -0,0 +1,11 @@ +package test; + +class Parent { + private static int private_ = 1; + static int packagePrivate_ = 2; + protected static int protected_ = 3; + public static int public_ = 4; +} + +class Child extends Parent { +} diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.txt b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.txt new file mode 100644 index 00000000000..17572bd080a --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.txt @@ -0,0 +1,21 @@ +package test + +public/*package*/ open class Child : test.Parent { + public/*package*/ constructor Child() + + // Static members + public/*package*/ final override /*1*/ /*fake_override*/ var packagePrivate_: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var private_: kotlin.Int + protected/*protected static*/ final override /*1*/ /*fake_override*/ var protected_: kotlin.Int + public final override /*1*/ /*fake_override*/ var public_: kotlin.Int +} + +public/*package*/ open class Parent { + public/*package*/ constructor Parent() + + // Static members + public/*package*/ final var packagePrivate_: kotlin.Int + private final var private_: kotlin.Int + protected/*protected static*/ final var protected_: kotlin.Int + public final var public_: kotlin.Int +} diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.txt b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.txt index 24d330c5a25..f64578f8efb 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.txt +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.txt @@ -5,9 +5,9 @@ public/*package*/ open class Child : test.Parent1, test.Parent2 { // Static members public const final override /*1*/ /*fake_override*/ val a: kotlin.Int - public final override /*1*/ var b: kotlin.String + public final var b: kotlin.String! public final var c: kotlin.Int - public final override /*1*/ var d: kotlin.String + public final var d: kotlin.String! public const final override /*1*/ /*fake_override*/ val e: kotlin.Int public open fun bar(): kotlin.Unit public open fun baz(): kotlin.Unit diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.txt b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.txt index c9ffde3a679..bdf5a2acda0 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.txt +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.txt @@ -25,9 +25,9 @@ public/*package*/ final enum class StaticMembersInEnum : kotlin.Enum public open fun foo(): kotlin.Unit diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index d238121c87e..15c8eae59c1 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -5124,6 +5124,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { doTest(fileName); } + @TestMetadata("javaDeprecatedInheritance.kt") + public void testJavaDeprecatedInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt"); + doTest(fileName); + } + @TestMetadata("javaDocDeprecated.kt") public void testJavaDocDeprecated() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/javaDocDeprecated.kt"); @@ -10179,6 +10185,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { doTest(fileName); } + @TestMetadata("shadowingPrimitiveStaticField.kt") + public void testShadowingPrimitiveStaticField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt"); + doTest(fileName); + } + @TestMetadata("Simple.kt") public void testSimple() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/Simple.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java index a7324fcb813..57f16f46e6f 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java @@ -1704,6 +1704,12 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { doTestCompiledJava(fileName); } + @TestMetadata("StaticMembersFromParentClassVisibility.java") + public void testStaticMembersFromParentClassVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java"); + doTestCompiledJava(fileName); + } + @TestMetadata("StaticMembersFromParentInterface.java") public void testStaticMembersFromParentInterface() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java"); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java index ae3d3e1bb0f..15d1a9444c3 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java @@ -4101,6 +4101,12 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD doTest(fileName); } + @TestMetadata("StaticMembersFromParentClassVisibility.java") + public void testStaticMembersFromParentClassVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java"); + doTest(fileName); + } + @TestMetadata("StaticMembersFromParentInterface.java") public void testStaticMembersFromParentInterface() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java"); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java index 3abdbca6c93..34116d7d0b6 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/DescriptorResolverUtils.java @@ -38,12 +38,29 @@ public final class DescriptorResolverUtils { } @NotNull - public static Collection resolveOverrides( + public static Collection resolveOverridesForNonStaticMembers( + @NotNull Name name, @NotNull Collection membersFromSupertypes, @NotNull Collection membersFromCurrent, + @NotNull ClassDescriptor classDescriptor, @NotNull ErrorReporter errorReporter +) { + return resolveOverrides(name, membersFromSupertypes, membersFromCurrent, classDescriptor, errorReporter, false); + } + + @NotNull + public static Collection resolveOverridesForStaticMembers( + @NotNull Name name, @NotNull Collection membersFromSupertypes, @NotNull Collection membersFromCurrent, + @NotNull ClassDescriptor classDescriptor, @NotNull ErrorReporter errorReporter +) { + return resolveOverrides(name, membersFromSupertypes, membersFromCurrent, classDescriptor, errorReporter, true); + } + + @NotNull + private static Collection resolveOverrides( @NotNull Name name, @NotNull Collection membersFromSupertypes, @NotNull Collection membersFromCurrent, @NotNull ClassDescriptor classDescriptor, - @NotNull final ErrorReporter errorReporter + @NotNull final ErrorReporter errorReporter, + final boolean isStaticContext ) { final Set result = new LinkedHashSet(); @@ -67,6 +84,17 @@ public final class DescriptorResolverUtils { public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) { // nop } + + @Override + public void setOverriddenDescriptors( + @NotNull CallableMemberDescriptor member, @NotNull Collection overridden + ) { + // do not set overridden descriptors for declared static fields and methods from java + if (isStaticContext && member.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) { + return; + } + super.setOverriddenDescriptors(member, overridden); + } } ); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt index 799e7c37859..1a966aa01c5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -29,7 +29,7 @@ import org.jetbrains.kotlin.load.java.BuiltinMethodsWithDifferentJvmName.isRemov import org.jetbrains.kotlin.load.java.BuiltinMethodsWithDifferentJvmName.sameAsRenamedInJvmBuiltin import org.jetbrains.kotlin.load.java.BuiltinMethodsWithSpecialGenericSignature.sameAsBuiltinMethodWithErasedValueParameters import org.jetbrains.kotlin.load.java.BuiltinSpecialProperties.getBuiltinSpecialPropertyGetterName -import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils +import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils.resolveOverridesForNonStaticMembers import org.jetbrains.kotlin.load.java.components.TypeUsage import org.jetbrains.kotlin.load.java.descriptors.JavaConstructorDescriptor import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor @@ -225,7 +225,7 @@ class LazyJavaClassMemberScope( var specialBuiltinsFromSuperTypes = SmartSet.create() // Merge functions with same signatures - val mergedFunctionFromSuperTypes = DescriptorResolverUtils.resolveOverrides( + val mergedFunctionFromSuperTypes = resolveOverridesForNonStaticMembers( name, functionsFromSupertypes, emptyList(), ownerDescriptor, ErrorReporter.DO_NOTHING) // add declarations @@ -251,8 +251,9 @@ class LazyJavaClassMemberScope( isSpecialBuiltinName: Boolean ) { - val additionalOverrides = - DescriptorResolverUtils.resolveOverrides(name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter) + val additionalOverrides = resolveOverridesForNonStaticMembers( + name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter + ) if (!isSpecialBuiltinName) { result.addAll(additionalOverrides) @@ -356,7 +357,7 @@ class LazyJavaClassMemberScope( searchMethodsInSupertypesWithoutBuiltinMagic(it) } - result.addAll(DescriptorResolverUtils.resolveOverrides( + result.addAll(resolveOverridesForNonStaticMembers( name, propertiesFromSupertypes + propertiesOverridesFromSuperTypes, result, ownerDescriptor, c.components.errorReporter)) } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt index ad6944efc22..51d09c68cd0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaStaticClassScope.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor import org.jetbrains.kotlin.incremental.components.LookupLocation import org.jetbrains.kotlin.incremental.components.NoLookupLocation -import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils +import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils.resolveOverridesForStaticMembers import org.jetbrains.kotlin.load.java.descriptors.getParentJavaStaticClassScope import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext import org.jetbrains.kotlin.load.java.structure.JavaClass @@ -76,7 +76,7 @@ class LazyJavaStaticClassScope( }?.let { result.add(it) } val functionsFromSupertypes = getStaticFunctionsFromJavaSuperClasses(name, ownerDescriptor) - result.addAll(DescriptorResolverUtils.resolveOverrides(name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter)) + result.addAll(resolveOverridesForStaticMembers(name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter)) if (jClass.isEnum) { when (name) { @@ -91,13 +91,13 @@ class LazyJavaStaticClassScope( val actualProperties = if (!result.isEmpty()) { - DescriptorResolverUtils.resolveOverrides(name, propertiesFromSupertypes, result, ownerDescriptor, c.components.errorReporter) + resolveOverridesForStaticMembers(name, propertiesFromSupertypes, result, ownerDescriptor, c.components.errorReporter) } else { propertiesFromSupertypes.groupBy { it.realOriginal }.flatMap { - DescriptorResolverUtils.resolveOverrides(name, it.value, result, ownerDescriptor, c.components.errorReporter) + resolveOverridesForStaticMembers(name, it.value, result, ownerDescriptor, c.components.errorReporter) } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt index ac9a2bd6b13..c5105bd2c0e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassScope.kt @@ -67,7 +67,7 @@ class FunctionClassScope( /* membersFromSupertypes = */ descriptors, /* membersFromCurrent = */ if (isFunction && name == invoke?.name) listOf(invoke) else listOf(), functionClass, - object : OverridingStrategy { + object : OverridingStrategy() { override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) { OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null) result.add(fakeOverride) diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingStrategy.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingStrategy.kt index 29a966e1c6c..fca7b1955b1 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingStrategy.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingStrategy.kt @@ -18,8 +18,12 @@ package org.jetbrains.kotlin.resolve import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor -interface OverridingStrategy { - fun addFakeOverride(fakeOverride: CallableMemberDescriptor) +abstract class OverridingStrategy { + abstract fun addFakeOverride(fakeOverride: CallableMemberDescriptor) - fun conflict(fromSuper: CallableMemberDescriptor, fromCurrent: CallableMemberDescriptor) + abstract fun conflict(fromSuper: CallableMemberDescriptor, fromCurrent: CallableMemberDescriptor) + + open fun setOverriddenDescriptors(member: CallableMemberDescriptor, overridden: Collection) { + member.overriddenDescriptors = overridden + } } \ No newline at end of file diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java index 7462bd55001..1e39e7149f4 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java @@ -317,7 +317,7 @@ public class OverridingUtil { } } - fromCurrent.setOverriddenDescriptors(overridden); + strategy.setOverriddenDescriptors(fromCurrent, overridden); return bound; } @@ -501,7 +501,9 @@ public class OverridingUtil { }); CallableMemberDescriptor fakeOverride = mostSpecific.copy(current, modality, visibility, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false); - fakeOverride.setOverriddenDescriptors(effectiveOverridden); + strategy.setOverriddenDescriptors(fakeOverride, effectiveOverridden); + assert !fakeOverride.getOverriddenDescriptors().isEmpty() + : "Overridden descriptors should be set for " + CallableMemberDescriptor.Kind.FAKE_OVERRIDE; strategy.addFakeOverride(fakeOverride); } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index 3f5c8103f79..4bd87af1d6e 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt @@ -220,7 +220,7 @@ class DeserializedClassDescriptor( private fun generateFakeOverrides(name: Name, fromSupertypes: Collection, result: MutableCollection) { val fromCurrent = ArrayList(result) - OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, fromCurrent, classDescriptor, object : OverridingStrategy { + OverridingUtil.generateOverridesInFunctionGroup(name, fromSupertypes, fromCurrent, classDescriptor, object : OverridingStrategy() { override fun addFakeOverride(fakeOverride: CallableMemberDescriptor) { // TODO: report "cannot infer visibility" OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, null)