Add new tests

2020-02-04 10:57:33 +01:00
parent 0570c05683
commit 0c0bd67a6b
50 changed files with 1959 additions and 1 deletions
@@ -14901,6 +14901,89 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                runTest("compiler/testData/codegen/box/jvm8/defaults/superCall.kt");
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractFirBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_IR, testDataFilePath, "// IGNORE_BACKEND_FIR: ");
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("callStackTrace.kt")
+                public void testCallStackTrace() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/callStackTrace.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -15002,6 +15085,84 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                }
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NoDefaultImpls extends AbstractFirBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_IR, testDataFilePath, "// IGNORE_BACKEND_FIR: ");
+                }
+
+                public void testAllFilesPresentInNoDefaultImpls() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDelegation")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -0,0 +1,38 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.test2(this, "OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+
+fun box(): String {
+
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2("OK")
+}
@@ -0,0 +1,35 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.test2(this, "OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String test2(String p) {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,39 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface3 {
+    default String test() {
+        return KInterface3.DefaultImpls.test2(this, "OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String test2(String p) {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+interface KInterface3 : KInterface2 {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,42 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.getBar(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    override val foo: String
+        get() = "OK"
+}
+
+
+fun box(): String {
+
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().bar
+
+}
@@ -0,0 +1,39 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.getBar(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String getBar() {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    override val foo: String
+        get() = "OK"
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,41 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface3 {
+    default String test() {
+        return KInterface3.DefaultImpls.getBar(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    override val foo: String
+        get() = "OK"
+}
+
+interface KInterface3 : KInterface2 {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,43 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+// FILE: Simple.java
+
+public interface Simple extends KInterface {
+    default java.util.List<String> compatibilityCall() {
+        return KInterface.DefaultImpls.call(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface  {
+    fun call(): List<String> {
+        return Thread.currentThread().getStackTrace().map { it.className + "." + it.methodName }
+    }
+}
+
+
+fun box(): String {
+    var result = Foo().compatibilityCall()
+    if (result[1] != "KInterface.call") return "fail 1: ${result[1]}"
+    if (result[2] != "KInterface.access\$call\$jd") return "fail 2: ${result[2]}"
+    if (result[3] != "KInterface\$DefaultImpls.call") return "fail 3: ${result[3]}"
+    if (result[4] != "Simple.compatibilityCall") return "fail 4: ${result[4]}"
+    if (result[5] != "MainKt.box") return "fail 5: ${result[5]}"
+
+    result = Foo().call()
+    if (result[1] != "KInterface.call") return "fail 1: ${result[1]}"
+    if (result[2] != "MainKt.box") return "fail 2: ${result[2]}"
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+interface Test {
+    fun test(s: String ="OK"): String {
+        return s
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    val defaultImpls = java.lang.Class.forName(Test::class.java.canonicalName + "\$DefaultImpls")
+
+    val declaredMethod = defaultImpls.getDeclaredMethod("test\$default", Test::class.java, String::class.java, Int::class.java, Any::class.java)
+    return declaredMethod.invoke(null, TestClass(), null, 1, null) as String
+}
@@ -0,0 +1,16 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface A {
+    fun foo(x: String = "OK"): String {
+        return x
+    }
+}
+
+fun box(): String {
+    val x = object : A {}
+    return x.foo()
+}
@@ -0,0 +1,12 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+interface I {
+    fun foo(x: String = "OK"): String = x
+}
+
+interface J : I
+
+object O : J
+
+fun box(): String = O.foo()
@@ -0,0 +1,37 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.test2(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface  {
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+interface KInterface2 : KInterface {
+
+}
+
+
+fun box(): String {
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2()
+}
@@ -0,0 +1,13 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// !JVM_DEFAULT_MODE: all-compatibility
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+interface A {
+    fun String.foo(k: String) = "O" + k
+}
+
+fun box(): String =
+    object : A {
+        fun box() = "FAIL".foo("K")
+    }.box()
@@ -0,0 +1,24 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+
+annotation class Property(val value: String)
+annotation class Accessor(val value: String)
+
+interface Z {
+    @Property("OK")
+    val z: String
+        @Accessor("OK")
+        get() = "OK"
+}
+
+
+class Test : Z
+
+fun box() : String {
+    val value = Z::z.annotations.filterIsInstance<Property>().single().value
+    if (value != "OK") return value
+    return (Z::z.getter.annotations.single() as Accessor).value
+}
@@ -0,0 +1,33 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface {
+    default String test() {
+        return KInterface.DefaultImpls.test2(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface  {
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+
+fun box(): String {
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2()
+}
@@ -1,7 +1,9 @@
 // !JVM_DEFAULT_MODE: compatibility
 // TARGET_BACKEND: JVM
-
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
 interface I {
+    @JvmDefault
    fun foo(x: String = "OK"): String = x
 }

@@ -0,0 +1,38 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.super.test2("OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+
+fun box(): String {
+
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2("OK")
+}
@@ -0,0 +1,35 @@
+// !JVM_DEFAULT_MODE: all
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.super.test2("OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String test2(String p) {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,39 @@
+// !JVM_DEFAULT_MODE: all
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface3 {
+    default String test() {
+        return KInterface3.super.test2("OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String test2(String p) {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+interface KInterface3 : KInterface2 {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,42 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return getBar();
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    override val foo: String
+        get() = "OK"
+}
+
+
+fun box(): String {
+
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().bar
+
+}
@@ -0,0 +1,39 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.super.getBar();
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String getBar() {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    override val foo: String
+        get() = "OK"
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,41 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface3 {
+    default String test() {
+        return getBar();
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    override val foo: String
+        get() = "OK"
+}
+
+interface KInterface3 : KInterface2 {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}
@@ -0,0 +1,24 @@
+// !JVM_DEFAULT_MODE: all
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+interface Test {
+    fun test(s: String ="OK"): String {
+        return s
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    try {
+        val defaultImpls = java.lang.Class.forName(Test::class.java.canonicalName + "\$DefaultImpls")
+    } catch (e: ClassNotFoundException) {
+        return "OK"
+    }
+    return "fail: DefaultImpls shouldn't be generated"
+}
@@ -0,0 +1,16 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface A {
+    fun foo(x: String = "OK"): String {
+        return x
+    }
+}
+
+fun box(): String {
+    val x = object : A {}
+    return x.foo()
+}
@@ -0,0 +1,12 @@
+// !JVM_DEFAULT_MODE: all
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+interface I {
+    fun foo(x: String = "OK"): String = x
+}
+
+interface J : I
+
+object O : J
+
+fun box(): String = O.foo()
@@ -0,0 +1,37 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return test2();
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface  {
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+interface KInterface2 : KInterface {
+
+}
+
+
+fun box(): String {
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2()
+}
@@ -0,0 +1,13 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// !JVM_DEFAULT_MODE: all
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+interface A {
+    fun String.foo(k: String) = "O" + k
+}
+
+fun box(): String =
+    object : A {
+        fun box() = "FAIL".foo("K")
+    }.box()
@@ -0,0 +1,24 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+
+annotation class Property(val value: String)
+annotation class Accessor(val value: String)
+
+interface Z {
+    @Property("OK")
+    val z: String
+        @Accessor("OK")
+        get() = "OK"
+}
+
+
+class Test : Z
+
+fun box() : String {
+    val value = Z::z.annotations.filterIsInstance<Property>().single().value
+    if (value != "OK") return value
+    return (Z::z.getter.annotations.single() as Accessor).value
+}
@@ -0,0 +1,33 @@
+// !JVM_DEFAULT_MODE: all
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface {
+    default String test() {
+        return test2();
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface  {
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+
+fun box(): String {
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2()
+}
@@ -0,0 +1,19 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// FULL_JDK
+
+interface KInterface {
+
+    fun test(s: String ="OK"): String {
+        return s
+    }
+}
+
+// 1 INVOKESTATIC KInterface.access\$test\$jd
+// 1 INVOKESTATIC KInterface.test\$default
+
+// from $default
+// 1 INVOKEINTERFACE KInterface.test
+
+//from $jd
+// 1 INVOKESPECIAL KInterface.test
@@ -0,0 +1,22 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+
+interface A {
+
+    fun foo() = "FAIL"
+}
+
+interface Left : A { }
+interface Right : A {
+
+    override fun foo() = "OK"
+}
+
+interface C : Left, Right {}
+
+fun box(): String {
+    val x = object : C {}
+    return x.foo()
+}
+
+// 0 INVOKESTATIC .*\$DefaultImpls\.foo
@@ -0,0 +1,18 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+
+interface KInterface  {
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+interface KInterface2 : KInterface  {
+
+}
+
+// 1 INVOKESTATIC KInterface2.access\$test2\$jd
+// 1 INVOKESTATIC KInterface.access\$test2\$jd
+
+// 1 INVOKESPECIAL KInterface2.test2
+// 1 INVOKESPECIAL KInterface.test2
@@ -0,0 +1,21 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+
+interface KInterface  {
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+interface KInterface2 : KInterface  {
+    abstract override fun test2(): String
+}
+
+// 1 INVOKESTATIC KInterface.access\$test2\$jd
+// +
+// 0 INVOKESTATIC KInterface2.access\$test2\$jd
+// =
+// 1 INVOKESTATIC KInterface
+
+// 1 INVOKESPECIAL KInterface.test2
+// 0 INVOKESPECIAL KInterface2.test2
@@ -0,0 +1,23 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+
+interface KInterface {
+
+    var bar: String
+        get() = "OK"
+        set(field) {}
+}
+
+interface KInterface2 : KInterface {
+
+}
+
+// 1 INVOKESTATIC KInterface2.access\$getBar\$jd
+// 1 INVOKESTATIC KInterface2.access\$setBar\$jd
+// 1 INVOKESTATIC KInterface.access\$getBar\$jd
+// 1 INVOKESTATIC KInterface.access\$setBar\$jd
+
+// 1 INVOKESPECIAL KInterface2.getBar
+// 1 INVOKESPECIAL KInterface2.setBar
+// 1 INVOKESPECIAL KInterface.getBar
+// 1 INVOKESPECIAL KInterface.setBar
@@ -0,0 +1,34 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// FULL_JDK
+// FILE: 1.kt
+interface KInterface  {
+    fun call(): List<String> {
+        return Thread.currentThread().getStackTrace().map { it.className + "." + it.methodName }
+    }
+
+    fun superCall()  = Thread.currentThread().getStackTrace().map { it.className + "." + it.methodName }
+}
+
+// FILE: main.kt
+interface KInterface2 : KInterface  {
+
+}
+
+class Foo: KInterface2 {
+    fun superCall2() = super<KInterface2>.superCall()
+}
+
+fun box(): String {
+    var result = Foo().call()
+    if (result[1] != "KInterface.call") return "fail 1: ${result[1]}"
+    if (result[2] != "MainKt.box") return "fail 2: ${result[2]}"
+
+    result = Foo().superCall2()
+    if (result[1] != "KInterface.superCall") return "fail 1: ${result[1]}"
+    if (result[2] != "Foo.superCall2") return "fail 2: ${result[2]}"
+    if (result[3] != "MainKt.box") return "fail 3: ${result[3]}"
+
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FILE: 1.kt
+interface Test {
+    fun test(): String {
+        return "OK"
+    }
+}
+
+// FILE: 2.kt
+class TestClass : Test {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return TestClass().test()
+}
@@ -0,0 +1,21 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FILE: 1.kt
+interface Test {
+    fun test(): String {
+        return "OK"
+    }
+}
+
+// FILE: 2.kt
+
+interface Test2 : Test {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return object : Test2 {}.test()
+}
@@ -0,0 +1,25 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FILE: 1.kt
+interface Test {
+    fun test(): String {
+        return "OK"
+    }
+
+    fun defaultImplTrigger(): String {
+        return "OK"
+    }
+}
+
+// FILE: 2.kt
+
+interface Test2 : Test {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return object : Test2 {}.test()
+}
@@ -0,0 +1,18 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FILE: 1.kt
+interface Test {
+    val prop: String
+        get() =  "OK"
+}
+
+// FILE: 2.kt
+class TestClass : Test {
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return TestClass().prop
+}
@@ -0,0 +1,18 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FILE: 1.kt
+interface Test {
+    val prop: String
+        get() =  "OK"
+}
+
+// FILE: 2.kt
+interface Test2 : Test {
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return object : Test2 {}.prop
+}
@@ -0,0 +1,21 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FILE: 1.kt
+interface Test {
+    val prop: String
+        get() =  "OK"
+
+    val defaultImplTrigger: String
+        get() =  "OK"
+}
+
+// FILE: 2.kt
+interface Test2 : Test {
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return object : Test2 {}.prop
+}
@@ -16116,6 +16116,89 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                runTest("compiler/testData/codegen/box/jvm8/defaults/superCall.kt");
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("callStackTrace.kt")
+                public void testCallStackTrace() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/callStackTrace.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -16217,6 +16300,84 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                }
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NoDefaultImpls extends AbstractBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNoDefaultImpls() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDelegation")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -3193,6 +3193,44 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest {
                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
            }

+            @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractBytecodeTextTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/defaultArgs.kt");
+                }
+
+                @TestMetadata("simpleDiamond.kt")
+                public void testSimpleDiamond() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleDiamond.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleFunction.kt");
+                }
+
+                @TestMetadata("simpleFunctionWithAbstractOverride.kt")
+                public void testSimpleFunctionWithAbstractOverride() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleFunctionWithAbstractOverride.kt");
+                }
+
+                @TestMetadata("simpleProperty.kt")
+                public void testSimpleProperty() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleProperty.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -411,6 +411,54 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl
            public void testSuperPropAccessFromInterface2() throws Exception {
                runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface2.kt");
            }
+
+            @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractCompileKotlinAgainstKotlinTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, this, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, true);
+                }
+
+                @TestMetadata("callStackTrace.kt")
+                public void testCallStackTrace() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/callStackTrace.kt");
+                }
+
+                @TestMetadata("superCall.kt")
+                public void testSuperCall() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCall.kt");
+                }
+
+                @TestMetadata("superCallFromInterface.kt")
+                public void testSuperCallFromInterface() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface.kt");
+                }
+
+                @TestMetadata("superCallFromInterface2.kt")
+                public void testSuperCallFromInterface2() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface2.kt");
+                }
+
+                @TestMetadata("superPropAccess.kt")
+                public void testSuperPropAccess() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccess.kt");
+                }
+
+                @TestMetadata("superPropAccessFromInterface.kt")
+                public void testSuperPropAccessFromInterface() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface.kt");
+                }
+
+                @TestMetadata("superPropAccessFromInterface2.kt")
+                public void testSuperPropAccessFromInterface2() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface2.kt");
+                }
+            }
        }

        @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6")
@@ -16116,6 +16116,89 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                runTest("compiler/testData/codegen/box/jvm8/defaults/superCall.kt");
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractLightAnalysisModeTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("callStackTrace.kt")
+                public void testCallStackTrace() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/callStackTrace.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -16217,6 +16300,84 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                }
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NoDefaultImpls extends AbstractLightAnalysisModeTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNoDefaultImpls() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDelegation")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -14901,6 +14901,89 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                runTest("compiler/testData/codegen/box/jvm8/defaults/superCall.kt");
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractIrBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("callStackTrace.kt")
+                public void testCallStackTrace() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/callStackTrace.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -15002,6 +15085,84 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                }
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NoDefaultImpls extends AbstractIrBlackBoxCodegenTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNoDefaultImpls() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @TestMetadata("bridge.kt")
+                public void testBridge() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge.kt");
+                }
+
+                @TestMetadata("bridge2.kt")
+                public void testBridge2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge2.kt");
+                }
+
+                @TestMetadata("bridge3.kt")
+                public void testBridge3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridge3.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties.kt")
+                public void testBridgeWithProperties() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties2.kt")
+                public void testBridgeWithProperties2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties2.kt");
+                }
+
+                @TestMetadata("bridgeWithProperties3.kt")
+                public void testBridgeWithProperties3() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/bridgeWithProperties3.kt");
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgs.kt");
+                }
+
+                @TestMetadata("defaultArgsViaAnonymousObject.kt")
+                public void testDefaultArgsViaAnonymousObject() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/defaultArgsViaAnonymousObject.kt");
+                }
+
+                @TestMetadata("inheritedFunctionWithDefaultParameters.kt")
+                public void testInheritedFunctionWithDefaultParameters() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedFunctionWithDefaultParameters.kt");
+                }
+
+                @TestMetadata("inheritedJvmDefault.kt")
+                public void testInheritedJvmDefault() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/inheritedJvmDefault.kt");
+                }
+
+                @TestMetadata("interfaceExtension.kt")
+                public void testInterfaceExtension() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/interfaceExtension.kt");
+                }
+
+                @TestMetadata("propertyAnnotation.kt")
+                public void testPropertyAnnotation() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/propertyAnnotation.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/simpleFunction.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDelegation")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -3238,6 +3238,44 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest {
                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
            }

+            @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractIrBytecodeTextTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @TestMetadata("defaultArgs.kt")
+                public void testDefaultArgs() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/defaultArgs.kt");
+                }
+
+                @TestMetadata("simpleDiamond.kt")
+                public void testSimpleDiamond() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleDiamond.kt");
+                }
+
+                @TestMetadata("simpleFunction.kt")
+                public void testSimpleFunction() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleFunction.kt");
+                }
+
+                @TestMetadata("simpleFunctionWithAbstractOverride.kt")
+                public void testSimpleFunctionWithAbstractOverride() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleFunctionWithAbstractOverride.kt");
+                }
+
+                @TestMetadata("simpleProperty.kt")
+                public void testSimpleProperty() throws Exception {
+                    runTest("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility/simpleProperty.kt");
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -406,6 +406,54 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile
            public void testSuperPropAccessFromInterface2() throws Exception {
                runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface2.kt");
            }
+
+            @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractIrCompileKotlinAgainstKotlinTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @TestMetadata("callStackTrace.kt")
+                public void testCallStackTrace() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/callStackTrace.kt");
+                }
+
+                @TestMetadata("superCall.kt")
+                public void testSuperCall() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCall.kt");
+                }
+
+                @TestMetadata("superCallFromInterface.kt")
+                public void testSuperCallFromInterface() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface.kt");
+                }
+
+                @TestMetadata("superCallFromInterface2.kt")
+                public void testSuperCallFromInterface2() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface2.kt");
+                }
+
+                @TestMetadata("superPropAccess.kt")
+                public void testSuperPropAccess() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccess.kt");
+                }
+
+                @TestMetadata("superPropAccessFromInterface.kt")
+                public void testSuperPropAccessFromInterface() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface.kt");
+                }
+
+                @TestMetadata("superPropAccessFromInterface2.kt")
+                public void testSuperPropAccessFromInterface2() throws Exception {
+                    runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface2.kt");
+                }
+            }
        }

        @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6")
@@ -12596,6 +12596,19 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractIrJsCodegenBoxTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -12622,6 +12635,19 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                }
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NoDefaultImpls extends AbstractIrJsCodegenBoxTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNoDefaultImpls() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDelegation")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -12661,6 +12661,19 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true);
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class AllCompatibility extends AbstractJsCodegenBoxTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInAllCompatibility() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true);
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/compatibility")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)
@@ -12687,6 +12700,19 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                }
            }

+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NoDefaultImpls extends AbstractJsCodegenBoxTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNoDefaultImpls() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true);
+                }
+            }
+
            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDelegation")
            @TestDataPath("$PROJECT_ROOT")
            @RunWith(JUnit3RunnerWithInners.class)