diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt
index 08a4731e3c1d4..7bebf2acf00b7 100644
--- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt
+++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt
@@ -350,6 +350,9 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
     )
     var jvmDefault: String by FreezableVar(JvmDefaultMode.DEFAULT.description)
 
+    @Argument(value = "-Xjvm-default-allow-non-default-inheritance", description = "Allow inheritance from 'all*' modes for 'disable' one")
+    var jvmDefaultAllowDisableAgainstAll: Boolean by FreezableVar(false)
+
     @Argument(
         value = "-Xdefault-script-extension",
         valueDescription = "<script filename extension>",
@@ -549,6 +552,7 @@ default: `indy-with-constants` for JVM target 9 or greater, `inline` otherwise""
         result[AnalysisFlags.allowUnstableDependencies] = allowUnstableDependencies || useFir
         result[JvmAnalysisFlags.disableUltraLightClasses] = disableUltraLightClasses
         result[JvmAnalysisFlags.useIR] = !useOldBackend
+        result[JvmAnalysisFlags.jvmDefaultAllowNonDefaultInheritance] = jvmDefaultAllowDisableAgainstAll
         return result
     }
 
diff --git a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt
index e4278e6d7cedd..0fa6c90274674 100644
--- a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt
+++ b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt
@@ -18,6 +18,9 @@ object JvmAnalysisFlags {
     @JvmStatic
     val jvmDefaultMode by Delegates.JvmDefaultModeDisabledByDefault
 
+    @JvmStatic
+    val jvmDefaultAllowNonDefaultInheritance by AnalysisFlag.Delegates.Boolean
+
     @JvmStatic
     val inheritMultifileParts by AnalysisFlag.Delegates.Boolean
 
diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java
index 99447a1089806..9b075d728c4d7 100644
--- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java
+++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java
@@ -24723,6 +24723,40 @@ public void testNoDelegationToDefaultMethodInInterface2() throws Exception {
                 }
             }
 
+            @Nested
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            public class NonDefaultInheritance {
+                @Test
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @Test
+                @TestMetadata("simple.kt")
+                public void testSimple() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt");
+                }
+
+                @Test
+                @TestMetadata("simple2.kt")
+                public void testSimple2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt");
+                }
+
+                @Test
+                @TestMetadata("specialization.kt")
+                public void testSpecialization() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt");
+                }
+
+                @Test
+                @TestMetadata("superCall.kt")
+                public void testSuperCall() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt");
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt
index 881880e7bf522..fba69507d4827 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt
@@ -33,6 +33,7 @@ class JvmDefaultChecker(private val jvmTarget: JvmTarget, private val project: P
 
     override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) {
         val jvmDefaultMode = context.languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)
+        val allowNonDefaultInheritance = context.languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultAllowNonDefaultInheritance)
 
         val jvmDefaultAnnotation = descriptor.annotations.findAnnotation(JVM_DEFAULT_FQ_NAME)
         jvmDefaultAnnotation?.let { annotationDescriptor ->
@@ -60,13 +61,15 @@ class JvmDefaultChecker(private val jvmTarget: JvmTarget, private val project: P
             }
         }
 
-        if (descriptor is ClassDescriptor) {
-            val hasDeclaredJvmDefaults =
-                descriptor.unsubstitutedMemberScope.getContributedDescriptors().filterIsInstance<CallableMemberDescriptor>().any {
-                    it.kind.isReal && it.isCompiledToJvmDefault(jvmDefaultMode)
+        if (!allowNonDefaultInheritance) {
+            if (descriptor is ClassDescriptor) {
+                val hasDeclaredJvmDefaults =
+                    descriptor.unsubstitutedMemberScope.getContributedDescriptors().filterIsInstance<CallableMemberDescriptor>().any {
+                        it.kind.isReal && it.isCompiledToJvmDefault(jvmDefaultMode)
+                    }
+                if (!hasDeclaredJvmDefaults && !checkJvmDefaultsInHierarchy(descriptor, jvmDefaultMode)) {
+                    context.trace.report(ErrorsJvm.JVM_DEFAULT_THROUGH_INHERITANCE.on(declaration))
                 }
-            if (!hasDeclaredJvmDefaults && !checkJvmDefaultsInHierarchy(descriptor, jvmDefaultMode)) {
-                context.trace.report(ErrorsJvm.JVM_DEFAULT_THROUGH_INHERITANCE.on(declaration))
             }
         }
 
diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt
index 43ee90e40f2ff..0a1f84cc493c7 100644
--- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt
+++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt
@@ -71,6 +71,7 @@ class LanguageVersionSettingsBuilder {
             analysisFlag(AnalysisFlags.allowKotlinPackage, trueOrNull(LanguageSettingsDirectives.ALLOW_KOTLIN_PACKAGE in directives)),
 
             analysisFlag(JvmAnalysisFlags.jvmDefaultMode, directives.singleOrZeroValue(LanguageSettingsDirectives.JVM_DEFAULT_MODE)),
+            analysisFlag(JvmAnalysisFlags.jvmDefaultAllowNonDefaultInheritance, trueOrNull(LanguageSettingsDirectives.JVM_DEFAULT_ALLOW_NON_DEFAULT_INHERITANCE in directives)),
             analysisFlag(JvmAnalysisFlags.inheritMultifileParts, trueOrNull(LanguageSettingsDirectives.INHERIT_MULTIFILE_PARTS in directives)),
             analysisFlag(JvmAnalysisFlags.sanitizeParentheses, trueOrNull(LanguageSettingsDirectives.SANITIZE_PARENTHESES in directives)),
             analysisFlag(JvmAnalysisFlags.enableJvmPreview, trueOrNull(LanguageSettingsDirectives.ENABLE_JVM_PREVIEW in directives)),
diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt
index 26de582f4f15d..9e2cc65b3d488 100644
--- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt
+++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt
@@ -63,6 +63,10 @@ object LanguageSettingsDirectives : SimpleDirectivesContainer() {
         additionalParser = JvmDefaultMode.Companion::fromStringOrNull
     )
 
+    val JVM_DEFAULT_ALLOW_NON_DEFAULT_INHERITANCE by directive(
+        description = "Configures corresponding analysis flag (JvmAnalysisFlags.jvmDefaultAllowNonDefaultInheritance)",
+    )
+
     val INHERIT_MULTIFILE_PARTS by directive(
         description = "Enables corresponding analysis flag (JvmAnalysisFlags.inheritMultifileParts)"
     )
diff --git a/compiler/testData/cli/jvm/extraHelp.out b/compiler/testData/cli/jvm/extraHelp.out
index 7621fb5070451..3e755f14f7832 100644
--- a/compiler/testData/cli/jvm/extraHelp.out
+++ b/compiler/testData/cli/jvm/extraHelp.out
@@ -75,6 +75,8 @@ where advanced options include:
                                                               (annotating an existing method can break binary compatibility)
                              -Xjvm-default=compatibility      Allow usages of @JvmDefault; generate a compatibility accessor
                                                               in the 'DefaultImpls' class in addition to the default interface method
+  -Xjvm-default-allow-non-default-inheritance
+                             Allow inheritance from 'all*' modes for 'disable' one
   -Xklib=<path>              Paths to cross-platform libraries in .klib format
   -Xlambdas={class|indy}     Select code generation scheme for lambdas.
                              -Xlambdas=indy                      Generate lambdas using `invokedynamic` with `LambdaMetafactory.metafactory`. Requires `-jvm-target 1.8` or greater.
diff --git a/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt
new file mode 100644
index 0000000000000..f0e9e8ac5b1c3
--- /dev/null
+++ b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt
@@ -0,0 +1,57 @@
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// FULL_JDK
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// !JVM_DEFAULT_MODE: all
+// FILE: Foo.kt
+
+interface Foo {
+    fun toOverride(): String = "fail"
+    
+    fun nonOverride(): String = "K"
+}
+
+// MODULE: main(lib)
+// !JVM_DEFAULT_MODE: disable
+// !JVM_DEFAULT_ALLOW_NON_DEFAULT_INHERITANCE
+// FILE: main.kt
+
+interface Derived : Foo {
+    override fun toOverride(): String {
+        return "O"
+    }
+}
+
+class DerivedClass : Derived 
+
+
+fun box(): String {
+    checkMethodExists(DerivedClass::class.java, "toOverride")
+    checkNoMethod(DerivedClass::class.java, "nonOverride")
+
+    val value = DerivedClass()
+    return value.toOverride() + value.nonOverride()
+}
+
+fun checkNoMethod(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+    }
+    catch (e: NoSuchMethodException) {
+        return
+    }
+    throw AssertionError("fail: method $name was found in " + clazz)
+}
+
+fun checkMethodExists(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+        return
+    }
+    catch (e: NoSuchMethodException) {
+        throw AssertionError("fail: method $name was not found in " + clazz, e)
+    }
+
+}
diff --git a/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt
new file mode 100644
index 0000000000000..d87fa2c5e1253
--- /dev/null
+++ b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt
@@ -0,0 +1,39 @@
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// FULL_JDK
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// !JVM_DEFAULT_MODE: all
+// FILE: Foo.kt
+
+interface Foo {
+    fun toOverride(): List<String> = null!!
+    
+    fun nonOverride(): List<String> = Thread.currentThread().getStackTrace().map { it.className + "." + it.methodName }
+}
+
+// MODULE: main(lib)
+// !JVM_DEFAULT_MODE: disable
+// !JVM_DEFAULT_ALLOW_NON_DEFAULT_INHERITANCE
+// FILE: main.kt
+
+interface Derived : Foo {
+    override fun toOverride() = Thread.currentThread().getStackTrace().map { it.className + "." + it.methodName }
+}
+
+class DerivedClass : Derived 
+
+
+fun box(): String {
+    val override = DerivedClass().toOverride()
+    if (override[1] != "Derived\$DefaultImpls.toOverride") return "fail 1: ${override[1]}"
+    if (override[2] != "DerivedClass.toOverride") return "fail 2: ${override[2]}"
+    if (override[3] != "MainKt.box") return "fail 3: ${override[3]}"
+
+    val nonOverride = DerivedClass().nonOverride()
+    if (nonOverride[1] != "Foo.nonOverride") return "fail 3: ${nonOverride[1]}"
+    if (nonOverride[2] != "MainKt.box") return "fail 4: ${nonOverride[2]}"
+
+    return "OK"
+}
diff --git a/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt
new file mode 100644
index 0000000000000..9454eba85f45e
--- /dev/null
+++ b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt
@@ -0,0 +1,32 @@
+// CHECK_BYTECODE_LISTING
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// !JVM_DEFAULT_MODE: all
+// FILE: Foo.kt
+
+interface Foo<T> {
+    fun foo(p: T) = p
+}
+
+interface Foo2<T> {
+    fun foo(p: T): T = null!!
+}
+
+// MODULE: main(lib)
+// !JVM_DEFAULT_MODE: disable
+// !JVM_DEFAULT_ALLOW_NON_DEFAULT_INHERITANCE
+// FILE: main.kt
+class DerivedClass : Foo<String>
+
+interface DerivedInterface<T> : Foo2<T> {
+    override fun foo(p: T) = p
+}
+
+class DerivedClassWithSpecialization : DerivedInterface<String>
+
+fun box(): String {
+    return DerivedClass().foo("O") + DerivedClassWithSpecialization().foo("K")
+}
diff --git a/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.txt b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.txt
new file mode 100644
index 0000000000000..3dec278adf36b
--- /dev/null
+++ b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.txt
@@ -0,0 +1,46 @@
+Module: lib
+@kotlin.Metadata
+public interface Foo {
+    // source: 'Foo.kt'
+    public method foo(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+public interface Foo2 {
+    // source: 'Foo.kt'
+    public method foo(p0: java.lang.Object): java.lang.Object
+}
+Module: main
+@kotlin.Metadata
+public final class DerivedClass {
+    // source: 'main.kt'
+    public method <init>(): void
+}
+
+@kotlin.Metadata
+public final class DerivedClassWithSpecialization {
+    // source: 'main.kt'
+    public method <init>(): void
+    public @org.jetbrains.annotations.NotNull method foo(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String
+    public synthetic bridge method foo(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class DerivedInterface$DefaultImpls {
+    // source: 'main.kt'
+    public static method foo(@org.jetbrains.annotations.NotNull p0: DerivedInterface, p1: java.lang.Object): java.lang.Object
+    public final inner class DerivedInterface$DefaultImpls
+}
+
+@kotlin.Metadata
+public interface DerivedInterface {
+    // source: 'main.kt'
+    public abstract method foo(p0: java.lang.Object): java.lang.Object
+    public final inner class DerivedInterface$DefaultImpls
+}
+
+@kotlin.Metadata
+public final class MainKt {
+    // source: 'main.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+}
diff --git a/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt
new file mode 100644
index 0000000000000..b6b11cbfe86c2
--- /dev/null
+++ b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt
@@ -0,0 +1,26 @@
+// CHECK_BYTECODE_LISTING
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// !JVM_DEFAULT_MODE: all
+// FILE: Foo.kt
+
+interface Foo<T> {
+    fun foo(p: T) = p
+}
+
+// MODULE: main(lib)
+// !JVM_DEFAULT_MODE: disable
+// !JVM_DEFAULT_ALLOW_NON_DEFAULT_INHERITANCE
+// FILE: main.kt
+interface DerivedInterface<T> : Foo<T>
+
+class DerivedClass : DerivedInterface<String> {
+    override fun foo(p: String) = super.foo(p)
+}
+
+fun box(): String {
+    return DerivedClass().foo("OK")
+}
diff --git a/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.txt b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.txt
new file mode 100644
index 0000000000000..a6e9b21e54077
--- /dev/null
+++ b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.txt
@@ -0,0 +1,25 @@
+Module: lib
+@kotlin.Metadata
+public interface Foo {
+    // source: 'Foo.kt'
+    public method foo(p0: java.lang.Object): java.lang.Object
+}
+Module: main
+@kotlin.Metadata
+public final class DerivedClass {
+    // source: 'main.kt'
+    public method <init>(): void
+    public @org.jetbrains.annotations.NotNull method foo(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String
+    public synthetic bridge method foo(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+public interface DerivedInterface {
+    // source: 'main.kt'
+}
+
+@kotlin.Metadata
+public final class MainKt {
+    // source: 'main.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+}
diff --git a/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/library/a.kt b/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/library/a.kt
new file mode 100644
index 0000000000000..1f88c373c8be5
--- /dev/null
+++ b/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/library/a.kt
@@ -0,0 +1,5 @@
+package base
+
+interface UExpression {
+    fun evaluate(): Any? = "fail"
+}
\ No newline at end of file
diff --git a/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/output.txt b/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/output.txt
new file mode 100644
index 0000000000000..757824d99d598
--- /dev/null
+++ b/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/output.txt
@@ -0,0 +1,7 @@
+compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/source.kt:5:22: error: interfaces can call JVM-default members via super only within JVM-default members. Please use '-Xjvm-default=all/all-compatibility' modes for such calls
+        return super.evaluate()
+                     ^
+compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/source.kt:5:22: error: super calls of '@JvmDefault' members are only allowed with -Xjvm-default option
+        return super.evaluate()
+                     ^
+COMPILATION_ERROR
diff --git a/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/source.kt b/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/source.kt
new file mode 100644
index 0000000000000..a9cfc8da5665a
--- /dev/null
+++ b/compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/source.kt
@@ -0,0 +1,7 @@
+import base.*
+
+interface KotlinEvaluatableUElement : UExpression {
+    override fun evaluate(): Any? {
+        return super.evaluate()
+    }
+}
\ No newline at end of file
diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java
index 8870cd96b5b88..d4dbe44d3bab9 100644
--- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java
+++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java
@@ -24591,6 +24591,40 @@ public void testNoDelegationToDefaultMethodInInterface2() throws Exception {
                 }
             }
 
+            @Nested
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            public class NonDefaultInheritance {
+                @Test
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+                }
+
+                @Test
+                @TestMetadata("simple.kt")
+                public void testSimple() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt");
+                }
+
+                @Test
+                @TestMetadata("simple2.kt")
+                public void testSimple2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt");
+                }
+
+                @Test
+                @TestMetadata("specialization.kt")
+                public void testSpecialization() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt");
+                }
+
+                @Test
+                @TestMetadata("superCall.kt")
+                public void testSuperCall() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt");
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java
index fc2605a7e7770..86d4635092e12 100644
--- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java
+++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java
@@ -24723,6 +24723,40 @@ public void testNoDelegationToDefaultMethodInInterface2() throws Exception {
                 }
             }
 
+            @Nested
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            public class NonDefaultInheritance {
+                @Test
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+                }
+
+                @Test
+                @TestMetadata("simple.kt")
+                public void testSimple() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt");
+                }
+
+                @Test
+                @TestMetadata("simple2.kt")
+                public void testSimple2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt");
+                }
+
+                @Test
+                @TestMetadata("specialization.kt")
+                public void testSpecialization() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt");
+                }
+
+                @Test
+                @TestMetadata("superCall.kt")
+                public void testSuperCall() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt");
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
index ca7682f1c1e74..e6c62bc635930 100644
--- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
+++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
@@ -20710,6 +20710,39 @@ public void testNoDelegationToDefaultMethodInInterface2() throws Exception {
                 }
             }
 
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NonDefaultInheritance extends AbstractLightAnalysisModeTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+                }
+
+                @TestMetadata("simple.kt")
+                public void testSimple() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt");
+                }
+
+                @TestMetadata("simple2.kt")
+                public void testSimple2() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt");
+                }
+
+                @TestMetadata("specialization.kt")
+                public void testSpecialization() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt");
+                }
+
+                @TestMetadata("superCall.kt")
+                public void testSuperCall() throws Exception {
+                    runTest("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt");
+                }
+            }
+
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt
index 6cbc9bcbc5098..b442f3453b60a 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt
@@ -547,6 +547,16 @@ class CompileKotlinAgainstCustomBinariesTest : AbstractKotlinCompilerIntegration
         compileKotlin("source.kt", tmpdir, listOf(library), additionalOptions = listOf("-jvm-target", "1.8", "-Xjvm-default=all-compatibility"))
     }
 
+    fun testJvmDefaultNonDefaultInheritanceSuperCall() {
+        val library = compileLibrary("library", additionalOptions = listOf("-Xjvm-default=all"))
+        compileKotlin(
+            "source.kt",
+            tmpdir,
+            listOf(library),
+            additionalOptions = listOf("-jvm-target", "1.8", "-Xjvm-default=disable", "-Xjvm-default-allow-non-default-inheritance")
+        )
+    }
+
     fun testJvmDefaultCompatibilityAgainstJava() {
         val library = compileLibrary("library", additionalOptions = listOf("-Xjvm-default=disable"))
         compileKotlin(
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java
index 7ca3fefdb252f..c77da3c2849e1 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java
@@ -16604,6 +16604,19 @@ public void testAllFilesPresentInNoDelegation() throws Exception {
                 }
             }
 
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NonDefaultInheritance extends AbstractIrJsCodegenBoxES6Test {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR_ES6, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true);
+                }
+            }
+
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java
index 8223433f4d642..d5c368657fe12 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java
@@ -16010,6 +16010,19 @@ public void testAllFilesPresentInNoDelegation() throws Exception {
                 }
             }
 
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NonDefaultInheritance extends AbstractIrJsCodegenBoxTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+                }
+            }
+
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java
index ede78fb5a4938..4a3303cc3fa17 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java
@@ -16055,6 +16055,19 @@ public void testAllFilesPresentInNoDelegation() throws Exception {
                 }
             }
 
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NonDefaultInheritance extends AbstractJsCodegenBoxTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true);
+                }
+            }
+
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java
index c131548064da3..f6b4f042b5dec 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java
@@ -9540,6 +9540,19 @@ public void testAllFilesPresentInNoDelegation() throws Exception {
                 }
             }
 
+            @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class NonDefaultInheritance extends AbstractIrCodegenBoxWasmTest {
+                private void runTest(String testDataFilePath) throws Exception {
+                    KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath);
+                }
+
+                public void testAllFilesPresentInNonDefaultInheritance() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true);
+                }
+            }
+
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)