diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java index d5ac2ba994f..3e26e49537e 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForPackage.java @@ -51,6 +51,7 @@ public class KotlinLightClassForPackage extends KotlinWrappingLightClass impleme public static class FileStubCache { + @NotNull public static FileStubCache getInstance(@NotNull Project project) { return ServiceManager.getService(project, FileStubCache.class); } diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/duplicateJvmSignatureUtil.kt b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/duplicateJvmSignatureUtil.kt new file mode 100644 index 00000000000..e4ae2d6c692 --- /dev/null +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/duplicateJvmSignatureUtil.kt @@ -0,0 +1,57 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.asJava + +import com.intellij.psi.PsiElement +import org.jetbrains.jet.lang.resolve.Diagnostics +import org.jetbrains.jet.lang.psi.JetFile +import org.jetbrains.jet.lang.psi.JetClassBody +import org.jetbrains.jet.lang.psi.JetClassOrObject +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.jet.lang.psi.JetPropertyAccessor + +public fun getJvmSignatureDiagnostics(element: PsiElement): Diagnostics? { + var parent = element.getParent() + if (parent is JetFile) { + if (element is JetClassOrObject) { + return getDiagnosticsForNonLocalClass(element) + } + return getDiagnosticsForPackage(parent as JetFile) + } + else + if (element is JetPropertyAccessor) { + parent = parent?.getParent() + } + if (parent is JetClassBody) { + val parentsParent = parent?.getParent() + + if (parentsParent is JetClassOrObject) { + return getDiagnosticsForNonLocalClass(parentsParent) + } + } + return null +} + +private fun getDiagnosticsForPackage(file: JetFile): Diagnostics? { + val project = file.getProject() + val cache = KotlinLightClassForPackage.FileStubCache.getInstance(project) + return cache[file.getPackageFqName(), GlobalSearchScope.allScope(project)].getValue()?.extraDiagnostics +} + +private fun getDiagnosticsForNonLocalClass(jetClassOrObject: JetClassOrObject): Diagnostics { + return KotlinLightClassForExplicitDeclaration.getLightClassData(jetClassOrObject).extraDiagnostics +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt new file mode 100644 index 00000000000..6d9868c155a --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt @@ -0,0 +1,8 @@ +open class B { + fun getX() = 1 +} + +class C : B() { + val x: Int + get() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt new file mode 100644 index 00000000000..d703c3dd6da --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt @@ -0,0 +1,8 @@ +open class B { + val x: Int + get() = 1 +} + +class C : B() { + fun getX() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt new file mode 100644 index 00000000000..216a14f7e42 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt @@ -0,0 +1,8 @@ +trait T { + fun getX() = 1 +} + +class C : T { + val x: Int + get() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt new file mode 100644 index 00000000000..bd0d385cc61 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt @@ -0,0 +1,8 @@ +trait T { + val x: Int + get() = 1 +} + +class C : T { + fun getX() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt new file mode 100644 index 00000000000..bd31b6b5015 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt @@ -0,0 +1,4 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +fun foo(s: List) {} +fun foo(s: MutableList) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt new file mode 100644 index 00000000000..541320fe77b --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt @@ -0,0 +1,12 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +trait Foo { + fun foo(l: List) +} + +trait Bar { + fun foo(l: List) +} + +class Baz(f: Foo, b: Bar): Foo by f, Bar by b { +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt new file mode 100644 index 00000000000..988507ab862 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt @@ -0,0 +1,9 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +trait Foo { + fun foo(l: List) +} + +class Bar(f: Foo): Foo by f { + fun foo(l: List) {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt new file mode 100644 index 00000000000..22817b1aab6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt @@ -0,0 +1,6 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class G + +fun foo(x: G): G {null!!} +fun foo(x: G): G {null!!} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt new file mode 100644 index 00000000000..3fbb73bd8e4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt @@ -0,0 +1,12 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +trait Foo { + fun foo(l: List) {} +} + +trait Bar { + fun foo(l: List) {} +} + +class Baz(): Foo, Bar { +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt new file mode 100644 index 00000000000..f5277803b72 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt @@ -0,0 +1,4 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER -PLATFORM_CLASS_MAPPED_TO_KOTLIN + +fun foo(s: List) {} +fun foo(s: java.util.List) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt new file mode 100644 index 00000000000..f9bc8faedde --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt @@ -0,0 +1,4 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +fun foo(x: String) {} +fun foo(x: String?) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt new file mode 100644 index 00000000000..aa82166bf3e --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt @@ -0,0 +1,4 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER -PLATFORM_CLASS_MAPPED_TO_KOTLIN + +fun foo(s: java.lang.String) {} +fun foo(s: String) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt new file mode 100644 index 00000000000..f6229a343c2 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt @@ -0,0 +1,4 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +fun foo(x: T): T {null!!} +fun foo(x: Any): Any {null!!} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt new file mode 100644 index 00000000000..42f2695bc4d --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt @@ -0,0 +1,6 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +trait Foo + +fun foo(x: T): T {null!!} +fun foo(x: Foo): Foo {null!!} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt new file mode 100644 index 00000000000..72ad8bb6135 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt @@ -0,0 +1,8 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +trait Foo +trait Bar + +fun foo(x: T): T where T: Bar {null!!} +fun foo(x: Foo): Foo {null!!} +fun foo(x: Bar): Bar {null!!} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt new file mode 100644 index 00000000000..9321e6904e7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt @@ -0,0 +1,8 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +trait Foo +trait Bar + +fun foo(x: T): T where T: Foo, T: Bar {null!!} +fun foo(x: Foo): Foo {null!!} +fun foo(x: Bar): Bar {null!!} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt new file mode 100644 index 00000000000..c45452ddb8d --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt @@ -0,0 +1,4 @@ +class C { + val x = 1 + fun getX() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt new file mode 100644 index 00000000000..7a0befc98eb --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt @@ -0,0 +1,6 @@ +class C { + class object { + val x = 1 + fun getX() = 1 + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt new file mode 100644 index 00000000000..feaeeff8326 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt @@ -0,0 +1,6 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class C { + fun foo(x: Any) {} + fun Any.foo() {} +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt new file mode 100644 index 00000000000..d4772ea327a --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt @@ -0,0 +1,7 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class C { + fun getX(t: Any) = 1 + val Any.x: Int + get() = 1 +} diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt new file mode 100644 index 00000000000..a955d35df32 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt @@ -0,0 +1,7 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class C { + fun setX(x: Int) {} + + var x: Int = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt new file mode 100644 index 00000000000..a4a4cc49504 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt @@ -0,0 +1,8 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class C { + fun setX(x: Int) {} + + var x: Int = 1 + set(v) {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt new file mode 100644 index 00000000000..578c09ca8e7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt @@ -0,0 +1,6 @@ +fun foo() { + class C { + val x = 1 + fun getX() = 1 + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt new file mode 100644 index 00000000000..74205a15adf --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt @@ -0,0 +1,6 @@ +class B { + class C { + val x = 1 + fun getX() = 1 + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt new file mode 100644 index 00000000000..bc020563bab --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt @@ -0,0 +1,4 @@ +object C { + val x = 1 + fun getX() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt new file mode 100644 index 00000000000..c804c636cb1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt @@ -0,0 +1,5 @@ +fun foo() = + object { + val x = 1 + fun getX() = 1 + } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt new file mode 100644 index 00000000000..a66562d0df6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt @@ -0,0 +1,2 @@ +val x = 1 +fun getX() = 1 \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt new file mode 100644 index 00000000000..bd8b5362d63 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt @@ -0,0 +1,5 @@ +// FILE: a.kt +val x = 1 + +// FILE: b.kt +fun getX() = 1 \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt new file mode 100644 index 00000000000..d2b66799096 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt @@ -0,0 +1,3 @@ +val x: Int + get() = 1 +fun getX() = 1 \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt new file mode 100644 index 00000000000..1d310e1cf6b --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt @@ -0,0 +1,5 @@ +trait T { + val x: Int + get() = 1 + fun getX() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/componentInheritedFromTrait.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/componentInheritedFromTrait.kt new file mode 100644 index 00000000000..026efff3735 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/componentInheritedFromTrait.kt @@ -0,0 +1,5 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +data class C(val c: Int) { + fun `copy$default`(c: C, x: Int, m: Int) = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/defaults.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/defaults.kt new file mode 100644 index 00000000000..fde10128ebf --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/defaults.kt @@ -0,0 +1,6 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class C { + fun `a$default`(c: C, x: Int, m: Int) {} + fun a(x: Int = 1) {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt new file mode 100644 index 00000000000..6fe57a76192 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt @@ -0,0 +1,5 @@ +trait Foo + +class Bar(f: Foo) : Foo by f { + val `$delegate_0`: Foo? = null +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt new file mode 100644 index 00000000000..242d306a4a0 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt @@ -0,0 +1,7 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class C { + inner class D { + val `this$0`: C? = null + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt new file mode 100644 index 00000000000..0239e364628 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt @@ -0,0 +1,7 @@ +trait T { + fun getX() = 1 +} + +class C : T { + val x = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt new file mode 100644 index 00000000000..e277212ad58 --- /dev/null +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt @@ -0,0 +1,11 @@ +trait T1 { + fun getX() = 1 +} + +trait T2 { + val x: Int + get() = 1 +} + +class C : T1, T2 { +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/delegatedProperty.kt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/delegatedProperty.kt new file mode 100644 index 00000000000..2af8869417b --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/delegatedProperty.kt @@ -0,0 +1,7 @@ +import kotlin.properties.ReadWriteProperty +import kotlin.properties.Delegates + +class C { + val `x$delegate`: ReadWriteProperty? = null + val x: String? by Delegates.notNull() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNames.kt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNames.kt new file mode 100644 index 00000000000..34766d2379b --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNames.kt @@ -0,0 +1,7 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +import kotlin.platform.* + +[platformName("bar")] +fun foo(a: Any) {} + +fun Any.foo() {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNamesDuplicate.kt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNamesDuplicate.kt new file mode 100644 index 00000000000..b77fd476579 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNamesDuplicate.kt @@ -0,0 +1,7 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +import kotlin.platform.* + +[platformName("bar")] +fun foo(a: Any) {} + +fun bar(a: Any) {} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/checkers/BaseDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/BaseDiagnosticsTest.java index 00092caf066..ec5e468fd2e 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/BaseDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/BaseDiagnosticsTest.java @@ -27,6 +27,7 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiFileFactory; +import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; import kotlin.Function1; @@ -37,10 +38,13 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.asJava.AsJavaPackage; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.diagnostics.*; +import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.Diagnostics; import org.jetbrains.jet.utils.UtilsPackage; import org.junit.Assert; @@ -310,9 +314,18 @@ public abstract class BaseDiagnosticsTest extends JetLiteFixture { return true; } + Set jvmSignatureDiagnostics = new HashSet(); + Collection declarations = PsiTreeUtil.findChildrenOfType(jetFile, JetDeclaration.class); + for (JetDeclaration declaration : declarations) { + Diagnostics diagnostics = AsJavaPackage.getJvmSignatureDiagnostics(declaration); + if (diagnostics == null) continue; + jvmSignatureDiagnostics.addAll(diagnostics.forElement(declaration)); + } + final boolean[] ok = { true }; List diagnostics = ContainerUtil.filter( - CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, jetFile), + KotlinPackage.plus(CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, jetFile), + jvmSignatureDiagnostics), whatDiagnosticsToConsider ); CheckerTestUtil.diagnosticsDiff(diagnosedRanges, diagnostics, new CheckerTestUtil.DiagnosticDiffCallbacks() { diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index c6ed8fc219c..0fd899c31b3 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTest; @InnerTestClasses({JetDiagnosticsTestGenerated.Tests.class, JetDiagnosticsTestGenerated.Script.class, JetDiagnosticsTestGenerated.TailRecursion.class}) public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { @TestMetadata("compiler/testData/diagnostics/tests") - @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ClassObjects.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.CyclicHierarchy.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Deparenthesize.class, Tests.Enum.class, Tests.Evaluate.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.Imports.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inline.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Labels.class, Tests.Library.class, Tests.Multimodule.class, Tests.NamedArguments.class, Tests.NullabilityAndAutoCasts.class, Tests.NullableTypes.class, Tests.Numbers.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.Suppress.class, Tests.ThisAndSuper.class, Tests.Typedefs.class, Tests.Unit.class, Tests.Varargs.class, Tests.When.class}) + @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ClassObjects.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.CyclicHierarchy.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Deparenthesize.class, Tests.DuplicateJvmSignature.class, Tests.Enum.class, Tests.Evaluate.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.Imports.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inline.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Labels.class, Tests.Library.class, Tests.Multimodule.class, Tests.NamedArguments.class, Tests.NullabilityAndAutoCasts.class, Tests.NullableTypes.class, Tests.Numbers.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.Suppress.class, Tests.ThisAndSuper.class, Tests.Typedefs.class, Tests.Unit.class, Tests.Varargs.class, Tests.When.class}) public static class Tests extends AbstractJetDiagnosticsTest { @TestMetadata("Abstract.kt") public void testAbstract() throws Exception { @@ -2545,6 +2545,245 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { } + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature") + @InnerTestClasses({DuplicateJvmSignature.AccidentalOverrides.class, DuplicateJvmSignature.Erasure.class, DuplicateJvmSignature.FunctionAndProperty.class, DuplicateJvmSignature.SpecialNames.class, DuplicateJvmSignature.TraitImpl.class}) + public static class DuplicateJvmSignature extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides") + public static class AccidentalOverrides extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInAccidentalOverrides() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("classFunctionOverriddenByProperty.kt") + public void testClassFunctionOverriddenByProperty() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt"); + } + + @TestMetadata("classPropertyOverriddenByFunction.kt") + public void testClassPropertyOverriddenByFunction() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt"); + } + + @TestMetadata("traitFunctionOverriddenByProperty.kt") + public void testTraitFunctionOverriddenByProperty() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt"); + } + + @TestMetadata("traitPropertyOverriddenByFunction.kt") + public void testTraitPropertyOverriddenByFunction() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt"); + } + + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure") + public static class Erasure extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInErasure() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("collections.kt") + public void testCollections() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt"); + } + + @TestMetadata("delegateToTwoTraits.kt") + public void testDelegateToTwoTraits() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt"); + } + + @TestMetadata("delegationAndOwnMethod.kt") + public void testDelegationAndOwnMethod() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt"); + } + + @TestMetadata("genericType.kt") + public void testGenericType() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt"); + } + + @TestMetadata("inheritFromTwoTraits.kt") + public void testInheritFromTwoTraits() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt"); + } + + @TestMetadata("kotlinAndJavaCollections.kt") + public void testKotlinAndJavaCollections() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt"); + } + + @TestMetadata("nullableType.kt") + public void testNullableType() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt"); + } + + @TestMetadata("typeMappedToJava.kt") + public void testTypeMappedToJava() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt"); + } + + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt"); + } + + @TestMetadata("typeParameterWithBound.kt") + public void testTypeParameterWithBound() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt"); + } + + @TestMetadata("typeParameterWithTwoBounds.kt") + public void testTypeParameterWithTwoBounds() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt"); + } + + @TestMetadata("typeParameterWithTwoBoundsInWhere.kt") + public void testTypeParameterWithTwoBoundsInWhere() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt"); + } + + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty") + public static class FunctionAndProperty extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInFunctionAndProperty() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("class.kt") + public void testClass() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt"); + } + + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt"); + } + + @TestMetadata("extensionFunctionAndNormalFunction.kt") + public void testExtensionFunctionAndNormalFunction() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt"); + } + + @TestMetadata("extensionPropertyAndFunction.kt") + public void testExtensionPropertyAndFunction() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt"); + } + + @TestMetadata("functionAndSetter.kt") + public void testFunctionAndSetter() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt"); + } + + @TestMetadata("functionAndVar.kt") + public void testFunctionAndVar() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt"); + } + + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt"); + } + + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt"); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt"); + } + + @TestMetadata("objectExpression.kt") + public void testObjectExpression() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt"); + } + + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt"); + } + + @TestMetadata("topLevelDifferentFiles.kt") + public void testTopLevelDifferentFiles() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt"); + } + + @TestMetadata("topLevelGetter.kt") + public void testTopLevelGetter() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt"); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt"); + } + + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames") + public static class SpecialNames extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInSpecialNames() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("componentInheritedFromTrait.kt") + public void testComponentInheritedFromTrait() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/componentInheritedFromTrait.kt"); + } + + @TestMetadata("defaults.kt") + public void testDefaults() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/defaults.kt"); + } + + @TestMetadata("delegationBy.kt") + public void testDelegationBy() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt"); + } + + @TestMetadata("innerClassField.kt") + public void testInnerClassField() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt"); + } + + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl") + public static class TraitImpl extends AbstractJetDiagnosticsTest { + public void testAllFilesPresentInTraitImpl() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("oneTrait.kt") + public void testOneTrait() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt"); + } + + @TestMetadata("twoTraits.kt") + public void testTwoTraits() throws Exception { + doTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("DuplicateJvmSignature"); + suite.addTestSuite(DuplicateJvmSignature.class); + suite.addTestSuite(AccidentalOverrides.class); + suite.addTestSuite(Erasure.class); + suite.addTestSuite(FunctionAndProperty.class); + suite.addTestSuite(SpecialNames.class); + suite.addTestSuite(TraitImpl.class); + return suite; + } + } + @TestMetadata("compiler/testData/diagnostics/tests/enum") @InnerTestClasses({Enum.Inner.class}) public static class Enum extends AbstractJetDiagnosticsTest { @@ -7382,6 +7621,7 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { suite.addTest(DeclarationChecks.innerSuite()); suite.addTest(DelegatedProperty.innerSuite()); suite.addTestSuite(Deparenthesize.class); + suite.addTest(DuplicateJvmSignature.innerSuite()); suite.addTest(Enum.innerSuite()); suite.addTestSuite(Evaluate.class); suite.addTestSuite(Extensions.class); diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java index f87cb328be6..8ca556cf27f 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestWithStdLibGenerated.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTestWithStdLib; /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/testData/diagnostics/testsWithStdLib") -@InnerTestClasses({JetDiagnosticsTestWithStdLibGenerated.Annotations.class, JetDiagnosticsTestWithStdLibGenerated.CallableReference.class, JetDiagnosticsTestWithStdLibGenerated.FunctionLiterals.class, JetDiagnosticsTestWithStdLibGenerated.KotlinSignature.class}) +@InnerTestClasses({JetDiagnosticsTestWithStdLibGenerated.Annotations.class, JetDiagnosticsTestWithStdLibGenerated.CallableReference.class, JetDiagnosticsTestWithStdLibGenerated.DuplicateJvmSignature.class, JetDiagnosticsTestWithStdLibGenerated.FunctionLiterals.class, JetDiagnosticsTestWithStdLibGenerated.KotlinSignature.class}) public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnosticsTestWithStdLib { public void testAllFilesPresentInTestsWithStdLib() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), true); @@ -357,6 +357,29 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic } } + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature") + public static class DuplicateJvmSignature extends AbstractJetDiagnosticsTestWithStdLib { + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("delegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + doTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/delegatedProperty.kt"); + } + + @TestMetadata("platformNames.kt") + public void testPlatformNames() throws Exception { + doTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNames.kt"); + } + + @TestMetadata("platformNamesDuplicate.kt") + public void testPlatformNamesDuplicate() throws Exception { + doTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNamesDuplicate.kt"); + } + + } + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/functionLiterals") public static class FunctionLiterals extends AbstractJetDiagnosticsTestWithStdLib { public void testAllFilesPresentInFunctionLiterals() throws Exception { @@ -393,6 +416,7 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic suite.addTestSuite(JetDiagnosticsTestWithStdLibGenerated.class); suite.addTest(Annotations.innerSuite()); suite.addTest(CallableReference.innerSuite()); + suite.addTestSuite(DuplicateJvmSignature.class); suite.addTestSuite(FunctionLiterals.class); suite.addTestSuite(KotlinSignature.class); return suite; diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java b/idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java index a231e0dcdf6..448f51fcde6 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/DuplicateJvmSignatureAnnotator.java @@ -18,14 +18,11 @@ package org.jetbrains.jet.plugin.highlighter; import com.intellij.lang.annotation.AnnotationHolder; import com.intellij.lang.annotation.Annotator; -import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; -import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.asJava.KotlinLightClassForExplicitDeclaration; -import org.jetbrains.jet.asJava.KotlinLightClassForPackage; -import org.jetbrains.jet.lang.psi.JetClassBody; -import org.jetbrains.jet.lang.psi.JetClassOrObject; +import org.jetbrains.jet.asJava.AsJavaPackage; +import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.Diagnostics; import org.jetbrains.jet.plugin.project.TargetPlatform; @@ -35,38 +32,13 @@ public class DuplicateJvmSignatureAnnotator implements Annotator { @Override public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) { - Diagnostics diagnostics; + if (!(element instanceof JetFile) && !(element instanceof JetDeclaration)) return; + PsiFile file = element.getContainingFile(); + if (!(file instanceof JetFile) || TargetPlatformDetector.getPlatform((JetFile) file) != TargetPlatform.JVM) return; + + Diagnostics diagnostics = AsJavaPackage.getJvmSignatureDiagnostics(element); - PsiElement parent = element.getParent(); - if (parent instanceof JetFile) { - if (TargetPlatformDetector.getPlatform((JetFile) parent) != TargetPlatform.JVM) return; - diagnostics = getDiagnosticsForPackage((JetFile) parent); - } - else if (parent instanceof JetClassBody) { - PsiElement parentsParent = parent.getParent(); - if (!(parentsParent instanceof JetClassOrObject)) return; - - if (TargetPlatformDetector.getPlatform(((JetClassBody) parent).getContainingJetFile()) != TargetPlatform.JVM) return; - - diagnostics = getDiagnosticsForNonLocalClass((JetClassOrObject) parentsParent); - } - else { - return; - } + if (diagnostics == null) return; JetPsiChecker.annotateElement(element, holder, diagnostics); } - - @NotNull - private static Diagnostics getDiagnosticsForPackage(JetFile file) { - Project project = file.getProject(); - return KotlinLightClassForPackage.FileStubCache.getInstance(project).get( - file.getPackageFqName(), - GlobalSearchScope.allScope(project) - ).getValue().getExtraDiagnostics(); - } - - @NotNull - private static Diagnostics getDiagnosticsForNonLocalClass(JetClassOrObject jetClassOrObject) { - return KotlinLightClassForExplicitDeclaration.getLightClassData(jetClassOrObject).getExtraDiagnostics(); - } } diff --git a/idea/testData/checker/duplicateJvmSignature/traitImpl/twoTraits.kt b/idea/testData/checker/duplicateJvmSignature/traitImpl/twoTraits.kt new file mode 100644 index 00000000000..25cb919d2d4 --- /dev/null +++ b/idea/testData/checker/duplicateJvmSignature/traitImpl/twoTraits.kt @@ -0,0 +1,11 @@ +trait T1 { + fun getX() = 1 +} + +trait T2 { + val x: Int + get() = 1 +} + +class C : T1, T2 { +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java b/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java index 0f0a32a0bef..31b457e8c35 100644 --- a/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java @@ -422,7 +422,7 @@ public class JetPsiCheckerTestGenerated extends AbstractJetPsiCheckerTest { } @TestMetadata("idea/testData/checker/duplicateJvmSignature") - @InnerTestClasses({DuplicateJvmSignature.FunctionAndProperty.class}) + @InnerTestClasses({DuplicateJvmSignature.FunctionAndProperty.class, DuplicateJvmSignature.TraitImpl.class}) public static class DuplicateJvmSignature extends AbstractJetPsiCheckerTest { public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/checker/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), true); @@ -471,10 +471,24 @@ public class JetPsiCheckerTestGenerated extends AbstractJetPsiCheckerTest { } + @TestMetadata("idea/testData/checker/duplicateJvmSignature/traitImpl") + public static class TraitImpl extends AbstractJetPsiCheckerTest { + public void testAllFilesPresentInTraitImpl() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/checker/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("twoTraits.kt") + public void testTwoTraits() throws Exception { + doTest("idea/testData/checker/duplicateJvmSignature/traitImpl/twoTraits.kt"); + } + + } + public static Test innerSuite() { TestSuite suite = new TestSuite("DuplicateJvmSignature"); suite.addTestSuite(DuplicateJvmSignature.class); suite.addTestSuite(FunctionAndProperty.class); + suite.addTestSuite(TraitImpl.class); return suite; } }