Reflection and Generics in Kotlin

user_6888848 0
Viewed 202

I've written myself into a corner where I want an instance of Class<Foo<Bar>>. While there's no apparent reason that this shouldn't be valid, there seems to be no way to create one. Foo<Bar>::class.java is a syntax error, and Kotlin does not provide a public constructor for Class.

The code I'm writing is an abstraction layer over gson. Below is an overly-simplified example:

class Boxed<T : Any> (val value: T)

class BaseParser<U : Any> (
    private val clazz: Class<U>
) {
    //This works for 98% of cases
    open fun parse(s: String): U {
        return gson.fromJson(s, clazz)
    }
    
    //Presume that clazz is required for other omitted functions
}

//Typical subclass:
class FooParser : BaseParser<Foo>(Foo::class.java)

// Edge Case 
class BarParser : BaseParser<Boxed<Bar>>(Boxed<Bar>::class.java) {
    override fun parse(s: String): Boxed<Bar> {
        return Boxed(gson.fromJson(s, Bar::class.java))
    }
}
// not valid: "Only classes are allowed on the left hand side of a class literal"

In my production code, there are already dozens of subclasses that inherit from the base class, and many that override the "parse" function Ideally I'd like a solution that doesn't require refactoring the existing subclasses.

kotlin gson
3 Answers

Actually, there is a reason this is impossible. Class (or Kotlin's KClass) can't hold parameterized types. They can hold e.g. List, but they can't List<String>. To store Foo<Bar> you need Type (or Kotlin's KType) and specifically ParameterizedType. These classes are somewhat more complicated to use and harder to acquire than simple Class.

The easiest way to acquire Type in Kotlin is by using its typeOf() utility:

typeOf<Foo<Bar>>().javaType

Gson supports both Class and Type, so you should be able to use it instead.

user_4488750

The closest you'll get is Boxed::class.java. This is not a language restriction but a JVM restriction. JVM has type erasure, so no generic types exist after compilation (thats also one of the reasons generics cant be primitives, as they need to be reference types to behave). Does it work with the raw Boxed type class?

user_89979160

For this case, it looks like

BaseParser<Boxed<Bar>>(Boxed::class.java as Class<Boxed<Bar>>)

could work (that is, it will both type-check and succeed at runtime). But it depends on what exactly happens in the "Presume that clazz is required for other omitted functions" part. And obviously it doesn't allow actually distinguishing Boxed<Foo> and Boxed<Bar> classes.

I'd also consider broot's approach if possible, maybe by making BaseParser and new

class TypeBaseParser<U : Any>(private val tpe: Type)

extend a common abstract class/interface.

alexey_r_92040
Related