Reflection: add KTypeProjection and KType.arguments

#KT-8998 In Progress

core/builtins/src/kotlin/reflect/KType.kt

@@ -29,6 +29,12 @@ public interface KType {
      */
     public val classifier: KClassifier?
 
+    /**
+     * Type arguments passed for the parameters of the classifier in this type.
+     * For example, in the type `Array<out Number>` the only type argument is `out Number`.
+     */
+    public val arguments: List<KTypeProjection>
+
     /**
      * `true` if this type was marked nullable in the source code.
      *
@@ -42,9 +48,54 @@ public interface KType {
      *
      * ```
      * fun <T> foo(t: T) {
-     *     // isMarkedNullable == false for t's type, but t can be null here
+     *     // isMarkedNullable == false for t's type, but t can be null here when T = "Any?"
      * }
      * ```
      */
     public val isMarkedNullable: Boolean
 }
+
+/**
+ * Represents a type projection. Type projection is usually the argument to another type in a type usage.
+ * For example, in the type `Array<out Number>`, `out Number` is the covariant projection of the type represented by the class `Number`.
+ *
+ * Type projection is either the star projection, or an entity consisting of a specific type plus optional variance.
+ *
+ * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/generics.html#type-projections)
+ * for more information.
+ */
+public sealed class KTypeProjection {
+    /**
+     * The type specified in the projection, or `null` if this is a star projection.
+     */
+    public abstract val type: KType?
+
+    /**
+     * Invariant projection of a type. Invariant projection is just the type itself, without any use-site variance modifiers applied to it.
+     * For example, in the type `Set<String>`, `String` is an invariant projection of the type represented by the class `String`.
+     */
+    public data class Invariant(override val type: KType) : KTypeProjection()
+
+    /**
+     * Contravariant projection of a type, denoted by the `in` modifier applied to a type.
+     * For example, in the type `MutableList<in Number>`, `in Number` is a contravariant projection of the type of class `Number`.
+     */
+    public data class In(override val type: KType) : KTypeProjection()
+
+    /**
+     * Covariant projection of a type, denoted by the `out` modifier applied to a type.
+     * For example, in the type `Array<out Number>`, `out Number` is a covariant projection of the type of class `Number`.
+     */
+    public data class Out(override val type: KType) : KTypeProjection()
+
+    /**
+     * Star projection, denoted by the `*` character.
+     * For example, in the type `KClass<*>`, `*` is the star projection.
+     * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/generics.html#star-projections)
+     * for more information.
+     */
+    public object Star : KTypeProjection() {
+        override val type: KType?
+            get() = null
+    }
+}

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

@@ -23,11 +23,13 @@ import org.jetbrains.kotlin.load.java.structure.reflect.createArrayType
 import org.jetbrains.kotlin.load.java.structure.reflect.primitiveByWrapper
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.Variance
+import java.lang.reflect.GenericArrayType
+import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Type
-import kotlin.reflect.KClass
-import kotlin.reflect.KClassifier
-import kotlin.reflect.KType
-import kotlin.reflect.KTypeParameter
+import java.lang.reflect.WildcardType
+import kotlin.LazyThreadSafetyMode.PUBLICATION
+import kotlin.reflect.*
 
 internal class KTypeImpl(
         val type: KotlinType,
@@ -73,6 +75,53 @@ internal class KTypeImpl(
         }
     }
 
+    override val arguments: List<KTypeProjection>
+        get() {
+            val typeArguments = type.arguments
+            if (typeArguments.isEmpty()) return emptyList()
+
+            // Lazy because it's not needed to compute javaType right away, only inside the lazy value for each argument,
+            // and also because sometimes (e.g. in case of star projections), this won't be needed at all.
+            // Note that this instance is created before the loop because ParameterizedType#actualTypeArguments clones the array
+            val javaTypeArguments by lazy(PUBLICATION) {
+                (javaType as ParameterizedType).actualTypeArguments
+            }
+
+            return typeArguments.mapIndexed { i, typeProjection ->
+                if (typeProjection.isStarProjection) {
+                    KTypeProjection.Star
+                }
+                else {
+                    val type = KTypeImpl(typeProjection.type) {
+                        val javaType = javaType
+                        when (javaType) {
+                            is Class<*> -> {
+                                // It's either an array or a raw type.
+                                // TODO: return upper bound of the corresponding parameter for a raw type?
+                                if (javaType.isArray) javaType.componentType else Any::class.java
+                            }
+                            is GenericArrayType -> {
+                                if (i != 0) throw KotlinReflectionInternalError("Array type has been queried for a non-0th argument: $this")
+                                javaType.genericComponentType
+                            }
+                            is ParameterizedType -> {
+                                val argument = javaTypeArguments[i]
+                                // In "Foo<out Bar>", the JVM type of the first type argument should be "Bar", not "? extends Bar"
+                                if (argument !is WildcardType) argument
+                                else argument.lowerBounds.firstOrNull() ?: argument.upperBounds.first()
+                            }
+                            else -> throw KotlinReflectionInternalError("Non-generic type has been queried for arguments: $this")
+                        }
+                    }
+                    when (typeProjection.projectionKind) {
+                        Variance.INVARIANT -> KTypeProjection.Invariant(type)
+                        Variance.IN_VARIANCE -> KTypeProjection.In(type)
+                        Variance.OUT_VARIANCE -> KTypeProjection.Out(type)
+                    }
+                }
+            }
+        }
+
     override val isMarkedNullable: Boolean
         get() = type.isMarkedNullable