Tests: do not report backend diagnostics if there's frontend error

In most affected tests, the backend diagnostic such as "conflicting JVM
signature" or "accidental override" is directly caused by some already
existing error reported by frontend, so it doesn't make sense to check
backend diagnostics there.

Tests where that was not the case were moved/copied to
`testsWithJvmBackend`.

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/genericFunctions.kt

@@ -0,0 +1,26 @@
+// FIR_IDENTICAL
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T> test2(x: List<T>) = x<!>
+<!CONFLICTING_JVM_DECLARATIONS!>fun test2(x: List<String>) = x<!>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T> List<T>.test2a() {}<!>
+<!CONFLICTING_JVM_DECLARATIONS!>fun List<String>.test2a() {}<!>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T : Any> test3(x: List<T>) = x<!>
+<!CONFLICTING_JVM_DECLARATIONS!>fun test3(x: List<Any>) = x<!>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T : Any> List<T>.test3a() {}<!>
+<!CONFLICTING_JVM_DECLARATIONS!>fun List<Any>.test3a() {}<!>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T> test4(x: Map<T, T>) = x<!>
+<!CONFLICTING_JVM_DECLARATIONS!>fun <K, V> test4(x: Map<K, V>) = x<!>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T> Map<T, T>.test4a() {}<!>
+<!CONFLICTING_JVM_DECLARATIONS!>fun <K, V> Map<K, V>.test4a() {}<!>
+
+class Inv<T>
+
+fun <T> test6(x: Array<T>) = x
+fun test6(x: Array<String>) = x
+
+fun <T> test7(x: Inv<T>) = x
+fun <T> Inv<T>.test7() {}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritGenericMethodsWithDifferentSubstitution.fir.kt

@@ -0,0 +1,29 @@
+open class GenericBaseClass<T> {
+    open fun foo(x: T): T = x
+    open fun ambiguous(x: T): T = x
+}
+
+interface GenericBaseInterface<T> {
+    fun bar(x: T): T = x
+    fun ambiguous(x: T): T = x
+}
+
+class GenericDerivedClass<T> : GenericBaseClass<T>(), GenericBaseInterface<T> {
+    override fun foo(x: T): T = super.foo(x)
+    override fun bar(x: T): T = super.bar(x)
+    override fun ambiguous(x: T): T = foo(x)
+}
+
+<!CONFLICTING_INHERITED_JVM_DECLARATIONS!>class SpecializedDerivedClass : GenericBaseClass<Int>(), GenericBaseInterface<String> {
+    override fun foo(x: Int): Int = super.foo(x)
+    override fun bar(x: String): String = super.bar(x)
+    override fun ambiguous(x: String): String = bar(x)
+    override fun ambiguous(x: Int): Int = foo(x)
+}<!>
+
+class MixedDerivedClass<T> : GenericBaseClass<Int>(), GenericBaseInterface<T> {
+    override fun foo(x: Int): Int = super.foo(x)
+    override fun bar(x: T): T = super.bar(x)
+    override fun ambiguous(x: Int): Int = foo(x)
+    <!ACCIDENTAL_OVERRIDE!>override fun ambiguous(x: T): T = bar(x)<!>
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritGenericMethodsWithDifferentSubstitution.kt

@@ -0,0 +1,29 @@
+open class GenericBaseClass<T> {
+    open fun foo(x: T): T = x
+    open fun ambiguous(x: T): T = x
+}
+
+interface GenericBaseInterface<T> {
+    fun bar(x: T): T = x
+    fun ambiguous(x: T): T = x
+}
+
+class GenericDerivedClass<T> : GenericBaseClass<T>(), GenericBaseInterface<T> {
+    override fun foo(x: T): T = super.foo(x)
+    override fun bar(x: T): T = super.bar(x)
+    override fun ambiguous(x: T): T = foo(x)
+}
+
+<!CONFLICTING_INHERITED_JVM_DECLARATIONS!>class SpecializedDerivedClass : GenericBaseClass<Int>(), GenericBaseInterface<String> {
+    override fun foo(x: Int): Int = super.foo(x)
+    override fun bar(x: String): String = super.bar(x)
+    override fun ambiguous(x: String): String = bar(x)
+    override fun ambiguous(x: Int): Int = foo(x)
+}<!>
+
+class MixedDerivedClass<T> : GenericBaseClass<Int>(), GenericBaseInterface<T> {
+    override fun foo(x: Int): Int = super.foo(x)
+    override fun bar(x: T): T = super.bar(x)
+    override fun ambiguous(x: Int): Int = foo(x)
+    override <!ACCIDENTAL_OVERRIDE!>fun ambiguous(x: T): T = bar(x)<!>
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/javaInterop/inheritFromJavaCollectionSubclassWithContainsOverload.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -PARAMETER_NAME_CHANGED_ON_OVERRIDE
+// FILE: A.java
+abstract public class A implements java.util.Collection<String> {
+    public boolean contains(Object x) {return false;}
+    public boolean contains(String x) {return false;}
+}
+
+// FILE: main.kt
+abstract class KA : A() {
+    override fun <!ACCIDENTAL_OVERRIDE_CLASH_BY_JVM_SIGNATURE!>contains<!>(x: String) = false
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/javaInterop/inheritFromJavaCollectionSubclassWithContainsOverload.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -PARAMETER_NAME_CHANGED_ON_OVERRIDE
+// FILE: A.java
+abstract public class A implements java.util.Collection<String> {
+    public boolean contains(Object x) {return false;}
+    public boolean contains(String x) {return false;}
+}
+
+// FILE: main.kt
+abstract class KA : A() {
+    override <!ACCIDENTAL_OVERRIDE!>fun contains(x: String) = false<!>
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/javaInterop/supertypeDifferentParameterNullability.kt

@@ -0,0 +1,18 @@
+// FIR_IDENTICAL
+// FILE: A.java
+import org.jetbrains.annotations.*;
+
+public interface A {
+    void foo(@Nullable String x);
+}
+
+// FILE: B.java
+import org.jetbrains.annotations.*;
+
+public interface B {
+    void foo(@NotNull String x);
+}
+
+// FILE: C.kt
+
+<!CONFLICTING_INHERITED_JVM_DECLARATIONS!>interface I : A, B<!>

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/jvmName/conflictsWIthJvmNameInClass.fir.kt

@@ -0,0 +1,54 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -INAPPLICABLE_JVM_NAME
+// WITH_STDLIB
+<!CONFLICTING_JVM_DECLARATIONS!>@JvmName("bar")
+fun foo(a: Any) {}<!>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun bar(a: Any) {}<!>
+
+class C {
+    <!CONFLICTING_JVM_DECLARATIONS!>@JvmName("foo1")
+    fun foo(list: List<Int>) {}<!>
+
+    <!CONFLICTING_JVM_DECLARATIONS!>@JvmName("foo1")
+    fun foo(list: List<String>) {}<!>
+}
+
+// Conflicts in inheritance.
+
+// A1 -> B1 with accidental override
+
+open class A1 {
+    @JvmName("bar")
+    open fun foo() {}
+}
+
+class B1 : A1() {
+    <!ACCIDENTAL_OVERRIDE!>fun bar() {}<!>
+}
+
+// A2 -> B2 with intended override and conflicting JVM declarations
+
+open class A2 {
+    @JvmName("bar")
+    open fun foo() {}
+}
+
+class B2 : A2() {
+    override fun foo() {}
+
+    <!ACCIDENTAL_OVERRIDE!>fun bar() {}<!>
+}
+
+// A3 -> B3 -> C3 with accidental override
+
+open class A3 {
+    @JvmName("bar")
+    open fun foo() {}
+}
+
+open class B3: A3() {
+}
+
+class C3: B3() {
+    <!ACCIDENTAL_OVERRIDE!>fun bar() {}<!>
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/jvmName/conflictsWIthJvmNameInClass.kt

@@ -0,0 +1,54 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -INAPPLICABLE_JVM_NAME
+// WITH_STDLIB
+@JvmName("bar")
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(a: Any) {}<!>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun bar(a: Any) {}<!>
+
+class C {
+    @JvmName("foo1")
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(list: List<Int>) {}<!>
+
+    @JvmName("foo1")
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(list: List<String>) {}<!>
+}
+
+// Conflicts in inheritance.
+
+// A1 -> B1 with accidental override
+
+open class A1 {
+    @JvmName("bar")
+    open fun foo() {}
+}
+
+class B1 : A1() {
+    <!ACCIDENTAL_OVERRIDE!>fun bar() {}<!>
+}
+
+// A2 -> B2 with intended override and conflicting JVM declarations
+
+open class A2 {
+    @JvmName("bar")
+    open fun foo() {}
+}
+
+class B2 : A2() {
+    override fun foo() {}
+
+    <!ACCIDENTAL_OVERRIDE!>fun bar() {}<!>
+}
+
+// A3 -> B3 -> C3 with accidental override
+
+open class A3 {
+    @JvmName("bar")
+    open fun foo() {}
+}
+
+open class B3: A3() {
+}
+
+class C3: B3() {
+    <!ACCIDENTAL_OVERRIDE!>fun bar() {}<!>
+}