From 79d38a6c8fc66f910a693201fefe25029841ebbc Mon Sep 17 00:00:00 2001 From: Zalim Bashorov Date: Fri, 9 Oct 2015 21:40:33 +0300 Subject: [PATCH] Report the error when a declaration in Kotlin accidentally overrides a static member from Java --- ...FactoryForDuplicateSignatureDiagnostics.kt | 22 +++++--- .../JetDiagnosticsWithJava8TestGenerated.java | 30 +++++++++++ .../duplicateJvmSignature/statics/jjk.kt | 29 +++++++++++ .../duplicateJvmSignature/statics/jjk.txt | 45 ++++++++++++++++ .../tests/duplicateJvmSignature/statics/jk.kt | 22 ++++++++ .../duplicateJvmSignature/statics/jk.txt | 32 ++++++++++++ .../duplicateJvmSignature/statics/jkjk.kt | 34 ++++++++++++ .../duplicateJvmSignature/statics/jkjk.txt | 52 +++++++++++++++++++ .../kotlinMembersVsJavaNonVisibleStatics.kt | 24 +++++++++ .../kotlinMembersVsJavaNonVisibleStatics.txt | 20 +++++++ .../duplicateJvmSignature/statics/jjk.kt | 29 +++++++++++ .../duplicateJvmSignature/statics/jjk.txt | 41 +++++++++++++++ .../duplicateJvmSignature/statics/jk.kt | 22 ++++++++ .../duplicateJvmSignature/statics/jk.txt | 31 +++++++++++ .../duplicateJvmSignature/statics/jjk.kt | 31 +++++++++++ .../duplicateJvmSignature/statics/jjk.txt | 43 +++++++++++++++ .../duplicateJvmSignature/statics/jk.kt | 21 ++++++++ .../duplicateJvmSignature/statics/jk.txt | 29 +++++++++++ .../duplicateJvmSignature/statics/jkjk.kt | 36 +++++++++++++ .../duplicateJvmSignature/statics/jkjk.txt | 50 ++++++++++++++++++ .../kotlinMembersVsJavaNonVisibleStatics.kt | 22 ++++++++ .../kotlinMembersVsJavaNonVisibleStatics.txt | 17 ++++++ .../checkers/JetDiagnosticsTestGenerated.java | 33 ++++++++++++ ...JetDiagnosticsTestWithStdLibGenerated.java | 33 ++++++++++++ .../kotlin/load/java/descriptors/util.kt | 13 +++++ .../descriptors/LazyJavaStaticClassScope.kt | 9 +--- 26 files changed, 756 insertions(+), 14 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.txt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.txt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.txt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt create mode 100644 compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt create mode 100644 compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.kt create mode 100644 compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.txt create mode 100644 compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.kt create mode 100644 compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.txt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.txt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.txt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.txt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt create mode 100644 compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt index 7ad9f825d1e..63cef67adaa 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt @@ -29,11 +29,14 @@ import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider import org.jetbrains.kotlin.fileClasses.isInsideJvmMultifileClassFile import org.jetbrains.kotlin.idea.MainFunctionDetector import org.jetbrains.kotlin.load.java.descriptors.SamAdapterDescriptor +import org.jetbrains.kotlin.load.java.descriptors.getParentJavaStaticClassScope import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.psi.JetNamedFunction import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.jvm.diagnostics.* +import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter +import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue import org.jetbrains.kotlin.utils.addIfNotNull import java.util.* @@ -105,14 +108,14 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( if (origins.size() <= 1) continue var memberElement: PsiElement? = null - var nonFakeCount = 0 + var ownNonFakeCount = 0 for (origin in origins) { val member = origin.descriptor as? CallableMemberDescriptor? - if (member != null && member.getKind() != FAKE_OVERRIDE) { - nonFakeCount++ + if (member != null && member.containingDeclaration == classOrigin.descriptor && member.getKind() != FAKE_OVERRIDE) { + ownNonFakeCount++ // If there's more than one real element, the clashing signature is already reported. // Only clashes between fake overrides are interesting here - if (nonFakeCount > 1) continue@signatures + if (ownNonFakeCount > 1) continue@signatures if (member.getKind() != DELEGATION) { // Delegates don't have declarations in the code @@ -158,8 +161,13 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( } } - for (member in descriptor.getDefaultType().getMemberScope().getDescriptors()) { - processMember(member) + descriptor.defaultType.memberScope.getDescriptors().forEach(::processMember) + descriptor.getParentJavaStaticClassScope()?.run { + getDescriptors(DescriptorKindFilter.FUNCTIONS) + .filter { + it is FunctionDescriptor && Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, it, descriptor) + } + .forEach(::processMember) } return groupedBySignature @@ -171,4 +179,4 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( return descriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE && descriptor.getOverriddenDescriptors().all { isOrOverridesSamAdapter(it) } } -} \ No newline at end of file +} diff --git a/compiler/java8-tests/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsWithJava8TestGenerated.java b/compiler/java8-tests/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsWithJava8TestGenerated.java index 5f70cfddbd5..ce42eb9f4d7 100644 --- a/compiler/java8-tests/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsWithJava8TestGenerated.java +++ b/compiler/java8-tests/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsWithJava8TestGenerated.java @@ -68,6 +68,36 @@ public class JetDiagnosticsWithJava8TestGenerated extends AbstractJetDiagnostics } } + @TestMetadata("compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DuplicateJvmSignature extends AbstractJetDiagnosticsWithFullJdkTest { + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Statics extends AbstractJetDiagnosticsWithFullJdkTest { + public void testAllFilesPresentInStatics() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("jjk.kt") + public void testJjk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.kt"); + doTest(fileName); + } + + @TestMetadata("jk.kt") + public void testJk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.kt"); + doTest(fileName); + } + } + } + @TestMetadata("compiler/testData/diagnostics/testsWithJava8/statics") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.kt new file mode 100644 index 00000000000..31bf50861c9 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.kt @@ -0,0 +1,29 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public class A { + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: B.java + +public class B extends A { + public static void bar(int i) {} +} + +// FILE: K.kt + +open class K : B() { + fun foo() {} + fun foo(a: Any) {} + fun bar(i: Int) {} + fun bar(i: String) {} + fun baz(i: Int) {} + + companion object { + fun foo() {} + fun bar(i: Int) {} + } +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.txt new file mode 100644 index 00000000000..0e8448ee59b --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.txt @@ -0,0 +1,45 @@ +package + +public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public open class B : A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit +} + +public open class K : B { + public constructor K() + public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public final fun bar(/*0*/ i: kotlin.String): kotlin.Unit + public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public final fun foo(/*0*/ a: kotlin.Any): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.kt new file mode 100644 index 00000000000..07a720ac0dd --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.kt @@ -0,0 +1,22 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public class A { + public static int a = 1 + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: K.kt + +open class K : A() { + val a = 1 + fun foo() {} + fun foo(i: Int) {} + fun baz(i: Int) {} + + companion object { + fun foo() {} + } +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.txt new file mode 100644 index 00000000000..090d4d93738 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.txt @@ -0,0 +1,32 @@ +package + +public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public final var a: kotlin.Int + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public open class K : A { + public constructor K() + public final val a: kotlin.Int = 1 + public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public final fun foo(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt new file mode 100644 index 00000000000..b7705e58fd1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt @@ -0,0 +1,34 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public class A { + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: B.kt + +open class B : A() { +} + +// FILE: C.java + +public class C extends B { + public static void bar(int i) {} +} + +// FILE: K.kt + +open class K : C() { + fun foo() {} + fun foo(a: Any) {} + fun bar(i: Int) {} + fun bar(i: String) {} + fun baz(i: Int) {} + + companion object { + fun foo() {} + fun bar(i: Int) {} + } +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.txt new file mode 100644 index 00000000000..be03ae7242f --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.txt @@ -0,0 +1,52 @@ +package + +public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public open class B : A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class C : B { + public constructor C() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit +} + +public open class K : C { + public constructor K() + public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public final fun bar(/*0*/ i: kotlin.String): kotlin.Unit + public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public final fun foo(/*0*/ a: kotlin.Any): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt new file mode 100644 index 00000000000..5cde834931a --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt @@ -0,0 +1,24 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: foo/A.java + +package foo; + +public class A { + private static void foo(int s) {} + static void bar(double s) {} +} + +// FILE: K.kt +import foo.A + +open class K : A() { + fun foo(i: Int) {} + fun bar(d: Double) {} + fun baz(i: Int) {} + + companion object { + fun foo(i: Int) {} + fun bar(d: Double) {} + } +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt new file mode 100644 index 00000000000..a1adb7e0513 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt @@ -0,0 +1,20 @@ +package + +public open class K : foo.A { + public constructor K() + public final fun bar(/*0*/ d: kotlin.Double): kotlin.Unit + public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public final fun bar(/*0*/ d: kotlin.Double): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.kt b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.kt new file mode 100644 index 00000000000..21ab1027a35 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.kt @@ -0,0 +1,29 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public interface A { + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: B.java + +public interface B extends A { + public static void bar(int i) {} +} + +// FILE: K.kt + +open class K : B { + fun foo() {} + fun foo(a: Any) {} + fun bar(i: Int) {} + fun bar(i: String) {} + fun baz(i: Int) {} + + companion object { + fun foo() {} + fun bar(i: Int) {} + } +} diff --git a/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.txt b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.txt new file mode 100644 index 00000000000..5750f92af0d --- /dev/null +++ b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jjk.txt @@ -0,0 +1,41 @@ +package + +public interface A { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public interface B : A { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun bar(/*0*/ i: kotlin.Int): kotlin.Unit +} + +public open class K : B { + public constructor K() + public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public final fun bar(/*0*/ i: kotlin.String): kotlin.Unit + public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public final fun foo(/*0*/ a: kotlin.Any): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.kt b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.kt new file mode 100644 index 00000000000..4227b174430 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.kt @@ -0,0 +1,22 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public interface A { + public String a = "" + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: K.kt + +open class K : A { + val a = "" + fun foo() {} + fun foo(i: Int) {} + fun baz(i: Int) {} + + companion object { + fun foo() {} + } +} diff --git a/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.txt b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.txt new file mode 100644 index 00000000000..fa7470d9a57 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithJava8/duplicateJvmSignature/statics/jk.txt @@ -0,0 +1,31 @@ +package + +public interface A { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + 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 a: kotlin.String = "" + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public open class K : A { + public constructor K() + public final val a: kotlin.String = "" + public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public final fun foo(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt new file mode 100644 index 00000000000..26bbe9513e8 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt @@ -0,0 +1,31 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public class A { + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: B.java + +public class B extends A { + public static void bar(int i) {} +} + +// FILE: K.kt + +open class K : B() { + companion object { + @JvmStatic + fun foo() {} + @JvmStatic + fun foo(a: Any) {} + @JvmStatic + fun bar(i: Int) {} + @JvmStatic + fun bar(i: String) {} + @JvmStatic + fun baz(i: Int) {} + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.txt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.txt new file mode 100644 index 00000000000..13f23b91852 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.txt @@ -0,0 +1,43 @@ +package + +public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public open class B : A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit +} + +public open class K : B { + public constructor K() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + @kotlin.jvm.JvmStatic() public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + @kotlin.jvm.JvmStatic() public final fun bar(/*0*/ i: kotlin.String): kotlin.Unit + @kotlin.jvm.JvmStatic() public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @kotlin.jvm.JvmStatic() public final fun foo(): kotlin.Unit + @kotlin.jvm.JvmStatic() public final fun foo(/*0*/ a: kotlin.Any): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt new file mode 100644 index 00000000000..338db91ec7c --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt @@ -0,0 +1,21 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public class A { + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: K.kt + +open class K : A() { + companion object { + @JvmStatic + fun foo() {} + @JvmStatic + fun foo(i: Int) {} + @JvmStatic + fun baz(i: Int) {} + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.txt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.txt new file mode 100644 index 00000000000..cbd35c99c70 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.txt @@ -0,0 +1,29 @@ +package + +public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public open class K : A { + public constructor K() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + @kotlin.jvm.JvmStatic() public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @kotlin.jvm.JvmStatic() public final fun foo(): kotlin.Unit + @kotlin.jvm.JvmStatic() public final fun foo(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt new file mode 100644 index 00000000000..4ef4b531373 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt @@ -0,0 +1,36 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: A.java + +public class A { + public static void foo() {} + public static void baz(String s) {} +} + +// FILE: B.kt + +open class B : A() { +} + +// FILE: C.java + +public class C extends B { + public static void bar(int i) {} +} + +// FILE: K.kt + +open class K : C() { + companion object { + @JvmStatic + fun foo() {} + @JvmStatic + fun foo(a: Any) {} + @JvmStatic + fun bar(i: Int) {} + @JvmStatic + fun bar(i: String) {} + @JvmStatic + fun baz(i: Int) {} + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.txt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.txt new file mode 100644 index 00000000000..0c3da37051b --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.txt @@ -0,0 +1,50 @@ +package + +public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open fun foo(): kotlin.Unit +} + +public open class B : A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class C : B { + public constructor C() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun baz(/*0*/ s: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit +} + +public open class K : C { + public constructor K() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + @kotlin.jvm.JvmStatic() public final fun bar(/*0*/ i: kotlin.Int): kotlin.Unit + @kotlin.jvm.JvmStatic() public final fun bar(/*0*/ i: kotlin.String): kotlin.Unit + @kotlin.jvm.JvmStatic() public final fun baz(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @kotlin.jvm.JvmStatic() public final fun foo(): kotlin.Unit + @kotlin.jvm.JvmStatic() public final fun foo(/*0*/ a: kotlin.Any): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt new file mode 100644 index 00000000000..8b4d5883db4 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt @@ -0,0 +1,22 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +// FILE: foo/A.java + +package foo; + +public class A { + private static void foo(int s) {} + static void bar(double s) {} +} + +// FILE: K.kt +import foo.A + +open class K : A() { + companion object { + @JvmStatic + fun foo(i: Int) {} + @JvmStatic + fun bar(d: Double) {} + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt new file mode 100644 index 00000000000..60da4b5f349 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt @@ -0,0 +1,17 @@ +package + +public open class K : foo.A { + public constructor K() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + @kotlin.jvm.JvmStatic() public final fun bar(/*0*/ d: kotlin.Double): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @kotlin.jvm.JvmStatic() public final fun foo(/*0*/ i: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java index 70d1dac1368..d2160a6f0a5 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java @@ -5223,6 +5223,39 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { } } + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Statics extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInStatics() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("jjk.kt") + public void testJjk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.kt"); + doTest(fileName); + } + + @TestMetadata("jk.kt") + public void testJk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.kt"); + doTest(fileName); + } + + @TestMetadata("jkjk.kt") + public void testJkjk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") + public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); + doTest(fileName); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java index b1e3946059c..1c8c5dd0136 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestWithStdLibGenerated.java @@ -606,6 +606,39 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformStaticInObject.kt"); doTest(fileName); } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Statics extends AbstractJetDiagnosticsTestWithStdLib { + public void testAllFilesPresentInStatics() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("jjk.kt") + public void testJjk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt"); + doTest(fileName); + } + + @TestMetadata("jk.kt") + public void testJk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt"); + doTest(fileName); + } + + @TestMetadata("jkjk.kt") + public void testJkjk() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") + public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); + doTest(fileName); + } + } } @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/functionLiterals") diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt index 4a4b95c78a5..079af275654 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt @@ -17,8 +17,11 @@ package org.jetbrains.kotlin.load.java.descriptors import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl +import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaStaticClassScope +import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.types.JetType @@ -47,3 +50,13 @@ fun copyValueParameters( ) } } + +fun ClassDescriptor.getParentJavaStaticClassScope(): LazyJavaStaticClassScope? { + val superClassDescriptor = getSuperClassNotAny() ?: return null + + val staticScope = superClassDescriptor.staticScope + + if (staticScope !is LazyJavaStaticClassScope) return superClassDescriptor.getParentJavaStaticClassScope() + + return staticScope +} 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 dc8e465f9bc..012dab52b6c 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 @@ -23,6 +23,7 @@ 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.descriptors.getParentJavaStaticClassScope import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext import org.jetbrains.kotlin.load.java.structure.JavaClass import org.jetbrains.kotlin.name.FqName @@ -30,7 +31,6 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorFactory.createEnumValueOfMethod import org.jetbrains.kotlin.resolve.DescriptorFactory.createEnumValuesMethod import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.types.JetType import org.jetbrains.kotlin.utils.addIfNotNull @@ -104,12 +104,7 @@ public class LazyJavaStaticClassScope( override fun getContainingDeclaration() = super.getContainingDeclaration() as LazyJavaClassDescriptor private fun getStaticFunctionsFromJavaSuperClasses(name: Name, descriptor: ClassDescriptor): Set { - val superClassDescriptor = descriptor.getSuperClassNotAny() ?: return emptySet() - - val staticScope = superClassDescriptor.staticScope - - if (staticScope !is LazyJavaStaticClassScope) return getStaticFunctionsFromJavaSuperClasses(name, superClassDescriptor) - + val staticScope = descriptor.getParentJavaStaticClassScope() ?: return emptySet() return staticScope.getFunctions(name, NoLookupLocation.WHEN_GET_SUPER_MEMBERS).map { it as SimpleFunctionDescriptor }.toSet() }