JS: fix reified T::class for primitive T (e.g. Int) (KT-32215 fixed)

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

@@ -1,4 +1,8 @@
 // EXPECTED_REACHABLE_NODES: 1318
+
+// FILE: lib.kt
+// RECOMPILE
+
 package foo
 
 import kotlin.reflect.KClass
@@ -10,11 +14,17 @@ inline fun <reified T : Any> foo(b: Boolean = false): KClass<T> {
     return T::class
 }
 
+// FILE: main.kt
+package foo
+
 fun box(): String {
     check(A::class, foo<A>())
     check(B::class, foo<B>())
     check(O::class, foo<O>())
     check(E::class, foo<E>())
 
+    check(Int::class, foo<Int>())
+    check(ByteArray::class, foo<ByteArray>())
+
     return "OK"
 }

js/js.translator/testData/box/reflection/kClassOnReifiedTypeInLambda-advanced.kt

@@ -0,0 +1,30 @@
+// EXPECTED_REACHABLE_NODES: 1320
+// IGNORE_BACKEND: JS
+
+// FILE: lib.kt
+// RECOMPILE
+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 }
+}
+
+// FILE: main.kt
+package foo
+
+fun box(): String {
+    check(A::class, foo<A>()())
+    check(B::class, foo<B>()())
+    check(O::class, foo<O>()())
+    check(E::class, foo<E>()())
+
+    check(Int::class, foo<Int>()())
+    check(ByteArray::class, foo<ByteArray>()())
+
+    return "OK"
+}

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

@@ -0,0 +1,51 @@
+// EXPECTED_REACHABLE_NODES: 1321
+
+// MODULE: lib
+// FILE: lib.kt
+inline fun <reified T: Any> klassLib() = T::class
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+import kotlin.reflect.KClass
+
+inline fun <reified T: Any> klass() = T::class
+
+fun box(): String {
+    check(js("Object"), "Any", klass<Any>())
+    check(js("String"), "String", klass<String>())
+    check(js("Boolean"), "Boolean", klass<Boolean>())
+    check(js("Error"), "Throwable", klass<Throwable>())
+    check(js("Array"), "Array", klass<Array<Any>>())
+    check(js("Function"), "Function0", klass<Function0<*>>())
+    check(js("Function"), "Function1", klass<Function1<*, *>>())
+
+    check(js("Number"), "Byte", klass<Byte>())
+    check(js("Number"), "Short", klass<Short>())
+    check(js("Number"), "Int", klass<Int>())
+    check(js("Number"), "Float", klass<Float>())
+    check(js("Number"), "Double", klass<Double>())
+    check(js("Number"), "Number", klass<Number>())
+
+    check(js("Array"), "BooleanArray", klass<BooleanArray>())
+    check(js("Uint16Array"), "CharArray", klass<CharArray>())
+    check(js("Int8Array"), "ByteArray", klass<ByteArray>())
+    check(js("Int16Array"), "ShortArray", klass<ShortArray>())
+    check(js("Int32Array"), "IntArray", klass<IntArray>())
+    check(js("Array"), "LongArray", klass<LongArray>())
+    check(js("Float32Array"), "FloatArray", klass<FloatArray>())
+    check(js("Float64Array"), "DoubleArray", klass<DoubleArray>())
+
+    // Check same instance
+    if (Int::class !== klass<Int>()) return "Same instance check failed"
+
+    // Check inlining from other module works
+    check(js("Int8Array"), "ByteArray", klassLib<ByteArray>())
+
+    return "OK"
+}
+
+private fun check(nativeClass: dynamic, simpleName: String, c: KClass<*>) {
+    assertEquals(simpleName, c.simpleName, "Simple name of class has unexpected value")
+    assertEquals(nativeClass, c.js, "Kotlin class does not correspond native class ${nativeClass.name}")
+}