[JS IR] Introduce the GENERATE_INLINE_ANONYMOUS_FUNCTIONS feature flag

js/js.translator/testData/box/closure/inlineAnonymousFunctions/closureInWithInsideWith.kt

@@ -0,0 +1,25 @@
+// KT-4237 With in with
+
+package foo
+
+class A {
+    val ok = "OK"
+}
+
+class B
+
+fun <T> with(o: T, body: T.() -> Unit) {
+    o.body()
+}
+
+fun box(): String {
+    var o = ""
+
+    with(A()) {
+        with(B()) {
+            o = ok
+        }
+    }
+
+    return o
+}

js/js.translator/testData/box/closure/inlineAnonymousFunctions/inlineChain.kt

@@ -0,0 +1,29 @@
+// FILE: 1.kt
+
+package test
+
+interface  A {
+    fun run()
+}
+
+inline fun testNested(crossinline f: (String) -> Unit) {
+    object : A {
+        override fun run() {
+            f("OK")
+        }
+    }.run()
+}
+
+inline fun test(crossinline f: (String) -> Unit) {
+    testNested { it ->  { f(it) }()}
+}
+
+// FILE: 2.kt
+
+import test.*
+
+fun box(): String {
+    var result = "fail"
+    test { it -> result = it }
+    return result
+}

js/js.translator/testData/box/closure/inlineAnonymousFunctions/lambdaChain.kt

@@ -0,0 +1,29 @@
+// FILE: 1.kt
+
+package test
+
+inline fun <T> inlineFun(arg: T, f: (T) -> Unit) {
+    f(arg)
+}
+
+// FILE: 2.kt
+
+import test.*
+
+fun box(): String {
+    val param = "start"
+    var result = "fail"
+    inlineFun("1")  { c ->
+        {
+            inlineFun("2") { a ->
+                {
+                    {
+                        result = param + c + a
+                    }()
+                }()
+            }
+        }()
+    }
+
+    return if (result == "start12") "OK" else "fail: $result"
+}

js/js.translator/testData/box/closure/inlineAnonymousFunctions/lambdaParameters.kt

@@ -0,0 +1,16 @@
+fun <T> bar(x: T, y: (T) -> Boolean): Boolean = y(x) && jsTypeOf(x.asDynamic()) != "number"
+
+fun typeOf(x: dynamic) = js("typeof x")
+
+fun box(): String {
+    val f = { x: Char ->
+        val a: Char = x
+        val b: Any = x
+        typeOf(a) == "number" && typeOf(b) == "object"
+    }
+
+    if (!f('Q')) return "fail1"
+    if (!bar('W', f)) return "fail2"
+
+    return "OK"
+}

js/js.translator/testData/box/closure/inlineAnonymousFunctions/localParameterInCallback.kt

@@ -0,0 +1,30 @@
+// KJS_WITH_FULL_RUNTIME
+package foo
+
+
+fun box(): String {
+    val oneTwo = Array(2) {
+        it + 1
+    }
+    val a = ArrayList<() -> Int>()
+    for (i in oneTwo) {
+        for (l in 1..2) {
+            val j = l
+            a.add({
+                      var res = 0
+                      for (t in 0..2) {
+                          res += i * j
+                      }
+                      res
+                  })
+        }
+    }
+    var sum = 0
+    for (f in a) {
+        sum += f()
+    }
+
+    if (sum != 27) return "fail: $sum"
+
+    return "OK"
+}

js/js.translator/testData/box/closure/inlineAnonymousFunctions/twiceRegeneratedAnonymousObject.kt

@@ -0,0 +1,26 @@
+// WITH_STDLIB
+// WITH_COROUTINES
+// FILE: 1.kt
+package test
+
+inline fun foo(crossinline x: () -> Unit) = suspend {
+    try { } finally {
+        // This object is regenerated twice (normal return & "catch Throwable, execute finally, and rethrow")
+        // It doesn't *need* to be, but this should work regardless.
+        { x() }()
+    }
+}
+
+// FILE: 2.kt
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+import test.*
+
+var result = "fail"
+fun box(): String {
+    suspend {
+        foo { result = "OK" }()
+    }.startCoroutine(EmptyContinuation)
+    return result
+}