Java 8 rules for method overrides:

- base class method wins against a (default) interface method,
so an abstract base class method should always be implemented
in a derived class;

- interface methods clash regardless of abstract/default
with possibly undefined behavior at run-time,
so a class or interface should always define its own method
for methods inherited from multiple interfaces and not from base class;

- meaningful diagnostics for class inheriting conflicting JVM signatures.
Since no override will happen under Java 8 rules,
ACCIDENTAL_OVERRIDE is misleading for this case;

- update testData.

compiler/testData/codegen/box/bridges/complexTraitImpl.kt

@@ -9,7 +9,9 @@ interface B {
     fun foo(): ArrayList<String> = ArrayList(Arrays.asList("B"))
 }
 
-open class C : A(), B
+open class C : A(), B {
+    override fun foo(): ArrayList<String> = super<B>.foo()
+}
 
 interface D {
     fun foo(): Collection<String>

compiler/testData/codegen/box/bridges/fakeGenericContravariantOverride1.kt

@@ -1,30 +0,0 @@
-interface A<T> {
-    fun foo(t: T): String
-}
-
-interface B {
-    fun foo(t: Int) = "B"
-}
-
-class Z1 : A<Int>, B
-
-class Z2 : B, A<Int>
-
-fun box(): String {
-    val z1 = Z1()
-    val z2 = Z2()
-    val z1a: A<Int> = z1
-    val z1b: B = z1
-    val z2a: A<Int> = z2
-    val z2b: B = z2
-
-    return when {
-        z1.foo( 0)  != "B" -> "Fail #1"
-        z1a.foo( 0) != "B" -> "Fail #2"
-        z1b.foo( 0) != "B" -> "Fail #3"
-        z2.foo( 0)  != "B" -> "Fail #4"
-        z2a.foo( 0) != "B" -> "Fail #5"
-        z2b.foo( 0) != "B" -> "Fail #6"
-        else -> "OK"
-    }
-}

compiler/testData/codegen/box/bridges/fakeGenericContravariantOverride2.kt

@@ -1,30 +0,0 @@
-interface A<T> {
-    fun foo(t: T): String
-}
-
-interface B<T : Number> {
-    fun foo(a: T) = "B"
-}
-
-class Z1 : A<Int>, B<Int>
-
-class Z2 : B<Int>, A<Int>
-
-fun box(): String {
-    val z1 = Z1()
-    val z2 = Z2()
-    val z1a: A<Int> = z1
-    val z1b: B<Int> = z1
-    val z2a: A<Int> = z2
-    val z2b: B<Int> = z2
-
-    return when {
-        z1.foo( 0)  != "B" -> "Fail #1"
-        z1a.foo( 0) != "B" -> "Fail #2"
-        z1b.foo( 0) != "B" -> "Fail #3"
-        z2.foo( 0)  != "B" -> "Fail #4"
-        z2a.foo( 0) != "B" -> "Fail #5"
-        z2b.foo( 0) != "B" -> "Fail #6"
-        else -> "OK"
-    }
-}

compiler/testData/codegen/box/bridges/fakeOverrideOfPropertySetterInTraitImpl.kt

@@ -1,25 +0,0 @@
-var result = ""
-
-interface A {
-    var foo: String
-        get() = result
-        set(value) {
-            result += value
-        }
-}
-
-abstract class B {
-    abstract var foo: Any
-}
-
-class C : A, B()
-
-fun box(): String {
-    val c = C()
-    c.foo = "1"
-    val b: B = c
-    val a: A = c
-    b.foo = "2"
-    a.foo = "3"
-    return if (result == "123") "OK" else "Fail: $result"
-}

compiler/testData/codegen/box/bridges/fakeOverrideWithImplementationInTrait.kt

@@ -1,20 +0,0 @@
-interface A {
-    fun foo(): String = "A"
-}
-
-interface B {
-    fun foo(): Any
-}
-
-class C : A, B
-
-fun box(): String {
-    val c = C()
-    var result = ""
-    val b: B = c
-    val a: A = c
-    result += c.foo()
-    result += b.foo()
-    result += a.foo()
-    return if (result == "AAA") "OK" else "Fail: $result"
-}

compiler/testData/codegen/box/builtinsProperties/bridges.kt

@@ -9,6 +9,8 @@ class B0 : Collection<String>, A0 {
     override fun contains(o: String) = throw UnsupportedOperationException()
     override fun iterator() = throw UnsupportedOperationException()
     override fun containsAll(c: Collection<String>) = throw UnsupportedOperationException()
+    override val size: Int
+        get() = super.size
 }
 
 open class A1 {
@@ -45,6 +47,8 @@ class B4 : Collection<String>, I4<Int> {
     override fun contains(o: String) = throw UnsupportedOperationException()
     override fun iterator() = throw UnsupportedOperationException()
     override fun containsAll(c: Collection<String>) = throw UnsupportedOperationException()
+    override val size: Int
+        get() = super.size
 }
 
 interface I5 : Collection<String> {

compiler/testData/codegen/box/classes/kt2477.kt

@@ -10,8 +10,8 @@ interface B {
         get() = "FAIL"
 }
 
-abstract class C {
-    abstract protected val c: String
+open class C {
+    private val c: String = "FAIL"
 }
 
 open class D: C(), A, B {

compiler/testData/codegen/bytecodeText/interfaces/firstInheritedMethodIsAbstract.kt

@@ -6,7 +6,9 @@ interface B {
     fun foo(): String = "OK"
 }
 
-interface C : A, B
+interface C : A, B {
+    override fun foo(): String = super<B>.foo()
+}
 
 // There's no 'foo' in A$DefaultImpls, proguard and other tools may fail if we generate calls to it
 // 0 INVOKESTATIC A\$DefaultImpls.foo

compiler/testData/compileKotlinAgainstCustomBinaries/noWarningsOnJavaKotlinInheritance/noWarningsOnJavaKotlinInheritance.kt

@@ -11,4 +11,8 @@ interface KotlinTrait {
     public fun foo(someOtherName: Int) {}
 }
 
-class BothTraitsSubclass : JavaInterface, KotlinTrait
+class BothTraitsSubclass : JavaInterface, KotlinTrait {
+    override fun foo(someOtherName: Int) {
+        super.foo(someOtherName)
+    }
+}

compiler/testData/diagnostics/tests/declarationChecks/kt559.kt

@@ -14,17 +14,17 @@ abstract class D(): A() {
     override val i : Int = 34
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C<!>() : D() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class C<!>() : D() {
     fun test() {
         super.i
     }
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
     override fun foo(): Int {
         super.<!ABSTRACT_SUPER_CALL!>i<!>
 
         super.fff() //everything is ok
         return super.<!ABSTRACT_SUPER_CALL!>foo<!>()  //no error!!
     }
-}
+}

compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt

@@ -9,7 +9,7 @@ open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Br<!>(<!UNUSED_PARAMETER!>t<!> : T
 
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Br3<!>(t : T) : Br(t) {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class Br3<!>(t : T) : Br(t) {
 
 }
 
@@ -35,4 +35,4 @@ open class GC1(g : G<Int>) : G<Int> by g {
 
 open class GC2(g : G<Int>) : GC1(g) {
 
-}
+}

compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt

@@ -14,6 +14,6 @@ interface TwoImpl : Two {
   public override fun foo() = 2
 }
 
-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test1<!>() : TwoImpl, OneImpl {}
+<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED!>class Test1<!>() : TwoImpl, OneImpl {}
 class Test2(a : One) : One by a, Two {}
 <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test3<!>(a : One, b : Two) : Two by b, One by a {}

compiler/testData/diagnostics/tests/j+k/kt6720_abstractProperty.kt

@@ -11,8 +11,8 @@ public abstract class B implements A {
 
 // FILE: C.kt
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C<!> : B()
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class C<!> : B()
 
 fun main() {
     C().a
-}
+}

compiler/testData/diagnostics/tests/java8Overrides/abstractBaseClassMemberNotImplemented.kt

@@ -0,0 +1,9 @@
+abstract class ALeft {
+    abstract fun foo()
+}
+
+interface IRight {
+    fun foo() {}
+}
+
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class CDerived<!> : ALeft(), IRight

compiler/testData/diagnostics/tests/java8Overrides/abstractBaseClassMemberNotImplemented.txt

@@ -0,0 +1,24 @@
+package
+
+public abstract class ALeft {
+    public constructor ALeft()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class CDerived : ALeft, IRight {
+    public constructor CDerived()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface IRight {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/java8Overrides/abstractVsAbstract.kt

@@ -0,0 +1,13 @@
+interface ILeft {
+    fun foo()
+}
+
+interface IRight {
+    fun foo()
+}
+
+interface IDerived : ILeft, IRight
+
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class CDerived<!> : ILeft, IRight
+
+abstract class ADerived : ILeft, IRight

compiler/testData/diagnostics/tests/java8Overrides/abstractVsAbstract.txt

@@ -0,0 +1,38 @@
+package
+
+public abstract class ADerived : ILeft, IRight {
+    public constructor ADerived()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class CDerived : ILeft, IRight {
+    public constructor CDerived()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface IDerived : ILeft, IRight {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface ILeft {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface IRight {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/java8Overrides/defaultVsAbstract.kt

@@ -0,0 +1,13 @@
+interface ILeft {
+    fun foo() {}
+}
+
+interface IRight {
+    fun foo()
+}
+
+<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED!>interface IDerived<!> : ILeft, IRight
+
+<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED!>class CDerived<!> : ILeft, IRight
+
+abstract <!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED!>class ADerived<!> : ILeft, IRight

compiler/testData/diagnostics/tests/java8Overrides/defaultVsAbstract.txt

@@ -0,0 +1,38 @@
+package
+
+public abstract class ADerived : ILeft, IRight {
+    public constructor ADerived()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class CDerived : ILeft, IRight {
+    public constructor CDerived()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface IDerived : ILeft, IRight {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface ILeft {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface IRight {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/java8Overrides/singleRelevantDefault.kt

@@ -0,0 +1,9 @@
+interface ITop {
+    fun foo() {}
+}
+
+interface ILeft : ITop
+
+interface IRight : ITop
+
+interface IDerived : ILeft, IRight

compiler/testData/diagnostics/tests/java8Overrides/singleRelevantDefault.txt

@@ -0,0 +1,29 @@
+package
+
+public interface IDerived : ILeft, IRight {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface ILeft : ITop {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface IRight : ITop {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface ITop {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/modifiers/const/applicability.kt

@@ -22,7 +22,7 @@ abstract class C {
     }
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object D<!> : C() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>object D<!> : C() {
     <!INCOMPATIBLE_MODIFIERS!>override<!> <!INCOMPATIBLE_MODIFIERS!>const<!> val x: Int = 9
 
     const val inObject = 10

compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt

@@ -2,5 +2,5 @@ abstract class A {
     abstract fun foo(): Int
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
-}
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
+}

compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt

@@ -2,5 +2,5 @@ abstract class A {
     abstract val i: Int
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
 }

compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt

@@ -2,5 +2,5 @@ abstract class A {
     abstract var i: Int
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
 }

compiler/testData/diagnostics/tests/override/Generics.kt

@@ -40,15 +40,15 @@ abstract class MyAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {
     override fun bar(t: String) = t
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T>() {}
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R>() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T>() {}
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R>() {
     <!NOTHING_TO_OVERRIDE!>override<!> fun foo(r: R) = r
     <!CONFLICTING_OVERLOADS!><!NOTHING_TO_OVERRIDE!>override<!> val <T> pr : R<!> = r
 }
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String>() {}
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String>() {}
 abstract class MyLegalAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {}
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
     fun foo(t: T) = t
     fun bar(t: T) = t
     <!CONFLICTING_OVERLOADS!>val <R> pr : T<!> = t

compiler/testData/diagnostics/tests/override/NonGenerics.kt

@@ -21,9 +21,9 @@ open class MyClass() : MyTrait, MyAbstractClass() {
 
 class MyChildClass() : MyClass() {}
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass<!> : MyTrait, MyAbstractClass() {}
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass<!> : MyTrait, MyAbstractClass() {}
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass2<!>() : MyTrait, MyAbstractClass() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass2<!>() : MyTrait, MyAbstractClass() {
     override fun foo() {}
     override val pr : Unit = Unit
     override val prr : Unit = Unit
@@ -35,7 +35,7 @@ class MyChildClass() : MyClass() {}
     override val prr : Unit = Unit
 }
 
-<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass4<!>() : MyTrait, MyAbstractClass() {
+<!ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass4<!>() : MyTrait, MyAbstractClass() {
     <!VIRTUAL_MEMBER_HIDDEN!>fun foo()<!> {}
     <!VIRTUAL_MEMBER_HIDDEN, MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val pr : Unit<!>
     <!NOTHING_TO_OVERRIDE!>override<!> fun other() {}

compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt

@@ -8,7 +8,7 @@ interface B {
     fun foo() = 2
 }
 
-open <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class C<!> : A, B {}
+open <!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED!>class C<!> : A, B {}
 
 interface E {
     fun foo(): Int

compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsBothJavaAndKotlin.kt

@@ -10,4 +10,4 @@ interface KotlinTrait {
     public fun foo(someOtherName: Int) {}
 }
 
-class BothTraitsSubclass : JavaInterface, KotlinTrait
+<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED!>class BothTraitsSubclass<!> : JavaInterface, KotlinTrait

compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt

@@ -22,7 +22,7 @@ public interface B {
     <!ACCIDENTAL_OVERRIDE!>override fun foo(x: String?)<!> {}
 }
 
-interface <!ACCIDENTAL_OVERRIDE!>I<!> : A, B
+interface <!CONFLICTING_INHERITED_JVM_DECLARATIONS!>I<!> : A, B
 
 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C3<!> : I {
     <!ACCIDENTAL_OVERRIDE!>override fun foo(x: String)<!> {}
@@ -30,4 +30,4 @@ interface <!ACCIDENTAL_OVERRIDE!>I<!> : A, B
 
 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C4<!> : I {
     <!ACCIDENTAL_OVERRIDE!>override fun foo(x: String?)<!> {}
-}
+}

compiler/testData/diagnostics/tests/regressions/kt302.kt

@@ -10,4 +10,4 @@ interface B {
     open fun foo() {}
 }
 
-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class C<!> : A, B {} //should be error here
+<!MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED!>class C<!> : A, B {} //should be error here