tests: Update external tests (1.1.2-dev-393)

backend.native/tests/external/codegen/box/super/basicmethodSuperClass.kt

@@ -0,0 +1,17 @@
+// IGNORE_BACKEND: NATIVE
+
+class N() : ArrayList<Any>() {
+    override fun add(el: Any)  : Boolean {
+        if (!super<ArrayList>.add(el)) {
+            throw Exception()
+        }
+        return false
+    }
+}
+
+fun box(): String {
+    val n = N()
+    if (n.add("239")) return "fail"
+    if (n.get(0) == "239") return "OK";
+    return "fail";
+}

backend.native/tests/external/codegen/box/super/basicmethodSuperTrait.kt

@@ -0,0 +1,14 @@
+
+interface Tr {
+   fun extra() : String = "_"
+}
+
+class N() : Tr {
+   override fun extra() : String = super<Tr>.extra() + super<Tr>.extra()
+}
+
+fun box(): String {
+    val n = N()
+    if (n.extra() == "__") return "OK"
+    return "fail";
+}

backend.native/tests/external/codegen/box/super/basicproperty.kt

@@ -0,0 +1,24 @@
+open class M() {
+    open var b: Int = 0
+}
+
+class N() : M() {
+    val a : Int
+        get() {
+            super.b = super.b + 1
+            return super.b + 1
+        }
+    override var b: Int = a + 1
+
+    val superb : Int
+        get() = super.b
+}
+
+fun box(): String {
+    val n = N()
+    n.a
+    n.b
+    n.superb
+    if (n.b == 3 && n.a == 4 && n.superb == 3) return "OK";
+    return "fail";
+}

backend.native/tests/external/codegen/box/super/enclosedFun.kt

@@ -0,0 +1,31 @@
+interface BK {
+    fun x() : Int = 50
+}
+
+interface K : BK {
+    override fun x() : Int = super.x() * 2
+}
+
+open class M() {
+    open fun x() : Int = 10
+}
+
+open class N() : M(), K {
+
+    override fun x() : Int = 20
+
+    open inner class C() : K {
+        fun test1() = x()
+        fun test2() = super<M>@N.x()
+        fun test3() = super<K>@N.x()
+        fun test4() = super<K>.x()
+    }
+}
+
+fun box(): String {
+    if (N().C().test1() != 100) return "test1 fail";
+    if (N().C().test2() != 10)  return "test2 fail";
+    if (N().C().test3() != 100) return "test3 fail";
+    if (N().C().test4() != 100) return "test4 fail";
+    return "OK";
+}

backend.native/tests/external/codegen/box/super/enclosedVar.kt

@@ -0,0 +1,22 @@
+open class M() {
+    open var y = 500
+}
+
+open class N() : M() {
+
+    override var y = 200
+
+    open inner class C() {
+        fun test5() = y
+        fun test6() : Int {
+            super<M>@N.y += 200
+            return super<M>@N.y
+        }
+    }
+}
+
+fun box(): String {
+    if (N().C().test5() != 200) return "test5 fail";
+    if (N().C().test6() != 700) return "test6 fail";
+    return "OK";
+}

backend.native/tests/external/codegen/box/super/innerClassLabeledSuper.kt

@@ -0,0 +1,38 @@
+interface BK {
+    fun foo(): String
+    fun bar(): String
+}
+
+interface K : BK {
+    override fun foo() = bar()
+}
+
+class A : K {
+    override fun foo() = "A.foo"
+    override fun bar() = "A.bar"
+    
+    inner class B : K {
+        override fun foo() = "B.foo"
+        override fun bar() = "B.bar"
+        
+        fun test1() = super<K>@A.foo()
+        fun test2() = super<K>@B.foo()
+        fun test3() = super<K>.foo()
+        fun test4() = super@A.foo()
+        fun test5() = super@B.foo()
+        fun test6() = super.foo()
+    }
+}
+
+
+fun box(): String {
+    val b = A().B()
+    if (b.test1() != "A.bar") return "test1 ${b.test1()}"
+    if (b.test2() != "B.bar") return "test2 ${b.test2()}"
+    if (b.test3() != "B.bar") return "test3 ${b.test3()}"
+    if (b.test4() != "A.bar") return "test4 ${b.test4()}"
+    if (b.test5() != "B.bar") return "test5 ${b.test5()}"
+    if (b.test6() != "B.bar") return "test6 ${b.test6()}"
+    
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/innerClassLabeledSuper2.kt

@@ -0,0 +1,44 @@
+//inspired by kt3492
+interface BK {
+    fun foo(): String
+    fun bar(): String
+}
+
+interface KTrait: BK {
+    override fun foo() = bar()
+}
+
+open abstract class K : KTrait {
+
+}
+
+class A : K() {
+    override fun foo() = "A.foo"
+    override fun bar() = "A.bar"
+
+    inner class B : K() {
+        override fun foo() = "B.foo"
+        override fun bar() = "B.bar"
+
+        fun test1() = super<K>@A.foo()
+        fun test2() = super<K>@B.foo()
+        fun test3() = super<K>.foo()
+        fun test4() = super@A.foo()
+        fun test5() = super@B.foo()
+        fun test6() = super.foo()
+    }
+}
+
+
+fun box(): String {
+    val b = A().B()
+    if (b.test1() != "A.bar") return "test1 ${b.test1()}"
+    if (b.test2() != "B.bar") return "test2 ${b.test2()}"
+    if (b.test3() != "B.bar") return "test3 ${b.test3()}"
+    if (b.test4() != "A.bar") return "test4 ${b.test4()}"
+    if (b.test5() != "B.bar") return "test5 ${b.test5()}"
+    if (b.test6() != "B.bar") return "test6 ${b.test6()}"
+
+    return "OK"
+}
+

backend.native/tests/external/codegen/box/super/innerClassLabeledSuperProperty.kt

@@ -0,0 +1,38 @@
+interface Base {
+    val foo: String
+    fun bar(): String
+}
+
+abstract class K : Base {
+    override val foo = bar()
+}
+
+class A : K() {
+    override val foo = "A.foo"
+    override fun bar() = "A.bar"
+    
+    inner class B : K() {
+        override val foo = "B.foo"
+        override fun bar() = "B.bar"
+        
+        fun test1() = super<K>@A.foo
+        fun test2() = super<K>@B.foo
+        fun test3() = super<K>.foo
+        fun test4() = super@A.foo
+        fun test5() = super@B.foo
+        fun test6() = super.foo
+    }
+}
+
+
+fun box(): String {
+    val b = A().B()
+    if (b.test1() != "A.bar") return "test1 ${b.test1()}"
+    if (b.test2() != "B.bar") return "test2 ${b.test2()}"
+    if (b.test3() != "B.bar") return "test3 ${b.test3()}"
+    if (b.test4() != "A.bar") return "test4 ${b.test4()}"
+    if (b.test5() != "B.bar") return "test5 ${b.test5()}"
+    if (b.test6() != "B.bar") return "test6 ${b.test6()}"
+    
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/innerClassLabeledSuperProperty2.kt

@@ -0,0 +1,43 @@
+//inspired by kt3492
+interface Base {
+    val foo: String
+    fun bar(): String
+}
+
+abstract class KWithOverride : Base {
+    override val foo = bar()
+}
+
+abstract class K : KWithOverride() {
+
+}
+
+class A : K() {
+    override val foo = "A.foo"
+    override fun bar() = "A.bar"
+
+    inner class B : K() {
+        override val foo = "B.foo"
+        override fun bar() = "B.bar"
+
+        fun test1() = super<K>@A.foo
+        fun test2() = super<K>@B.foo
+        fun test3() = super<K>.foo
+        fun test4() = super@A.foo
+        fun test5() = super@B.foo
+        fun test6() = super.foo
+    }
+}
+
+
+fun box(): String {
+    val b = A().B()
+    if (b.test1() != "A.bar") return "test1 ${b.test1()}"
+    if (b.test2() != "B.bar") return "test2 ${b.test2()}"
+    if (b.test3() != "B.bar") return "test3 ${b.test3()}"
+    if (b.test4() != "A.bar") return "test4 ${b.test4()}"
+    if (b.test5() != "B.bar") return "test5 ${b.test5()}"
+    if (b.test6() != "B.bar") return "test6 ${b.test6()}"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/innerClassQualifiedFunctionCall.kt

@@ -0,0 +1,46 @@
+interface T {
+    open fun baz(): String = "T.baz"
+}
+
+open class A {
+    open val foo: String = "OK"
+    open fun bar(): String = "OK"
+    open fun boo(): String = "OK"
+}
+
+open class B : A(), T {
+    override fun bar(): String = "B"
+    override fun baz(): String = "B.baz"
+    inner class E {
+        val foo: String = super<A>@B.foo
+        fun bar() = super<A>@B.bar() + super@B.bar() + super@B.baz()
+    }
+}
+
+class C : B() {
+    override fun bar(): String = "C"
+    override fun boo(): String = "C"
+    inner class D {
+        val foo: String = super<B>@C.foo
+        fun bar() = super<B>@C.bar() + super<B>@C.boo()
+    }
+}
+
+fun box(): String {
+    var r = ""
+
+    r = B().E().foo
+    if (r != "OK") return "fail 1; r = $r"
+    r = ""
+    r = B().E().bar()
+    if (r != "OKOKT.baz") return "fail 2; r = $r"
+
+    r = ""
+    r = C().D().foo
+    if (r != "OK") return "fail 3; r = $r"
+    r = ""
+    r = C().D().bar()
+    if (r != "BOK") return "fail 4; r = $r"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/innerClassQualifiedPropertyAccess.kt

@@ -0,0 +1,45 @@
+interface T {
+    open val baz: String
+        get() = "T.baz"
+}
+
+open class A {
+    open val bar: String
+        get() = "OK"
+    open val boo: String
+        get() = "OK"
+}
+
+open class B : A(), T {
+    override val bar: String
+        get() = "B"
+    override val baz: String
+        get() = "B.baz"
+    inner class E {
+        val bar: String
+            get() = super<A>@B.bar + super@B.bar + super@B.baz
+    }
+}
+
+class C : B() {
+    override val bar: String
+        get() = "C"
+    override val boo: String
+        get() = "C"
+    inner class D {
+        val bar: String
+            get() = super<B>@C.bar + super<B>@C.boo
+    }
+}
+
+fun box(): String {
+    var r = ""
+
+    r = B().E().bar
+    if (r != "OKOKT.baz") return "fail 1; r = $r"
+
+    r = C().D().bar
+    if (r != "BOK") return "fail 2; r = $r"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/kt14243.kt

@@ -0,0 +1,18 @@
+interface Z<T> {
+    fun test(p: T): T {
+        return p
+    }
+}
+
+open class ZImpl : Z<String>
+
+class ZImpl2 : ZImpl() {
+
+    override fun test(p: String): String {
+        return super.test(p)
+    }
+}
+
+fun box(): String {
+    return ZImpl2().test("OK")
+}

backend.native/tests/external/codegen/box/super/kt14243_2.kt

@@ -0,0 +1,20 @@
+interface Z<T> {
+    fun test(p: T): T {
+        return p
+    }
+}
+
+open class ZImpl : Z<String>
+
+open class ZImpl2 : Z<String>, ZImpl()
+
+class ZImpl3 : ZImpl2() {
+
+    override fun test(p: String): String {
+        return super.test(p)
+    }
+}
+
+fun box(): String {
+    return ZImpl3().test("OK")
+}

backend.native/tests/external/codegen/box/super/kt14243_class.kt

@@ -0,0 +1,20 @@
+
+open class Z<T, Y> {
+    open fun test(p: T, z: Y): T {
+        return p
+    }
+}
+
+open class ZImpl<X> : Z<String, X>()
+
+open class ZImpl2 : ZImpl<String>()
+
+class ZImpl3 : ZImpl2() {
+    override fun test(p: String, z: String): String {
+        return super.test(p, z)
+    }
+}
+
+fun box(): String {
+    return ZImpl3().test("OK", "fail")
+}

backend.native/tests/external/codegen/box/super/kt14243_prop.kt

@@ -0,0 +1,21 @@
+interface Z<T> {
+    val value: T
+
+    val z: T
+        get() = value
+}
+
+open class ZImpl : Z<String> {
+    override val value: String
+        get() = "OK"
+}
+
+open class ZImpl2 : ZImpl() {
+    override val z: String
+        get() = super.z
+}
+
+
+fun box(): String {
+    return ZImpl2().value
+}

backend.native/tests/external/codegen/box/super/kt3492ClassFun.kt

@@ -0,0 +1,19 @@
+open class A {
+    open fun foo2(): String = "OK"
+}
+
+open class B : A() {
+
+}
+
+class C : B() {
+    inner class D {
+        val foo: String = super<B>@C.foo2()
+    }
+}
+
+fun box() : String {
+    val obj = C().D();
+    return obj.foo
+}
+

backend.native/tests/external/codegen/box/super/kt3492ClassProperty.kt

@@ -0,0 +1,15 @@
+open class A {
+    open val foo: String = "OK"
+}
+
+open class B : A() {
+
+}
+
+class C : B() {
+    inner class D {
+        val foo: String = super<B>@C.foo
+    }
+}
+
+fun box() = C().D().foo

backend.native/tests/external/codegen/box/super/kt3492TraitFun.kt

@@ -0,0 +1,19 @@
+interface ATrait {
+    open fun foo2(): String = "OK"
+}
+
+open class B : ATrait {
+
+}
+
+class C : B() {
+    inner class D {
+        val foo: String = super<B>@C.foo2()
+    }
+}
+
+fun box() : String {
+    val obj = C().D();
+    return obj.foo
+}
+

backend.native/tests/external/codegen/box/super/kt3492TraitProperty.kt

@@ -0,0 +1,16 @@
+interface A {
+    open val foo: String
+      get() = "OK"
+}
+
+open class B : A {
+
+}
+
+class C : B() {
+    inner class D {
+        val foo: String = super<B>@C.foo
+    }
+}
+
+fun box() = C().D().foo

backend.native/tests/external/codegen/box/super/kt4173.kt

@@ -0,0 +1,18 @@
+open class C(val f: () -> Unit) {
+    fun test() {
+        f()
+    }
+}
+
+class B(var x: Int) {
+    fun foo() {
+        object : C({x = 3}) {}.test()
+    }
+}
+
+
+fun box() : String {
+    val b = B(1)
+    b.foo()
+    return if (b.x != 3) "fail: b.x = ${b.x}" else "OK"
+}

backend.native/tests/external/codegen/box/super/kt4173_2.kt

@@ -0,0 +1,20 @@
+open class X(var s: ()-> Unit)
+
+open class C(val f: X) {
+    fun test() {
+        f.s()
+    }
+}
+
+class B(var x: Int) {
+    fun foo() {
+        object : C(object: X({x = 3}) {}) {}.test()
+    }
+}
+
+
+fun box() : String {
+    val b = B(1)
+    b.foo()
+    return if (b.x != 3) "fail: b.x = ${b.x}" else "OK"
+}

backend.native/tests/external/codegen/box/super/kt4173_3.kt

@@ -0,0 +1,27 @@
+open class C(s: Int) {
+    fun test() {
+
+    }
+}
+
+class B(var x: Int) {
+    fun foo() {
+        class A(val a: Int) : C({a}()) {
+
+        }
+        A(11).test()
+
+
+        class B(val a: Int) : C(a) {
+        }
+
+        B(11).test()
+    }
+}
+
+
+fun box() : String {
+    val b = B(1)
+    b.foo()
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/kt4982.kt

@@ -0,0 +1,21 @@
+abstract class WaitFor {
+    init {
+        condition()
+    }
+
+    abstract fun condition() : Boolean;
+}
+
+fun box(): String {
+    val local = ""
+    var result = "fail"
+    val s = object: WaitFor() {
+
+        override fun condition(): Boolean {
+            result = "OK"
+            return result.length== 2
+        }
+    }
+
+    return result;
+}

backend.native/tests/external/codegen/box/super/multipleSuperTraits.kt

@@ -0,0 +1,13 @@
+interface T1 {
+    fun foo() = "O"
+}
+
+interface T2 {
+    fun foo() = "K"
+}
+
+class A : T1, T2 {
+    override fun foo() = super<T1>.foo() + super<T2>.foo()
+}
+
+fun box() = A().foo()

backend.native/tests/external/codegen/box/super/traitproperty.kt

@@ -0,0 +1,31 @@
+interface M {
+    var backingB : Int
+    var b : Int
+        get() = backingB
+        set(value: Int) {
+            backingB = value
+        }
+}
+
+class N() : M {
+    public override var backingB : Int = 0
+
+    val a : Int
+        get() {
+            super.b = super.b + 1
+            return super.b + 1
+        }
+    override var b: Int = a + 1
+
+    val superb : Int
+        get() = super.b
+}
+
+fun box(): String {
+    val n = N()
+    n.a
+    n.b
+    n.superb
+    if (n.b == 3 && n.a == 4 && n.superb == 3) return "OK";
+    return "fail";
+}

backend.native/tests/external/codegen/box/super/unqualifiedSuper.kt

@@ -0,0 +1,66 @@
+open class Base() {
+    open fun baseFun(): String = "Base.baseFun()"
+
+    open fun unambiguous(): String = "Base.unambiguous()"
+
+    open val baseProp: String
+        get() = "Base.baseProp"
+}
+
+interface Interface {
+    fun interfaceFun(): String = "Interface.interfaceFun()"
+
+    fun unambiguous(): String // NB abstract
+}
+
+interface AnotherInterface
+
+interface DerivedInterface: Interface, AnotherInterface {
+    override fun interfaceFun(): String = "DerivedInterface.interfaceFun()"
+
+    override fun unambiguous(): String = "DerivedInterface.unambiguous()"
+
+    fun callsFunFromSuperInterface(): String = super.interfaceFun()
+}
+
+class Derived : Base(), Interface {
+    override fun baseFun(): String = "Derived.baseFun()"
+
+    override fun unambiguous(): String = "Derived.unambiguous()"
+
+    override fun interfaceFun(): String = "Derived.interfaceFun()"
+
+    override val baseProp: String
+        get() = "Derived.baseProp"
+
+    fun callsBaseFun(): String = super.baseFun()
+
+    fun callsUnambiguousFun(): String = super.unambiguous()
+
+    fun getsBaseProp(): String = super.baseProp
+
+    fun callsInterfaceFun(): String = super.interfaceFun()
+}
+
+fun box(): String {
+    val d = Derived()
+
+    val test1 = d.callsBaseFun()
+    if (test1 != "Base.baseFun()") return "Failed: d.callsBaseFun()==$test1"
+
+    val test2 = d.callsUnambiguousFun()
+    if (test2 != "Base.unambiguous()") return "Failed: d.callsUnambiguousFun()==$test2"
+
+    val test3 = d.getsBaseProp()
+    if (test3 != "Base.baseProp") return "Failed: d.getsBaseProp()==$test3"
+
+    val test4 = d.callsInterfaceFun()
+    if (test4 != "Interface.interfaceFun()") return "Failed: d.callsInterfaceFun()==$test4"
+
+    val di = object : DerivedInterface {}
+
+    val test5 = di.callsFunFromSuperInterface()
+    if (test5 != "Interface.interfaceFun()") return "Failed: di.callsFunFromSuperInterface()==$test5"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/unqualifiedSuperWithDeeperHierarchies.kt

@@ -0,0 +1,63 @@
+open class DeeperBase {
+    open fun deeperBaseFun(): String = "DeeperBase.deeperBaseFun()"
+
+    open val deeperBaseProp: String
+        get() = "DeeperBase.deeperBaseProp"
+}
+
+open class DeepBase : DeeperBase() {
+}
+
+interface DeeperInterface {
+    fun deeperInterfaceFun(): String = "DeeperInterface.deeperInterfaceFun()"
+
+    val deeperInterfaceProp: String
+        get() = "DeeperInterface.deeperInterfaceProp"
+}
+
+interface DeepInterface : DeeperInterface {
+    fun deepInterfaceFun(): String = "DeepInterface.deepInterfaceFun()"
+}
+
+class DeepDerived : DeepBase(), DeepInterface {
+    override fun deeperBaseFun(): String = "DeepDerived.deeperBaseFun()"
+
+    override val deeperBaseProp: String
+        get() = "DeepDerived.deeperBaseProp"
+
+    override fun deeperInterfaceFun(): String = "DeepDerived.deeperInterfaceFun()"
+
+    override val deeperInterfaceProp: String
+        get() = "DeepDerived.deeperInterfaceProp"
+
+    override fun deepInterfaceFun(): String = "DeepDerived.deepInterfaceFun()"
+
+    fun callsSuperDeeperBaseFun(): String = super.deeperBaseFun()
+
+    fun getsSuperDeeperBaseProp(): String = super.deeperBaseProp
+
+    fun callsSuperDeepInterfaceFun(): String = super.deepInterfaceFun()
+    fun callsSuperDeeperInterfaceFun(): String = super.deeperInterfaceFun()
+    fun getsSuperDeeperInterfaceProp(): String = super.deeperInterfaceProp
+}
+
+fun box(): String {
+    val dd = DeepDerived()
+
+    val test1 = dd.callsSuperDeeperBaseFun()
+    if (test1 != "DeeperBase.deeperBaseFun()") return "Failed: dd.callsSuperDeeperBaseFun()==$test1"
+
+    val test2 = dd.getsSuperDeeperBaseProp()
+    if (test2 != "DeeperBase.deeperBaseProp") return "Failed: dd.getsSuperDeeperBaseProp()==$test2"
+
+    val test3 = dd.callsSuperDeepInterfaceFun()
+    if (test3 != "DeepInterface.deepInterfaceFun()") return "Failed: dd.callsSuperDeepInterfaceFun()==$test3"
+
+    val test4 = dd.callsSuperDeeperInterfaceFun()
+    if (test4 != "DeeperInterface.deeperInterfaceFun()") return "Failed: dd.callsSuperDeeperInterfaceFun()==$test4"
+
+    val test5 = dd.getsSuperDeeperInterfaceProp()
+    if (test5 != "DeeperInterface.deeperInterfaceProp") return "Failed: dd.getsSuperDeeperInterfaceProp()==$test5"
+
+    return "OK"
+}

backend.native/tests/external/codegen/box/super/unqualifiedSuperWithMethodsOfAny.kt

@@ -0,0 +1,25 @@
+interface ISomething
+
+open class ClassWithToString {
+    override fun toString(): String = "C"
+}
+
+interface IWithToString {
+    override fun toString(): String
+}
+
+class C1 : ClassWithToString(), ISomething {
+    override fun toString(): String = super.toString()
+}
+
+class C2 : ClassWithToString(), IWithToString, ISomething  {
+    override fun toString(): String = super.toString()
+}
+
+fun box(): String {
+    return when {
+        C1().toString() != "C" -> "Failed #1"
+        C2().toString() != "C" -> "Failed #2"
+        else -> "OK"
+    }
+}