JvmDefault. Allow non default inheritance with special flag

 #KT-47000

(cherry picked from commit afc149d)

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
     }
 

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
 

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))
             }
         }
 

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)),

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)"
     )

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.

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)
+    }
+
+}

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"
+}

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")
+}

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
+}

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")
+}

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
+}

compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/library/a.kt

@@ -0,0 +1,5 @@
+package base
+
+interface UExpression {
+    fun evaluate(): Any? = "fail"
+}

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

compiler/testData/compileKotlinAgainstCustomBinaries/jvmDefaultNonDefaultInheritanceSuperCall/source.kt

@@ -0,0 +1,7 @@
+import base.*
+
+interface KotlinEvaluatableUElement : UExpression {
+    override fun evaluate(): Any? {
+        return super.evaluate()
+    }
+}