JS backend: basic support for class literals.

Added:
* the ability to get KClass using class literals (`::class`);
* the ability to get KClass from JsClass and vice versa;
* the ability to get simpleName.

 #KT-13345 Fixed

js/js.translator/testData/box/reflection/_common.kt

@@ -20,3 +20,18 @@ enum class E {
 
 @JsName("Q")
 class R
+
+fun check(x: Any, y: Any, shouldBeEqual: Boolean = true, shouldBeSame: Boolean = true) {
+    assertNotEquals(null, x)
+    assertNotEquals(null, y)
+    if (shouldBeEqual) {
+        assertEquals(x, y)
+
+        if (shouldBeSame && x !== y) {
+            fail("Expected same instances, got expected = '$x', actual = '$y'")
+        }
+    }
+    else {
+        assertNotEquals(x, y)
+    }
+}

js/js.translator/testData/box/reflection/jsClass.kt

@@ -1,21 +1,12 @@
 package foo
 
-fun check(x: JsClass<*>, y: JsClass<*>, 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)
+    check(jsClass<E>(), E.Y.jsClass, shouldBeEqual = false)
 // TODO uncomment after KT-13338 is fixed
 //    check(jsClass<E>(), E.Z.jsClass)
 

js/js.translator/testData/box/reflection/jsClassOnReifiedType.kt

@@ -6,10 +6,10 @@ inline fun <reified T : Any> foo(): 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>())
+    check(jsClass<A>(), foo<A>())
+    check(jsClass<B>(), foo<B>())
+    check(jsClass<O>(), foo<O>())
+    check(jsClass<E>(), foo<E>())
 
     return "OK"
 }

js/js.translator/testData/box/reflection/kClass.kt

@@ -0,0 +1,14 @@
+package foo
+
+fun box(): String {
+    check(A::class, A()::class)
+    check(B::class, B()::class)
+    check(O::class, (O)::class)
+    assertNotEquals(null, I::class)
+    check(E::class, E.X::class)
+    check(E::class, E.Y::class, shouldBeEqual = false)
+// TODO uncomment after KT-13338 is fixed
+//    check(E::class, E.Z::class)
+
+    return "OK"
+}

js/js.translator/testData/box/reflection/kClassOnReifiedType.kt

@@ -0,0 +1,19 @@
+package foo
+
+import kotlin.reflect.KClass
+
+inline fun <reified T : Any> foo(b: Boolean = false): KClass<T> {
+    if (b) {
+        val T = 1
+    }
+    return T::class
+}
+
+fun box(): String {
+    check(A::class, foo<A>())
+    check(B::class, foo<B>())
+    check(O::class, foo<O>())
+    check(E::class, foo<E>())
+
+    return "OK"
+}

js/js.translator/testData/box/reflection/kClassSimpleName.kt

@@ -0,0 +1,40 @@
+package foo
+
+class undefined
+
+class Outer {
+    class Nested
+
+    inner class Inner
+}
+
+fun testWithInstance() {
+    assertEquals("A", A()::class.simpleName)
+    assertEquals("B", B()::class.simpleName)
+    assertEquals("O", (O)::class.simpleName)
+    assertEquals("E", E.X::class.simpleName)
+    assertEquals("Y", E.Y::class.simpleName)
+// TODO uncomment after KT-13338 is fixed
+//    assertEquals("E", E.Z::class.simpleName)
+    assertEquals("undefined", undefined()::class.simpleName)
+    assertEquals("Nested", Outer.Nested()::class.simpleName)
+    assertEquals("Inner", Outer().Inner()::class.simpleName)
+}
+
+fun testWithClassReference() {
+    assertEquals("A", A::class.simpleName)
+    assertEquals("B", B::class.simpleName)
+    assertEquals("O", O::class.simpleName)
+    assertEquals("I", I::class.simpleName)
+    assertEquals("E", E::class.simpleName)
+    assertEquals("undefined", foo.undefined::class.simpleName)
+    assertEquals("Nested", Outer.Nested::class.simpleName)
+    assertEquals("Inner", Outer.Inner::class.simpleName)
+}
+
+fun box(): String {
+    testWithInstance()
+    testWithClassReference()
+
+    return "OK"
+}

js/js.translator/testData/box/reflection/kClassToAndFromJsClass.kt

@@ -0,0 +1,29 @@
+package foo
+
+import kotlin.reflect.KClass
+
+fun check(k: KClass<*>, j: JsClass<*>) {
+    assertNotEquals(null, k)
+    assertNotEquals(null, j)
+
+    assertEquals(k.js, j)
+    assertEquals(k, j.kotlin)
+    assertEquals(j, j.kotlin.js)
+    assertEquals(k, k.js.kotlin)
+}
+
+fun jsClassbyName(name: String) = js("JS_TESTS").foo[name]
+
+fun box(): String {
+    check(A::class, jsClassbyName("A"))
+    check(B::class, jsClassbyName("B"))
+    check(O::class, jsClassbyName("O").constructor)
+    check(I::class, jsClassbyName("I"))
+    check(E::class, jsClassbyName("E"))
+    check(E.X::class, jsClassbyName("E").X.constructor)
+    check(E.Y::class, jsClassbyName("E").Y.constructor)
+// TODO uncomment after KT-13338 is fixed
+//    check(E.Z::class, jsClassbyName("E").Z.constructor)
+
+    return "OK"
+}