JS backend: remove dangerous package, correct translation for call, assignments, binary operations, support try...catch as expression

#KT-5576 Fixed
 #KT-5594 Fixed
 #KT-3166 Fixed
 #KT-5545 Fixed
 #KT-5594 Fixed
 #KT-5258 Fixed

JS backend: fix KT-4879: extra side effect when use when in default arguments

 #KT-4879 Fixed

JS backend: improve and fix WhenTranslator, fix order of evaluation for condtitions, fix KT-5263 (JS: extra tmp when initialize val in when by expression with if)

 #KT-5263 Fixed

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

@@ -0,0 +1,26 @@
+package foo
+
+fun box(): Boolean {
+    if (f(0) != -3) {
+        return false
+    }
+    if (f(102) != 201) {
+        return false;
+    }
+    if (f(103) != 100) {
+        return false
+    }
+    if (f(-100) != -100) {
+        return false
+    }
+    if (f(-99) != -201) {
+        return false
+    }
+
+    return true
+}
+
+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/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/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 = array(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/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/callVarargs.kt

@@ -0,0 +1,23 @@
+package foo
+
+var global: String = ""
+
+fun bar(s: String, value: Int): Int {
+    global += s
+    return value
+}
+
+fun baz(vararg args: Int): String {
+    return "baz: ${args.size}"
+}
+
+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)
+
+    return "OK"
+}

js/js.translator/testData/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/dangerousInline.kt

@@ -0,0 +1,9 @@
+package foo
+
+var i = 0
+
+inline fun f() = i * 2
+
+fun box(): Boolean {
+    return (++i + f()) == 3
+}

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

@@ -0,0 +1,22 @@
+package foo
+
+fun box(): Boolean {
+    if (f(0) != 201) {
+        return false
+    }
+    if (f(1) != 104) {
+        return false
+    }
+    if (f(-2) != -100) {
+        return false
+    }
+    return true
+}
+
+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/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/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(): Boolean {
+    d = d-- + f() + when(d) {
+        -100 -> return true
+        1 -> 1
+        else -> return false
+    }
+    return false
+}

js/js.translator/testData/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/ifAsFunArgument.kt

@@ -0,0 +1,13 @@
+package foo
+
+fun box(): Boolean {
+    var i = 0
+    val c = sum(++i, if (i == 0) return false else i + 2)
+    if (c != 4) {
+        return false
+    }
+    return true
+}
+
+
+fun sum(a1: Int, a2: Int) = a1 + a2

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

@@ -0,0 +1,10 @@
+package foo
+
+fun box(): Boolean {
+    var  i = 0
+    var t = ++i + if (i == 0) 0 else 2
+    if (t != 3) {
+        return false
+    }
+    return true
+}

js/js.translator/testData/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/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/expression/evaluationOrder/cases/orOrWithSideEffect.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("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/expression/evaluationOrder/cases/whenAsMinusArgument.kt

@@ -0,0 +1,15 @@
+package foo
+
+fun box(): Boolean {
+    var  i = 0
+    var t = ++i + when(i) {
+        3 -> 4
+        1 -> 2
+        0 -> 1
+        else -> 100
+    }
+    if (t != 3) {
+        return false
+    }
+    return true
+}

js/js.translator/testData/expression/evaluationOrder/cases/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/expression/for/cases/forWithComplexOneStatement.kt

@@ -0,0 +1,12 @@
+package foo
+
+fun box(): String {
+    var s: String = ""
+
+    s = ""
+    for(i in 0..2)
+        try { s += "A"} finally {}
+    assertEquals("AAA", s)
+
+    return "OK"
+}

js/js.translator/testData/expression/if/cases/ifInsideLambda.kt

@@ -0,0 +1,43 @@
+// http://youtrack.jetbrains.com/issue/KT-5594
+// JS: compiler crashes
+
+package foo
+
+fun bar(f: () -> Unit) {
+}
+
+fun test() {
+    bar {
+        // val actionId: Any = 1
+        val item: Any? = 1
+        if (item != null) {
+            // In original version, as I remember, `when` was an important to reproduce, but now it is not.
+            // when(actionId){
+            //     1 -> { 1 }
+            //     "2" -> { "2"}
+            //      else -> {}
+            // }
+        }
+    }
+    bar {
+        val actionId: Any = 1
+        val item: Any? = 1
+        if (item != null) {
+            when (actionId) {
+                1 -> {
+                    1
+                }
+                "2" -> {
+                    "2"
+                }
+                else -> {
+                }
+            }
+        }
+    }
+
+}
+
+fun box(): String {
+    return "OK"
+}

js/js.translator/testData/expression/if/cases/nestedIf.kt

@@ -0,0 +1,35 @@
+// JS: generate wrong code for nested if
+// http://youtrack.jetbrains.com/issue/KT-5576
+
+package foo
+
+fun test2(a: Boolean, b: Boolean, c: Boolean) {
+    val a =
+            if (a) {
+                if (b) {
+                    "1"
+                } else if (c) {
+                    "2"
+                } else {
+                    throw Exception("Rest parameter must be array types")
+                }
+            }
+            else {
+                "3"
+            }
+}
+
+fun box(): String {
+
+    test2(true, true, false)
+    var wasException = false
+    try {
+        test2(true, false, false)
+    }
+    catch(e: Exception) {
+        wasException = true
+    }
+    assertEquals(true, wasException)
+
+    return "OK"
+}

js/js.translator/testData/expression/try/cases/tryCatchExpr.kt

@@ -0,0 +1,20 @@
+package foo
+
+fun box(): String {
+    var res = try { 10 } catch(e: Exception) { 20 }
+    assertEquals(10, res)
+
+    res = try { 10 } catch(e: Exception) { 20 } finally { 80 }
+    assertEquals(10, res)
+
+    res = try { 10; throw RuntimeException() } catch(e: Exception) { 20 }
+    assertEquals(20, res)
+
+    res = try { 10; throw RuntimeException() } catch(e: Exception) { 20 } finally { 100 }
+    assertEquals(20, res)
+
+    res = 50 + try { 10 } catch(e: Exception) { 20 }
+    assertEquals(60, res)
+
+    return "OK"
+}

js/js.translator/testData/expression/while/cases/whileWithComplexOneStatement.kt

@@ -0,0 +1,19 @@
+package foo
+
+fun box(): String {
+    var s: String = ""
+
+    var i:Int = 0
+    while(i<2)
+        try { s += "A"; i++} finally {}
+    assertEquals("AA", s)
+
+    s = ""
+    i = 0
+    do
+        try { s += "A"; i++} finally {}
+    while(i<2)
+    assertEquals("AA", s)
+
+    return "OK"
+}