[JS IR] Add properties lazy initialization with multiple modules

[JS IR] Move tests into compiler/testData

[JS IR] Add cyclic dependencies with lazy property initialization

[JS IR] Add test on not initialization in case of call non properties (classed, objects, enum classes, const vals)

[JS IR] Add initialization through top level

[JS IR] Ignore enum getInstance function in property lazy initialization

[JS IR] Use let function with useful result instead of pure apply and also

[JS IR] Remove duplicated tests in js.translator

compiler/testData/codegen/box/properties/lazyInitialization.kt

@@ -0,0 +1,18 @@
+// IGNORE_BACKEND: JS
+// DONT_TARGET_EXACT_BACKEND: WASM
+// PROPERTY_LAZY_INITIALIZATION
+
+// FILE: A.kt
+
+val o = "O"
+
+// FILE: B.kt
+val ok = o + k
+
+// FILE: C.kt
+
+val k = "K"
+
+// FILE: main.kt
+
+fun box(): String = ok

compiler/testData/codegen/box/properties/lazyInitializationCyclicImports.kt

@@ -0,0 +1,39 @@
+// IGNORE_BACKEND: JS
+// DONT_TARGET_EXACT_BACKEND: WASM
+// PROPERTY_LAZY_INITIALIZATION
+
+// FILE: A.kt
+var log = ""
+
+val a1 = "a".also {
+    log += "a1"
+}
+val b1 = a2.also {
+    log += "b1"
+}
+val c1 = a3.also {
+    log += "c1"
+}
+
+// FILE: B.kt
+val a2 = a1.also {
+    log += "a2"
+}
+val b2 = "b".also {
+    log += "b2"
+}
+
+// FILE: C.kt
+val a3 = b1.also {
+    log += "a3"
+}
+val b3 = b2.also {
+    log += "b3"
+}
+val c3 = "c".also {
+    log += "c3"
+}
+
+// FILE: main.kt
+
+fun box(): String = if (log == "a1a2b2b1a3b3c3c1") "OK" else "fail: $log"

compiler/testData/codegen/box/properties/lazyInitializationMultiModule.kt

@@ -0,0 +1,10 @@
+// DONT_TARGET_EXACT_BACKEND: WASM
+// PROPERTY_LAZY_INITIALIZATION
+
+// MODULE: lib1
+var log = ""
+val a = 1.also { log += "a" }
+val b = 2.also { log += "b" }
+
+// MODULE: main(lib1)
+fun box(): String = if (log + a == "ab1") "OK" else "fail"

compiler/testData/codegen/box/properties/lazyInitializationOrder.kt

@@ -0,0 +1,36 @@
+// EXPECTED_REACHABLE_NODES: 1239
+// DONT_TARGET_EXACT_BACKEND: WASM
+// PROPERTY_LAZY_INITIALIZATION
+
+// FILE: A.kt
+
+val a = "A".let {
+    flag = !flag
+    if (flag) {
+        it
+    } else {
+        "!A"
+    }
+}
+
+val b = "B".let {
+    flag = !flag
+    if (!flag) {
+        it
+    } else {
+        "!B"
+    }
+}
+
+// FILE: B.kt
+var flag: Boolean = false
+
+// FILE: main.kt
+
+fun box(): String {
+    return if (
+        a == "A" && b == "B"
+    )
+        "OK"
+    else "a = $a; b = ${b}"
+}

compiler/testData/codegen/box/properties/lazyInitializationPure.kt

@@ -0,0 +1,36 @@
+// TARGET_BACKEND: JS_IR
+// PROPERTY_LAZY_INITIALIZATION
+
+// FILE: A.kt
+
+val a = "A"
+
+// FILE: B.kt
+val b = "B".let {
+    it + "B"
+}
+
+val c = b
+
+// FILE: C.kt
+val d = "D".let {
+    it + "D"
+}
+
+val e = d
+
+// FILE: main.kt
+
+fun box(): String {
+    // Get only e to initialize all properties in file
+    e
+    return if (
+        js("a") === "A" &&
+        js("typeof b") == "undefined" &&
+        js("typeof c") == "undefined" &&
+        js("d") === "DD" &&
+        js("e") === "DD"
+    )
+        "OK"
+    else "a = ${js("a")}; typeof b = ${js("typeof b")}; typeof c = ${js("typeof c")}; d = ${js("d")}; e = ${js("e")}"
+}

compiler/testData/codegen/box/properties/lazyInitializationSplitPerModule.kt

@@ -0,0 +1,22 @@
+// IGNORE_BACKEND: JS
+// DONT_TARGET_EXACT_BACKEND: WASM
+// SPLIT_PER_MODULE
+// PROPERTY_LAZY_INITIALIZATION
+
+// MODULE: lib1
+// FILE: A.kt
+val o = "O"
+
+// FILE: B.kt
+val okCandidate = o + k
+
+// FILE: C.kt
+val k = "K"
+
+// MODULE: lib2(lib1)
+// FILE: lib2.kt
+val ok = okCandidate
+
+// MODULE: main(lib1, lib2)
+// FILE: main.kt
+fun box(): String = ok

compiler/testData/codegen/box/properties/lazyInitializationThroughTopFun.kt

@@ -0,0 +1,17 @@
+// TARGET_BACKEND: JS_IR
+// DONT_TARGET_EXACT_BACKEND: WASM
+// PROPERTY_LAZY_INITIALIZATION
+
+// FILE: A.kt
+val a = "a".let {
+    it + "a"
+}
+
+fun foo() =
+    2 + 2
+
+// FILE: main.kt
+fun box(): String {
+    val foo = foo()
+    return if (js("typeof a") == "string" && js("a") == "aa") "OK" else "fail"
+}

compiler/testData/codegen/box/properties/noInitializationLazilyOnNonPropertiesCall.kt

@@ -0,0 +1,38 @@
+// TARGET_BACKEND: JS_IR
+// DONT_TARGET_EXACT_BACKEND: WASM
+// PROPERTY_LAZY_INITIALIZATION
+
+// FILE: A.kt
+val a1 = "a".let {
+    it + "a"
+}
+
+object A {
+    private val foo = "foo"
+    val foo2 = foo
+    val ok = "OK"
+}
+
+class B(private val foo: String) {
+    val ok = foo
+
+    constructor(arg: Int) : this(arg.toString())
+}
+
+enum class C {
+    OK
+}
+
+const val b = "b"
+
+// FILE: main.kt
+fun box(): String {
+    val foo = A.ok
+    val bar = B("foo").ok
+    val bay = B(1).ok
+    C.OK
+    C.values()
+    C.valueOf("OK")
+    val baz = b
+    return if (js("typeof a1") == "undefined") "OK" else "fail"
+}