Why the type of expression objectOfTypeT::class is KClass<out T>? - kotlin

Question

Suppose we have generic function:
fun <T: Any> foo(o: T) {
o::class
}
The o::class's type is KClass<out T>. Why there is the out variance annotation, and why is it not KClass<out Any> (because T's erasure is Any)
This out variance annotation screwed my nice reflection code
EDIT:
After digging a while, I found kotlin rely on Object::getClass to get a Class to create a KClass, the actual creation code has a signature like fun <T: Any> create(jClass: Class<T>): KClass<T>. However this leads to another problem. The o::class should be of type KClass<Any> because jClass parameter of that create method should be of type Class<Object>, since the erasure of static type T is just Any (or Object, to which is mapped on JVM).

Answer 1

Why there is the out variance annotation?
This is expected behavior of the Bounded Class Reference in kotlin 1.1.
We know an instance of subclass can be assign to a supperclass, for example:
val long:Number = 1L;
val int:Number = 1;
We also know generic inheritance is not like class inheritance, for example:
val long:KClass<Long> = Long::class;
val number:KClass<Number> = long;
// ^
// can't be compiled, required KClass<Number> but found KClass<Number>
So we makes the code to be compiled by using Generic Type Projection as below:
val number:KClass<out Number> = long;
In Short, an variable of supperclass (Number) can be assign to an instances of any its subclasses (Long, Int, Double and .etc), but when get the KClass reference from the Number reference it should be return a KClass<out Number> rather than KClass<Number>, because KClass<Int> is not a subtype of the KClass<Number>.
The same rule applies in java, for example:
Number number = 1L;
Class<? extends Number> type = number.getClass();
Why is it not KClass (because T's erasure is Any)?
Because your method uses generic parameter T, but java.lang.Object#getClass don't uses any generic parameter at all and its return type is Class<? extends Object>.
However, the T#javaClass property takes a generic parameter T and you can see the code below that kotin cast a Class<?> to a Class<T>. so the Upper Bounded Wildcard of the o::class in the foo method is KClass<? extends T> rather than KClass<? extends Object> in java.
public inline val <T: Any> T.javaClass : Class<T>
#Suppress("UsePropertyAccessSyntax")
get() = (this as java.lang.Object).getClass() as Class<T>
// force to casting a Class<?> to a Class<T> ---^
A KClass<? extends T> is a subtype of KClass<?>, according to LISP principle you can't assign a superclass instance to a subclass type.
fun <T : Any> foo(value: T) {
val type: Class<out T> = (value as java.lang.Object).getClass();
// ^
// Compilation Error:
// you can't assign Class<? extends Object> to a Class<? extends T>
}
you can also see the method generic signature as below:
val noneGenericParametersMethod= Object::class.java.getDeclaredMethod("getClass")!!
val genericParametersMethod by lazy {
val it = object {
fun <T : Any> foo(): Class<out T> = TODO();
};
return#lazy it.javaClass.getDeclaredMethod("foo")!!;
}
println(genericParametersMethod.toGenericString())
// ^--- its return type is java.lang.Class<? extends T>
println(noneGenericParametersMethod.toGenericString())
// ^--- its return type is java.lang.Class<? extends Object>
Base on the above, the expression o::class actually returns a Raw Type KClass rather than a parameterized type KClass<out T>, and a Raw Type can be assign to any Parameterized Type, However, kotlin has no Raw Type, so kotlin compiler narrow the raw type KClass into the parameterized type KClass<out T>, just like as narrow an List<*> to an Iterable<*>. an example of Raw Type in java:
Box rawBox = new Box(); // rawBox is a raw type of Box<T>
Box<Integer> intBox = rawBox; // warning: unchecked conversion
Why java can't assign T.getClass() into a Class<? extends T>?
If you get deep into the documentation of the java.lang.Object#getClass method, you will found the result as below:
The actual result type is Class<? extends |X|> where |X| is the erasure of the static type of the expression on which getClass is called.
"The erasure of the static type": which means |X| is the bounded type rather than the actual generic argument type in runtime, for example:
// Object.getClass() using the bounded static type `Number`
// v
<T extends Number> Class<? extends Number> foo(T value){
return value.getClass();
}