How to iterate over class properties in Kotlin

I have an abstract class ConfigGroup that has the super class ConfigElement.
In ConfigElement a method toJson() is definded. ConfigGroup overrides this method.

Currently toJson() in ConfigGroup looks like this:

override fun toJson(): JsonObject {
        val map: HashMap<String, JsonObject> = HashMap()
        for (child in this::class.declaredMemberProperties) {
            map[child.name] = (child.get(this) as ConfigElement).toJson()
        }
        return JsonObject(map)
    }

But when I try to compile it I get Type mismatch: inferred type is ConfigGroup but Nothing was expected

I am a bit confused since it is almost the same as the example in Kotlin: Iterate over components of object . The only difference being that I try to get the properties from within the same class and therefore have to use the this keyword.

The problem here is that the Kotlin compiler isn't smart enough to understand you use exactly the same object for ::class and for get(). In this specific case this is type-safe and could be allowed. However, in more generic case acquiring a KProperty from an object and using it to fetch values isn't type-safe and Kotlin intentionally disallows it.

We can fix the problem in the same way as in other cases where the compiler doesn't understand the code is type-safe - by making an unchecked cast:

(child as KProperty1<ConfigGroup, *>).get(this) // or even: KProperty1<Any, *>

But wait, why acquiring members of a variable typed as Animal and then using it against animal instance isn't type-safe? Isn't it guaranteed animal has all required members for an animal? Well, not exactly. We may acquire members of a dog and then use it against a cat, because both of them are animals.

fun main() {
    printProperties(Dog(), Cat())
}

fun printProperties(animal1: Animal, animal2: Animal) {
    for (prop in animal1::class.declaredMemberProperties) {
        println("${prop.name}: ${(prop).get(animal2)}") // isn't typesafe, so doesn't compile
    }
}

Inside printProperties, both animal1 and animal2 are of type Animal, but their runtime types are different and because of that it is not type-safe to acquire properties from animal1 and use them against animal2.

Kotlin protects against this type of a problem by using variance. If we do Animal::class we get a KClass<Animal>, so we can use this class for consuming animal objects. But if we do animal::class, we get KClass<out Animal>, because we can't be sure what is the exact type of animal. KClass<out Animal> basically says we have a KClass for an animal or one of its subtypes and we don't know which one. By default we can't use this KClass for consuming animal objects.

In your specific case it is guaranteed we acquired KClass from exactly the same runtime type we then try to consume, so this is type-safe and we can safely use an unchecked cast.