Merge

backend.native/tests/codegen/basics/cast_null.kt

@@ -0,0 +1,48 @@
+fun main(args: Array<String>) {
+    testCast(null, false)
+    testCastToNullable(null, true)
+    testCastToNullable(Test(), true)
+    testCastToNullable("", false)
+    testCastNotNullableToNullable(Test(), true)
+    testCastNotNullableToNullable("", false)
+
+    println("Ok")
+}
+
+class Test
+
+fun ensure(b: Boolean) {
+    if (!b) {
+        println("Error")
+    }
+}
+
+fun testCast(x: Any?, expectSuccess: Boolean) {
+    try {
+        x as Test
+    } catch (e: Throwable) {
+        ensure(!expectSuccess)
+        return
+    }
+    ensure(expectSuccess)
+}
+
+fun testCastToNullable(x: Any?, expectSuccess: Boolean) {
+    try {
+        x as Test?
+    } catch (e: Throwable) {
+        ensure(!expectSuccess)
+        return
+    }
+    ensure(expectSuccess)
+}
+
+fun testCastNotNullableToNullable(x: Any, expectSuccess: Boolean) {
+    try {
+        x as Test?
+    } catch (e: Throwable) {
+        ensure(!expectSuccess)
+        return
+    }
+    ensure(expectSuccess)
+}

backend.native/tests/codegen/basics/superFunCall.kt

@@ -0,0 +1,19 @@
+open class C {
+    open fun f() = "<fun:C>"
+}
+
+class C1: C() {
+    override fun f() = super<C>.f() + "<fun:C1>"
+}
+
+open class C2: C() {
+}
+
+class C3: C2() {
+    override fun f() = super<C2>.f() + "<fun:C3>"
+}
+
+fun main(args: Array<String>) {
+    println(C1().f())
+    println(C3().f())
+}

backend.native/tests/codegen/basics/superGetterCall.kt

@@ -0,0 +1,19 @@
+open class C {
+    open val p1 = "<prop:C>"
+}
+
+class C1: C() {
+    override val p1 = super<C>.p1 + "<prop:C1>"
+}
+
+open class C2: C() {
+}
+
+class C3: C2() {
+    override val p1 = super<C2>.p1 + "<prop:C3>"
+}
+
+fun main(args: Array<String>) {
+    println(C1().p1)
+    println(C3().p1)
+}

backend.native/tests/codegen/basics/superSetterCall.kt

@@ -0,0 +1,32 @@
+open class C {
+    open var p2 = "<prop:C>"
+        set(value)  { field = "<prop:C>" + value }
+}
+
+class C1: C() {
+    override var p2 = super<C>.p2 + "<prop:C1>"
+        set(value) {
+            super<C>.p2 = value
+            field = "<prop:C1>" + super<C>.p2
+        }
+}
+
+open class C2: C() {
+}
+
+class C3: C2() {
+    override var p2 = super<C2>.p2 + "<prop:C3>"
+        set(value) {
+            super<C2>.p2 = value
+            field = "<prop:C3>" + super<C2>.p2
+        }
+}
+
+fun main(args: Array<String>) {
+    val c1 = C1()
+    val c3 = C3()
+    c1.p2 = "zzz"
+    c3.p2 = "zzz"
+    println(c1.p2)
+    println(c3.p2)
+}

backend.native/tests/codegen/basics/typealias1.kt

@@ -0,0 +1,6 @@
+fun main(args: Array<String>) {
+    println(Bar(42).x)
+}
+
+class Foo(val x: Int)
+typealias Bar = Foo

backend.native/tests/codegen/basics/unchecked_cast1.kt

@@ -0,0 +1,16 @@
+fun main(args: Array<String>) {
+    foo<String>("17")
+    bar<String>("17")
+    foo<String>(42)
+    bar<String>(42)
+}
+
+fun <T> foo(x: Any?) {
+    val y = x as T
+    println(y.toString())
+}
+
+fun <T> bar(x: Any?) {
+    val y = x as? T
+    println(y.toString())
+}

backend.native/tests/codegen/basics/unchecked_cast2.kt

@@ -0,0 +1,10 @@
+fun main(args: Array<String>) {
+    try {
+        val x = cast<String>(Any())
+        println(x.length)
+    } catch (e: Throwable) {
+        println("Ok")
+    }
+}
+
+fun <T> cast(x: Any?) = x as T

backend.native/tests/codegen/basics/unchecked_cast3.kt

@@ -0,0 +1,35 @@
+fun main(args: Array<String>) {
+    testCast<Test>(Test(), true)
+    testCast<Test>(null, false)
+    testCastToNullable<Test>(null, true)
+
+    println("Ok")
+}
+
+class Test
+
+fun ensure(b: Boolean) {
+    if (!b) {
+        println("Error")
+    }
+}
+
+fun <T : Any> testCast(x: Any?, expectSuccess: Boolean) {
+    try {
+        x as T
+    } catch (e: Throwable) {
+        ensure(!expectSuccess)
+        return
+    }
+    ensure(expectSuccess)
+}
+
+fun <T : Any> testCastToNullable(x: Any?, expectSuccess: Boolean) {
+    try {
+        x as T?
+    } catch (e: Throwable) {
+        ensure(!expectSuccess)
+        return
+    }
+    ensure(expectSuccess)
+}

backend.native/tests/codegen/boxing/boxing14.kt

@@ -0,0 +1,5 @@
+fun main(args: Array<String>) {
+    42.println()
+}
+
+fun <T> T.println() = println(this.toString())

backend.native/tests/codegen/boxing/boxing15.kt

@@ -0,0 +1,5 @@
+fun main(args: Array<String>) {
+    println(foo(17))
+}
+
+fun <T : Int> foo(x: T): Int = x

backend.native/tests/codegen/branching/when9.kt

@@ -0,0 +1,10 @@
+fun main(args: Array<String>) {
+    foo(0)
+    println("Ok")
+}
+
+fun foo(x: Int) {
+    when (x) {
+        0 -> 0
+    }
+}

backend.native/tests/codegen/enum/companionObject.kt

@@ -0,0 +1,24 @@
+enum class Game {
+    ROCK,
+    PAPER,
+    SCISSORS;
+
+    companion object {
+        fun foo() = ROCK
+        val bar = PAPER
+        val values2 = values()
+        val scissors = valueOf("SCISSORS")
+    }
+}
+
+fun box(): String {
+    if (Game.foo() != Game.ROCK) return "Fail 1"
+    if (Game.bar != Game.PAPER) return "Fail 2: ${Game.bar}"
+    if (Game.values().size != 3) return "Fail 3"
+    if (Game.valueOf("SCISSORS") != Game.SCISSORS) return "Fail 4"
+    if (Game.values2.size != 3) return "Fail 5"
+    if (Game.scissors != Game.SCISSORS) return "Fail 6"
+    return "OK"
+}
+
+fun main(args: Array<String>) = println(box())

backend.native/tests/codegen/enum/test0.kt

@@ -0,0 +1,9 @@
+val TOP_LEVEL = 5
+
+enum class MyEnum(value: Int) {
+    VALUE(TOP_LEVEL)
+}
+
+fun main(args: Array<String>) {
+    println(MyEnum.VALUE.toString())
+}

backend.native/tests/codegen/enum/test1.kt

@@ -0,0 +1,8 @@
+enum class Zzz(val zzz: String, val x: Int) {
+    Z1("z1", 1),
+    Z2("z2", 2)
+}
+
+fun main(args: Array<String>) {
+    println(Zzz.Z1.zzz + Zzz.Z2.x)
+}

backend.native/tests/codegen/enum/vCallNoEntryClass.kt

@@ -0,0 +1,13 @@
+enum class Zzz(val zzz: String, val x: Int) {
+    Z1("z1", 1),
+    Z2("z2", 2),
+    Z3("z3", 3);
+
+    override fun toString(): String{
+        return "('$zzz', $x)"
+    }
+}
+
+fun main(args: Array<String>) {
+    println(Zzz.Z3.toString())
+}

backend.native/tests/codegen/enum/vCallWithEntryClass.kt

@@ -0,0 +1,15 @@
+enum class Zzz {
+    Z1 {
+        override fun f() = "z1"
+    },
+
+    Z2 {
+        override fun f() = "z2"
+    };
+
+    open fun f() = ""
+}
+
+fun main(args: Array<String>) {
+    println(Zzz.Z1.f() + Zzz.Z2.f())
+}

backend.native/tests/codegen/enum/valueOf.kt

@@ -0,0 +1,8 @@
+enum class E {
+    E1,
+    E2
+}
+
+fun main(args: Array<String>) {
+    println(E.valueOf("E1").toString())
+}

backend.native/tests/codegen/enum/values.kt

@@ -0,0 +1,8 @@
+enum class E {
+    E1,
+    E2
+}
+
+fun main(args: Array<String>) {
+    println(E.values()[1].toString())
+}

backend.native/tests/codegen/function/defaults4.kt

@@ -2,10 +2,12 @@ open class A {
     open fun foo(x: Int = 42) = println(x)
 }
 
-class B : A() {
+open class B : A()
+
+class C : B() {
     override fun foo(x: Int) = println(x + 1)
 }
 
 fun main(args: Array<String>) {
-    B().foo()
+    C().foo()
 }

backend.native/tests/codegen/innerClass/generic.kt

@@ -0,0 +1,15 @@
+class Outer {
+    inner class Inner<T>(val t: T) {
+        fun box() = t
+    }
+}
+
+fun box(): String {
+    if (Outer().Inner("OK").box() != "OK") return "Fail"
+    val x: Outer.Inner<String> = Outer().Inner("OK")
+    return x.box()
+}
+
+fun main(args: Array<String>) {
+    println(box())
+}

backend.native/tests/codegen/innerClass/getOuterVal.kt

@@ -0,0 +1,12 @@
+class Outer(val s: String) {
+    inner class Inner {
+        fun box() = s
+    }
+}
+
+fun box() = Outer("OK").Inner().box()
+
+fun main(args: Array<String>)
+{
+    println(box())
+}

backend.native/tests/codegen/innerClass/qualifiedThis.kt

@@ -0,0 +1,46 @@
+open class ABase
+{
+    open fun zzz() = "a_base"
+}
+
+open class BBase
+{
+    open fun zzz() = "b_base"
+}
+
+class D() {
+    val z = "d"
+}
+
+class A: ABase() { // implicit label @A
+    val z = "a"
+    override fun zzz() = "a"
+    inner class B: BBase() { // implicit label @B
+        val z = "b"
+        override fun zzz() = "b"
+        fun D.foo() : String { // implicit label @foo
+            if(this@A.z != "a") return "Fail1"
+            if(this@B.z != "b") return "Fail2"
+
+            if(super@A.zzz() != "a_base") return "Fail3"
+            if(super<BBase>.zzz() != "b_base") return "Fail4"
+            if(super@B.zzz() != "b_base") return "Fail5"
+            if(this@A.zzz() != "a") return "Fail6"
+            if(this@B.zzz() != "b") return "Fail7"
+
+            if(this.z != "d") return "Fail8"
+
+            return "OK"
+        }
+
+        fun bar(d: D): String {
+            return d.foo()
+        }
+    }
+}
+
+fun box() = A().B().bar(D())
+
+fun main(args : Array<String>) {
+    println(box())
+}

backend.native/tests/codegen/innerClass/simple.kt

@@ -0,0 +1,12 @@
+class Outer {
+    inner class Inner {
+        fun box() = "OK"
+    }
+}
+
+fun box() = Outer().Inner().box()
+
+fun main(args: Array<String>)
+{
+    println(box())
+}

backend.native/tests/codegen/objectExpression/1.kt

@@ -0,0 +1,13 @@
+fun main(args: Array<String>) {
+    val a = "a"
+
+    val x = object {
+        override fun toString(): String {
+            return foo(a) + foo("b")
+        }
+
+        fun foo(s: String) = s + s
+    }
+
+    println(x.toString())
+}

backend.native/tests/codegen/objectExpression/2.kt

@@ -0,0 +1,17 @@
+fun main(args: Array<String>) {
+    val a = "a"
+
+    val x = object {
+        override fun toString(): String {
+            return foo {
+                a
+            }
+        }
+
+        fun foo(lambda: () -> String) = lambda()
+    }
+
+    print(x)
+}
+
+fun print(x: Any) = println(x.toString())

backend.native/tests/codegen/objectExpression/3.kt

@@ -0,0 +1,17 @@
+fun main(args: Array<String>) {
+    var cnt = 0
+
+    var x: Any = ""
+
+    for (i in 0 .. 1) {
+        print(x)
+        cnt++
+        val y = object {
+            override fun toString() = cnt.toString()
+        }
+        x = y
+    }
+    print(x)
+}
+
+fun print(x: Any) = println(x.toString())