JS: refactor generation of functions with optional parameters. Fix #KT-7302, #KT-13888

js/js.translator/testData/box/defaultArguments/complexExpressionAsConstructorDefaultArgument.kt

@@ -0,0 +1,25 @@
+package foo
+
+var global: String = ""
+
+fun bar(): Int {
+    global += ":bar:"
+    return 100
+}
+
+fun baz() = 1
+
+class A(val x: Int = when (baz()) { 1 -> bar(); else -> 0 })
+
+fun box(): String {
+    global = ""
+    val a1 = A(10)
+    assertEquals(10, a1.x)
+    assertEquals("", global)
+
+    val a2 = A()
+    assertEquals(100, a2.x)
+    assertEquals(":bar:", global)
+
+    return "OK"
+}

js/js.translator/testData/box/defaultArguments/complexExpressionAsDefaultArgument.kt

@@ -10,7 +10,9 @@ fun bar(): Int {
     return 100
 }
 
-fun foo(a: Int = when { else -> bar() }): Int = a + 1
+fun baz() = 1
+
+fun foo(a: Int = when (baz()) { 1 -> bar(); else -> 0 }): Int = a + 1
 
 fun bar0(x: String = try { global } finally {}): String {
     return "bar: ${x}"

js/js.translator/testData/box/defaultArguments/complexExpressionAsOverriddenDefaultArgument.kt

@@ -0,0 +1,42 @@
+// http://youtrack.jetbrains.com/issue/KT-4879
+// JS: extra side effect when use when in default arguments
+
+package foo
+
+var global: String = ""
+
+fun bar(): Int {
+    global += ":bar:"
+    return 100
+}
+
+fun baz() = 1
+
+open class A {
+    open fun foo(a: Int = when (baz()) { 1 -> bar(); else -> 0 }): Int = a + 1
+
+    open fun bar0(x: String = try { global } finally {}): String {
+        return "bar: ${x}"
+    }
+}
+
+class B : A() {
+    override fun foo(a: Int) = a + 2
+
+    override fun bar0(x: String) = "B.bar: $x"
+}
+
+fun box(): String {
+    global = ""
+    val b = B()
+    assertEquals(102, b.foo(100))
+    assertEquals("", global)
+
+    assertEquals(102, b.foo())
+    assertEquals(":bar:", global)
+
+    assertEquals("B.bar: q", b.bar0("q"))
+    assertEquals("B.bar: :bar:", b.bar0())
+
+    return "OK"
+}

js/js.translator/testData/box/defaultArguments/superCall.kt

@@ -0,0 +1,28 @@
+package foo
+
+open class A {
+    open fun foo(x: Int = 20, y: Int = 3) = x + y
+}
+
+open class B : A() {
+    override fun foo(x: Int, y: Int) = 0
+
+    fun bar1() = super.foo()
+
+    fun bar2() = super.foo(30)
+
+    fun bar3() = super.foo(y = 4)
+}
+
+fun box(): String {
+    val v1 = B().bar1()
+    if (v1 != 23) return "fail1: $v1"
+
+    val v2 = B().bar2()
+    if (v2 != 33) return "fail2: $v2"
+
+    val v3 = B().bar3()
+    if (v3 != 24) return "fail3: $v3"
+
+    return "OK"
+}

js/js.translator/testData/box/multiModule/interfaceMethodWithDefaultParameter.kt

@@ -0,0 +1,13 @@
+// MODULE: lib
+// FILE: lib.kt
+public interface I {
+    public fun f(p: String = "O"): String
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+public class C : I {
+    override fun f(p: String) = p + "K"
+}
+
+fun box() = C().f()

js/js.translator/testData/box/native/callbackOptionalParameter.js

@@ -0,0 +1,4 @@
+function bar(a) {
+    a.foo_za3lpa$();
+    a.foo_za3lpa$(99);
+}

js/js.translator/testData/box/native/callbackOptionalParameter.kt

@@ -0,0 +1,26 @@
+package foo
+
+var global = ""
+
+open class A {
+    open fun foo(x: Int = 23) {
+        global += "A.foo($x);"
+    }
+}
+
+class B : A() {
+    override fun foo(x: Int) {
+        global += "B.foo($x);"
+    }
+}
+
+@native fun bar(a: A)
+
+fun box(): String {
+    bar(A())
+    bar(B())
+
+    if (global != "A.foo(23);A.foo(99);B.foo(23);B.foo(99);") return "fail: $global"
+
+    return "OK"
+}