[Test] Move KotlinAgainstKotlin tests under BlackBoxCodegen tests

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/callStackTrace.kt

@@ -0,0 +1,36 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// FULL_JDK
+// MODULE: lib
+// 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 }
+}
+
+// MODULE: main(lib)
+// 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"
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy/simple.kt

@@ -0,0 +1,37 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "O"
+    }
+
+    fun delegatedTest(): String {
+        return "fail"
+    }
+}
+
+class Delegate : Test {
+    override fun test(): String {
+        return "Fail"
+    }
+
+    override fun delegatedTest(): String {
+        return "K"
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+class TestClass(val foo: Test) : Test by foo
+
+fun box(): String {
+    val testClass = TestClass(Delegate())
+    return testClass.test() + testClass.delegatedTest()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy/simpleProperty.kt

@@ -0,0 +1,34 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    val test: String
+        get() = "O"
+
+    val testDelegated: String
+        get() = "fail"
+
+}
+
+class Delegate : Test {
+    override val test: String
+        get() = "fail"
+
+    override val testDelegated: String
+        get() = "K"
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+class TestClass(val foo: Test) : Test by foo
+
+fun box(): String {
+    val testClass = TestClass(Delegate())
+    return testClass.test + testClass.testDelegated
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCall.kt

@@ -0,0 +1,22 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    fun test(): String {
+        return "OK"
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+class TestClass : Test {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return TestClass().test()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface.kt

@@ -0,0 +1,23 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    fun test(): String {
+        return "OK"
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+
+interface Test2 : Test {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return object : Test2 {}.test()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface2.kt

@@ -0,0 +1,27 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    fun test(): String {
+        return "OK"
+    }
+
+    fun defaultImplTrigger(): String {
+        return "OK"
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+
+interface Test2 : Test {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return object : Test2 {}.test()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccess.kt

@@ -0,0 +1,20 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    val prop: String
+        get() =  "OK"
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+class TestClass : Test {
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return TestClass().prop
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface.kt

@@ -0,0 +1,20 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    val prop: String
+        get() =  "OK"
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+interface Test2 : Test {
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return object : Test2 {}.prop
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface2.kt

@@ -0,0 +1,23 @@
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    val prop: String
+        get() =  "OK"
+
+    val defaultImplTrigger: String
+        get() =  "OK"
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+interface Test2 : Test {
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return object : Test2 {}.prop
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/interop/likeMemberClash.kt

@@ -0,0 +1,28 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// FULL_JDK
+// MODULE: lib
+// FILE: 1.kt
+// !JVM_DEFAULT_MODE: disable
+interface Check {
+    fun test(): String {
+        return "fail";
+    }
+}
+
+interface SubCheck : Check {
+    override fun test(): String {
+        return "OK"
+    }
+}
+
+
+open class CheckClass : Check
+
+// FILE: main.kt
+// !JVM_DEFAULT_MODE: all
+// JVM_TARGET: 1.8
+class SubCheckClass : CheckClass(), SubCheck
+
+fun box(): String {
+    return SubCheckClass().test()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/interop/likeSpecialization.kt

@@ -0,0 +1,23 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// WITH_RUNTIME
+// JVM_TARGET: 1.8
+// MODULE: lib
+// FILE: 1.kt
+// !JVM_DEFAULT_MODE: disable
+
+interface Foo<T> {
+    fun test(p: T) = p
+    val T.prop: String
+        get() = "K"
+}
+
+interface FooDerived: Foo<String>
+
+// FILE: main.kt
+// !JVM_DEFAULT_MODE: all-compatibility
+open class UnspecializedFromDerived : FooDerived
+
+fun box(): String {
+    val foo = UnspecializedFromDerived()
+    return foo.test("O") + with(foo) { "K".prop }
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes.kt

@@ -0,0 +1,43 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// FULL_JDK
+// MODULE: lib
+// 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
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+interface KInterface2 : KInterface  {
+    override fun superCall() = super.superCall()
+}
+
+interface KInterface3 : KInterface2  {
+
+}
+
+class Foo: KInterface3 {
+    fun superCall2() = super<KInterface3>.superCall()
+}
+
+fun box(): String {
+    var result = Foo().call()
+    if (result[1] != "KInterface\$DefaultImpls.call") return "fail 1: ${result[1]}"
+    if (result[2] != "KInterface2\$DefaultImpls.call") return "fail 2: ${result[2]}"
+    if (result[3] != "KInterface3\$DefaultImpls.call") return "fail 3: ${result[3]}"
+    if (result[4] != "Foo.call") return "fail 4: ${result[4]}"
+    if (result[5] != "MainKt.box") return "fail 5: ${result[5]}"
+
+    result = Foo().superCall2()
+    if (result[1] != "KInterface\$DefaultImpls.superCall") return "fail 1: ${result[1]}"
+    if (result[2] != "KInterface2.superCall") return "fail 2: ${result[2]}"
+    if (result[3] != "Foo.superCall2") return "fail 3: ${result[3]}"
+    if (result[4] != "MainKt.box") return "fail 4: ${result[4]}"
+
+    return "OK"
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes2.kt

@@ -0,0 +1,28 @@
+// MODULE: lib
+// FILE: 1.kt
+// !JVM_DEFAULT_MODE: disable
+
+interface Foo<T> {
+    fun test(p: T) = "fail"
+    val T.prop: String
+        get() = "fail"
+}
+
+// FILE: main.kt
+// !JVM_DEFAULT_MODE: all
+// JVM_TARGET: 1.8
+interface Foo2: Foo<String> {
+    override fun test(p: String) = p
+
+    override val String.prop: String
+        get() = this
+}
+
+interface Foo3: Foo<String>, Foo2
+
+class Base : Foo3
+
+fun box(): String {
+    val base = Base()
+    return base.test("O") + with(base) { "K".prop }
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes2Compatibility.kt

@@ -0,0 +1,28 @@
+// MODULE: lib
+// FILE: 1.kt
+// !JVM_DEFAULT_MODE: disable
+
+interface Foo<T> {
+    fun test(p: T) = "fail"
+    val T.prop: String
+        get() = "fail"
+}
+
+// FILE: main.kt
+// !JVM_DEFAULT_MODE: all-compatibility
+// JVM_TARGET: 1.8
+interface Foo2: Foo<String> {
+    override fun test(p: String) : String = p
+
+    override val String.prop: String
+        get() = this
+}
+
+interface Foo3: Foo<String>, Foo2
+
+class Base : Foo3
+
+fun box(): String {
+    val base = Base()
+    return base.test("O") + with(base) { "K".prop }
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes3.kt

@@ -0,0 +1,31 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// FULL_JDK
+// MODULE: lib
+// FILE: 1.kt
+// !JVM_DEFAULT_MODE: disable
+interface KInterface  {
+    fun call(): List<String> {
+        return Thread.currentThread().getStackTrace().map { it.className + "." + it.methodName }
+    }
+}
+
+// FILE: main.kt
+// !JVM_DEFAULT_MODE: all
+// JVM_TARGET: 1.8
+interface KInterface2 : KInterface  {
+
+}
+
+class Foo: KInterface2 {
+
+}
+
+fun box(): String {
+    var result = Foo().call()
+    if (result[1] != "KInterface\$DefaultImpls.call") return "fail 1: ${result[1]}"
+    if (result[2] != "KInterface2\$DefaultImpls.call") return "fail 2: ${result[2]}"
+    if (result[3] != "Foo.call") return "fail 3: ${result[3]}"
+    if (result[4] != "MainKt.box") return "fail 4: ${result[4]}"
+
+    return "OK"
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/interop/newSchemeWithJvmDefault.kt

@@ -0,0 +1,40 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// FULL_JDK
+// WITH_RUNTIME
+// JVM_TARGET: 1.8
+// MODULE: lib
+// FILE: 1.kt
+// !JVM_DEFAULT_MODE: enable
+interface KInterface  {
+    @JvmDefault
+    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
+// !JVM_DEFAULT_MODE: all
+interface KInterface2 : KInterface  {
+    override fun superCall() = super.superCall()
+}
+
+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\$DefaultImpls.superCall") return "fail 1: ${result[1]}"
+    if (result[2] != "KInterface2.superCall") return "fail 2: ${result[2]}"
+    if (result[3] != "Foo.superCall2") return "fail 3: ${result[3]}"
+    if (result[4] != "MainKt.box") return "fail 4: ${result[4]}"
+
+
+    return "OK"
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/superCall.kt

@@ -0,0 +1,23 @@
+// !JVM_DEFAULT_MODE: enable
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "OK"
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+class TestClass : Test {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return TestClass().test()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface.kt

@@ -0,0 +1,25 @@
+// !JVM_DEFAULT_MODE: enable
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "OK"
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+
+interface Test2 : Test {
+    @JvmDefault
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return object : Test2 {}.test()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface2.kt

@@ -0,0 +1,29 @@
+// !JVM_DEFAULT_MODE: enable
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "OK"
+    }
+
+    fun defaultImplTrigger(): String {
+        return "OK"
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+
+interface Test2 : Test {
+    @JvmDefault
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    return object : Test2 {}.test()
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccess.kt

@@ -0,0 +1,22 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// !JVM_DEFAULT_MODE: enable
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    val prop: String
+        get() =  "OK"
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+class TestClass : Test {
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return TestClass().prop
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface.kt

@@ -0,0 +1,23 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// !JVM_DEFAULT_MODE: enable
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    val prop: String
+        get() =  "OK"
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+interface Test2 : Test {
+    @JvmDefault
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return object : Test2 {}.prop
+}

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface2.kt

@@ -0,0 +1,26 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// !JVM_DEFAULT_MODE: enable
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: 1.kt
+interface Test {
+    @JvmDefault
+    val prop: String
+        get() =  "OK"
+
+    val defaultImplTrigger: String
+        get() =  "OK"
+}
+
+// MODULE: main(lib)
+// FILE: 2.kt
+interface Test2 : Test {
+    @JvmDefault
+    override val prop: String
+        get() = super.prop
+}
+
+fun box(): String {
+    return object : Test2 {}.prop
+}