JVM: partially reify typeOf and signatures as soon as possible

E.g. when substituting T -> Array<T>, write the bytecode for the
Array<...> part for typeOf.

This fixes various issues where either Array nesting levels, nullability
information (for typeOf), or entire reification markers were missing,
causing incorrect outputs ranging from missing `?`s to missing `[]`s to
just reified types not really being reified.

^KT-53761 Fixed

compiler/testData/codegen/box/reflection/typeOf/arrayOfNullableReified.kt

@@ -0,0 +1,21 @@
+// IGNORE_BACKEND: JS_IR, JS_IR_ES6
+// WITH_REFLECT
+
+import kotlin.reflect.typeOf
+import kotlin.test.assertEquals
+
+inline fun <reified T> typeOfArrayOfNArrayOf() =
+    typeOf<Array<Array<T>?>>()
+
+inline fun <reified T> myTypeOf() =
+    typeOf<T>()
+
+inline fun <reified T> myTypeOfArrayOfNArrayOf() =
+    typeOf<Array<Array<T>?>>()
+
+fun box(): String {
+    assertEquals(typeOf<Array<Array<String>?>>(), typeOfArrayOfNArrayOf<String>())
+    assertEquals(typeOf<Array<Array<String>?>>(), myTypeOf<Array<Array<String>?>>())
+    assertEquals(typeOf<Array<Array<String>?>>(), myTypeOfArrayOfNArrayOf<String>())
+    return "OK"
+}

compiler/testData/codegen/box/reflection/typeOf/reifiedAsNestedArgument.kt

@@ -0,0 +1,20 @@
+// IGNORE_BACKEND: JS, JS_IR, JS_IR_ES6
+// WITH_REFLECT
+
+import kotlin.reflect.typeOf
+import kotlin.reflect.KType
+import kotlin.test.assertEquals
+
+inline fun <reified T> foo() =
+    object { val x = typeOf<T>() }.x
+
+inline fun <reified T> bar(expected: KType) {
+    assertEquals(expected, foo<List<T>>())
+    assertEquals(expected, object { val x = typeOf<List<T>>() }.x)
+    assertEquals(expected, typeOf<List<T>>())
+}
+
+fun box(): String {
+    bar<Int>(typeOf<List<Int>>())
+    return "OK"
+}

compiler/testData/codegen/box/reified/typeTokenWrapper.kt

@@ -0,0 +1,33 @@
+// TARGET_BACKEND: JVM
+// ISSUE: KT-53761
+// WITH_STDLIB
+// IGNORE_BACKEND: ANDROID
+
+import kotlin.test.assertEquals
+
+open class TypeToken<T> {
+    val type = javaClass.genericSuperclass
+}
+
+inline fun <reified E> myTypeOf() =
+    object : TypeToken<E>() {}.type
+
+inline fun <reified T> myTypeOfArrayOf() =
+    object : TypeToken<Array<T>>() {}.type
+
+inline fun <reified T> myTypeOfArrayOf2() =
+    myTypeOf<Array<T>>()
+
+inline fun <reified T> myTypeOfListOf() =
+    object : TypeToken<List<T>>() {}.type
+
+inline fun <reified T> myTypeOfListOf2() =
+    myTypeOf<List<T>>()
+
+fun box(): String {
+    assertEquals(myTypeOf<Array<String>>(), myTypeOfArrayOf<String>())
+    assertEquals(myTypeOf<Array<String>>(), myTypeOfArrayOf2<String>())
+    assertEquals(myTypeOf<List<String>>(), myTypeOfListOf<String>())
+    assertEquals(myTypeOf<List<String>>(), myTypeOfListOf2<String>())
+    return "OK"
+}