From afc149d4607f2bb38326bb3de92d31fb0b6ba189 Mon Sep 17 00:00:00 2001
From: Mikhael Bogdanov <mikhael.bogdanov@jetbrains.com>
Date: Sat, 30 Oct 2021 15:00:15 +0200
Subject: [PATCH] JvmDefault. Allow non default inheritance with special flag

 #KT-47000
---
 .../arguments/K2JVMCompilerArguments.kt       |  4 ++
 .../kotlin/config/JvmAnalysisFlags.kt         |  3 +
 .../FirBlackBoxCodegenTestGenerated.java      | 34 +++++++++++
 .../resolve/jvm/checkers/JvmDefaultChecker.kt | 15 +++--
 .../LanguageVersionSettingsBuilder.kt         |  1 +
 .../directives/LanguageSettingsDirectives.kt  |  4 ++
 compiler/testData/cli/jvm/extraHelp.out       |  2 +
 .../defaults/nonDefaultInheritance/simple.kt  | 57 +++++++++++++++++++
 .../defaults/nonDefaultInheritance/simple2.kt | 39 +++++++++++++
 .../nonDefaultInheritance/specialization.kt   | 32 +++++++++++
 .../nonDefaultInheritance/specialization.txt  | 46 +++++++++++++++
 .../nonDefaultInheritance/superCall.kt        | 26 +++++++++
 .../nonDefaultInheritance/superCall.txt       | 25 ++++++++
 .../library/a.kt                              |  5 ++
 .../output.txt                                |  7 +++
 .../source.kt                                 |  7 +++
 .../codegen/BlackBoxCodegenTestGenerated.java | 34 +++++++++++
 .../IrBlackBoxCodegenTestGenerated.java       | 34 +++++++++++
 .../LightAnalysisModeTestGenerated.java       | 33 +++++++++++
 .../CompileKotlinAgainstCustomBinariesTest.kt | 10 ++++
 .../IrJsCodegenBoxES6TestGenerated.java       | 13 +++++
 .../IrJsCodegenBoxTestGenerated.java          | 13 +++++
 .../IrCodegenBoxWasmTestGenerated.java        | 13 +++++
 .../js/testNew/JsCodegenBoxTestGenerated.java | 10 ++++
 24 files changed, 461 insertions(+), 6 deletions(-)
 create mode 100644 compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple.kt
 create mode 100644 compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/simple2.kt
 create mode 100644 compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.kt
 create mode 100644 compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization.txt
 create mode 100644 compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.kt
 create mode 100644 compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/superCall.txt
 create mode 100644 compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/library/a.kt
 create mode 100644 compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/output.txt
 create mode 100644 compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/source.kt

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 b3332977bae86..77174e065f07a 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
@@ -337,6 +337,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>",
@@ -531,6 +534,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 6a0ab44303178..f25b6ba92328d 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
@@ -25251,6 +25251,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 056c834be9af8..48329dee8e6e0 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
@@ -35,6 +35,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 ->
@@ -62,13 +63,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 778e83720a6c1..c45560031b1b0 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 d8d29032f2bd9..d6ff975d2b646 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
@@ -59,6 +59,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 06b78e98bf529..3c37824064bbf 100644
--- a/compiler/testData/cli/jvm/extraHelp.out
+++ b/compiler/testData/cli/jvm/extraHelp.out
@@ -71,6 +71,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 0efcb97abad4f..b3cb7c67710b5 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
@@ -25113,6 +25113,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 7b885e92ee165..d1b87a961b94f 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
@@ -25251,6 +25251,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 f0e1cb0b0118e..73cd60bc688d5 100644
--- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
+++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
@@ -21159,6 +21159,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 5b787fc069bc2..8deb2a0ba7877 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
@@ -16833,6 +16833,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 5487cf9bb0a21..70516549a3cba 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
@@ -16239,6 +16239,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/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java
index dc2f06b7db79a..098065770cd4b 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
@@ -15525,6 +15525,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)
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testNew/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testNew/JsCodegenBoxTestGenerated.java
index c62093ea036b5..dcaf0373d49d7 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testNew/JsCodegenBoxTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/testNew/JsCodegenBoxTestGenerated.java
@@ -18269,6 +18269,16 @@ public void testAllFilesPresentInNoDelegation() 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.JS, true);
+                }
+            }
+
             @Nested
             @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection")
             @TestDataPath("$PROJECT_ROOT")