JS: move expressions test to box tests

js/js.translator/testData/box/dynamic/_common.js

@@ -0,0 +1,34 @@
+var bar = {
+    boo: function (a) {
+        return "bar.boo(" + a + ")";
+    },
+    invoke: function () {
+        return renderInvocation("bar.invoke", arguments)
+    },
+    num: 42,
+    str: "ok!",
+    obj: {
+        name: "bar.obj"
+    },
+    1: {
+        one: "1.one"
+    },
+    5: 0,
+    0 : "zero",
+    get: function(a, b, c) {
+        return renderInvocation("bar.get", arguments)
+    },
+    set: function(a, b, c) {
+        return renderInvocation("bar.set", arguments)
+    }
+};
+
+var arr = [{ it : "is", 1 : "object" }, 65, undefined, -2, "Yo!"];
+
+function baz() {
+    return renderInvocation("baz", arguments)
+}
+
+function renderInvocation(prefix, args) {
+    return prefix + "(" + Array.prototype.slice.call(args) + ")"
+}

js/js.translator/testData/box/dynamic/_common.kt

@@ -0,0 +1,18 @@
+package foo
+
+@native
+var bar: dynamic = noImpl
+
+@native
+var arr: dynamic = noImpl
+
+@native
+var baz: dynamic = noImpl
+
+object t {
+    override fun toString() = "object t {}"
+}
+
+object n {
+    fun valueOf() = 42
+}

js/js.translator/testData/box/dynamic/binaryOperations.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    assertEquals(60, a * 5)
+    assertEquals(-21.4, a - b)
+    assertEquals("12text", a + c)
+    assertEquals("text foo", c + " foo")
+    assertEquals("text33.4", c + b)
+    assertEquals("12[object Object]", a + bar)
+    assertEquals(2, a % 5)
+    assertEquals("42.35928143712575text[object Object]", a / b + d * n + c + bar)
+    assertEquals("12text[object Object]4233.4", a + c + bar + n + b)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/callGetMethod.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.get()", bar.get())
+    assertEquals("bar.get(some text)", bar.get("some text"))
+    assertEquals("bar.get(1,2,3)", bar.get(1, 2, 3))
+    assertEquals("bar.get(1,second,2,3)", bar.get(1, "second", 2, 3))
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/callMethods.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.boo(23)", bar.boo(23))
+    assertEquals("bar.boo(Hello)", bar.boo("Hello"))
+    assertEquals("bar.boo(object t {})", bar.boo(t))
+    assertEquals("bar.boo(null)", bar.boo(null))
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/callSetMethod.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.set()", bar.set())
+    assertEquals("bar.set(some text)", bar.set("some text"))
+    assertEquals("bar.set(1,2,3)", bar.set(1, 2, 3))
+    assertEquals("bar.set(1,second,2,3)", bar.set(1, "second", 2, 3))
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/compareTo.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    testFalse { a > b }
+    testTrue { b <= 34 }
+    testTrue { c >= "text" }
+    testFalse { c <= "abc" }
+    testTrue { d >= 1 }
+    testFalse { d <= 0 }
+    testTrue { d && true }
+    testTrue { false || d }
+    testFalse { d && a < c }
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/equals.kt

@@ -0,0 +1,47 @@
+package foo
+
+object f {
+    var equalsCalled = 0
+
+    override fun equals(other: Any?): Boolean {
+        equalsCalled++
+        if (equalsCalled > 1) return false
+        return super.equals(other)
+    }
+}
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    val v: dynamic = 42
+    val tt: dynamic = "object t {}"
+
+    testFalse { a == 34 }
+    testFalse { a == "34" }
+    testTrue { a == 12 }
+    testTrue { a == "12" }
+    testFalse { a != 12 }
+    testFalse { a != "12" }
+    testTrue { c == "text" }
+    testTrue { d == 1 }
+    testFalse { d == 0 }
+    testFalse { c != "text" }
+    testTrue { v == n }
+    testTrue { tt == t }
+    testFalse { v == bar }
+    testTrue { n != bar }
+
+    testFalse { a.equals(34) }
+    testFalse { a.equals("34") }
+    testTrue { a.equals(12) }
+    testFalse { a.equals("12") }
+
+    val ff: dynamic = f
+    testFalse { ff.equals(v) }
+    assertEquals(1, f.equalsCalled)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/getByBrackets.kt

@@ -0,0 +1,36 @@
+package foo
+
+fun box(): String {
+    assertEquals(42, bar["num"])
+    assertEquals("ok!", bar["str"])
+    assertEquals(bar.obj, bar["obj"])
+    assertEquals("zero", bar[0])
+    assertEquals("e", bar[0][1])
+    assertEquals(0, bar[5])
+    assertEquals("1.one", bar[1].one)
+    assertEquals("bar.obj", bar.obj["name"])
+    assertEquals("bar.obj", bar["obj"]["name"])
+    assertEquals("baz", baz["name"])
+    assertEquals(0, baz["length"])
+    assertEquals("is", arr["0"].it)
+    assertEquals("object", arr["0"][1])
+    assertEquals("is", arr[0]["it"])
+    assertEquals(undefined, arr[2])
+    assertEquals(-2, arr[3])
+    assertEquals(5, arr["length"])
+
+    assertEquals(undefined, bar["num0"])
+    assertEquals(undefined, bar["STR"])
+    assertEquals(undefined, bar[2])
+    assertEquals(undefined, bar.obj["foo"])
+    assertEquals(undefined, bar["obj"].foo)
+    assertEquals(undefined, bar["obj"]["foo"])
+    assertEquals(undefined, baz[3])
+    assertEquals(undefined, baz["function"])
+    assertEquals(undefined, arr["6"])
+    assertEquals(undefined, arr[7])
+    assertEquals(undefined, arr[10])
+    assertEquals(undefined, arr["name"])
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/identityEquals.kt

@@ -0,0 +1,28 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    val v: dynamic = 42
+    val tt: dynamic = "object t {}"
+
+    testFalse { a === 34 }
+    testFalse { a === "34" }
+    testTrue { a === 12 }
+    testFalse { a === "12" }
+    testFalse { a !== 12 }
+    testTrue { a !== "12" }
+    testTrue { c === "text" }
+    testFalse { d === 1 }
+    testFalse { d === 0 }
+    testFalse { c !== "text" }
+    testFalse { v === n }
+    testFalse { tt === t }
+    testFalse { v === bar }
+    testTrue { n !== bar }
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/in.kt

@@ -0,0 +1,57 @@
+package foo
+
+fun box(): String {
+    testTrue { "num" in bar }
+    testTrue { "str" in bar }
+    testTrue { "obj" in bar }
+    testTrue { 0 in bar }
+    testTrue { 5 in bar }
+    testTrue { 1 in bar }
+    testTrue { "name" in bar.obj }
+    testTrue { "name" in baz }
+    testTrue { "length" in baz }
+    testTrue { "0" in arr }
+    testTrue { 0 in arr }
+    testTrue { 2 in arr }
+    testTrue { 3 in arr }
+    testTrue { "length" in arr }
+
+    testFalse { "num" !in bar }
+    testFalse { "str" !in bar }
+    testFalse { "obj" !in bar }
+    testFalse { 0 !in bar }
+    testFalse { 5 !in bar }
+    testFalse { 1 !in bar }
+    testFalse { "name" !in bar.obj }
+    testFalse { "name" !in baz }
+    testFalse { "length" !in baz }
+    testFalse { "0" !in arr }
+    testFalse { 0 !in arr }
+    testFalse { 2 !in arr }
+    testFalse { 3 !in arr }
+    testFalse { "length" !in arr }
+
+    testFalse { "num0" in bar }
+    testFalse { "STR" in bar }
+    testFalse { 2 in bar }
+    testFalse { "foo" in bar.obj }
+    testFalse { 3 in baz }
+    testFalse { "function" in baz }
+    testFalse { "6" in arr }
+    testFalse { 7 in arr }
+    testFalse { 10 in arr }
+    testFalse { "name" in arr }
+
+    testTrue { "num0" !in bar }
+    testTrue { "STR" !in bar }
+    testTrue { 2 !in bar }
+    testTrue { "foo" !in bar.obj }
+    testTrue { 3 !in baz }
+    testTrue { "function" !in baz }
+    testTrue { "6" !in arr }
+    testTrue { 7 !in arr }
+    testTrue { 10 !in arr }
+    testTrue { "name" !in arr }
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/incrementAndDecrement.kt

@@ -0,0 +1,28 @@
+package foo
+
+fun box(): String {
+    var a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    assertEquals(11, --a)
+    assertEquals(11, a)
+    assertEquals(11, a--)
+    assertEquals(10, a)
+    assertEquals(10, a++)
+    assertEquals(11, a)
+    assertEquals(12, ++a)
+    assertEquals(12, a)
+
+    assertEquals(32.4, --b)
+    assertEquals(32.4, b)
+    assertEquals(32.4, b--)
+    assertEquals(31.4, b)
+    assertEquals(31.4, b++)
+    assertEquals(32.4, b)
+    assertEquals(33.4, ++b)
+    assertEquals(33.4, b)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/infixCall.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.boo(23)", bar boo 23)
+    assertEquals("bar.boo(Hello)", bar boo "Hello")
+    assertEquals("bar.boo(object t {})", bar boo t)
+    assertEquals("bar.boo(null)", bar boo null)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/invoke.kt

@@ -0,0 +1,9 @@
+package foo
+
+fun box(): String {
+    assertEquals("bar.invoke(32,object t {})", bar.invoke(32, t))
+    assertEquals("bar.invoke(77)", bar invoke 77)
+    assertEquals("baz(object t {},object t {})", baz(t, t))
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/is.kt

@@ -0,0 +1,23 @@
+// FILE: is.kt
+package foo
+
+class A
+
+@native
+class B
+
+fun box(): String {
+    val a: dynamic = A()
+    testTrue { a is A }
+    testFalse { a is B }
+
+    val b: dynamic = B()
+    testTrue { b is B }
+    testFalse { b is A }
+
+    return "OK"
+}
+
+// FILE: is.js
+function B() {
+}

js/js.translator/testData/box/dynamic/isJsPrimitiveType.kt

@@ -0,0 +1,32 @@
+package foo
+
+enum class Type {
+    NUMBER,
+    STRING,
+    BOOLEAN,
+    OBJECT
+}
+
+fun test(a: dynamic, actualType: Type) {
+    assertEquals(actualType == Type.NUMBER, a is Int, "$a is Int")
+    assertEquals(actualType == Type.NUMBER, a is Number, "$a is Number")
+    assertEquals(actualType == Type.NUMBER, a is Double, "$a is Double")
+    assertEquals(actualType == Type.BOOLEAN, a is Boolean, "$a is Boolean")
+    assertEquals(actualType == Type.STRING, a is String, "$a is String")
+}
+
+fun box(): String {
+    test(1, Type.NUMBER)
+
+    test(12.3, Type.NUMBER)
+    test(12.3f, Type.NUMBER)
+
+    test("text", Type.STRING)
+
+    test(true, Type.BOOLEAN)
+    test(false, Type.BOOLEAN)
+
+    test(object {}, Type.OBJECT)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/iterator.kt

@@ -0,0 +1,32 @@
+package foo
+
+fun testFor(expected: Int, d: dynamic, case: String) {
+    var actual = 0
+    for (v in d) {
+        actual += v as Int
+    }
+    assertEquals(expected, actual, "testFor on $case")
+}
+
+fun testIterator(expected: Int, d: dynamic, case: String) {
+    var actual = 0
+    val it = d.iterator()
+    while (it.hasNext()) {
+        actual += it.next() as Int
+    }
+    assertEquals(expected, actual, "testIterator on $case")
+}
+
+fun test(expected: Int, d: dynamic, case: String) {
+    testFor(expected, d, case)
+    testIterator(expected, d, case)
+}
+
+fun box(): String {
+    test(6, arrayOf(1, 2, 3), "array")
+    test(64, byteArrayOf(42, 22), "byte array")
+    test(66, listOf(55, 3, 8), "list")
+    test(167, setOf(55, 3, 8, 101), "set")
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/nameClashing.kt

@@ -0,0 +1,26 @@
+package foo
+
+fun assertContains(expectedName: String, f: () -> Unit) {
+    val s = f.toString()
+    assertTrue(s.contains(expectedName), "\"$s\" dosn't contain \"$expectedName\"")
+}
+
+fun box(): String {
+    val d: dynamic = bar
+
+    val a = {
+        val somethingBefore = 1
+        d.somethingBefore
+    }
+
+    assertContains("var somethingBefore = 1;", a)
+
+    val b = {
+        d.somethingAfter
+        val somethingAfter = 1
+    }
+
+    assertContains("var somethingAfter = 1;", b)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/operationsWithAssignment.kt

@@ -0,0 +1,25 @@
+package foo
+
+fun box(): String {
+    var a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    a += d
+    assertEquals(13, a)
+    c += a
+    assertEquals("text13", c)
+    a %= 7
+    assertEquals(6, a)
+    b -= 32
+    assertEquals(1.3999999999999986, b)
+    b *= n
+    assertEquals(58.79999999999994, b)
+    b /= a
+    assertEquals(9.79999999999999, b)
+    c += a * 3 + b / n
+    assertEquals("text1318.233333333333334", c)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/propertyAccess.kt

@@ -0,0 +1,38 @@
+package foo
+
+fun box(): String {
+    assertEquals(42, bar.num)
+    assertEquals("ok!", bar.str)
+    assertEquals("bar.obj", bar.obj.name)
+    assertEquals("baz", baz.name)
+
+    assertEquals(undefined, bar.num0)
+    assertEquals(undefined, bar.str0)
+    assertEquals(undefined, bar.obj.noname)
+    assertEquals(undefined, baz.boo)
+
+
+    bar.num = 22
+    assertEquals(22, bar.num)
+
+    bar.str = undefined
+    assertEquals(undefined, bar.str)
+
+    bar.obj.name = "new bar.obj"
+    assertEquals("new bar.obj", bar.obj.name)
+
+
+    bar.num0 = 100
+    assertEquals(100, bar.num0)
+
+    bar.str0 = "new str"
+    assertEquals("new str", bar.str0)
+
+    bar.obj.noname = "noname value"
+    assertEquals("noname value", bar.obj.noname)
+
+    baz.boo = "baz"
+    assertEquals("baz", baz.boo)
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/setByBrackets.kt

@@ -0,0 +1,62 @@
+package foo
+
+fun box(): String {
+    bar["num"] = "some"
+    assertEquals("some", bar["num"])
+
+    bar["str"] = "OK!"
+    assertEquals("OK!", bar["str"])
+
+    var tmp = bar["obj"]
+    bar["obj"] = bar[0]
+    bar[0] = tmp
+    assertEquals("zero", bar["obj"])
+    assertEquals(tmp, bar[0])
+    assertEquals("bar.obj", bar[0].name)
+
+    bar[5] = 27
+    assertEquals(27, bar[5])
+
+    bar[0]["name"] = "new name"
+    assertEquals("new name", bar[0]["name"])
+
+    arr["0"].it = 23
+    assertEquals(23, arr["0"].it)
+
+    arr[0][1] = "ooo"
+    assertEquals("ooo", arr[0][1])
+
+    arr[2] = 37
+    assertEquals(37, arr[2])
+
+    arr[3] = 77
+    assertEquals(77, arr[3])
+
+    arr["length"] = 3
+    assertEquals(3, arr["length"])
+
+
+    bar["num0"] = "new value"
+    assertEquals("new value", bar["num0"])
+
+    bar["STR"] = 12
+    assertEquals(12, bar["STR"])
+
+
+    bar[2] = "bar[2]"
+    assertEquals("bar[2]", bar[2])
+
+    arr["6"] = "0"
+    assertEquals("0", arr["6"])
+    assertEquals(7, arr.length)
+
+    arr[10] = 15
+    assertEquals(undefined, arr[7])
+    assertEquals(15, arr[10])
+    assertEquals(11, arr.length)
+
+    arr["name"] = "My Array"
+    assertEquals("My Array", arr["name"])
+
+    return "OK"
+}

js/js.translator/testData/box/dynamic/unaryOperations.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    val a: dynamic = 12
+    var b: dynamic = 33.4
+    var c: dynamic = "text"
+    val d: dynamic = true
+
+    assertEquals(-12, -a)
+    assertEquals(33.4, +b)
+    testTrue { d }
+    testFalse { !d }
+    testTrue { !!d }
+    testFalse { !a }
+    testTrue { !!a }
+    testFalse { !b }
+    testTrue { !!b }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/_common.kt

@@ -0,0 +1,25 @@
+package kotlin
+
+// CHECK_NOT_REFERENCED: Kotlin.isInstanceOf
+// CHECK_NOT_REFERENCED: Kotlin.isTypeOf
+// CHECK_NOT_REFERENCED: Kotlin.orNull
+
+fun success(message: String, fn: ()->Unit) {
+    try {
+        fn()
+    }
+    catch (e: Exception) {
+        throw Exception("Exception was thrown: message=$message, exception=$e")
+    }
+}
+
+fun failsClassCast(message: String, fn: ()->Unit) {
+    try {
+        fn()
+    }
+    catch (e: ClassCastException) {
+        return
+    }
+
+    throw Exception("Expected ClassCastException to be thrown: message=$message")
+}

js/js.translator/testData/box/expression/cast/castExtensionToKMutableProperty.kt

@@ -0,0 +1,21 @@
+package foo
+
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KMutableProperty1
+
+class A
+
+var A.x: Int
+    get() = 23
+    set(value) { }
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(true, (A::x as Any) is KMutableProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(23, ((A::x as Any) as KMutableProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KMutableProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KMutableProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castExtensionToKProperty1.kt

@@ -0,0 +1,17 @@
+package foo
+
+import kotlin.reflect.KProperty1
+
+class A
+
+val A.x: Int
+    get() = 23
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToAny.kt

@@ -0,0 +1,20 @@
+package foo
+
+class A
+
+fun box(): String {
+    val nil: A? = null
+    val a = A()
+
+    success("10 as Any") { assertEquals<Any>(10, 10 as Any) }
+    success("\"abc\" as Any") { assertEquals<Any>("abc", "abc" as Any) }
+    success("\"abc\" as Any") { assertEquals<Any>(true, true as Any) }
+    val array = arrayOf(1, 2)
+    success("arrayOf(1, 2) as Any") { assertEquals<Any>(array, array as Any) }
+    success("{ 0 } as Any") { { 0 } as Any }
+    success("a as Any") { assertEquals<Any>(a, a as Any) }
+    success("object{} as Any") { object{} as Any }
+    failsClassCast("nil as Any") { nil as Any }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToArray.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    val ints: Any? = arrayOf(1, 2)
+    val strings: Any? = arrayOf("a", "b")
+    val nil: Any? = null
+    val obj: Any? = object{}
+
+    success("ints") { ints as Array<*> }
+    success("strings") { strings as Array<*> }
+    failsClassCast("null") { nil as Array<*> }
+    failsClassCast("obj") { obj as Array<*> }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToFunction.kt

@@ -0,0 +1,13 @@
+package foo
+
+fun test(fn: Any?): Function0<Int> =
+        fn as Function0<Int>
+
+fun box(): String {
+    val get11: Any? = { 11 }
+    assertEquals(11, test(get11)(), "get11")
+    failsClassCast("null") { test(null)() }
+    failsClassCast("object {}") { test(object {})() }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToGenericType.kt

@@ -0,0 +1,50 @@
+package foo
+
+class A(val s: String)
+
+fun <T> castsNotNullToNullableT(a: Any) {
+    a as T
+    a as T?
+    a as? T
+    a as? T?
+}
+
+fun <T> castsNullableToNullableT(a: Any?) {
+    a as T
+    a as T?
+    a as? T
+    a as? T?
+}
+
+
+fun <T : Any> castsNotNullToNotNullT(a: Any) {
+    a as T
+    a as T?
+    a as? T
+    a as? T?
+}
+
+fun <T : Any> castNullableToNotNullT(a: Any?) {
+    a as T
+}
+
+fun <T : Any> castsNullableToNotNullT(a: Any?) {
+    a as T?
+    a as? T
+    a as? T?
+}
+
+fun box(): String {
+    val a = A("OK")
+
+    success("castsNotNullToNullableT<A>(a)") { castsNotNullToNullableT<A>(a) }
+    success("castsNullableToNullableT<A>(a)") { castsNullableToNullableT<A>(a) }
+    success("castsNullableToNullableT<A>(null)") { castsNullableToNullableT<A>(null) }
+    success("castsNotNullToNotNullT<A>(a)") { castsNotNullToNotNullT<A>(a) }
+    success("castsNullableToNotNullT<A>(a)") { castsNullableToNotNullT<A>(a) }
+    success("castsNullableToNotNullT<A>(null)") { castsNullableToNotNullT<A>(null) }
+    success("castNullableToNotNullT<A>(a)") { castNullableToNotNullT<A>(a) }
+    failsClassCast("castNullableToNotNullT<A>(null)") { castNullableToNotNullT<A>(null) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToGenericTypeWithMultipleUpperBounds.kt

@@ -0,0 +1,59 @@
+package foo
+
+open class A()
+
+interface X
+
+interface Y
+
+class B() : A(), X, Y {
+    override fun toString() = "B"
+}
+
+class C() : A(), X, Y {
+    override fun toString() = "C"
+}
+
+class D() : A() {
+    override fun toString() = "D"
+}
+
+class E() : X {
+    override fun toString() = "E"
+}
+
+class F() : A(), Y {
+    override fun toString() = "E"
+}
+
+fun <T> test(a: Any): String where T : A, T : X, T : Y {
+    return (try {
+        a as T
+    }
+    catch (e: Exception) {
+        "error"
+    }).toString()
+}
+
+fun box(): String {
+    val b = B()
+    val c = C()
+    val d = D()
+    val e = E()
+    val f = F()
+
+    assertEquals("B", test<B>(b))
+    assertEquals("B", test<C>(b))
+
+    assertEquals("C", test<B>(c))
+    assertEquals("C", test<C>(c))
+
+    assertEquals("error", test<B>(d))
+    assertEquals("error", test<C>(d))
+    assertEquals("error", test<B>(e))
+    assertEquals("error", test<C>(e))
+    assertEquals("error", test<B>(f))
+    assertEquals("error", test<C>(f))
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToGenericTypeWithUpperBound.kt

@@ -0,0 +1,39 @@
+package foo
+
+open class A
+class B : A()
+class C
+
+fun <T : A> notNullToNotNullT(a: Any): T = a as T
+
+fun <T : A> nullableToNotNullT(a: Any?): T = a as T
+
+fun <T : A> notNullToNullableT(a: Any): T? = a as T?
+
+fun <T : A> nullableToNullableT(a: Any?): T? = a as T?
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    val c = C()
+
+    success("notNullToNotNullT<A>(a)") { assertEquals(a, notNullToNotNullT<A>(a)) }
+    success("notNullToNotNullT<A>(b)") { assertEquals(b, notNullToNotNullT<A>(b)) }
+    failsClassCast("notNullToNotNullT<A>(c)") { notNullToNotNullT<A>(c) }
+
+    success("nullableToNotNullT<A>(a)") {assertEquals(a, nullableToNotNullT<A>(a)) }
+    success("nullableToNotNullT<A>(b)") {assertEquals(b, nullableToNotNullT<A>(b)) }
+    failsClassCast("nullableToNotNullT<A>(c)") { nullableToNotNullT<A>(c) }
+    failsClassCast("nullableToNotNullT<A>(null)") { nullableToNotNullT<A>(null) }
+
+    success("notNullToNullableT<A>(a)") {  assertEquals(a, notNullToNullableT<A>(a))}
+    success("notNullToNullableT<A>(b)") {  assertEquals(b, notNullToNullableT<A>(b))}
+    failsClassCast("notNullToNullableT<A>(c)") { notNullToNullableT<A>(c) }
+
+    success("nullableToNullableT<A>(a)") { assertEquals(a, nullableToNullableT<A>(a)) }
+    success("nullableToNullableT<A>(b)") { assertEquals(b, nullableToNullableT<A>(b)) }
+    success("nullableToNullableT<A>(null)") { assertEquals(null, nullableToNullableT<A>(null)) }
+    failsClassCast("nullableToNullableT<A>(c)") { nullableToNullableT<A>(c) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKMutableProperty0.kt

@@ -0,0 +1,17 @@
+package foo
+
+import kotlin.reflect.KProperty0
+import kotlin.reflect.KMutableProperty0
+
+var x = 23
+
+fun box(): String {
+    assertEquals(true, (::x as Any) is KProperty0<*>)
+    assertEquals(true, (::x as Any) is KMutableProperty0<*>)
+    assertEquals(23, ((::x as Any) as KProperty0<Any>)())
+    assertEquals(23, ((::x as Any) as KMutableProperty0<Any>)())
+    assertEquals(false, (23 as Any) is KMutableProperty0<*>)
+    assertEquals(false, ({ x } as Any) is KMutableProperty0<*>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKMutableProperty1.kt

@@ -0,0 +1,20 @@
+package foo
+
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KMutableProperty1
+
+class A {
+    var x = 23
+}
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(true, (A::x as Any) is KMutableProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(23, ((A::x as Any) as KMutableProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KProperty1<*, *>)
+    assertEquals(false, (23 as Any) is KMutableProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KMutableProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKProperty0.kt

@@ -0,0 +1,14 @@
+package foo
+
+import kotlin.reflect.KProperty0
+
+val x = 23
+
+fun box(): String {
+    assertEquals(true, (::x as Any) is KProperty0<*>)
+    assertEquals(23, ((::x as Any) as KProperty0<Any>)())
+    assertEquals(false, (23 as Any) is KProperty0<*>)
+    assertEquals(false, ({ x } as Any) is KProperty0<*>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToKProperty1.kt

@@ -0,0 +1,16 @@
+package foo
+
+import kotlin.reflect.KProperty1
+
+class A {
+    val x = 23
+}
+
+fun box(): String {
+    assertEquals(true, (A::x as Any) is KProperty1<*, *>)
+    assertEquals(23, ((A::x as Any) as KProperty1<A, Any>)(A()))
+    assertEquals(false, (23 as Any) is KProperty1<*, *>)
+    assertEquals(false, ({ A().x } as Any) is KProperty1<*, *>)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToNotNull.kt

@@ -0,0 +1,18 @@
+package foo
+
+interface A
+
+class AImpl: A
+
+fun test(x: Any?): A = x as A
+
+fun box(): String {
+    var a: A = AImpl()
+    assertEquals(a, test(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test(a), "a = object : A{}")
+    failsClassCast("test(null)") { test(null) }
+    failsClassCast("test(object{})") { test(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/castToNullable.kt

@@ -0,0 +1,18 @@
+package foo
+
+interface A
+
+class AImpl : A {}
+
+fun test(x: Any?): A? = x as A?
+
+fun box(): String {
+    var a: A? = AImpl()
+    assertEquals(a, test(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test(a), "a = object : A{}")
+    assertEquals(null, test(null), "test(null)")
+    failsClassCast("test(object{})") { test(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/implicitCastToLong.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    var a: Long = 23
+    var b: Long = 200 + 30
+    var c: Long = id((2000).plus(300))
+
+    assertEquals(24L, a + 1)
+    assertEquals(231L, b + 1)
+    assertEquals(2301L, c + 1)
+
+    return "OK"
+}
+
+fun id(x: Long) = x

js/js.translator/testData/box/expression/cast/noRuntimeTypeCheck.kt

@@ -0,0 +1,28 @@
+package foo
+
+// CHECK_NOT_CALLED_IN_SCOPE: scope=box function=isType
+
+open class A()
+
+class B() : A()
+
+fun box(): String {
+    assertTrue(B() is A)
+    assertTrue(B() is A?)
+    assertTrue(B() is B)
+    assertTrue(B() is B?)
+    assertTrue((B() as B?) is A?)
+    assertTrue((null as A?) is A?)
+
+    assertNotEquals(null, B() as? A)
+    assertNotEquals(null, B() as? A?)
+    assertNotEquals(null, B() as? B)
+    assertNotEquals(null, B() as? B?)
+
+    assertNotEquals(null, B() as A)
+    assertNotEquals(null, B() as A?)
+    assertNotEquals(null, B() as B)
+    assertNotEquals(null, B() as B?)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/primitiveToClass.kt

@@ -0,0 +1,19 @@
+package foo
+
+interface A
+
+class B
+
+fun box(): String {
+    assertEquals(false, (23 as Any) is A)
+    assertEquals(false, (23 as Any) is B)
+    assertEquals(false, (23L as Any) is A)
+    assertEquals(false, (23L as Any) is B)
+    assertEquals(false, ("qwe" as Any) is A)
+    assertEquals(false, ("qwe" as Any) is B)
+    assertEquals(false, ({ 23 } as Any) is A)
+    assertEquals(false, ({ 23 } as Any) is B)
+    assertEquals(false, (true as Any) is A)
+    assertEquals(false, (true as Any) is B)
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/reifiedToNotNull.kt

@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: test
+
+interface A
+
+class AImpl: A
+
+inline
+fun <reified T> test(x: Any?): T = x as T
+
+fun box(): String {
+    var a: A = AImpl()
+    assertEquals(a, test<A>(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test<A>(a), "a = object : A{}")
+    failsClassCast("test(null)") { test<A>(null) }
+    failsClassCast("test(object{})") { test<A>(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/reifiedToNullable1.kt

@@ -0,0 +1,19 @@
+package foo
+
+interface A
+
+class AImpl : A {}
+
+inline
+fun <reified T> test(x: Any?): T = x as T
+
+fun box(): String {
+    var a: A? = AImpl()
+    assertEquals(a, test<A?>(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test<A?>(a), "a = object : A{}")
+    assertEquals(null, test<A?>(null), "test(null)")
+    failsClassCast("test(object{})") { test<A?>(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/reifiedToNullable2.kt

@@ -0,0 +1,19 @@
+package foo
+
+interface A
+
+class AImpl : A {}
+
+inline
+fun <reified T> test(x: Any?): T? = x as T?
+
+fun box(): String {
+    var a: A? = AImpl()
+    assertEquals(a, test<A>(a), "a = AImpl()")
+    a = object : A {}
+    assertEquals(a, test<A>(a), "a = object : A{}")
+    assertEquals(null, test<A>(null), "test(null)")
+    failsClassCast("test(object{})") { test<A>(object{}) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToGenericTypeWithUpperBound.kt

@@ -0,0 +1,26 @@
+package foo
+
+open class A
+class B : A()
+class C
+
+fun <T : A> notNullToNullableT(a: Any): T? = a as? T?
+
+fun <T : A> nullableToNullableT(a: Any?): T? = a as? T?
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    val c = C()
+
+    success("notNullToNullableT<A>(a)") { assertEquals(a, notNullToNullableT<A>(a)) }
+    success("notNullToNullableT<A>(b)") { assertEquals(b, notNullToNullableT<A>(b)) }
+    success("notNullToNullableT<A>(c)") { assertEquals(null, notNullToNullableT<A>(c)) }
+
+    success("nullableToNullableT<A>(a)") { assertEquals(a, nullableToNullableT<A>(a)) }
+    success("nullableToNullableT<A>(b)") { assertEquals(b, nullableToNullableT<A>(b)) }
+    success("nullableToNullableT<A>(null)") { assertEquals(null, nullableToNullableT<A>(null)) }
+    success("nullableToNullableT<A>(c)") { assertEquals(null, nullableToNullableT<A>(c)) }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToNotNull.kt

@@ -0,0 +1,16 @@
+package foo
+
+class A
+class B
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a as? A, "a")
+    assertEquals(null, nil as? A, "nil")
+    assertEquals(null, b as? A, "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToNullable.kt

@@ -0,0 +1,16 @@
+package foo
+
+class A
+class B
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a as? A?, "a")
+    assertEquals(null, nil as? A?, "nil")
+    assertEquals(null, b as? A?, "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToReifiedNotNull.kt

@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: castTo
+
+class A
+class B
+
+inline
+fun <reified T> Any?.castTo(): T? = this as? T
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a.castTo<A>(), "a")
+    assertEquals(null, nil.castTo<A>(), "nil")
+    assertEquals(null, b.castTo<A>(), "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/safeCastToReifiedNullable.kt

@@ -0,0 +1,21 @@
+package foo
+
+// CHECK_NOT_CALLED: castTo
+
+class A
+class B
+
+inline
+fun <reified T> Any?.castTo(): T? = this as? T?
+
+fun box(): String {
+    val a: Any? = A()
+    val nil: Any? = null
+    val b: Any? = B()
+
+    assertEquals(a, a.castTo<A>(), "a")
+    assertEquals(null, nil.castTo<A>(), "nil")
+    assertEquals(null, b.castTo<A>(), "b")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/smartCastInExtensionFunction.kt

@@ -0,0 +1,55 @@
+package foo
+
+class A {
+    fun foo(a: Int) = "A.foo($a)"
+}
+
+fun Any.bar() = "Any.bar()"
+fun A.bar() = "A.bar()"
+
+fun boo(a: Any) = "boo(Any)"
+fun boo(a: A) = "boo(A)"
+
+fun Any.testInTopLevel() {
+    assertEquals(bar(), "Any.bar()", "bar()")
+    assertEquals(this.bar(), "Any.bar()", "this.bar()")
+    assertEquals(boo(this), "boo(Any)", "boo(this)")
+
+    if (this is A) {
+        assertEquals(foo(47), "A.foo(47)", "foo(47)")
+        assertEquals(bar(), "A.bar()", "bar()")
+
+        assertEquals(this.foo(47), "A.foo(47)", "this.foo(47)")
+        assertEquals(this.bar(), "A.bar()", "this.bar()")
+
+        assertEquals(boo(this), "boo(A)", "boo(this: A)")
+    }
+}
+
+class B {
+    fun Any.test() {
+        assertEquals(bar(), "Any.bar()", "bar()")
+        assertEquals(this.bar(), "Any.bar()", "this.bar()")
+        assertEquals(boo(this), "boo(Any)", "boo(this)")
+
+        if (this is A) {
+            assertEquals(foo(47), "A.foo(47)", "foo(47)")
+            assertEquals(bar(), "A.bar()", "bar()")
+
+            assertEquals(this.foo(47), "A.foo(47)", "this.foo(47)")
+            assertEquals(this.bar(), "A.bar()", "this.bar()")
+
+            assertEquals(boo(this), "boo(A)", "boo(this: A)")
+        }
+    }
+
+    fun testInClass() {
+        A().test()
+    }
+}
+
+fun box(): String {
+    A().testInTopLevel()
+    B().testInClass()
+    return "OK"
+}

js/js.translator/testData/box/expression/cast/smartCastInFunction.kt

@@ -0,0 +1,45 @@
+package foo
+
+class A {
+    fun foo(a: Int) = "A.foo($a)"
+}
+
+fun Any.bar() = "Any.bar()"
+fun A.bar() = "A.bar()"
+
+fun boo(a: Any) = "boo(Any)"
+fun boo(a: A) = "boo(A)"
+
+fun testInTopLevel(a: Any) {
+    assertEquals(a.bar(), "Any.bar()", "bar()")
+    assertEquals(a.bar(), "Any.bar()", "this.bar()")
+    assertEquals(boo(a), "boo(Any)", "boo(this)")
+
+    if (a is A) {
+        assertEquals(a.foo(47), "A.foo(47)", "a.foo(47)")
+        assertEquals(a.bar(), "A.bar()", "a.bar()")
+        assertEquals(boo(a), "boo(A)", "boo(a: A)")
+    }
+}
+
+class B {
+    fun testInClass(a: Any) {
+        assertEquals(a.bar(), "Any.bar()", "bar()")
+        assertEquals(a.bar(), "Any.bar()", "this.bar()")
+        assertEquals(boo(a), "boo(Any)", "boo(this)")
+
+        if (a is A) {
+            assertEquals(a.foo(47), "A.foo(47)", "a.foo(47)")
+            assertEquals(a.bar(), "A.bar()", "a.bar()")
+            assertEquals(boo(a), "boo(A)", "boo(a: A)")
+        }
+    }
+
+}
+
+fun box(): String {
+    testInTopLevel(A())
+    B().testInClass(A())
+
+    return "OK"
+}

js/js.translator/testData/box/expression/compareTo/customCompareToMethod.kt

@@ -0,0 +1,39 @@
+package foo
+
+class A(val value: Int) : Comparable<A> {
+    override public fun compareTo(other: A): Int = other.value.compareTo(value)
+}
+
+class B(val value: Int)
+
+fun testExtensionFunctionAsCompareTo() {
+    val compareTo: B.( B ) -> Int = { other -> other.value.compareTo(this.value) }
+
+    val x: B = B(100)
+    val y: B = B(200)
+
+    assertEquals(1, x.compareTo(y), "ext fun: x compareTo y")
+}
+
+fun testMethodAsCompareTo() {
+    val x: A = A(100)
+    val y: A = A(200)
+
+    assertEquals(false, x < y, "meth: x < y")
+    assertEquals(true, x > y, "meth: x > y")
+    assertEquals(1, x.compareTo(y), "meth: x compareTo y")
+
+    val comparable: Comparable<A> = x
+    assertEquals(false, comparable < y, "meth: (x: Comparable<A>) < y")
+    assertEquals(true, comparable > y, "meth: (x: Comparable<A>) > y")
+    assertEquals(1, comparable.compareTo(y), "meth: (x: Comparable<A>) compareTo y")
+}
+
+fun box(): String {
+
+    testExtensionFunctionAsCompareTo()
+
+    testMethodAsCompareTo()
+
+    return "OK"
+}

js/js.translator/testData/box/expression/dollarParameter/dollarParameter.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun MyController(`$scope`: String): String {
+    return "Hello " + `$scope` + "!"
+}
+
+fun box(): String {
+    assertEquals("Hello world!", MyController("world"))
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/arrays.kt

@@ -0,0 +1,13 @@
+package foo
+
+fun box(): String {
+    val a = arrayOf(1, 2, 3)
+    val b = arrayOf(1, 2, 3)
+    val c = a
+
+    if (a == b) return "fail1"
+    if (a != c) return "fail2"
+    if (c == b) return "fail3"
+
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/compareNullableListWithNull.kt

@@ -0,0 +1,14 @@
+// KT-3518 Null pointer during null comparison in JS Backend
+package foo
+
+class MyClazz(val nullableL : List<String>?)
+
+fun box(): String {
+    val a = MyClazz(null)
+    if(a.nullableL != null) return "a.nullableL != null"
+
+    val b = MyClazz(listOf("somthing"))
+    if(b.nullableL == null) return "b.nullableL == null"
+
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/compareNullablesWithCustomEquals.kt

@@ -0,0 +1,47 @@
+package foo
+
+class A {
+    override fun equals(other: Any?) = this === other
+}
+
+fun box(): String {
+    val a: A? = null
+    val b: A? = null
+    val c: A? = A()
+    val d: A? = A()
+    val e: A = A()
+
+    // compare nullable vals with null
+    testTrue { a == b }
+    testTrue { a == a }
+    testFalse { a != b }
+    testFalse { a != a }
+
+    // compare null and non-null inside nullable vals
+    testFalse { a == c }
+    testTrue { a != c }
+    testFalse { c == a }
+    testTrue { c != a }
+
+    // compare nullables vals with non-null
+    testFalse { c == d }
+    testTrue { c == c }
+    testTrue { c != d }
+    testFalse { d == c }
+    testTrue { d != c }
+    testFalse { d != d }
+
+    // compare nullable val with null with non-nullable
+    testFalse { a == e }
+    testTrue { a != e }
+    testFalse { e == a }
+    testTrue { e != a }
+
+    // compare nullable val with non-null with non-nullable
+    testFalse { c == e }
+    testTrue { c != e }
+    testFalse { e == c }
+    testTrue { e != c }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/compareToNullWithCustomEquals.kt

@@ -0,0 +1,16 @@
+package foo
+
+class A {
+    override fun equals(other: Any?) = super.equals(other)
+}
+
+fun box(): String {
+    val a: A? = null
+
+    testTrue { a == null }
+    testFalse { a != null }
+    testTrue { null == a }
+    testFalse { null != a }
+
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/customEqualsMethod.kt

@@ -0,0 +1,24 @@
+package foo
+
+class Foo(val name: String) {
+    override fun equals(other: Any?): Boolean {
+        if (other !is Foo) {
+            return false
+        }
+        return this.name == other.name
+    }
+}
+
+fun callEqualsMethod(v1: Foo?, v2: Foo?): Boolean {
+    return v1 == v2
+}
+
+fun box(): String {
+    val a = Foo("abc")
+    val b = Foo("abc")
+    val c = Foo("def")
+
+    if (!callEqualsMethod(a, b)) return "fail1"
+    if (callEqualsMethod(a, c)) return "fail2"
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/customEqualsMethodOnAny.kt

@@ -0,0 +1,24 @@
+package foo
+
+class Foo(val name: String) {
+    override fun equals(other: Any?): Boolean {
+        if (other !is Foo) {
+            return false
+        }
+        return this.name == other.name
+    }
+}
+
+fun callEqualsMethod(v1: Any?, v2: Any?): Boolean {
+    return v1 == v2
+}
+
+fun box(): String {
+    val a = Foo("abc")
+    val b = Foo("abc")
+    val c = Foo("def")
+
+    if (!callEqualsMethod(a, b)) return "fail1"
+    if (callEqualsMethod(a, c)) return "fail2"
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/equalsBehaviorOnNull.kt

@@ -0,0 +1,23 @@
+package foo
+
+var log = ""
+
+class A {
+    override fun equals(o: Any?): Boolean {
+        log += "$o;"
+        return true
+    }
+}
+
+fun box(): String {
+    val a = A()
+
+    assertTrue(a.equals("aaa"))
+    assertEquals("aaa;", log)
+    assertFalse(a == null)
+    assertEquals("aaa;", log)
+    assertTrue(a.equals(null))
+    assertEquals("aaa;null;", log)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/equalsNullOrUndefined.kt

@@ -0,0 +1,23 @@
+package foo
+
+fun box(): String {
+    val a: Int? = null
+    val r = a == null
+    if (!r || a != null)
+        return "wrong result on simple nullable check"
+
+    //force using Kotlin.equals
+    val t = null
+    if (t != undefined)
+        return "wrong result when compare null and undefined using Kotlin.equals"
+
+    var i = 0;
+    fun foo(): Int? = ++i;
+    if (foo() == null)
+        return "wrong result on nullable check with side effects"
+
+    if (i != 1)
+        return "wrong affects when using nullable check with side effects"
+
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/explicitEqualsMethod.kt

@@ -0,0 +1,28 @@
+package foo
+
+class Foo(val name: String) {
+    override fun equals(other: Any?): Boolean {
+        if (other !is Foo) {
+            return false
+        }
+        return this.name == other.name
+    }
+}
+
+class Bar() {
+
+}
+
+fun box(): String {
+    val a = Foo("abc")
+    val b = Foo("abc")
+    val c = Foo("def")
+
+    if (!(a.equals(b))) return "fail1"
+    if (a.equals(c)) return "fail2"
+    if (Bar().equals(Bar())) return "fail3"
+    val g = Bar()
+    if (!(g.equals(g))) return "fail4"
+    if (g.equals(Bar())) return "fail5"
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/explicitEqualsMethodForPrimitives.kt

@@ -0,0 +1,21 @@
+package foo
+
+fun box(): String {
+    val a = 2
+    if (!(a.equals(a))) return "fail1"
+    if (!(a.equals(2))) return "fail2"
+    if (!(a.equals(2.0))) return "fail3"
+    val c = "a"
+    if (!("a".equals(c))) return "fail4"
+    if (!((null as Any?)?.equals(null) ?: true)) return "fail5"
+    val d = 5.6
+    if (!(d.toShort().equals(5.toShort()))) return "fail6"
+    if (!(d.toByte().equals(5.toByte()))) return "fail7"
+    if (!(d.toFloat().equals(5.6.toFloat()))) return "fail8"
+    if (!(d.toInt().equals(5))) return "fail9"
+    if (true.equals(false)) return "fail10"
+
+    val n: Number = 3
+    if (!(n.equals(3.3.toInt()))) return "fail11"
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/kt2370.kt

@@ -0,0 +1,13 @@
+package foo
+
+import java.util.*
+
+fun box(): String {
+    val data = ArrayList<String>()
+    data.add("foo")
+    data.add("bar")
+    data.add("whatnot")
+    val data2 = ArrayList<String>()
+    data2.addAll(data)
+    return if (data.equals(data2)) "OK" else "fail"
+}

js/js.translator/testData/box/expression/equals/stringsEqual.kt

@@ -0,0 +1,12 @@
+package foo
+
+fun box(): String {
+    val a = "abc"
+    val b = "abc"
+    val c = "def"
+
+    if (a != b) return "fail1"
+    if (a == c) return "fail2"
+
+    return "OK"
+}

js/js.translator/testData/box/expression/equals/superEquals.kt

@@ -0,0 +1,51 @@
+package foo
+
+open class A {
+    var log = ""
+
+    var called = false
+
+    override fun equals(other: Any?): Boolean {
+        if (called) fail("recursion detected")
+
+        log += "A.equals;"
+
+        called = true
+        val result = super.equals(other)
+        called = false
+        return result
+    }
+}
+
+class B : A() {
+    override fun equals(other: Any?): Boolean {
+        log += "B.equals;"
+        if (other == null) return false
+        return super.equals(other)
+    }
+}
+
+
+fun box(): String {
+    val a = A()
+    testFalse { a == A() }
+    assertEquals("A.equals;", a.log)
+
+    val b1 = B()
+    testTrue { b1 == b1 }
+    assertEquals("B.equals;A.equals;", b1.log)
+
+    val b2 = B()
+    testFalse { b2 == B() }
+    assertEquals("B.equals;A.equals;", b2.log)
+
+    val b3 = B()
+    testFalse { b3 == null }
+    assertEquals("", b3.log)
+
+    val b4 = B()
+    testFalse { b4.equals(null) }
+    assertEquals("B.equals;", b4.log)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/2dangerousInExpression.kt

@@ -0,0 +1,26 @@
+package foo
+
+fun box(): String {
+    if (f(0) != -3) {
+        return "fail1"
+    }
+    if (f(102) != 201) {
+        return "fail2"
+    }
+    if (f(103) != 100) {
+        return "fail3"
+    }
+    if (f(-100) != -100) {
+        return "fail4"
+    }
+    if (f(-99) != -201) {
+        return "fail5"
+    }
+
+    return "OK"
+}
+
+fun f(i: Int): Int {
+    var j = i
+    return --j + (if (j < -100) return -100 else --j) + (if (j > 100) return 100 else 0)
+}

js/js.translator/testData/box/expression/evaluationOrder/andAndWithBreakContinueReturn.kt

@@ -0,0 +1,97 @@
+package foo
+
+var global: String = ""
+
+fun id(s: String, b: Boolean): Boolean {
+    global += s
+    return b
+}
+
+fun bar(b: Boolean): String {
+    if (id("A", b) && return "A")
+        return "B"
+    else
+        return "C"
+}
+
+fun testBreak(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) && break
+    }
+    assertEquals(expected, i, "break 1")
+    assertEquals("A", global, "break 1")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) && break
+        }
+    }
+    assertEquals(expected, i, "break 2")
+    assertEquals("A", global, "break 2")
+}
+
+fun testContinue(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) && continue
+        n++
+    }
+    assertEquals(expected, n, "continue 1")
+    assertEquals("A", global, "continue 1")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) && continue
+            assertEquals(x, b)
+        }
+        n++
+    }
+    assertEquals(expected, n, "continue 2")
+    assertEquals("A", global, "continue 2")
+}
+
+fun box(): String {
+    var b: Boolean
+
+    testBreak(true, 2)
+    testBreak(false, 6)
+
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) break && id("A", false)
+    }
+    assertEquals(2, i, "break && false")
+    assertEquals("", global, "break && false")
+
+    testContinue(true, 4)
+    testContinue(false, 5)
+
+    global = ""
+    i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) continue && id("A", false)
+        n++
+    }
+    assertEquals(4, n, "continue && false")
+    assertEquals("", global, "continue && false")
+
+    assertEquals("A", bar(true), "bar")
+    assertEquals("A", global, "bar")
+
+    global = ""
+    assertEquals("C", bar(false))
+    assertEquals("A", global, "bar")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/andAndWithSideEffect.kt

@@ -0,0 +1,81 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String, value: Boolean): Boolean {
+    global += s
+    return value
+}
+
+fun box(): String {
+
+    // Simple && Simple
+    global = ""
+    assertEquals(true, bar("A", true) && bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", true) && bar("B", false))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && bar("B", false))
+    assertEquals("A", global)
+
+    // Simple && Complex
+    global = ""
+    assertEquals(true, bar("A", true) && try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", true) && try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) && try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    // Complex && Simple
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} && bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", true) } finally {} && bar("B", false))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && bar("B", false))
+    assertEquals("A", global)
+
+    // Complex && Complex
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} && try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", true) } finally {} && try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} && try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/assignToArrayElementWithSideEffect.kt

@@ -0,0 +1,79 @@
+package foo
+
+var global: String = ""
+
+class A {
+    var prop: Int = 0
+}
+
+fun bar(s: String, index: Int): Int {
+    global += s
+    return index
+}
+
+val baz: Int
+    get() {
+        global += ":baz:"; return 1
+    }
+
+fun box(): String {
+    val a = arrayOf(0,1,2,3)
+
+
+    global = ""
+    a[bar("A", 1)] = try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a[1])
+
+    global = ""
+    a[bar("A", 1)] += try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(20, a[1])
+
+    global = ""
+    a[bar("A", 1)] -= try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a[1])
+
+    global = ""
+    a[bar("A", 1)] *= try { global += "B"; 2 } finally {}
+    assertEquals("AB", global)
+    assertEquals(20, a[1])
+
+    global = ""
+    a[bar("A", 1)] /= try { global += "B"; 5 } finally {}
+    assertEquals("AB", global)
+    assertEquals(4, a[1])
+
+    global = ""
+    a[bar("A", 1)] %= try { global += "B"; 3 } finally {}
+    assertEquals("AB", global)
+    assertEquals(1, a[1])
+
+    global = ""
+    a[bar("A", 1)]++
+    assertEquals("A", global)
+    assertEquals(2, a[1])
+
+    global = ""
+    a[try { bar("A", 1)} finally {}]++
+    assertEquals("A", global)
+    assertEquals(3, a[1])
+
+    global = ""
+    ++a[bar("A", 1)]
+    assertEquals("A", global)
+    assertEquals(4, a[1])
+
+    global = ""
+    ++a[try { bar("A", 1)} finally {}]
+    assertEquals("A", global)
+    assertEquals(5, a[1])
+
+    global = ""
+    a[baz] = try { global += "right"; 100 } finally {}
+    assertEquals(":baz:right", global)
+    assertEquals(100, a[1])
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/assignToDotQualifiedWithSideEffect.kt

@@ -0,0 +1,59 @@
+package foo
+
+var global: String = ""
+
+class A {
+    var prop: Int = 0
+}
+
+fun bar(s: String, a: A): A {
+    global += s
+    return a
+}
+
+
+fun box(): String {
+    val a = A()
+
+    global = ""
+    bar("A", a).prop = try { global += "B"; 10 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a.prop)
+
+    global = ""
+    bar("A", a).prop += try { global += "B"; 20 } finally {}
+    assertEquals("AB", global)
+    assertEquals(30, a.prop)
+
+    global = ""
+    bar("A", a).prop -= try { global += "B"; 20 } finally {}
+    assertEquals("AB", global)
+    assertEquals(10, a.prop)
+
+    global = ""
+    bar("A", a).prop *= try { global += "B"; 2 } finally {}
+    assertEquals("AB", global)
+    assertEquals(20, a.prop)
+
+    global = ""
+    bar("A", a).prop /= try { global += "B"; 5 } finally {}
+    assertEquals("AB", global)
+    assertEquals(4, a.prop)
+
+    global = ""
+    bar("A", a).prop %= try { global += "B"; 3 } finally {}
+    assertEquals("AB", global)
+    assertEquals(1, a.prop)
+
+    global = ""
+    (try { bar("A", a) } finally {}).prop++
+    assertEquals("A", global)
+    assertEquals(2, a.prop)
+
+    global = ""
+    ++(try { bar("A", a) } finally {}).prop
+    assertEquals("A", global)
+    assertEquals(3, a.prop)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/callArgs.kt

@@ -0,0 +1,48 @@
+package foo
+
+var global = ""
+
+fun addToGlobal(s: String): String {
+    global += s
+    return ""
+}
+
+fun bar(s: String, u: Int) { global += ":bar:${s}" }
+
+class A() {
+    fun memFun(s: String) { global += ":memFun:${s}" }
+}
+
+class B() {
+    fun A.bExt(s: String) { global += ":bExt:${s}" }
+
+    fun baz(s: String, a: A) = a.bExt(s)
+}
+
+fun A.extFun(s: String) { global += ":extFun:${s}" }
+
+fun box(): String {
+
+    bar(addToGlobal("A"), try { global += "B"; 10 } finally {})
+    assertEquals("AB:bar:", global)
+
+    global = ""
+    val a = A()
+    a.memFun(try { "A" } finally {})
+    assertEquals(":memFun:A", global)
+
+    global = ""
+    (try { global += "A"; a } finally {}).memFun("B")
+    assertEquals("A:memFun:B", global)
+
+    global = ""
+    (try { global += "A"; a } finally {}).memFun(try { global += "B"; "C" } finally {})
+    assertEquals("AB:memFun:C", global)
+
+    global = ""
+    val b = B()
+    b.baz("S", a)
+    assertEquals(":bExt:S", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/callVarargs.kt

@@ -0,0 +1,29 @@
+package foo
+
+var global: String = ""
+
+fun <T> bar(s: String, value: T): T {
+    global += s
+    return value
+}
+
+fun <T> baz(vararg args: T): String {
+    return "baz: ${args.size}"
+}
+
+fun <T> idVarArg(vararg a: T) = a
+
+fun box(): String {
+    baz(bar("A", 10), try { global += "B"; 20} finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    baz(bar("A", 10), 30, if (true) { while(false){}; global+= "B"; 20 } else { 50 })
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals("baz: 4", baz(bar("A", 1), *try {bar("B", arrayOf(2, 3))} catch(e: Exception) { bar("C", arrayOf(4, 5))}, bar("D", 6)))
+    assertEquals("ABD", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/callWithBreakContinueReturn.kt

@@ -0,0 +1,88 @@
+package foo
+
+var global: String = ""
+
+fun f(arg1: String, arg2: String, arg3: String): String {
+    global += ":f:"
+    return arg1 + arg2 + arg3
+}
+
+fun id(s: String): String {
+    global += s
+    return s
+}
+
+fun bar(s: String): String {
+    return f(id(s), if (true) return ":bar:" else return "b", id(s))
+}
+
+fun box(): String {
+    var b: Boolean
+
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) f(id("A"), break, id("B"))
+    }
+    assertEquals(2, i, "break 1")
+    assertEquals("A", global, "break 1")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = f(id("A"), break, id("B"))
+        }
+    }
+    assertEquals(2, i, "break 2")
+    assertEquals("A", global, "break 2")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = "B" + f(id("A"), break, id("B"))
+        }
+    }
+    assertEquals(2, i, "break 3")
+    assertEquals("A", global, "break 3")
+
+    global = ""
+    i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) f(id("A"), continue, id("B"))
+        n++
+    }
+    assertEquals(4, n, "continue 1")
+    assertEquals("A", global, "continue 1")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = f(id("A"), continue, id("B"))
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 2")
+    assertEquals("A", global, "continue 2")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = "B" + f(id("A"), continue, id("B"))
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 3")
+    assertEquals("A", global, "continue 3")
+
+    global = ""
+    assertEquals(":bar:", bar("A"))
+    assertEquals("A", global, "bar")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/castWithBreakContinueReturn.kt

@@ -0,0 +1,120 @@
+package foo
+
+fun castWithReturn(): Int {
+    return (return 23) as Int
+}
+
+fun safeCastWithReturn(): Int? {
+    return (return 23) as Int?
+}
+
+fun isWithReturn(): Int {
+    return if ((return 23) is Int) 2 else 3
+}
+
+fun castWithBreak(): Int {
+    var result = 23
+    while (result < 40) {
+        if ((break as Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun safeCastWithBreak(): Int {
+    var result = 23
+    while (result < 40) {
+        if ((break as Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun isWithBreak(): Int {
+    var result = 23
+    while (result < 40) {
+        if (break is Int) result += 2 else result += 3
+    }
+    return result
+}
+
+fun castWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun castNullableWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as Int?) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun safeCastWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as? Int) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun safeCastNullableWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if ((continue as? Int?) == 0) result += 2 else result += 3
+    }
+    return result
+}
+
+fun isWithContinue(): Int {
+    var result = 25
+    while (result in 24..30) {
+        --result
+        if (continue is Int) result += 2 else result += 3
+    }
+    return result
+}
+
+fun isNullableWithContinue(): Int {
+    var result = 23
+    while (result in 24..30) {
+        --result
+        if (continue is Int?) result += 2 else result += 3
+    }
+    return result
+}
+
+fun whenWithReturn(): Int {
+    return when ((return 23) as Int) {
+        is Int -> 24
+        else -> 25
+    }
+}
+
+fun box(): String {
+    assertEquals(23, castWithReturn())
+    assertEquals(23, safeCastWithReturn())
+    assertEquals(23, isWithReturn())
+
+    assertEquals(23, castWithBreak())
+    assertEquals(23, safeCastWithBreak())
+    assertEquals(23, isWithBreak())
+
+    assertEquals(23, castWithContinue())
+    assertEquals(23, safeCastWithContinue())
+    assertEquals(23, isWithContinue())
+
+    assertEquals(23, castNullableWithContinue())
+    assertEquals(23, safeCastNullableWithContinue())
+    assertEquals(23, isNullableWithContinue())
+
+    assertEquals(23, whenWithReturn())
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/compareToIntrinsicWithSideEffect.kt

@@ -0,0 +1,61 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String): String {
+    global += s
+    return s
+}
+
+fun box(): String {
+
+    global = ""
+    assertEquals(true, bar("A") < bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") <= bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A") > bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A") >= bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") < try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") <= try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {}  > bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {} >= bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {}  < try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {}  <= try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {} > try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {} >= try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/dangerousInline.kt

@@ -0,0 +1,9 @@
+package foo
+
+var i = 0
+
+inline fun f() = i * 2
+
+fun box(): String {
+    return if ((++i + f()) == 3) "OK" else "fail"
+}

js/js.translator/testData/box/expression/evaluationOrder/dangerousInsideDangerous.kt

@@ -0,0 +1,22 @@
+package foo
+
+fun box(): String {
+    if (f(0) != 201) {
+        return "fail1"
+    }
+    if (f(1) != 104) {
+        return "fail2"
+    }
+    if (f(-2) != -100) {
+        return "fail3"
+    }
+    return "OK"
+}
+
+fun f(i: Int): Int {
+    var j = i
+    return ++j + if (j != 1) {
+        (if (j > 0) 100 else return -100) + 2
+    }
+    else 200
+}

js/js.translator/testData/box/expression/evaluationOrder/elvisComplex.kt

@@ -0,0 +1,22 @@
+package foo
+
+var sideEffect: Int = 0;
+
+class A(val x: Int)
+
+val global_a = A(1)
+val global_b = A(2)
+
+fun nullFun(value: Boolean): Any? = if (value) null else global_a
+
+fun box(): String {
+
+    nullFun(false) ?: global_b
+    assertEquals(global_a, nullFun(false) ?: try { ++sideEffect; global_b } finally {}, "false, global_b")
+    assertEquals(0, sideEffect, "false, global_b side effect")
+
+    assertEquals(global_b, nullFun(true) ?: try { ++sideEffect; global_b } finally {}, "true, global_b")
+    assertEquals(1, sideEffect, "true, global_b side effect")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/elvisWithBreakContinueReturn.kt

@@ -0,0 +1,74 @@
+package foo
+
+class A
+
+fun bar(a: A?): String {
+    if ((a ?: return "A") != null)
+        return "B"
+    else
+        return "C"
+}
+
+fun testBreak(a: A?, expected: Int) {
+    var i = 0
+    while(i++<5) {
+        if (i==2) a ?: break
+    }
+    assertEquals(expected, i, "break 1")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            var x = a ?: break
+        }
+    }
+    assertEquals(expected, i, "break 2")
+}
+
+fun testContinue(a: A?, expected: Int) {
+    var i = 0
+    var n = 0
+    while(i++<5) {
+        if (i==2) a ?: continue
+        n++
+    }
+    assertEquals(expected, n)
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2)  {
+            var x = a ?: continue
+        }
+        n++
+    }
+    assertEquals(expected, n)
+}
+
+fun box(): String {
+
+    testBreak(null, 2)
+    testBreak(A(), 6)
+
+    var i = 0
+    while(i++<5) {
+        if (i==2) break ?: null
+    }
+    assertEquals(2, i, "break ?: null")
+
+    testContinue(null, 4)
+    testContinue(A(), 5)
+
+    i = 0
+    var n = 0
+    while(i++<5) {
+        if (i==2) continue ?: null
+        n++
+    }
+    assertEquals(4, n, "continue ?: null")
+
+    assertEquals("A", bar(null))
+    assertEquals("B", bar(A()))
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/equalsIntrinsicWithSideEffect.kt

@@ -0,0 +1,45 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String): String {
+    global += s
+    return s
+}
+
+fun box(): String {
+
+    global = ""
+    assertEquals(false, bar("A") == bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") != bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A") == try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, bar("A") != try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {}  == bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {} != bar("B"))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A") } finally {}  == try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(true, try { bar("A") } finally {} != try { bar("B") } finally {})
+    assertEquals("AB", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/evaluationOrder1.kt

@@ -0,0 +1,17 @@
+package foo
+
+var d = 0
+
+fun f(): Int {
+    d = if (d < 0) -100 else 100
+    return d
+}
+
+fun box(): String {
+    d = d-- + f() + when(d) {
+        -100 -> return "OK"
+        1 -> 1
+        else -> return "fail1"
+    }
+    return "fail2"
+}

js/js.translator/testData/box/expression/evaluationOrder/evaluationOrder2.kt

@@ -0,0 +1,29 @@
+// Order of evaluation differs for JVM and Javascript backend
+// http://youtrack.jetbrains.com/issue/KT-5254
+
+package foo
+
+var s = ""
+
+fun a():String {
+    s += "A"
+    return ""
+}
+
+fun b():String {
+    s += "B"
+    return ""
+}
+
+fun c():String {
+    s += "C"
+    return ""
+}
+
+
+fun box(): String {
+    var res = (if(true) {a()} else "") + b() + (if (true) {c()} else "")
+    assertEquals("ABC", s)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/ifAsFunArgument.kt

@@ -0,0 +1,13 @@
+package foo
+
+fun box(): String {
+    var i = 0
+    val c = sum(++i, if (i == 0) return "fail1" else i + 2)
+    if (c != 4) {
+        return "fail2: $c"
+    }
+    return "OK"
+}
+
+
+fun sum(a1: Int, a2: Int) = a1 + a2

js/js.translator/testData/box/expression/evaluationOrder/ifAsPlusArgument.kt

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): String {
+    var  i = 0
+    var t = ++i + if (i == 0) 0 else 2
+    if (t != 3) {
+        return "fail: $t"
+    }
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/ifWithComplex.kt

@@ -0,0 +1,28 @@
+package foo
+
+var sideEffect: Int = 0;
+
+fun id(value: Boolean): Boolean = value
+
+fun box(): String {
+
+    assertEquals(if (id(true)) try { ++sideEffect; 10 } finally {} else 20, 10)
+    assertEquals(1, sideEffect)
+
+    assertEquals(if (id(false)) try { ++sideEffect; 10 } finally {} else 20, 20)
+    assertEquals(1, sideEffect)
+
+    assertEquals(if (id(true)) 100 else try { ++sideEffect; 200 } finally {}, 100)
+    assertEquals(1, sideEffect)
+
+    assertEquals(if (id(false)) 100 else try { ++sideEffect; 200 } finally {}, 200)
+    assertEquals(2, sideEffect)
+
+    assertEquals(if (id(true)) try { ++sideEffect; 1000 } finally {} else try { ++sideEffect; 2000 } finally {}, 1000)
+    assertEquals(3, sideEffect)
+
+    assertEquals(if (id(false)) try { ++sideEffect; 1000 } finally {} else try { ++sideEffect; 2000 } finally {}, 2000)
+    assertEquals(4, sideEffect)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/intrinsicComplex.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    var x = 0
+    assertEquals(false, ++x > x)
+    assertEquals(false, ++x > try {x} finally {})
+
+    assertEquals(false, x++ > x)
+    assertEquals(false, x++ > try {x} finally {})
+
+    assertEquals(true, ++x == x)
+    assertEquals(true, ++x == try {x} finally {})
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/intrinsicWithBreakContinueReturn.kt

@@ -0,0 +1,133 @@
+package foo
+
+var global: String = ""
+
+class A {
+    var prop: Boolean = false
+}
+
+fun getA(): A = try { global += "getA"; A() } finally {}
+
+fun barEq(): String {
+    10 == return "eq"
+}
+
+fun barLt(): String {
+    10 < (return "lt") as Int
+}
+
+fun setGlobal(i: Int): Int {
+    global = "setGlobal"
+    return i
+}
+
+fun box(): String {
+    var b: Boolean
+
+    var i = 0
+    while(i++<5) {
+        if (i==2) 10 == break
+    }
+    assertEquals(2, i, "break 1")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) 10 < (break as Int)
+    }
+    assertEquals(2, i, "break 2")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            var x = 10 == break;
+        }
+    }
+    assertEquals(2, i, "break 3")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            var x = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 4")
+
+    i = 0
+    var bVar: Boolean
+    while(i++<5) {
+        if (i==2) {
+            bVar = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 5")
+
+    i = 0
+    var bVarArray = arrayOf(true, false)
+    while(i++<5) {
+        if (i==2) {
+            bVarArray[try { global += "A"; 0} finally {}] = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 6")
+    assertEquals("A", global, "break 6")
+
+    i = 0
+    while(i++<5) {
+        if (i==2) {
+            bVarArray[setGlobal(0)] = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 6a")
+    assertEquals("setGlobal", global, "break 6a")
+
+    i = 0
+    global = ""
+    while(i++<5) {
+        if (i==2) {
+            getA().prop = 10 < (break as Int)
+        }
+    }
+    assertEquals(2, i, "break 7")
+    assertEquals("getA", global, "break 7")
+
+    i = 0
+    var n = 0
+    while(i++<5) {
+        if (i==2) 10 == continue
+        n++
+    }
+    assertEquals(4, n, "continue 1")
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2) 10 < (continue as Int)
+        n++
+    }
+    assertEquals(4, n, "continue 2")
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2)  {
+            var x = 10 == continue
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 3")
+
+    i = 0
+    n = 0
+    while(i++<5) {
+        if (i==2)  {
+            var x = 10 < (continue as Int)
+        }
+        n++
+    }
+    assertEquals(4, n, "continue 4")
+
+    assertEquals("eq", barEq())
+    assertEquals("lt", barLt())
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/literalFunctionAsArgumentWithSideEffect.kt

@@ -0,0 +1,35 @@
+// http://youtrack.jetbrains.com/issue/KT-4225
+// Compiler to JavaScript produces semantically wrong code
+
+package  foo
+
+var i = 0
+var j = 0
+
+var global: String = ""
+
+fun incI(){
+    i++
+}
+
+fun incJ(a: Any){
+    j++
+}
+
+fun foo(f: () -> Unit) = f
+
+fun box(): String {
+    val bar = 1
+
+    val f = foo {
+        incI()
+        incJ(if (bar == 2) "A" else "B")
+    }
+
+    global +="i = $i, j = $j"
+    f()
+    global +=" : i = $i, j = $j"
+    assertEquals("i = 0, j = 0 : i = 1, j = 1", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/loopWithBreakContinueReturnInCondition.kt

@@ -0,0 +1,87 @@
+package foo
+
+var global: String = ""
+
+
+fun whileReturn(): String {
+    var i = 0
+    while(if (i<2) true else { global += ":return:"; return ":whileReturn:"}) {
+        i++
+        global += "A"
+    }
+    return ":whileReturn:after:"
+}
+
+fun whileImmediateReturn(): String {
+    var i = 0
+    while(return ":whileImmediateReturn:") {
+        global += "A"
+    }
+    return ":whileImmediateReturn:after"
+}
+
+fun doWhileReturn(): String {
+    var i = 0
+    do {
+        i++
+        global += "A"
+    }
+    while(if (i<2) true else { global += ":return:"; return ":doWhileReturn:"})
+    return ":doWhileReturn:after:"
+}
+
+fun doWhileReturnFromCondition(): String {
+    var i = 0
+    do {
+        global += "A"
+    } while(return ":doWhileReturnFromCondition:")
+    return ":doWhileReturnFromCondition:after"
+}
+
+fun doWhileImmediateReturn(): String {
+    var i = 0
+    do {
+        return ":doWhileImmediateReturn:"
+        global += "A"
+    } while(false)
+    return ":doWhileImmediateReturn:after"
+}
+
+fun forReturn(b: Boolean): String {
+    var i = 0
+    for(i in (if (b) 1..2 else { global += ":return:"; return ":forReturn:"})) {
+        global += "A"
+    }
+    return ":forReturn:after:"
+}
+
+fun box(): String {
+    assertEquals(":whileReturn:", whileReturn())
+    assertEquals("AA:return:", global)
+
+    global = ""
+    assertEquals(":whileImmediateReturn:", whileImmediateReturn())
+    assertEquals("", global)
+
+    global = ""
+    assertEquals(":doWhileReturn:", doWhileReturn())
+    assertEquals("AA:return:", global)
+
+    global = ""
+    assertEquals(":doWhileReturnFromCondition:", doWhileReturnFromCondition())
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(":doWhileImmediateReturn:", doWhileImmediateReturn())
+    assertEquals("", global)
+
+    global = ""
+    assertEquals(":forReturn:after:", forReturn(true))
+    assertEquals("AA", global)
+
+    global = ""
+    assertEquals(":forReturn:", forReturn(false))
+    assertEquals(":return:", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/orOrWithBreakContinueReturn.kt

@@ -0,0 +1,94 @@
+package foo
+
+var global: String = ""
+
+fun id(s: String, b: Boolean): Boolean {
+    global += s
+    return b
+}
+
+fun bar(b: Boolean): String {
+    if (id("A",b) || return "A")
+        return "B"
+    else
+        return "C"
+}
+
+fun testBreak(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) || break
+    }
+    assertEquals(expected, i, "break 1")
+    assertEquals("A", global, "break 1")
+
+    global = ""
+    i = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) || break
+        }
+    }
+    assertEquals(expected, i, "break 2")
+    assertEquals("A", global, "break 2")
+}
+
+fun testContinue(b: Boolean, expected: Int) {
+    global = ""
+    var i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) id("A", b) || continue
+        n++
+    }
+    assertEquals(expected, n, "continue 1")
+    assertEquals("A", global, "continue 1")
+
+    global = ""
+    i = 0
+    n = 0
+    while (i++ < 5) {
+        if (i == 2) {
+            var x = id("A", b) || continue
+        }
+        n++
+    }
+    assertEquals(expected, n, "continue 2")
+    assertEquals("A", global, "continue 2")
+}
+
+fun box(): String {
+
+    testBreak(true, 6)
+    testBreak(false, 2)
+
+    global = ""
+    var i = 0
+    while (i++ < 5) {
+        if (i == 2) break || id("A", true)
+    }
+    assertEquals(2, i, "break || true")
+    assertEquals("", global, "break || false")
+
+    testContinue(true, 5)
+    testContinue(false, 4)
+
+    global = ""
+    i = 0
+    var n = 0
+    while (i++ < 5) {
+        if (i == 2) continue || id("A", true)
+        n++
+    }
+    assertEquals(4, n, "continue || true")
+    assertEquals("", global, "continue || true")
+
+    assertEquals("B", bar(true))
+    assertEquals("A", global, "bar")
+    global = ""
+    assertEquals("A", bar(false))
+    assertEquals("A", global, "bar")
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/orOrWithSideEffect.kt

@@ -0,0 +1,86 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String, value: Boolean): Boolean {
+    global += s
+    return value
+}
+
+fun box(): String {
+    val a =  if (true || if(bar("A", false)) {2} else {3} == 0) true else false
+    assertEquals("", global)
+
+    true || if(bar("A", false)) {2} else {3} == 0
+    assertEquals("", global)
+
+    // Simple || Simple
+    global = ""
+    assertEquals(true, bar("A", true) || bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", true) || bar("B", false))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", false) || bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) || bar("B", false))
+    assertEquals("AB", global)
+
+    // Simple || Complex
+    global = ""
+    assertEquals(true, bar("A", true) || try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", true) || try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, bar("A", false) || try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, bar("A", false) || try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    // Complex || Simple
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || bar("B", true))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || bar("B", false))
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", false) } finally {} || bar("B", true))
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} || bar("B", false))
+    assertEquals("AB", global)
+
+    // Complex || Complex
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || try { bar("B", true) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", true) } finally {} || try { bar("B", false) } finally {})
+    assertEquals("A", global)
+
+    global = ""
+    assertEquals(true, try { bar("A", false) } finally {} || try { bar("B", true) } finally {})
+    assertEquals("AB", global)
+
+    global = ""
+    assertEquals(false, try { bar("A", false) } finally {} || try { bar("B", false) } finally {})
+    assertEquals("AB", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/reassignmentLhsCaching.kt

@@ -0,0 +1,55 @@
+package foo
+
+var log = ""
+
+class A(val value: Int) {
+    operator fun plus(other: A): A {
+        log += "A.plus(${other.value});"
+        return A(value + other.value)
+    }
+}
+
+val _array = arrayOf(A(2))
+
+fun getArray(): Array<A> {
+    log += "getArray();"
+    return _array
+}
+
+fun getArrayIndex(): Int {
+    log += "getArrayIndex();"
+    return 0
+}
+
+class B(value: Int) {
+    var a = A(value)
+}
+
+val _property = B(10)
+val _functionResult = B(100)
+
+val foo: B
+    get() {
+        log += "foo;"
+        return _property
+    }
+
+fun bar(): B {
+    log += "bar();"
+    return _functionResult
+}
+
+fun box(): String {
+    getArray()[getArrayIndex()] += A(3)
+    assertEquals(5, _array[0].value)
+
+    foo.a += A(20)
+    assertEquals(30, _property.a.value)
+
+    bar().a += A(200)
+    assertEquals(300, _functionResult.a.value)
+
+    assertEquals("getArray();getArrayIndex();A.plus(3);foo;A.plus(20);bar();A.plus(200);", log)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/whenAsMinusArgument.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): String {
+    var  i = 0
+    var t = ++i + when(i) {
+        3 -> 4
+        1 -> 2
+        0 -> 1
+        else -> 100
+    }
+    if (t != 3) {
+        return "fail: $t"
+    }
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/whenJsLiteralWithSideEffect.kt

@@ -0,0 +1,38 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String): Int {
+    global += s
+    return 1
+}
+fun testWhen() {
+    global = ""
+    when(arrayOf(bar("A"),2,3)) {
+        arrayOf(1) -> println("1")
+        arrayOf(2) -> println("2")
+        else  -> println("else")
+    }
+    assertEquals("A", global)
+
+}
+
+fun testIntrinsic() {
+    global = ""
+    val x = arrayOf(bar("A")) == try { arrayOf(bar("B")) } finally {}
+    assertEquals("AB", global)
+}
+
+fun testElvis() {
+    global = ""
+    var x = arrayOf(bar("A")) ?: 10
+    assertEquals("A", global)
+}
+
+fun box(): String {
+    testWhen()
+    testIntrinsic()
+    testElvis()
+
+    return "OK"
+}

js/js.translator/testData/box/expression/evaluationOrder/whenWithComplexConditions.kt

@@ -0,0 +1,68 @@
+package foo
+
+var global: String = ""
+
+fun id(s: String, value: Boolean): Boolean {
+    global += s
+    return value
+}
+
+fun box(): String {
+
+    when {
+      id("A", true) || id("B", true) -> 10
+    }
+    assertEquals("A", global)
+
+    global = ""
+    when {
+        id("A", false) || id("B", true) || id("C", true) -> 10
+    }
+    assertEquals("AB", global)
+
+    global = ""
+    var b = true
+    when {
+        try { global += "A"; b } finally {} -> 10
+        try { global += "B"; !b } finally {} -> 20
+    }
+    assertEquals("A", global)
+
+    global = ""
+    b = false
+    when {
+        try { global += "A"; b } finally {} -> 10
+        try { global += "B"; !b } finally {} -> 20
+    }
+    assertEquals("AB", global)
+
+    global = ""
+    b = true
+    when {
+        b || try { global += "A"; !b } finally {} -> 10
+    }
+    assertEquals("", global)
+
+    global = ""
+    b = false
+    when {
+        b || try { global += "A"; !b } finally {} -> 10
+    }
+    assertEquals("A", global)
+
+    global = ""
+    when {
+        false -> {
+            global += "A"
+        }
+        try { global += "B"; false } finally {} -> {
+            global += "D"
+        }
+        else -> {
+            global += "C"
+        }
+    }
+    assertEquals("BC", global)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/for/forIteratesOverArray.kt

@@ -0,0 +1,34 @@
+package foo
+
+val a1 = arrayOfNulls<Int>(10)
+
+fun box(): String {
+    var c = 0
+    var d = 0
+    a1[3] = 3
+    a1[5] = 5
+
+    for (a: Int? in a1) {
+        if (a != null) {
+            c += 1;
+        }
+        else {
+            d += 1
+        }
+    }
+    assertEquals(2, c)
+    assertEquals(8, d)
+
+    var s: String = ""
+    for(i in arrayOf(0,1,2))
+        try { s += "A${i}:"} finally {}
+    assertEquals("A0:A1:A2:", s)
+
+    var sLong = 0L
+    var aLong = longArrayOf(1,2,3,4,5,6,7,8,9,10)
+    for(i in aLong)
+        sLong += i
+    assertEquals(55L, sLong)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/for/forIteratesOverLiteralRange.kt

@@ -0,0 +1,50 @@
+package foo
+
+var global: String = ""
+
+fun up(s: String, value: Int): Int {
+    global += s
+    return value
+}
+
+fun box(): String {
+
+    // http://youtrack.jetbrains.com/issue/KT-5262
+    // JS: wrong code for `for` over range when start greater end
+    var n: Int = 0
+    for(i in 3..0)
+        n++
+    assertEquals(0, n)
+
+    for(i in 0..3)
+        n++
+    assertEquals(4, n)
+
+    // Evaluation order
+    for (i in up("A", 0)..up("B", 5)) {
+    }
+    assertEquals("AB", global)
+
+    global = ""
+    for (i in try { up("A", 0) } finally {} ..up("B", 5)) {
+    }
+    assertEquals("AB", global)
+
+    global = ""
+    for (i in up("A", 0).. try { up("B", 5)} finally {}) {
+    }
+    assertEquals("AB", global)
+
+    global = ""
+    for (i in try { up("A", 0) } finally {}.. try { up("B", 5)} finally {}) {
+    }
+    assertEquals("AB", global)
+
+    var sLong = 0L
+    for(i in 0L..10L)
+        sLong += i
+    assertEquals(55L, sLong)
+
+
+    return "OK"
+}

js/js.translator/testData/box/expression/for/forIteratesOverNonLiteralRange.kt

@@ -0,0 +1,22 @@
+package foo
+
+fun box(): String {
+    var n = 0
+    var r = 3..0
+    for(i in r)
+        n++
+    assertEquals(0, n)
+
+    r = 0..3
+    for(i in r)
+        n++
+    assertEquals(4, n)
+
+    var sLong = 0L
+    var rLong = 0L..10L
+    for(i in rLong)
+        sLong += i
+    assertEquals(55L, sLong)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/for/forIteratesOverSomethingWithIterator.kt

@@ -0,0 +1,21 @@
+package foo
+
+class Iter(val upper: Int) {
+    var count: Int = 0
+    operator fun hasNext(): Boolean = count < upper
+    operator fun next(): Int = count++
+}
+
+class A(val upper: Int) {
+    operator fun iterator(): Iter = Iter(upper)
+}
+
+fun box(): String {
+    var n = 0
+    for(i in A(10)) {
+        n++
+    }
+    assertEquals(10, n)
+
+    return "OK"
+}

js/js.translator/testData/box/expression/for/forOnEmptyArray.kt

@@ -0,0 +1,10 @@
+package foo
+
+val a1 = arrayOfNulls<Int>(0)
+
+fun box(): String {
+    for (a in a1) {
+        return "fail"
+    }
+    return "OK"
+}