I am having trouble implementing a method from an interface that was defined in Java. It has a

Class<T>

return type, but I can't seem to make it work with nullable types without triggering a compiler warning

override fun toType(): Class<Boolean?> = 
        Boolean::class.java as Class<Boolean?>

This works, but the cast triggers the warning:

Unchecked cast Class<Boolean> to Class<Boolean?>

I tried to qualify it as <out Boolean>, but I can't seem to make it work?

are you looking for

Class<Boolean>?

instead?

no. the return type needs to be a

Class<T>

There is no

Class<Boolean?>

, so you may need to look at your generics.

@Ruckus is correct, there is no

Class<Boolean?>

What is the actual return type of the method from the Java interface? Assuming that Java interface isn't marked with

@Nullable

the return type should be

Class<Boolean>!

So, in this case,

Class<Boolean>

or

Class<Boolean>?

should work.

Oh, I hadn't tried with

Boolean

before, since I always use it with Boolean? types :grinning_face_with_one_large_and_one_small_eye:

Class<Boolean?>

implies that

Class<Boolean>

and

Class<null>

are valid.

Class<null>

isn't possible.

Class<Boolean>?

implies that null is a valid return value.

Got everything else, but not sure I could wrap my head around the

implies that [...] Class<null> is valid

bit. Isn't the T in generics supposed to be the "placeholder of a type"? And isn't

Boolean?

a type?

Boolean?

is a type, but there are restrictions on what you can pass to generics as parameters.

Ah ok! Do you know where i can read more on that? i couldn't find these specifics in the documentation

Thanks for your help 🙂

You are running into a platform type. If Java says

Boolean

, Kotlin cannot know if it's nullable or not, so it sees it as a platform type, which adjusts to being nullable or not nullable depending on context. If you are overriding a method, IntelliJ will choose the conservative way and choose nullable. but in this case that's not correct, so if you change the return type to

Class<Boolean>

your code still compiles and makes sense.

The interface is

Class<T> toType();

It is applied to my Kotlin class, tho, which has a

Boolean?

type

You can probably do something like this:

class EnabledIndicatorConverter: Converter<BigDecimal, Boolean> {

    override fun to(isEnabled: Boolean?): BigDecimal? {
        return isEnabled?.let { BigDecimal.ONE } 
                ?: BigDecimal.ZERO
    }

    override fun fromType(): Class<BigDecimal> =
            BigDecimal::class.java

    override fun toType(): Class<Boolean> =
            Boolean::class.java

}

Yeah, that worked!