Reflection: add KType.jvmErasure

#KT-8998 In Progress

core/reflection.jvm/src/kotlin/reflect/jvm/KTypesJvm.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmName("KTypesJvm")
+package kotlin.reflect.jvm
+
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.ClassKind.ANNOTATION_CLASS
+import org.jetbrains.kotlin.descriptors.ClassKind.INTERFACE
+import kotlin.reflect.*
+import kotlin.reflect.jvm.internal.KTypeImpl
+
+/**
+ * Returns the [KClass] instance representing the runtime class to which this type is erased to on JVM.
+ */
+val KType.jvmErasure: KClass<*>
+    get() = classifier?.jvmErasure ?: throw KotlinReflectionInternalError("Cannot calculate JVM erasure for type: $this")
+
+internal val KClassifier.jvmErasure: KClass<*>
+    get() = when (this) {
+        is KClass<*> -> this
+        is KTypeParameter -> {
+            // See getRepresentativeUpperBound in typeSignatureMapping.kt
+            val bounds = upperBounds
+            val representativeBound = bounds.firstOrNull {
+                val classDescriptor = (it as KTypeImpl).type.constructor.declarationDescriptor as? ClassDescriptor
+                classDescriptor != null && classDescriptor.kind != INTERFACE && classDescriptor.kind != ANNOTATION_CLASS
+            } ?: bounds.firstOrNull()
+            representativeBound?.jvmErasure ?: Any::class
+        }
+        else -> throw KotlinReflectionInternalError("Cannot calculate JVM erasure for type: $this")
+    }

core/reflection.jvm/src/kotlin/reflect/jvm/internal/KTypeImpl.kt

@@ -29,7 +29,11 @@ import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Type
 import java.lang.reflect.WildcardType
 import kotlin.LazyThreadSafetyMode.PUBLICATION
-import kotlin.reflect.*
+import kotlin.reflect.KClassifier
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.KotlinReflectionInternalError
+import kotlin.reflect.jvm.jvmErasure
 
 internal class KTypeImpl(
         val type: KotlinType,
@@ -48,19 +52,10 @@ internal class KTypeImpl(
                 if (jClass.isArray) {
                     // There may be no argument if it's a primitive array (such as IntArray)
                     val argument = type.arguments.singleOrNull()?.type ?: return KClassImpl(jClass)
-
-                    val elementClassifier = convert(argument)
-                    val elementType = when (elementClassifier) {
-                        is KClass<*> -> elementClassifier
-                        is KTypeParameter -> {
-                            // For arrays of type parameters (`Array<T>`) we return the KClass representing `Array<Any>`
-                            // since there's no other sensible option
-                            // TODO: return `Array<erasure-of-T>`
-                            Any::class
-                        }
-                        else -> TODO("Arrays of type alias classifiers are not yet supported")
-                    }
-                    return KClassImpl(elementType.java.createArrayType())
+                    val elementClassifier =
+                            convert(argument)
+                            ?: throw KotlinReflectionInternalError("Cannot determine classifier for array element type: $this")
+                    return KClassImpl(elementClassifier.jvmErasure.java.createArrayType())
                 }
 
                 if (!TypeUtils.isNullableType(type)) {