[FIR-TEST] Add new testdata generated after changes in previous commit

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/generic.fir.kt

@@ -0,0 +1,60 @@
+// !JVM_TARGET: 1.8
+// !JVM_DEFAULT_MODE: enable
+
+interface A<T> {
+    @JvmDefault
+    fun test(p: T) {
+    }
+}
+
+interface ANonDefault {
+    fun test(p: String) {}
+}
+
+interface B<T> : A<T> {
+
+    override fun test(p: T)
+    {}
+}
+
+interface C<T> : A<T>, ANonDefault {
+
+    override fun test(p: T)
+    {}
+
+    override fun test(p: String) {
+    }
+}
+
+interface C1 : C<String> {
+    override fun test(p: String) {
+
+    }
+}
+
+interface C2 : C<String>, ANonDefault {
+    override fun test(p: String) {
+
+    }
+}
+
+interface D<T> : ANonDefault, A<T> {
+
+    override fun test(p: T)
+    {}
+
+    override fun test(p: String) {
+    }
+}
+
+interface D1 : D<String> {
+    override fun test(p: String) {
+
+    }
+}
+
+interface D2 : ANonDefault, D<String> {
+    override fun test(p: String) {
+
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/javaOverride.fir.kt

@@ -0,0 +1,72 @@
+// !JVM_DEFAULT_MODE: enable
+// !JVM_TARGET: 1.8
+
+// FILE: JavaInterface.java
+public interface JavaInterface {
+    default void test() {}
+
+    default void testForNonDefault() {}
+
+    void testAbstract();
+}
+
+// FILE: 1.kt
+
+interface KotlinInterface : JavaInterface {
+    @JvmDefault
+    override fun test() {}
+
+    override fun testForNonDefault() {}
+
+    override fun testAbstract() {}
+}
+
+interface KotlinInterface2 : JavaInterface, KotlinInterface {
+    @JvmDefault
+    override fun test() {}
+
+    override fun testForNonDefault() {}
+
+    override fun testAbstract() {}
+}
+
+
+interface KotlinInterfaceForIndirect : JavaInterface {
+
+}
+
+interface KotlinInterfaceIndirectInheritance : KotlinInterfaceForIndirect {
+
+    @JvmDefault
+    override fun test() {}
+
+    override fun testForNonDefault() {}
+
+    override fun testAbstract() {}
+}
+
+open class KotlinClass : JavaInterface {
+    override fun test() {}
+
+    override fun testForNonDefault() {}
+
+    override fun testAbstract() {}
+}
+
+interface KotlinInterfaceX  {
+
+    fun test() {}
+
+    fun testForNonDefault() {}
+
+    fun testAbstract() {}
+}
+
+interface KotlinInterfaceManySuper: JavaInterface, KotlinInterfaceX {
+    @JvmDefault
+    override fun test() {}
+
+    override fun testForNonDefault() {}
+
+    override fun testAbstract() {}
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultInInheritance.fir.kt

@@ -0,0 +1,36 @@
+// !JVM_TARGET: 1.8
+
+interface A {
+    @JvmDefault
+    fun test() {
+    }
+}
+
+interface B : A {
+
+}
+
+
+open class Foo : B
+open class Foo2 : B, A
+
+open class FooNoError : B {
+    override fun test() {
+    }
+}
+open class Foo2NoError : B, A {
+    override fun test() {
+    }
+}
+
+class Bar : Foo()
+class Bar2 : Foo(), A
+class Bar3 : Foo(), B
+
+open class BarWithJvmDefault : B {
+    @JvmDefault
+    override fun test() {
+    }
+}
+
+class BarWithJvmDefaultSuper: BarWithJvmDefault()

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaults.fir.kt

@@ -0,0 +1,322 @@
+// !JVM_DEFAULT_MODE: enable
+// !JVM_TARGET: 1.8
+
+public interface KInterface {
+    @JvmDefault
+    fun test(): String {
+        return "OK";
+    }
+
+    @JvmDefault
+    val property: String
+        get() = "OK"
+
+
+    fun testNonDefault(): String {
+        return "OK";
+    }
+
+    val propertyNonDefault: String
+        get() = "OK"
+}
+
+// FILE: 1.kt
+
+interface KotlinInterface : KInterface {
+    @JvmDefault
+    fun fooo() {
+        super.test()
+        super.property
+
+        super.testNonDefault()
+        super.propertyNonDefault
+
+        object  {
+            fun run () {
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>test<!>()
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>property<!>
+
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+            }
+        }
+    }
+
+    @JvmDefault
+    val propertyy: String
+        get() {
+            super.test()
+            super.property
+
+            super.testNonDefault()
+            super.propertyNonDefault
+
+            object  {
+                fun run () {
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>test<!>()
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>property<!>
+
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+                }
+            }
+            return ""
+        }
+
+    fun foooNonDefault() {
+        super.test()
+        super.property
+
+        super.testNonDefault()
+        super.propertyNonDefault
+
+        object  {
+            fun run () {
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>test<!>()
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>property<!>
+
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+            }
+        }
+    }
+
+    val propertyyNonDefault: String
+        get() {
+            super.test()
+            super.property
+
+            super.testNonDefault()
+            super.propertyNonDefault
+
+            object  {
+                fun run () {
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>test<!>()
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>property<!>
+
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+                }
+            }
+            return ""
+        }
+
+
+}
+
+interface KotlinInterfaceIndirectInheritance : KotlinInterface {
+    @JvmDefault
+    fun foooo() {
+        super.test()
+        super.property
+
+        super.testNonDefault()
+        super.propertyNonDefault
+
+        object  {
+            fun run () {
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>property<!>
+
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+            }
+        }
+    }
+
+    @JvmDefault
+    val propertyyy: String
+        get() {
+            super.test()
+            super.property
+
+            super.testNonDefault()
+            super.propertyNonDefault
+
+            object  {
+                fun run () {
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>property<!>
+
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+                }
+            }
+            return ""
+        }
+
+    fun fooooNonDefault() {
+        super.test()
+        super.property
+
+        super.testNonDefault()
+        super.propertyNonDefault
+
+        object  {
+            fun run () {
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>property<!>
+
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+            }
+        }
+    }
+
+    val propertyyyNonDefault: String
+        get() {
+            super.test()
+            super.property
+
+            super.testNonDefault()
+            super.propertyNonDefault
+
+            object  {
+                fun run () {
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>property<!>
+
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+                }
+            }
+            return ""
+        }
+}
+
+open class KotlinClass : KInterface {
+    fun foo() {
+        super.test()
+        super.property
+
+        super.testNonDefault()
+        super.propertyNonDefault
+
+        object  {
+            fun run () {
+                super@KotlinClass.<!UNRESOLVED_REFERENCE!>test<!>()
+                super@KotlinClass.<!UNRESOLVED_REFERENCE!>property<!>
+
+                super@KotlinClass.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                super@KotlinClass.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+            }
+        }
+    }
+
+    val xproperty: String
+        get() {
+            super.test()
+            super.property
+
+            super.testNonDefault()
+            super.propertyNonDefault
+
+            object  {
+                fun run () {
+                    super@KotlinClass.<!UNRESOLVED_REFERENCE!>test<!>()
+                    super@KotlinClass.<!UNRESOLVED_REFERENCE!>property<!>
+
+                    super@KotlinClass.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                    super@KotlinClass.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+                }
+            }
+
+            return ""
+        }
+}
+
+class KotlinClassIndirectInheritance : KotlinClass() {
+    fun foo2() {
+        super.test()
+        super.property
+
+        super.testNonDefault()
+        super.propertyNonDefault
+
+        object  {
+            fun run () {
+                super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>property<!>
+
+                super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+            }
+        }
+
+    }
+
+    val property2: String
+        get() {
+            super.test()
+            super.property
+
+            super.testNonDefault()
+            super.propertyNonDefault
+
+            object  {
+                fun run () {
+                    super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                    super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>property<!>
+
+                    super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                    super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+                }
+            }
+            return ""
+        }
+}
+
+class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance {
+    fun foo() {
+        super.test()
+        super.property
+
+        super.testNonDefault()
+        super.propertyNonDefault
+
+        object  {
+            fun run () {
+                super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>test<!>()
+                super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>property<!>
+
+                super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+            }
+        }
+    }
+
+    val xproperty: String
+        get() {
+            super.test()
+            super.property
+
+            super.testNonDefault()
+            super.propertyNonDefault
+
+            object  {
+                fun run () {
+                    super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>test<!>()
+                    super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>property<!>
+
+                    super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>testNonDefault<!>()
+                    super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>propertyNonDefault<!>
+                }
+            }
+            return ""
+        }
+}
+
+fun test() {
+    KotlinClass().test()
+    KotlinClass().property
+    KotlinClass().propertyNonDefault
+    KotlinClassIndirectInheritance2().test()
+    KotlinClassIndirectInheritance2().testNonDefault()
+    KotlinClassIndirectInheritance2().propertyyy
+    KotlinClassIndirectInheritance2().propertyyyNonDefault
+
+    KotlinClass().test()
+    KotlinClass().testNonDefault()
+    KotlinClass().property
+    KotlinClass().propertyNonDefault
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultsWithJava.fir.kt

@@ -0,0 +1,162 @@
+// !JVM_DEFAULT_MODE: enable
+// !JVM_TARGET: 1.8
+// FILE: JavaInterface.java
+
+public interface JavaInterface {
+    default String test() {
+        return "OK";
+    }
+
+    default String testOverride() {
+        return "OK";
+    }
+}
+
+// FILE: 1.kt
+
+interface KotlinInterface : JavaInterface {
+    @JvmDefault
+    fun fooo() {
+        super.test()
+
+        object  {
+            fun run () {
+                super@KotlinInterface.<!UNRESOLVED_REFERENCE!>test<!>()
+            }
+        }
+    }
+
+    @JvmDefault
+    val propertyy: String
+        get() {
+            super.test()
+
+            object  {
+                fun run () {
+                    super@KotlinInterface.<!UNRESOLVED_REFERENCE!>test<!>()
+                }
+            }
+            return ""
+        }
+
+    @JvmDefault
+    override fun testOverride(): String {
+        return "OK";
+    }
+}
+
+interface KotlinInterfaceIndirectInheritance : KotlinInterface {
+    @JvmDefault
+    fun foooo() {
+        super.test()
+
+        object  {
+            fun run () {
+                super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+            }
+        }
+    }
+
+    @JvmDefault
+    val propertyyy: String
+        get() {
+            super.test()
+
+            object  {
+                fun run () {
+                    super@KotlinInterfaceIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                }
+            }
+            return ""
+        }
+}
+
+open class KotlinClass : JavaInterface {
+    fun foo() {
+        super.test()
+        super.testOverride()
+
+        object  {
+            fun run () {
+                super@KotlinClass.<!UNRESOLVED_REFERENCE!>test<!>()
+            }
+        }
+    }
+
+    val property: String
+        get() {
+            super.test()
+            super.testOverride()
+
+            object  {
+                fun run () {
+                    super@KotlinClass.<!UNRESOLVED_REFERENCE!>test<!>()
+                }
+            }
+            return ""
+        }
+}
+
+class KotlinClassIndirectInheritance : KotlinClass() {
+    fun foo2() {
+        super.test()
+        super.testOverride()
+
+        object  {
+            fun run () {
+                super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+            }
+        }
+    }
+
+    val property2: String
+        get() {
+            super.test()
+            super.testOverride()
+
+            object  {
+                fun run () {
+                    super@KotlinClassIndirectInheritance.<!UNRESOLVED_REFERENCE!>test<!>()
+                }
+            }
+            return ""
+        }
+}
+
+class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance {
+    fun foo() {
+        super.test()
+        super.testOverride()
+
+        object  {
+            fun run () {
+                super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>test<!>()
+            }
+        }
+    }
+
+    val property: String
+        get() {
+            super.test()
+            super.testOverride()
+
+            object  {
+                fun run () {
+                    super@KotlinClassIndirectInheritance2.<!UNRESOLVED_REFERENCE!>test<!>()
+                }
+            }
+            return ""
+        }
+}
+
+fun test() {
+    KotlinClass().foo()
+    KotlinClass().property
+    KotlinClassIndirectInheritance2().foo()
+    KotlinClassIndirectInheritance2().property
+
+    KotlinClass().test()
+    KotlinClass().property
+    KotlinClass().testOverride()
+    KotlinClassIndirectInheritance().testOverride()
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/noJvmDefaultFlag.fir.kt

@@ -0,0 +1,29 @@
+// !JVM_TARGET: 1.8
+
+interface B {
+
+    @JvmDefault
+    fun test() {}
+
+    @JvmDefault
+    abstract fun test2(s: String = "")
+
+    @JvmDefault
+    abstract fun test3()
+
+
+    @JvmDefault
+    abstract val prop: String
+
+    @JvmDefault
+    abstract val prop2: String
+
+    @JvmDefault
+    val prop3: String
+        get() = ""
+
+    @JvmDefault
+    var prop4: String
+        get() = ""
+        set(value) {}
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/notInterface.fir.kt

@@ -0,0 +1,22 @@
+// !JVM_TARGET: 1.8
+
+abstract class A {
+
+    @JvmDefault
+    fun test() {}
+
+    @JvmDefault
+    abstract fun test2(s: String = "")
+
+    @JvmDefault
+    abstract fun test3()
+}
+
+object B {
+
+    @JvmDefault
+    fun test() {}
+
+    @JvmDefault
+    fun test2(s: String = "") {}
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/propertyAccessor.fir.kt

@@ -0,0 +1,14 @@
+// !JVM_TARGET: 1.8
+// !JVM_DEFAULT_MODE: enable
+
+interface B {
+
+    @JvmDefault
+    val prop1: String
+    @JvmDefault get() = ""
+
+
+    var prop2: String
+        @JvmDefault get() = ""
+        @JvmDefault set(value) {}
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/simpleOverride.fir.kt

@@ -0,0 +1,31 @@
+// !JVM_TARGET: 1.8
+// !JVM_DEFAULT_MODE: enable
+
+interface A {
+    @JvmDefault
+    fun test() {}
+}
+
+interface Abstract : A {
+    override fun test()
+}
+
+interface ANonDefault {
+    fun test() {}
+}
+
+interface B: A {
+    override fun test() {}
+}
+
+interface C: ANonDefault, A {
+    override fun test() {}
+}
+
+interface D: A, ANonDefault {
+    override fun test() {}
+}
+
+class Foo : A {
+    override fun test() {}
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/simplePropertyOverride.fir.kt

@@ -0,0 +1,32 @@
+// !JVM_TARGET: 1.8
+// !JVM_DEFAULT_MODE: enable
+
+interface A {
+    @JvmDefault
+    val test: String
+        get() = "OK"
+}
+
+interface Abstract : A {
+    override val test: String
+}
+
+interface ANonDefault {
+    val test: String
+        get() = "ANonDefault"
+}
+
+interface B: A {
+    override val test: String
+        get() = "B"
+}
+
+interface C: ANonDefault, A {
+    override val test: String
+        get() = "C"
+}
+
+interface D: A, ANonDefault {
+    override val test: String
+        get() = "C"
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.fir.kt

@@ -0,0 +1,62 @@
+// !JVM_TARGET: 1.8
+// FILE: 1.kt
+interface A {
+    @JvmDefault
+    fun test() {
+    }
+}
+
+// FILE: 2.kt
+interface B : A {
+
+}
+
+interface C : B {
+    @JvmDefault
+    override fun test() {
+        super.test()
+    }
+}
+
+open class Foo : B {
+    override fun test() {
+        super.test()
+    }
+}
+open class Foo2 : B
+
+open class Bar : Foo2() {
+    override fun test() {
+        super.test()
+    }
+}
+
+open class Bar2 : Bar() {
+    override fun test() {
+        super.test()
+    }
+}
+
+class ManySupers: Foo2(), B {
+    fun foo() {
+        super<Foo2>.test()
+        super<B>.test()
+        super.test()
+    }
+}
+
+class ManySupers2: Foo2(), C {
+    fun foo() {
+        super<Foo2>.test()
+        super<C>.test()
+        super.test()
+    }
+}
+
+class ManySupers3: Bar2(), C {
+    fun foo() {
+        super<Bar2>.test()
+        super<C>.test()
+        super.test()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity.fir.kt

@@ -0,0 +1,32 @@
+// !JVM_TARGET: 1.8
+interface A {
+    @JvmDefault
+    fun test() {
+    }
+}
+
+interface B{
+    fun test() {
+    }
+}
+
+interface AB: A, B
+
+interface BA: B, A
+
+
+interface C : A, B {
+    @JvmDefault
+    override fun test() {
+        super<B>.test()
+        super<A>.test()
+    }
+}
+
+interface D : B, A {
+    @JvmDefault
+    override fun test() {
+        super<B>.test()
+        super<A>.test()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity2.fir.kt

@@ -0,0 +1,32 @@
+// !JVM_TARGET: 1.8
+interface A {
+    @JvmDefault
+    fun test()
+}
+
+interface B{
+    fun test() {
+    }
+}
+
+interface AB: A, B
+
+interface BA: B, A
+
+class C : A, B {
+    override fun test() {
+        super<B>.test()
+    }
+}
+
+class D : B, A {
+    override fun test() {
+        super<B>.test()
+    }
+}
+
+class E: B, A {
+    fun foo() {
+        super<B>.test()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity3.fir.kt

@@ -0,0 +1,31 @@
+// !JVM_TARGET: 1.8
+interface A {
+    @JvmDefault
+    fun test() {
+
+    }
+}
+
+interface B{
+    fun test()
+}
+interface AB : A, B
+interface BA : B, A
+
+class C : A, B {
+    override fun test() {
+        super<A>.test()
+    }
+}
+
+class D : B, A {
+    override fun test() {
+        super<A>.test()
+    }
+}
+
+class E: B, A {
+    fun foo() {
+        super<A>.test()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/target6.fir.kt

@@ -0,0 +1,29 @@
+// !JVM_TARGET: 1.6
+
+interface B {
+
+    @JvmDefault
+    fun test() {}
+
+    @JvmDefault
+    abstract fun test2(s: String = "")
+
+    @JvmDefault
+    abstract fun test3()
+
+
+    @JvmDefault
+    abstract val prop: String
+
+    @JvmDefault
+    abstract val prop2: String
+
+    @JvmDefault
+    val prop3: String
+        get() = ""
+
+    @JvmDefault
+    var prop4: String
+        get() = ""
+        set(value) {}
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/target8.fir.kt

@@ -0,0 +1,30 @@
+// !JVM_TARGET: 1.8
+// !JVM_DEFAULT_MODE: enable
+
+interface B {
+
+    @JvmDefault
+    fun test() {}
+
+    @JvmDefault
+    abstract fun test2(s: String = "")
+
+    @JvmDefault
+    abstract fun test3()
+
+
+    @JvmDefault
+    abstract val prop: String
+
+    @JvmDefault
+    abstract val prop2: String
+
+    @JvmDefault
+    val prop3: String
+        get() = ""
+
+    @JvmDefault
+    var prop4: String
+        get() = ""
+        set(value) {}
+}