Diagnostic tests for duplicate JVM signatures

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);
         }

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

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt

@@ -0,0 +1,8 @@
+open class B {
+    fun getX() = 1
+}
+
+class C : B() {
+    val x: Int
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>get() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt

@@ -0,0 +1,8 @@
+open class B {
+    val x: Int
+        get() = 1
+}
+
+class C : B() {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt

@@ -0,0 +1,8 @@
+trait T {
+    fun getX() = 1
+}
+
+class C : T {
+    val x: Int
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>get() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt

@@ -0,0 +1,8 @@
+trait T {
+    val x: Int
+        get() = 1
+}
+
+class C : T {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: List<String>) {}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: MutableList<String>) {}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+trait Foo<T> {
+    fun foo(l: List<T>)
+}
+
+trait Bar<T> {
+    fun foo(l: List<T>)
+}
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>class Baz(f: Foo<String>, b: Bar<Int>): Foo<String> by f, Bar<Int> by b {
+}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+trait Foo<T> {
+    fun foo(l: List<T>)
+}
+
+class Bar(f: Foo<String>): Foo<String> by f {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(l: List<Int>) {}<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt

@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class G<T>
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: G<String>): G<Int> {null!!}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: G<Int>): G<String> {null!!}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+trait Foo<T> {
+    fun foo(l: List<T>) {}
+}
+
+trait Bar<T> {
+    fun foo(l: List<T>) {}
+}
+
+<!CONFLICTING_JVM_DECLARATIONS!>class Baz()<!>: Foo<String>, Bar<Int> {
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -PLATFORM_CLASS_MAPPED_TO_KOTLIN
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: List<String>) {}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: java.util.List<String>) {}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: String) {}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: String?) {}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -PLATFORM_CLASS_MAPPED_TO_KOTLIN
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: java.lang.String) {}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: String) {}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T> foo(x: T): T {null!!}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Any): Any {null!!}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt

@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+trait Foo
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T: Foo> foo(x: T): T {null!!}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Foo): Foo {null!!}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+trait Foo
+trait Bar
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T: Foo> foo(x: T): T where T: Bar {null!!}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Foo): Foo {null!!}<!>
+fun foo(x: Bar): Bar {null!!}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+trait Foo
+trait Bar
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T> foo(x: T): T where T: Foo, T: Bar {null!!}<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Foo): Foo {null!!}<!>
+fun foo(x: Bar): Bar {null!!}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt

@@ -0,0 +1,4 @@
+class C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt

@@ -0,0 +1,6 @@
+class C {
+    class object {
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+    }
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt

@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Any) {}<!>
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun Any.foo() {}<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt

@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX(t: Any) = 1<!>
+    val Any.x: Int
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>get() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt

@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun setX(x: Int) {}<!>
+
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>var x: Int = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun setX(x: Int) {}<!>
+
+    var x: Int = 1
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>set(v) {}<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt

@@ -0,0 +1,6 @@
+fun foo() {
+    class C {
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+    }
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt

@@ -0,0 +1,6 @@
+class B {
+    class C {
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+    }
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt

@@ -0,0 +1,4 @@
+object C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt

@@ -0,0 +1,5 @@
+fun foo() =
+    object {
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+    }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt

@@ -0,0 +1,2 @@
+<!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt

@@ -0,0 +1,5 @@
+// FILE: a.kt
+<!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+
+// FILE: b.kt
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt

@@ -0,0 +1,3 @@
+val x: Int
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>get() = 1<!>
+<!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt

@@ -0,0 +1,5 @@
+trait T {
+    val x: Int
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>get() = 1<!>
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX() = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/componentInheritedFromTrait.kt

@@ -0,0 +1,5 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+data class C(val c: Int) {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun `copy$default`(c: C, x: Int, m: Int) = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/defaults.kt

@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>class C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun `a$default`(c: C, x: Int, m: Int) {}<!>
+    fun a(x: Int = 1) {}
+}<!>

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt

@@ -0,0 +1,5 @@
+trait Foo
+
+class Bar(f: Foo) : Foo by f {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>val `$delegate_0`: Foo? = null<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt

@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class C {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>inner class D {
+        <!CONFLICTING_PLATFORM_DECLARATIONS!>val `this$0`: C? = null<!>
+    }<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt

@@ -0,0 +1,7 @@
+trait T {
+    fun getX() = 1
+}
+
+class C : T {
+    <!CONFLICTING_PLATFORM_DECLARATIONS!>val x = 1<!>
+}

compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt

@@ -0,0 +1,11 @@
+trait T1 {
+    fun getX() = 1
+}
+
+trait T2 {
+    val x: Int
+        get() = 1
+}
+
+<!CONFLICTING_PLATFORM_DECLARATIONS!>class C : T1, T2<!> {
+}

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<Any, Any>? = null
+    val x: String? by Delegates.notNull()
+}

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

compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/platformNamesDuplicate.kt

@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+import kotlin.platform.*
+
+<!CONFLICTING_JVM_DECLARATIONS!>[platformName("bar")]
+fun foo(a: Any)<!> {}
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun bar(a: Any)<!> {}

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<Diagnostic> jvmSignatureDiagnostics = new HashSet<Diagnostic>();
+            Collection<JetDeclaration> 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<Diagnostic> diagnostics = ContainerUtil.filter(
-                    CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, jetFile),
+                    KotlinPackage.plus(CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, jetFile),
+                                       jvmSignatureDiagnostics),
                     whatDiagnosticsToConsider
             );
             CheckerTestUtil.diagnosticsDiff(diagnosedRanges, diagnostics, new CheckerTestUtil.DiagnosticDiffCallbacks() {

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);

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;

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

idea/testData/checker/duplicateJvmSignature/traitImpl/twoTraits.kt

@@ -0,0 +1,11 @@
+trait T1 {
+    fun getX() = 1
+}
+
+trait T2 {
+    val x: Int
+        get() = 1
+}
+
+<error>class C : T1, T2</error> {
+}

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;
         }
     }