[JS IR] Support per-file mode and ES modules

2021-02-23 15:44:06 +03:00
parent f479ac5c3a
commit 3f8dce4b53
140 changed files with 5136 additions and 609 deletions
@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O {
+    operator fun invoke() = "OK"
+}
+
+inline fun callO() = O()
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = O()
+    if (a != "OK") return "fail: simple: $a"
+
+    val b = callO()
+    if (b != "OK") return "fail: inline: $a"
+
+    return "OK"
+}
@@ -0,0 +1,72 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+class A(val x: Int) {
+    constructor(a: Int, b: Int) : this(a + b)
+}
+
+external class B(x: Int) {
+    constructor(a: Int, b: Int)
+
+    val x: Int
+}
+
+// TODO: may be useful after implementing local classes in inline functions
+/*
+inline fun foo(p: Int, q: Int, r: Int): Pair<Int, Int> {
+    class C(val x : Int) {
+        constructor(a: Int, b: Int) : this(a + b)
+    }
+    return Pair(C(p).x, C(q, r).x)
+}
+*/
+
+inline fun callPrimaryConstructor(x: Int) = A(x).x
+
+inline fun callSecondaryConstructor(x: Int, y: Int) = A(x, y).x
+
+// FILE: lib.js
+
+function B(x, y) {
+    this.x = x;
+    if (typeof y !== 'undefined') {
+        this.x += y;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = A(23).x
+    if (a != 23) return "fail: primary constructor: $a"
+
+    val b = A(40, 2).x
+    if (b != 42) return "fail: secondary constructor: $b"
+
+    val c = B(99).x
+    if (c != 99) return "fail: native primary constructor: $c"
+
+    val d = B(100, 11).x
+    if (d != 111) return "fail: native secondary constructor: $d"
+
+    /*
+    val (e, f) = foo(123, 320, 1)
+    if (e != 123) return "fail: local primary constructor: $e"
+    if (f != 321) return "fail: local secondary constructor: $f"
+    */
+
+    val g = callPrimaryConstructor(55)
+    if (g != 55) return "fail: primary constructor from inline function: $g"
+
+    val h = callSecondaryConstructor(990, 9)
+    if (h != 999) return "fail: secondary constructor from inline function: $h"
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+open class A {
+    fun foo() = 23
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+import lib.A
+
+class B : A() {
+    fun bar() = foo() + 1
+}
+
+fun box(): String {
+    val result = B().bar()
+    if (result != 24) return "fail: $result"
+    return "OK"
+}
@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// FILE: lib1.mjs
+export default function() {
+    return "OK";
+}
+
+// MODULE: lib2
+// FILE: lib2.kt
+@JsModule("./lib1.mjs")
+external fun foo(): String
+
+// MODULE: lib3(lib2)
+// FILE: lib3.kt
+inline fun bar() = foo()
+
+// MODULE: main(lib3)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// FILE: lib-1.mjs
+export default function foo() {
+    return "OK";
+}
+
+// MODULE: lib2
+// FILE: lib2.kt
+@JsModule("./lib-1.mjs")
+external fun foo(): String
+
+// MODULE: lib3(lib2)
+// FILE: lib3.kt
+inline fun bar() = foo()
+
+// MODULE: main(lib3)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// FILE: lib1.mjs
+export function foo() {
+    return "OK";
+}
+
+// MODULE: lib2
+// FILE: lib2.kt
+@file:JsModule("./lib1.mjs")
+
+external fun foo(): String
+
+// MODULE: lib3(lib2)
+// FILE: lib3.kt
+inline fun bar() = foo()
+
+// MODULE: main(lib3)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,16 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib1
+// FILE: lib1.kt
+
+fun foo() = "OK"
+
+// MODULE: lib2(lib1)
+// FILE: lib2.kt
+
+inline fun bar() = foo()
+
+// MODULE: main(lib1, lib2)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,16 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: 1
+// FILE: lib1.kt
+
+fun foo() = "OK"
+
+// MODULE: 2(1)
+// FILE: lib2.kt
+
+inline fun bar() = foo()
+
+// MODULE: main(2)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,19 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+fun bar(f: () -> String) = f()
+
+inline fun foo(): String {
+    return bar { "OK" }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box() = foo()
@@ -0,0 +1,37 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+var log = ""
+
+object O {
+    init {
+        log += "O.init;"
+    }
+
+    fun result() = "OK"
+}
+
+fun getResult(): String {
+    log += "before;"
+    val result = O.result()
+    log += "after;"
+    return result
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val result = getResult()
+    if (result != "OK") return "fail: unexpected result: $result"
+
+    if (log != "before;O.init;after;") return "fail: wrong evaluation order: $log"
+
+    return "OK"
+}
@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O {
+    val result = "OK"
+
+    inline fun foo(): String {
+        val o = object {
+            fun bar() = O
+        }
+        return fetch(o.bar())
+    }
+}
+
+fun fetch(o: O) = o.result
+
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box() = O.foo()
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    var o: Any = O
+    if (o !is O) return "fail1"
+    if (!(o is O)) return "fail2"
+
+    return "OK"
+}
@@ -0,0 +1,44 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+class A(val x: Int)
+
+fun A.foo() = 23 + x
+
+inline fun A.baz() = 99 + x
+
+inline fun A.callFoo() = foo()
+
+inline fun A.buzz(): Int {
+    val o = object {
+        fun f() = 111 + x
+    }
+    return o.f()
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = A(1).foo()
+    if (a != 24) return "fail: simple function: $a"
+
+    val c = A(1).baz()
+    if (c != 100) return "fail: inline function: $c"
+
+    val d = A(1).buzz()
+    if (d != 112) return "fail: inline function with object expression: $d"
+
+    val e = A(2).callFoo()
+    if (e != 25) return "fail: inline function calling another function: $e"
+
+    return "OK"
+}
@@ -0,0 +1,51 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+fun foo() = 23
+
+external fun bar(): Int = definedExternally
+
+inline fun baz() = 99
+
+inline fun callFoo() = foo()
+
+inline fun buzz(): Int {
+    val o = object {
+        fun f() = 111
+    }
+    return o.f()
+}
+
+// FILE: lib.js
+
+function bar() {
+    return 42;
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+fun box(): String {
+    val a = lib.foo()
+    if (a != 23) return "fail: simple function: $a"
+
+    val b = lib.bar()
+    if (b != 42) return "fail: native function: $b"
+
+    val c = lib.baz()
+    if (c != 99) return "fail: inline function: $c"
+
+    val d = lib.buzz()
+    if (d != 111) return "fail: inline function with object expression: $d"
+
+    val e = lib.callFoo()
+    if (e != 23) return "fail: inline function calling another function: $e"
+
+    return "OK"
+}
@@ -0,0 +1,38 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+var foo = 23
+
+var bar: Int = 42
+    get() = field
+    set(value) {
+        field = value
+    }
+
+@JsName("faz") var baz = 99
+
+// MODULE: main(lib)
+// FILE: lib.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23) return "fail: simple property initial value: $foo"
+    foo = 24
+    if (foo != 24) return "fail: simple property new value: $foo"
+
+    if (bar != 42) return "fail: property with accessor initial value: $bar"
+    bar = 43
+    if (bar != 43) return "fail: property with accessor new value: $bar"
+
+    if (baz != 99) return "fail: renamed property initial value: $baz"
+    baz = 100
+    if (baz != 100) return "fail: renamed property new value: $baz"
+
+
+    return "OK"
+}
@@ -0,0 +1,48 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+val foo = 23
+
+val boo: Int
+    get() = 42
+
+external val bar: Int = definedExternally
+
+external val far: Int
+    get() = definedExternally
+
+// TODO: annotations like this are not serialized properly. Uncomment after KT-14529 gets fixed
+/*
+val fuzz: Int
+    @JsName("getBuzz") get() = 55
+    */
+
+inline fun fetchFoo() = foo
+
+@JsName("fee")
+val tee = 2525
+
+// FILE: lib.js
+
+var bar = 99
+var far = 111
+
+// MODULE: main(lib)
+// FILE: lib.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23) return "fail: simple property: $foo"
+    if (boo != 42) return "fail: property with accessor: $boo"
+    if (bar != 99) return "fail: native property: $bar"
+    if (far != 111) return "fail: native property with accessor: $far"
+    //if (fuzz != 55) return "fail: property with JsName on accessor: $fuzz"
+    if (tee != 2525) return "fail: native property with JsName: $tee"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1289
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O {
+    operator fun invoke() = "OK"
+}
+
+inline fun callO() = O()
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = O()
+    if (a != "OK") return "fail: simple: $a"
+
+    val b = callO()
+    if (b != "OK") return "fail: inline: $a"
+
+    return "OK"
+}
@@ -0,0 +1,74 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1291
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+class A(val x: Int) {
+    constructor(a: Int, b: Int) : this(a + b)
+}
+
+external class B(x: Int) {
+    constructor(a: Int, b: Int)
+
+    val x: Int
+}
+
+// TODO: may be useful after implementing local classes in inline functions
+/*
+inline fun foo(p: Int, q: Int, r: Int): Pair<Int, Int> {
+    class C(val x : Int) {
+        constructor(a: Int, b: Int) : this(a + b)
+    }
+    return Pair(C(p).x, C(q, r).x)
+}
+*/
+
+inline fun callPrimaryConstructor(x: Int) = A(x).x
+
+inline fun callSecondaryConstructor(x: Int, y: Int) = A(x, y).x
+
+// FILE: lib.js
+
+function B(x, y) {
+    this.x = x;
+    if (typeof y !== 'undefined') {
+        this.x += y;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = A(23).x
+    if (a != 23) return "fail: primary constructor: $a"
+
+    val b = A(40, 2).x
+    if (b != 42) return "fail: secondary constructor: $b"
+
+    val c = B(99).x
+    if (c != 99) return "fail: native primary constructor: $c"
+
+    val d = B(100, 11).x
+    if (d != 111) return "fail: native secondary constructor: $d"
+
+    /*
+    val (e, f) = foo(123, 320, 1)
+    if (e != 123) return "fail: local primary constructor: $e"
+    if (f != 321) return "fail: local secondary constructor: $f"
+    */
+
+    val g = callPrimaryConstructor(55)
+    if (g != 55) return "fail: primary constructor from inline function: $g"
+
+    val h = callSecondaryConstructor(990, 9)
+    if (h != 999) return "fail: secondary constructor from inline function: $h"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1292
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+open class A {
+    fun foo() = 23
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+import lib.A
+
+class B : A() {
+    fun bar() = foo() + 1
+}
+
+fun box(): String {
+    val result = B().bar()
+    if (result != 24) return "fail: $result"
+    return "OK"
+}
@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1283
+// MODULE: lib1
+// FILE: lib1.kt
+
+fun foo() = "OK"
+
+// MODULE: lib2(lib1)
+// FILE: lib2.kt
+
+inline fun bar() = foo()
+
+// MODULE: main(lib1, lib2)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1283
+// MODULE: 1
+// FILE: lib1.kt
+
+fun foo() = "OK"
+
+// MODULE: 2(1)
+// FILE: lib2.kt
+
+inline fun bar() = foo()
+
+// MODULE: main(2)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1283
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+fun bar(f: () -> String) = f()
+
+inline fun foo(): String {
+    return bar { "OK" }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box() = foo()
@@ -0,0 +1,39 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1289
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+var log = ""
+
+object O {
+    init {
+        log += "O.init;"
+    }
+
+    fun result() = "OK"
+}
+
+fun getResult(): String {
+    log += "before;"
+    val result = O.result()
+    log += "after;"
+    return result
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val result = getResult()
+    if (result != "OK") return "fail: unexpected result: $result"
+
+    if (log != "before;O.init;after;") return "fail: wrong evaluation order: $log"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1382
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O {
+    val result = "OK"
+
+    inline fun foo(): String {
+        val o = object {
+            fun bar() = O
+        }
+        return fetch(o.bar())
+    }
+}
+
+fun fetch(o: O) = o.result
+
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box() = O.foo()
@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1284
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    var o: Any = O
+    if (o !is O) return "fail1"
+    if (!(o is O)) return "fail2"
+
+    return "OK"
+}
@@ -0,0 +1,46 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1290
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+class A(val x: Int)
+
+fun A.foo() = 23 + x
+
+inline fun A.baz() = 99 + x
+
+inline fun A.callFoo() = foo()
+
+inline fun A.buzz(): Int {
+    val o = object {
+        fun f() = 111 + x
+    }
+    return o.f()
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = A(1).foo()
+    if (a != 24) return "fail: simple function: $a"
+
+    val c = A(1).baz()
+    if (c != 100) return "fail: inline function: $c"
+
+    val d = A(1).buzz()
+    if (d != 112) return "fail: inline function with object expression: $d"
+
+    val e = A(2).callFoo()
+    if (e != 25) return "fail: inline function calling another function: $e"
+
+    return "OK"
+}
@@ -0,0 +1,53 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1287
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+fun foo() = 23
+
+external fun bar(): Int = definedExternally
+
+inline fun baz() = 99
+
+inline fun callFoo() = foo()
+
+inline fun buzz(): Int {
+    val o = object {
+        fun f() = 111
+    }
+    return o.f()
+}
+
+// FILE: lib.js
+
+function bar() {
+    return 42;
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+fun box(): String {
+    val a = lib.foo()
+    if (a != 23) return "fail: simple function: $a"
+
+    val b = lib.bar()
+    if (b != 42) return "fail: native function: $b"
+
+    val c = lib.baz()
+    if (c != 99) return "fail: inline function: $c"
+
+    val d = lib.buzz()
+    if (d != 111) return "fail: inline function with object expression: $d"
+
+    val e = lib.callFoo()
+    if (e != 23) return "fail: inline function calling another function: $e"
+
+    return "OK"
+}
@@ -0,0 +1,40 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1286
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+var foo = 23
+
+var bar: Int = 42
+    get() = field
+    set(value) {
+        field = value
+    }
+
+@JsName("faz") var baz = 99
+
+// MODULE: main(lib)
+// FILE: lib.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23) return "fail: simple property initial value: $foo"
+    foo = 24
+    if (foo != 24) return "fail: simple property new value: $foo"
+
+    if (bar != 42) return "fail: property with accessor initial value: $bar"
+    bar = 43
+    if (bar != 43) return "fail: property with accessor new value: $bar"
+
+    if (baz != 99) return "fail: renamed property initial value: $baz"
+    baz = 100
+    if (baz != 100) return "fail: renamed property new value: $baz"
+
+
+    return "OK"
+}
@@ -0,0 +1,50 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_FILE
+// EXPECTED_REACHABLE_NODES: 1287
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+val foo = 23
+
+val boo: Int
+    get() = 42
+
+external val bar: Int = definedExternally
+
+external val far: Int
+    get() = definedExternally
+
+// TODO: annotations like this are not serialized properly. Uncomment after KT-14529 gets fixed
+/*
+val fuzz: Int
+    @JsName("getBuzz") get() = 55
+    */
+
+inline fun fetchFoo() = foo
+
+@JsName("fee")
+val tee = 2525
+
+// FILE: lib.js
+
+var bar = 99
+var far = 111
+
+// MODULE: main(lib)
+// FILE: lib.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23) return "fail: simple property: $foo"
+    if (boo != 42) return "fail: property with accessor: $boo"
+    if (bar != 99) return "fail: native property: $bar"
+    if (far != 111) return "fail: native property with accessor: $far"
+    //if (fuzz != 55) return "fail: property with JsName on accessor: $fuzz"
+    if (tee != 2525) return "fail: native property with JsName: $tee"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1289
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O {
+    operator fun invoke() = "OK"
+}
+
+inline fun callO() = O()
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = O()
+    if (a != "OK") return "fail: simple: $a"
+
+    val b = callO()
+    if (b != "OK") return "fail: inline: $a"
+
+    return "OK"
+}
@@ -0,0 +1,74 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1291
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+class A(val x: Int) {
+    constructor(a: Int, b: Int) : this(a + b)
+}
+
+external class B(x: Int) {
+    constructor(a: Int, b: Int)
+
+    val x: Int
+}
+
+// TODO: may be useful after implementing local classes in inline functions
+/*
+inline fun foo(p: Int, q: Int, r: Int): Pair<Int, Int> {
+    class C(val x : Int) {
+        constructor(a: Int, b: Int) : this(a + b)
+    }
+    return Pair(C(p).x, C(q, r).x)
+}
+*/
+
+inline fun callPrimaryConstructor(x: Int) = A(x).x
+
+inline fun callSecondaryConstructor(x: Int, y: Int) = A(x, y).x
+
+// FILE: lib.js
+
+function B(x, y) {
+    this.x = x;
+    if (typeof y !== 'undefined') {
+        this.x += y;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = A(23).x
+    if (a != 23) return "fail: primary constructor: $a"
+
+    val b = A(40, 2).x
+    if (b != 42) return "fail: secondary constructor: $b"
+
+    val c = B(99).x
+    if (c != 99) return "fail: native primary constructor: $c"
+
+    val d = B(100, 11).x
+    if (d != 111) return "fail: native secondary constructor: $d"
+
+    /*
+    val (e, f) = foo(123, 320, 1)
+    if (e != 123) return "fail: local primary constructor: $e"
+    if (f != 321) return "fail: local secondary constructor: $f"
+    */
+
+    val g = callPrimaryConstructor(55)
+    if (g != 55) return "fail: primary constructor from inline function: $g"
+
+    val h = callSecondaryConstructor(990, 9)
+    if (h != 999) return "fail: secondary constructor from inline function: $h"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1292
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+open class A {
+    fun foo() = 23
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+import lib.A
+
+class B : A() {
+    fun bar() = foo() + 1
+}
+
+fun box(): String {
+    val result = B().bar()
+    if (result != 24) return "fail: $result"
+    return "OK"
+}
@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1283
+// MODULE: lib1
+// FILE: lib1.kt
+
+fun foo() = "OK"
+
+// MODULE: lib2(lib1)
+// FILE: lib2.kt
+
+inline fun bar() = foo()
+
+// MODULE: main(lib1, lib2)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1283
+// MODULE: 1
+// FILE: lib1.kt
+
+fun foo() = "OK"
+
+// MODULE: 2(1)
+// FILE: lib2.kt
+
+inline fun bar() = foo()
+
+// MODULE: main(2)
+// FILE: main.kt
+
+fun box() = bar()
@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1283
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+fun bar(f: () -> String) = f()
+
+inline fun foo(): String {
+    return bar { "OK" }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box() = foo()
@@ -0,0 +1,39 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1289
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+var log = ""
+
+object O {
+    init {
+        log += "O.init;"
+    }
+
+    fun result() = "OK"
+}
+
+fun getResult(): String {
+    log += "before;"
+    val result = O.result()
+    log += "after;"
+    return result
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    val result = getResult()
+    if (result != "OK") return "fail: unexpected result: $result"
+
+    if (log != "before;O.init;after;") return "fail: wrong evaluation order: $log"
+
+    return "OK"
+}
@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1382
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O {
+    val result = "OK"
+
+    inline fun foo(): String {
+        val o = object {
+            fun bar() = O
+        }
+        return fetch(o.bar())
+    }
+}
+
+fun fetch(o: O) = o.result
+
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box() = O.foo()
@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1284
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+object O
+
+// MODULE: main(lib)
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    var o: Any = O
+    if (o !is O) return "fail1"
+    if (!(o is O)) return "fail2"
+
+    return "OK"
+}
@@ -0,0 +1,46 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1290
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+class A(val x: Int)
+
+fun A.foo() = 23 + x
+
+inline fun A.baz() = 99 + x
+
+inline fun A.callFoo() = foo()
+
+inline fun A.buzz(): Int {
+    val o = object {
+        fun f() = 111 + x
+    }
+    return o.f()
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+import lib.*
+
+fun box(): String {
+    val a = A(1).foo()
+    if (a != 24) return "fail: simple function: $a"
+
+    val c = A(1).baz()
+    if (c != 100) return "fail: inline function: $c"
+
+    val d = A(1).buzz()
+    if (d != 112) return "fail: inline function with object expression: $d"
+
+    val e = A(2).callFoo()
+    if (e != 25) return "fail: inline function calling another function: $e"
+
+    return "OK"
+}
@@ -0,0 +1,53 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1287
+// MODULE: lib
+// FILE: lib.kt
+
+package lib
+
+fun foo() = 23
+
+external fun bar(): Int = definedExternally
+
+inline fun baz() = 99
+
+inline fun callFoo() = foo()
+
+inline fun buzz(): Int {
+    val o = object {
+        fun f() = 111
+    }
+    return o.f()
+}
+
+// FILE: lib.js
+
+function bar() {
+    return 42;
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+package main
+
+fun box(): String {
+    val a = lib.foo()
+    if (a != 23) return "fail: simple function: $a"
+
+    val b = lib.bar()
+    if (b != 42) return "fail: native function: $b"
+
+    val c = lib.baz()
+    if (c != 99) return "fail: inline function: $c"
+
+    val d = lib.buzz()
+    if (d != 111) return "fail: inline function with object expression: $d"
+
+    val e = lib.callFoo()
+    if (e != 23) return "fail: inline function calling another function: $e"
+
+    return "OK"
+}
@@ -0,0 +1,40 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1286
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+var foo = 23
+
+var bar: Int = 42
+    get() = field
+    set(value) {
+        field = value
+    }
+
+@JsName("faz") var baz = 99
+
+// MODULE: main(lib)
+// FILE: lib.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23) return "fail: simple property initial value: $foo"
+    foo = 24
+    if (foo != 24) return "fail: simple property new value: $foo"
+
+    if (bar != 42) return "fail: property with accessor initial value: $bar"
+    bar = 43
+    if (bar != 43) return "fail: property with accessor new value: $bar"
+
+    if (baz != 99) return "fail: renamed property initial value: $baz"
+    baz = 100
+    if (baz != 100) return "fail: renamed property new value: $baz"
+
+
+    return "OK"
+}
@@ -0,0 +1,50 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// SPLIT_PER_MODULE
+// EXPECTED_REACHABLE_NODES: 1287
+// MODULE: lib
+// FILE: lib.kt
+package lib
+
+val foo = 23
+
+val boo: Int
+    get() = 42
+
+external val bar: Int = definedExternally
+
+external val far: Int
+    get() = definedExternally
+
+// TODO: annotations like this are not serialized properly. Uncomment after KT-14529 gets fixed
+/*
+val fuzz: Int
+    @JsName("getBuzz") get() = 55
+    */
+
+inline fun fetchFoo() = foo
+
+@JsName("fee")
+val tee = 2525
+
+// FILE: lib.js
+
+var bar = 99
+var far = 111
+
+// MODULE: main(lib)
+// FILE: lib.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23) return "fail: simple property: $foo"
+    if (boo != 42) return "fail: property with accessor: $boo"
+    if (bar != 99) return "fail: native property: $bar"
+    if (far != 111) return "fail: native property with accessor: $far"
+    //if (fuzz != 55) return "fail: property with JsName on accessor: $fuzz"
+    if (tee != 2525) return "fail: native property with JsName: $tee"
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// EXPECTED_REACHABLE_NODES: 1252
+// INFER_MAIN_MODULE
+// ES_MODULES
+
+// MODULE: export-all-file
+// FILE: lib.kt
+@file:JsExport
+
+abstract class A {
+    abstract fun foo(k: String): String
+}
+
+class B : A() {
+    override fun foo(k: String): String {
+        return "O" + k
+    }
+}
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+import { B } from "./export-all-file/index.js";
+console.assert(new B().foo("K") == "OK");
@@ -0,0 +1,16 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// SKIP_MINIFICATION
+// INFER_MAIN_MODULE
+// SKIP_NODE_JS
+// ES_MODULES
+
+// MODULE: non-identifier-module-name
+// FILE: lib.kt
+@JsName("foo")
+@JsExport
+public fun foo(k: String): String = "O$k"
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+import { foo } from "./non-identifier-module-name/index.js";
+console.assert(foo("K") == "OK");
@@ -0,0 +1,39 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// EXPECTED_REACHABLE_NODES: 1252
+// INFER_MAIN_MODULE
+
+// ES_MODULES
+// MODULE: overriden-chain-non-export-intermediate
+// FILE: lib.kt
+@JsExport
+abstract class A {
+    abstract fun foo(): String
+
+    abstract fun bar(): String
+}
+
+abstract class B : A() {
+    abstract fun baz(): String
+
+    override fun foo(): String = "foo"
+}
+
+@JsExport
+class C : B() {
+    override fun bar(): String = "bar"
+    override fun baz(): String = "baz"
+
+    fun bay(): String = "bay"
+}
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+import { C } from "./overriden-chain-non-export-intermediate/index.js";
+
+function test(c) {
+    if (c.foo() === "foo" && c.bar() === "bar" && c.bay() == "bay") return "OK"
+
+    return "fail"
+}
+
+console.assert(test(new C()) == "OK");
@@ -0,0 +1,41 @@
+// EXPECTED_REACHABLE_NODES: 1252
+// INFER_MAIN_MODULE
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+
+// MODULE: overriden-external-method-with-same-name-method
+// FILE: lib.kt
+external abstract class Foo {
+    abstract fun o(): String
+}
+
+abstract class Bar : Foo() {
+    abstract fun String.o(): String
+
+    override fun o(): String {
+        return "O".o()
+    }
+}
+
+@JsExport
+class Baz : Bar() {
+    override fun String.o(): String {
+        return this
+    }
+}
+
+// FILE: foo.js
+function Foo() {}
+Foo.prototype.k = function() {
+    return "K"
+}
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+import { Baz } from "./overriden-external-method-with-same-name-method/index.js";
+
+function test(foo) {
+    return foo.o() + foo.k()
+}
+
+console.assert(test(new Baz())  == "OK");
@@ -0,0 +1,44 @@
+// EXPECTED_REACHABLE_NODES: 1252
+// IGNORE_BACKEND: JS
+// INFER_MAIN_MODULE
+// ES_MODULES
+
+// MODULE: overriden-external-method-with-same-stable-name-method
+// FILE: lib.kt
+external abstract class Foo {
+    abstract fun o(): String
+}
+
+abstract class Bar : Foo() {
+    @JsName("oStable")
+    abstract fun String.o(): String
+
+    override fun o(): String {
+        return "O".o()
+    }
+}
+
+@JsExport
+class Baz : Bar() {
+    override fun String.o(): String {
+        return this
+    }
+}
+
+// FILE: foo.js
+function Foo() {}
+Foo.prototype.k = function() {
+    return "K"
+}
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+import { Baz } from "./overriden-external-method-with-same-stable-name-method/index.js";
+
+function test(foo) {
+    const oStable = foo.oStable("OK")
+    if (oStable !== "OK") return "false: " + oStable
+    return foo.o() + foo.k()
+}
+
+console.assert(test(new Baz()) == "OK");
@@ -0,0 +1,17 @@
+// IGNORE_BACKEND: JS
+// EXPECTED_REACHABLE_NODES: 1270
+// SKIP_MINIFICATION
+// INFER_MAIN_MODULE
+// ES_MODULES
+
+// MODULE: if
+// FILE: lib.kt
+@JsName("foo")
+@JsExport
+public fun foo(k: String): String = "O$k"
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+import { foo } from "./if/index.js";
+
+console.assert(foo("K") == "OK");
@@ -0,0 +1,41 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+
+// MODULE: lib
+// FILE: a.kt
+@file:JsModule("./foo.mjs")
+
+external fun fooF(): String
+
+// FILE: b.kt
+@file:JsModule("./bar.mjs")
+
+external fun barF(): String
+
+// FILE: c.kt
+// RECOMPILE
+fun dummyF() = "dummy"
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+fun box(): String {
+    val foo = fooF()
+    if (foo != "foo") return "fail1: $foo"
+
+    val bar = barF()
+    if (bar != "bar") return "fail2: $bar"
+
+    return "OK"
+}
+
+
+// FILE: foo.mjs
+export function fooF() {
+    return "foo";
+}
+
+// FILE: bar.mjs
+export function barF() {
+    return "bar";
+}
@@ -0,0 +1,35 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+
+// FILE: main.kt
+interface I {
+    fun ok(): String
+}
+
+inline fun ok(): I {
+    return object : I {
+        override fun ok() = "OK"
+    }
+}
+
+@JsName("convolutedOk")
+@JsExport
+inline fun convolutedOk(): I {
+    val fail = object : I {
+        override fun ok() = "fail"
+    }.ok()
+
+    return ok()
+}
+
+@JsExport
+fun testOk(ok: Any): String {
+    if (ok !is I) return "fail"
+    return ok.ok()
+}
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+import { convolutedOk, testOk } from "./JS_TESTS/index.js";
+
+console.assert(testOk(convolutedOk()) == "OK");
@@ -0,0 +1,55 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+
+// SKIP_DCE_DRIVEN
+// SKIP_MINIFICATION
+// ES_MODULES
+
+// FILE: api.kt
+
+@JsExport
+data class Point(val x: Int, val y: Int) {
+    override fun toString(): String = "[${x}::${y}]"
+}
+
+// we need his class to make sure that there's more than one ping method in existence - due to peculiarities of current namer otherwise test can pass but JsExport won't be actually respected
+data class AltPoint(val x: Int, val y: Int)
+
+// FILE: main.kt
+external interface JsResult {
+    val copy00: String
+    val copy01: String
+    val copy10: String
+    val copy11: String
+    val component1: Int
+    val component2: Int
+}
+
+@JsModule("./dataClass.mjs")
+external fun jsBox(): JsResult
+
+fun box(): String {
+    val res = jsBox()
+    if (res.copy00 != "[3::7]") {
+        return "Fail1: ${res.copy00}"
+    }
+    if (res.copy01 != "[3::11]") {
+        return "Fail2: ${res.copy01}"
+    }
+    if (res.copy10 != "[15::7]") {
+        return "Fail3: ${res.copy10}"
+    }
+    if (res.copy11 != "[13::11]") {
+        return "Fail4: ${res.copy11}"
+    }
+    if (res.component1 != 3) {
+        return "Fail5: ${res.component1}"
+    }
+    if (res.component2 != 7) {
+        return "Fail6: ${res.component2}"
+    }
+
+
+
+
+    return "OK"
+}
@@ -0,0 +1,14 @@
+import { Point } from "./JS_TESTS/index.js";
+
+export default function() {
+    var p = new Point(3, 7);
+
+    return {
+        "copy00": p.copy().toString(),
+        "copy01": p.copy(undefined, 11).toString(),
+        "copy10": p.copy(15).toString(),
+        "copy11": p.copy(13, 11).toString(),
+        "component1": p.component1(),
+        "component2": p.component2()
+    };
+};
@@ -0,0 +1,118 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// SKIP_DCE_DRIVEN
+// SKIP_MINIFICATION
+// ES_MODULES
+
+@JsExport
+fun ping(a: String = "A", b: Int = 1): String {
+    return "$a::$b"
+}
+
+@JsExport
+open class Ping(private val defaultSeed: Int = 3) {
+    private fun calculate(n: Int) = n * n
+    fun ping(s: Int = defaultSeed, c: (Int) -> Int = ::calculate): Int {
+        return c(s)
+    }
+}
+
+@JsExport
+class Pong: Ping()
+
+@JsExport
+@JsName("pong")
+fun bing(a: String = "A", b: Int = 1): String {
+    return "$b::$a"
+}
+
+@JsExport
+class Foo {
+    @JsName("foo")
+    fun value(value: Long = 5L) = if (value == 5L) "C" else "fail"
+}
+
+@JsExport
+fun transform(i: Int = 10, t: (Int) -> Int = {it * it}): Int {
+    return t(i)
+}
+
+external interface JsResult {
+    val ping00: String
+    val ping01: String
+    val ping10: String
+    val ping11: String
+
+    val pong00: String
+    val pong01: String
+    val pong10: String
+    val pong11: String
+
+    val transform00: Int
+    val transform11: Int
+
+    val Ping_ping00a: Int
+    val Ping_ping00b: Int
+    val Ping_ping11: Int
+
+    val Pong_ping00: Int
+
+    val Foo: String
+}
+
+@JsModule("./exportedDefaultStub.mjs")
+external fun jsBox(): JsResult
+
+fun box(): String {
+    val res = jsBox()
+    if (res.ping00 != "A::1") {
+        return "fail0: ${res.ping00}"
+    }
+    if (res.ping01 != "A::10") {
+        return "fail1: ${res.ping01}"
+    }
+    if (res.ping10 != "X::1") {
+        return "fail2: ${res.ping10}"
+    }
+    if (res.ping11 != "Z::5") {
+        return "fail3: ${res.ping11}"
+    }
+
+    if (res.pong00 != "1::A") {
+        return "fail4: ${res.pong00}"
+    }
+    if (res.pong01 != "10::A") {
+        return "fail5: ${res.pong01}"
+    }
+    if (res.pong10 != "1::X") {
+        return "fail6: ${res.pong10}"
+    }
+    if (res.pong11 != "5::Z") {
+        return "fail7: ${res.pong11}"
+    }
+
+    if (res.transform00 != 100) {
+        return "fail8: ${res.transform00}"
+    }
+    if (res.transform11 != -125) {
+        return "fail9: ${res.transform11}"
+    }
+
+    if (res.Ping_ping00a != 9) {
+        return "fail10: ${res.Ping_ping00a}"
+    }
+    if (res.Ping_ping00b != 100) {
+        return "fail11: ${res.Ping_ping00b}"
+    }
+    if (res.Ping_ping11 != -64) {
+        return "fail12: ${res.Ping_ping11}"
+    }
+    if (res.Pong_ping00 != 9) {
+        return "fail13: ${res.Pong_ping00}"
+    }
+
+    if (res.Foo != "C") {
+        return "fail14: ${res.Foo}"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,36 @@
+import * as api from "./JS_TESTS/index.js";
+
+export default function() {
+    var ping = api.ping;
+    var pong = api.pong;
+    var transform = api.transform;
+    var Ping = api.Ping;
+    var Pong = api.Pong;
+    var Foo = api.Foo;
+
+    return {
+        "ping00": ping(),
+        "ping01": ping(undefined, 10),
+        "ping10": ping("X"),
+        "ping11": ping("Z", 5),
+
+        "pong00": pong(),
+        "pong01": pong(undefined, 10),
+        "pong10": pong("X"),
+        "pong11": pong("Z", 5),
+
+        "transform00": transform(),
+        "transform11": transform(-5, function (it) {
+            return it * it * it
+        }),
+
+        "Ping_ping00a": new Ping().ping(),
+        "Ping_ping00b": new Ping(10).ping(),
+        "Ping_ping11": new Ping().ping(-4, function (it) {
+            return it * it * it
+        }),
+
+        "Pong_ping00": new Pong().ping(),
+        "Foo": new Foo().foo()
+    };
+}
@@ -0,0 +1,38 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// SKIP_MINIFICATION
+// ES_MODULES
+// FILE: api.kt
+
+@JsExport
+class A() {
+    fun ping() = "ping"
+}
+
+@JsExport
+class B() {
+    @JsName("pong")
+    fun ping() = "pong"
+}
+
+// we need his class to make sure that there's more than one ping method in existence - due to peculiarities of current namer otherwise test can pass but JsExport won't be actually respected
+class C() {
+    fun ping() = "pong"
+}
+
+
+// FILE: main.kt
+external interface JsResult {
+    val res: String
+}
+
+@JsModule("./jsExportInClass.mjs")
+external fun jsBox(): JsResult
+
+fun box(): String {
+    val res = jsBox().res
+    if (res != "pingpong") {
+        return "Fail: ${res}"
+    }
+
+    return "OK"
+}
@@ -0,0 +1,7 @@
+import { A, B } from "./JS_TESTS/index.js";
+
+export default function() {
+    return {
+        "res": (new A().ping()) + (new B().pong())
+    };
+};
@@ -0,0 +1,28 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// SKIP_MINIFICATION
+// ES_MODULES
+
+// FILE: api.kt
+@JsExport
+class Something<T: Something<T>> {
+    fun ping(): String {
+        return "OK"
+    }
+}
+
+@JsExport
+fun ping(s: Something<*>): String {
+    return s.ping()
+}
+
+// FILE: main.kt
+external interface JsResult {
+    val pingCall: () -> String
+}
+
+@JsModule("./recursiveExport.mjs")
+external fun jsBox(): JsResult
+
+fun box(): String {
+    return jsBox().pingCall()
+}
@@ -0,0 +1,9 @@
+import { ping, Something } from "./JS_TESTS/index.js"
+
+export default function() {
+    return {
+        "pingCall": function() {
+            return ping(new Something())
+        },
+    };
+};
@@ -0,0 +1,33 @@
+// EXPECTED_REACHABLE_NODES: 1284
+// ES_MODULES
+// DONT_TARGET_EXACT_BACKEND: JS
+
+package foo
+
+@JsModule("./externalClass.mjs")
+external class A(x: Int = definedExternally) {
+    val x: Int
+
+    fun foo(y: Int): Int = definedExternally
+
+    fun bar(vararg arg: String): String = definedExternally
+}
+
+class C {
+    val e = arrayOf("e")
+    val f = arrayOf("f")
+    val a = A(1)
+
+    fun qux() = a.bar(*e, *f)
+}
+
+
+fun box(): String {
+    val a = A(23)
+    assertEquals(23, a.x)
+    assertEquals(65, a.foo(42))
+
+    assertEquals(C().qux(), "(ef)")
+
+    return "OK"
+}
@@ -0,0 +1,11 @@
+export default function A(x) {
+    this.x = x;
+}
+
+A.prototype.foo = function (y) {
+    return this.x + y;
+};
+
+A.prototype.bar = function() {
+    return "(" + Array.prototype.join.call(arguments, "") + ")";
+};
@@ -0,0 +1,62 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// FILE: a.kt
+@file:JsModule("./a.mjs")
+package a
+
+external class A {
+    fun foo(): String
+}
+
+external fun bar(): Int
+
+external val prop: Int
+
+// FILE: b.kt
+@file:JsModule("./b.mjs")
+package b
+
+external class A {
+    fun foo(): String
+}
+
+external fun bar(): Int
+
+external var prop: Int
+
+// FILE: main.kt
+
+import a.A as O
+import b.A as K
+
+fun box(): String {
+    if (a.bar() != 1) return "fail 1"
+    if (a.prop != 10) return "fail 2"
+    if (b.bar() != 2) return "fail 3"
+    if (b.prop != 20) return "fail 4"
+
+    return O().foo() + K().foo()
+}
+
+// FILE: a.mjs
+export function A() {}
+
+A.prototype.foo = function () {
+   return "O";
+};
+
+export function bar() { return 1; }
+
+export let prop = 10
+
+
+// FILE: b.mjs
+export function A() {}
+
+A.prototype.foo = function () {
+    return "K";
+};
+
+export function bar() { return 2; }
+
+export let prop = 20;
@@ -0,0 +1,46 @@
+// EXPECTED_REACHABLE_NODES: 1284
+// ES_MODULES
+// DONT_TARGET_EXACT_BACKEND: JS
+
+package foo
+
+@JsModule("./externalClassWithDefaults.mjs")
+external open class A(ss: String = definedExternally) {
+    val s: String
+    fun foo(y: String = definedExternally): String = definedExternally
+    fun bar(y: String = definedExternally): String = definedExternally
+}
+
+class C: A {
+    constructor(ss: String) : super(ss) {}
+    constructor() : super() {}
+
+    fun qux(s: String = "O") = s
+}
+
+
+fun box(): String {
+    val a = A()
+    val c = C()
+
+    val r1 = a.foo("O") + c.foo()
+    if (r1 != "OK") return "Fail1: $r1"
+
+    val r2 = a.bar() + c.bar("K")
+    if (r2 != "OK") return "Fail2: $r2"
+
+    val r3 = c.qux() + c.qux("K")
+    if (r3 != "OK") return "Fail3: $r3"
+
+    if (a.s != "A") return "Fail4: ${a.s}"
+    if (c.s != "A") return "Fail5: ${c.s}"
+
+    val a2 = A("A2")
+    val c2 = C("C2")
+
+    val r6 = a2.s + c2.s
+    if (r6 != "A2C2") return "Fail6: $r6"
+
+    return "OK"
+
+}
@@ -0,0 +1,9 @@
+export default function A(ss) {
+    this.s = ss || "A"
+}
+A.prototype.foo = function (y) {
+    return y || "K";
+};
+A.prototype.bar = function (y) {
+    return y || "O";
+};
@@ -0,0 +1,26 @@
+// EXPECTED_REACHABLE_NODES: 1334
+// ES_MODULES
+// DONT_TARGET_EXACT_BACKEND: JS
+
+package foo
+
+@JsModule("./externalConstructor.mjs")
+open external class A(data: String) {
+    constructor(data: Int)
+    constructor(data: Boolean)
+
+    val data: Any
+}
+
+class B(data: String) : A(data)
+
+class C(data: Int) : A(data)
+
+class D(data: Boolean) : A(data)
+
+fun box(): String {
+    assertEquals("13", B("13").data)
+    assertEquals(42, C(42).data)
+    assertEquals(true, D(true).data)
+    return "OK"
+}
@@ -0,0 +1,3 @@
+export default function (data) {
+    this.data = data
+}
@@ -0,0 +1,11 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+package foo
+
+@JsModule("./externalFunction.mjs")
+external fun foo(y: Int): Int = definedExternally
+
+fun box(): String {
+    assertEquals(65, foo(42))
+    return "OK"
+}
@@ -0,0 +1,3 @@
+export default function(y) {
+    return 23 + y;
+}
@@ -0,0 +1,14 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+package foo
+
+@JsModule("./externalFunctionNameClash.mjs")
+external fun foo(y: Int): Int = definedExternally
+
+fun foo(y: String): String = y + "K"
+
+fun box(): String {
+    val foo10 = foo(10)
+    if (foo10 != 33) return "Fail: $foo10"
+    return "OK"
+}
@@ -0,0 +1,3 @@
+export default function(y) {
+    return 23 + y;
+}
@@ -0,0 +1,16 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+package foo
+
+@JsModule("./externalObject.mjs")
+external object A {
+    val x: Int = definedExternally
+
+    fun foo(y: Int): Int = definedExternally
+}
+
+fun box(): String {
+    assertEquals(23, A.x)
+    assertEquals(65, A.foo(42))
+    return "OK"
+}
@@ -0,0 +1,6 @@
+export default {
+    x: 23,
+    foo: function(y) {
+        return this.x + y;
+    }
+};
@@ -0,0 +1,45 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// FILE: a.kt
+@file:JsModule("./externalPackage.mjs")
+package foo
+
+external class A(x: Int) {
+    val x: Int
+
+    fun foo(y: Int): Int = definedExternally
+
+    class Nested {
+        val y: Int
+    }
+}
+
+external object B {
+    val x: Int = definedExternally
+
+    fun foo(y: Int): Int = definedExternally
+}
+
+external fun foo(y: Int): Int = definedExternally
+
+external val bar: Int = definedExternally
+
+// FILE: b.kt
+package foo
+
+fun box(): String {
+    val a = A(23)
+    assertEquals(23, a.x)
+    assertEquals(65, a.foo(42))
+
+    val nested = A.Nested()
+    assertEquals(55, nested.y)
+
+    assertEquals(123, B.x)
+    assertEquals(265, B.foo(142))
+
+    assertEquals(365, foo(42))
+    assertEquals(423, bar)
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+export function A(x) {
+    this.x = x;
+}
+A.prototype.foo = function (y) {
+    return this.x + y;
+};
+
+function Nested() {
+    this.y = 55;
+}
+A.Nested = Nested;
+
+export var B = {
+    x: 123,
+    foo: function(y) {
+        return this.x + y;
+    }
+};
+
+export function foo(y) {
+    return 323 + y;
+}
+
+export var bar = 423;
@@ -0,0 +1,5 @@
+C = {
+    f: function() {
+        return 12345;
+    }
+};
@@ -0,0 +1,47 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// FILE: lib.kt
+@file:JsModule("./externalPackageInDifferentFile.mjs")
+package foo
+
+external class A(x: Int = definedExternally) {
+    val x: Int
+
+    fun foo(y: Int): Int = definedExternally
+}
+
+external object B {
+    val x: Int = definedExternally
+
+    fun foo(y: Int): Int = definedExternally
+}
+
+external fun foo(y: Int): Int = definedExternally
+
+external val bar: Int = definedExternally
+
+// FILE: lib2.kt
+package foo
+
+external object C {
+    fun f(): Int = definedExternally
+}
+
+// FILE: main.kt
+package foo
+
+fun box(): String {
+    val a = A(23)
+    assertEquals(23, a.x)
+    assertEquals(65, a.foo(42))
+
+    assertEquals(123, B.x)
+    assertEquals(265, B.foo(142))
+
+    assertEquals(365, foo(42))
+    assertEquals(423, bar)
+
+    assertEquals(12345, C.f())
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+function A(x) {
+    this.x = x;
+}
+A.prototype.foo = function (y) {
+    return this.x + y;
+};
+
+var B = {
+    x: 123,
+    foo: function(y) {
+        return this.x + y;
+    }
+};
+
+function foo(y) {
+    return 323 + y;
+}
+
+var bar = 423;
+
+export { A, B, foo, bar };
@@ -0,0 +1,11 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+package foo
+
+@JsModule("./externalProperty.mjs")
+external val foo: Int = definedExternally
+
+fun box(): String {
+    assertEquals(23, foo)
+    return "OK"
+}
@@ -0,0 +1 @@
+export default 23;
@@ -0,0 +1,33 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// FILE: bar.kt
+@file:JsModule("./interfaces.mjs")
+@file:JsQualifier("foo")
+package foo
+
+external interface Bar {
+    fun ping(): String
+}
+
+// FILE: baz.kt
+@file:JsModule("./interfaces.mjs")
+package boo
+
+external interface Baz {
+    fun pong(): Int
+}
+
+// FILE: root.kt
+@file:JsModule("./interfaces.mjs")
+import foo.Bar
+import boo.Baz
+
+external val bar: Bar
+external val baz: Baz
+
+// FILE: test.kt
+fun box(): String {
+    if (bar.ping() != "ping" || baz.pong() != 194) return "Fail"
+
+    return "OK"
+}
@@ -0,0 +1,12 @@
+export var bar = {
+    ping() {
+        return "ping"
+    }
+};
+
+export var baz = {
+    pong() {
+        return 194
+    }
+};
+
@@ -0,0 +1,15 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+@JsModule("./topLevelVarargFun.mjs")
+external fun foo(vararg arg: String): String
+
+fun box(): String {
+    val x = arrayOf("a", "b")
+    var r = foo(*x)
+    if (r != "(ab)") return "fail1: $r"
+
+    r = foo("c", "d")
+    if (r != "(cd)") return "fail2: $r"
+
+    return "OK"
+}
@@ -0,0 +1,3 @@
+export default function() {
+    return "(" + Array.prototype.join.call(arguments, "") + ")";
+};
@@ -0,0 +1,34 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: main
+// FILE: lib.kt
+@file:JsModule("./foo.mjs")
+package lib
+
+@JsName("default")
+external val foo: Int
+
+// FILE: lib2.kt
+@file:JsModule("./bar.mjs")
+package lib
+
+@JsName("default")
+external fun foo(): Int
+
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23 && foo() != 23) return "fail"
+    return "OK"
+}
+
+// FILE: foo.mjs
+
+export default 23;
+
+// FILE: bar.mjs
+
+export default function() { return 23; };
@@ -0,0 +1,32 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+// MODULE: main
+// FILE: lib.kt
+@file:JsModule("./foo.mjs")
+package lib
+
+@JsName("test")
+external val foo: Int
+
+// FILE: lib2.kt
+@file:JsModule("./bar.mjs")
+package lib
+
+@JsName("test")
+external val bar: Int
+
+// FILE: main.kt
+package main
+
+import lib.*
+
+fun box(): String {
+    if (foo != 23 || bar != 45) return "fail"
+    return "OK"
+}
+
+// FILE: foo.mjs
+export var test = 23;
+
+// FILE: bar.mjs
+export var test = 45;
@@ -0,0 +1,59 @@
+// DONT_TARGET_EXACT_BACKEND: JS
+// ES_MODULES
+
+// FILE: main.kt
+
+@JsExport
+open class A {
+    @JsName("foo")
+    open protected fun foo(n: Int) = 23
+
+    @JsName("bar")
+    fun bar(n: Int) = foo(n) + 100
+}
+
+@JsExport
+open class B {
+    @JsName("foo")
+    protected fun foo(n: Int) = 42
+
+    @JsName("bar")
+    open fun bar(n: Int) = 142
+}
+
+// FILE: entry.mjs
+// ENTRY_ES_MODULE
+
+import { A, B } from "./JS_TESTS/index.js";
+
+function createA() {
+    function ADerived() {
+    }
+    ADerived.prototype = Object.create(A.prototype);
+    ADerived.prototype.foo = function(n) {
+        return 24;
+    };
+    return new ADerived();
+}
+
+function createB() {
+    function BDerived() {
+    }
+    BDerived.prototype = Object.create(B.prototype);
+    BDerived.prototype.bar = function(n) {
+        return this.foo(n);
+    };
+    return new BDerived();
+}
+
+function box() {
+    let a = createA();
+    if (a.bar(0) != 124) return "fail1";
+
+    let b = createB();
+    if (b.bar(0) != 42) return "fail2";
+
+    return "OK";
+}
+
+console.assert(box() == "OK");