JS backend: add the ability to get JS constructor function by class name and from instance. Support it for reified type parameters too. Add ability to get name of class.

#KT-5987 Fixed
 #KT-4115 Fixed

js/js.translator/testData/kotlin_lib_ecma5.js

@@ -192,7 +192,7 @@
     }
 
     Kotlin.createTraitNow = function (bases, properties, staticProperties) {
-        var obj = function () {};
+        var obj = {};
 
         obj.$metadata$ = computeMetadata(bases, properties, staticProperties);
         obj.$metadata$.type = Kotlin.TYPE.TRAIT;
@@ -301,6 +301,7 @@
     Kotlin.createTrait = function (basesFun, properties, staticProperties) {
         function $o() {
             var klass = Kotlin.createTraitNow(getBases(basesFun), properties, staticProperties);
+            klass.name = $o.className;
             Object.defineProperty(this, $o.className, {value: klass});
             return klass;
         }
@@ -320,8 +321,8 @@
     Kotlin.createObject = function (basesFun, constructor, functions, staticProperties) {
         constructor = constructor || function() {};
         function $o() {
-            var klass = Kotlin.createClassNow(getBases(basesFun), null, functions, staticProperties);
-            var obj = new klass();
+            var klass = Kotlin.createClassNow(getBases(basesFun), constructor, functions, staticProperties);
+            var obj = Object.create(klass.prototype);
             var metadata = klass.$metadata$;
             metadata.type = Kotlin.TYPE.OBJECT;
             Object.defineProperty(this, $o.className, {value: obj});

js/js.translator/testData/reflection/light/_commonFiles/declarations.kt

@@ -0,0 +1,20 @@
+package foo
+
+open class A
+
+class B : A() {
+    val a = 1
+}
+
+object O
+
+interface I
+
+enum class E {
+    X,
+    Y {
+        val a = 1
+    },
+    Z {}
+}
+

js/js.translator/testData/reflection/light/cases/jsClass.kt

@@ -0,0 +1,23 @@
+package foo
+
+fun <T> check(x: JsClass<T>, y: JsClass<T>, shouldBeEquals: Boolean = true) {
+    assertNotEquals(null, x)
+    assertNotEquals(null, y)
+    if (shouldBeEquals)
+        assertEquals(x, y)
+    else
+        assertNotEquals(x, y)
+}
+
+fun box(): String {
+    check(jsClass<A>(), A().jsClass)
+    check(jsClass<B>(), B().jsClass)
+    check(jsClass<O>(), O.jsClass)
+    assertNotEquals(null, jsClass<I>())
+    check(jsClass<E>(), E.X.jsClass)
+    check(jsClass<E>(), E.Y.jsClass, shouldBeEquals = false)
+// TODO uncomment after KT-13338 is fixed
+//    check(jsClass<E>(), E.Z.jsClass)
+
+    return "OK"
+}

js/js.translator/testData/reflection/light/cases/jsClassName.kt

@@ -0,0 +1,26 @@
+package foo
+
+fun testWithInstance() {
+    assertEquals("A", A().jsClass.name)
+    assertEquals("B", B().jsClass.name)
+    assertEquals("O", O.jsClass.name)
+    assertEquals("E", E.X.jsClass.name)
+    assertEquals("Y", E.Y.jsClass.name)
+// TODO uncomment after KT-13338 is fixed
+//    assertEquals("E", E.Z.jsClass.name)
+}
+
+fun testWithClassReference() {
+    assertEquals("A", jsClass<A>().name)
+    assertEquals("B", jsClass<B>().name)
+    assertEquals("O", jsClass<O>().name)
+    assertEquals("I", jsClass<I>().name)
+    assertEquals("E", jsClass<E>().name)
+}
+
+fun box(): String {
+    testWithInstance()
+    testWithClassReference()
+
+    return "OK"
+}

js/js.translator/testData/reflection/light/cases/jsClassOnReifiedType.kt

@@ -0,0 +1,15 @@
+package foo
+
+inline fun <reified T> foo(): JsClass<T> {
+    val T = 1
+    return jsClass<T>()
+}
+
+fun box(): String {
+    assertEquals(jsClass<A>(), foo<A>())
+    assertEquals(jsClass<B>(), foo<B>())
+    assertEquals(jsClass<O>(), foo<O>())
+    assertEquals(jsClass<E>(), foo<E>())
+
+    return "OK"
+}