JS: create new common directory for all generated tests, migrate several tests there

js/js.translator/testData/box/classObject/accessing.kt

@@ -0,0 +1,53 @@
+// KT-4130 object fields are not evaluated correctly
+
+package foo
+
+class Foo() {
+    companion object {
+        val bar = "Foo.bar ";
+        var boo = "FAIL";
+        fun baz() = "Foo.baz() "
+
+        fun testImplicitThis(): String {
+            boo = "Implicit"
+            return baz() + bar + boo
+        }
+        fun testExplicitThis(): String {
+            this.boo = "Explicit"
+            return this.baz() + this.bar + this.boo
+        }
+    }
+
+    val a = bar
+    val b = Foo.bar
+    val c = baz()
+    val d = Foo.baz()
+    val e: String
+    val f: String
+
+    init {
+        e = bar
+        f = Foo.bar
+        boo = "O"
+        Foo.boo += "K"
+    }
+}
+
+fun box(): String {
+    assertEquals("Foo.baz() Foo.bar Implicit", Foo.testImplicitThis(), "testImplicitThis")
+    assertEquals("Foo.baz() Foo.bar Explicit", Foo.testExplicitThis(), "testExplicitThis")
+
+    val foo = Foo()
+    assertEquals("Foo.bar ", foo.a, "foo.a")
+    assertEquals("Foo.bar ", foo.b, "foo.b")
+    assertEquals("Foo.baz() ", foo.c, "foo.c")
+    assertEquals("Foo.baz() ", foo.d, "foo.d")
+    assertEquals("Foo.bar ", foo.e, "foo.e")
+    assertEquals("Foo.bar ", foo.f, "foo.f")
+
+    assertEquals("OK", Foo.boo, "Foo.boo")
+    assertEquals("Foo.bar ", Foo.bar, "Foo.bar")
+    assertEquals("Foo.baz() ", Foo.baz(), "Foo.baz()")
+
+    return "OK"
+}

js/js.translator/testData/box/classObject/defaultObjectSameNamesAsInOuter.kt

@@ -0,0 +1,20 @@
+package foo
+
+class A {
+    private val p: Int
+        get() = 4
+
+    companion object B {
+        val p: Int
+            get() = 6
+    }
+
+    fun a() = p + B.p
+}
+
+
+fun box(): String {
+    if (A().a() != 10) return "Fail"
+
+    return "OK"
+}

js/js.translator/testData/box/classObject/enumCompanionObject.kt

@@ -0,0 +1,15 @@
+// See KT-6326, KT-6777
+package foo
+
+enum class Foo {
+    A;
+
+    companion object {
+        val a = A
+    }
+}
+
+fun box(): String {
+    assertEquals("A", Foo.a.name)
+    return "OK"
+}

js/js.translator/testData/box/classObject/inTrait.kt

@@ -0,0 +1,11 @@
+package foo
+
+interface A {
+    companion object {
+        val OK: String = "OK"
+    }
+}
+
+fun box(): String {
+    return A.OK
+}

js/js.translator/testData/box/classObject/invokeOperatorInCompanionObject.kt

@@ -0,0 +1,22 @@
+// See KT-11100
+package foo
+
+class Div {
+    var className: String? = null
+
+    companion object {
+        operator fun invoke(init: Div.() -> Unit): Div {
+            val div = Div()
+            div.init()
+            return div
+        }
+    }
+}
+
+fun box(): String {
+    val x = Div {
+        className = "ui container"
+    }
+    assertEquals("ui container", x.className)
+    return "OK"
+}

js/js.translator/testData/box/classObject/namedClassObject.kt

@@ -0,0 +1,33 @@
+package foo
+
+interface Named {
+    companion object Bar {
+        val g = "a";
+    }
+}
+
+class Foo {
+    companion object {
+        val g = "b";
+    }
+}
+
+fun box(): String {
+    assertEquals("a", Named.Bar.g, "Named.Bar.g")
+    assertEquals("a", Named.g, "Named.g")
+
+    assertEquals("b", Foo.Companion.g, "Foo.Companion.g")
+    assertEquals("b", Foo.g, "Foo.g")
+
+    assertEquals("b", foo(Foo), "foo(Foo)")
+    assertEquals("b", foo(Foo.Companion), "foo(Foo.Companion)")
+
+    assertEquals("c", Named.ext(), "Named.ext()")
+    assertEquals("c", Named.Bar.ext(), "Named.Bar.ext()")
+
+    return "OK"
+}
+
+fun foo(f: Foo.Companion) = f.g
+
+fun Named.Bar.ext() = "c"

js/js.translator/testData/box/classObject/objectInCompanionObject.kt

@@ -0,0 +1,25 @@
+// See KT-6203
+package foo
+
+class TestClass {
+    object a {
+        override fun toString() = "a"
+    }
+
+    companion object {
+        object b {
+            override fun toString() = "b"
+        }
+    }
+
+    fun test() = convert(a) + convert(b)
+}
+
+fun convert(o: Any) = o.toString()
+
+fun box(): String {
+    assertEquals("ab", TestClass().test())
+    assertEquals("ab2", convert(TestClass.a) + convert(TestClass.Companion.b) + "2")
+
+    return "OK"
+}

js/js.translator/testData/box/classObject/setVar.kt

@@ -0,0 +1,26 @@
+package foo
+
+class A {
+    var a = 3
+    companion object {
+        var a = -2
+    }
+}
+
+
+fun box(): String {
+    A.a = 2
+    if (A.a != 2) return "A.a != 2, it: ${A.a}"
+
+    val a = A
+    a.a = 3
+    if (a.a != 3) return "a = A; a.a = 3; a != 3, it: ${a.a}"
+
+    if (A().a != 3) return "A().a != 3, it: ${A().a}"
+
+    val x = A()
+    x.a = 4
+    if (x.a != 4) return "x = A(); x.a = 4; x.a != 4, it: ${x.a}"
+
+    return "OK"
+}

js/js.translator/testData/box/classObject/simple.kt

@@ -0,0 +1,22 @@
+package foo
+
+class A {
+    val a = 3
+    companion object {
+        val a = 2
+        val b = 5
+    }
+}
+
+
+fun box(): String {
+    if (A.a != 2) return "A.a != 2, it: ${A.a}"
+    if (A.b != 5) return "A.b != 5, it: ${A.b}"
+
+    val b = A
+    if (b.a != 2) return "b = A; b != 2, it: ${b.a}"
+
+    if (A().a != 3) return "A().a != 3, it: ${A().a}"
+
+    return "OK"
+}

js/js.translator/testData/box/classObject/withInheritance.kt

@@ -0,0 +1,31 @@
+package foo
+
+open class A {
+    val a = 3
+    fun foo(): Int {
+        return 5
+    }
+    companion object: A() {
+        val c = a
+    }
+}
+
+class B {
+    companion object: A() {
+    }
+}
+
+fun box(): String {
+    if (A.a != 3) return "A.a != 3, it: ${A.a}"
+    if (A.foo() != 5) return "A.foo() != 5, it: ${A.foo()}"
+
+    val a = A
+    if (a.c != 3) return "a = A; a.c != 3, it: ${a.c}"
+
+    if (A().a != 3) return "A().a != 3, it: ${A().a}"
+
+    if (B.a != 3) return "B.a != 3, it: ${B.a}"
+    val b = B
+    if (b.foo() != 5) return "b = B; b.foo() != 5, it: ${b.foo()}"
+    return "OK"
+}