возможно я просто херней занимаюсь) Есть примерно такая структура:

            "nodeType": "Expr_Assign",
            "var": {
                "nodeType": "Expr_Variable",
                "name": {
                    "nodeType": "Scalar_String",
                    "value": "huina",
                    "attributes": {
                        "startLine": 114,
                        "startFilePos": 3269,
                        "endLine": 114,
                        "endFilePos": 3275,
                        "kind": 1
                    }
                }
            }

проблема в том, что name'ом может быть и string:

            "nodeType": "Expr_Assign",
            "var": {
                "nodeType": "Expr_Variable",
                "name": "associative"
            }

и таких приколов есть достаточно. Вот я и пытаюсь упростить себе работу, что бы оно десеарилизровалось само в нужный враппер в зависимости от типа

            "nodeType": "Expr_Assign",
            "var": {
                "nodeType": "Expr_Variable",
                "name": {
                    "nodeType": "Scalar_String",
                    "value": "huina",
                    "attributes": {
                        "startLine": 114,
                        "startFilePos": 3269,
                        "endLine": 114,
                        "endFilePos": 3275,
                        "kind": 1
                    }
                }
            }

            "nodeType": "Expr_Assign",
            "var": {
                "nodeType": "Expr_Variable",
                "name": "associative"
            }

Я думаю, что вам в https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/json_transformations.md

Там очень похожие примеры есть. Но разумеется, будет работать только для жсона

так я оттуда) Просто хотел что бы магия сама со всем разобралась, как в случае с sealed. Видимо не получится

Есть в жсон сериализаторе ключ для поля типа, но он глобальныц

Вообще надо issue завести, там довольно легко сделать локальный тайп-ключ кастомным

@Serializable
sealed class Sealed {
    @Serializable
    @SerialName("SealedSub")
    data class SealedSub(val i: Int) : Sealed()

    @SerialName("NestedSealed")
    open class NestedSealed : Sealed() {
        @Serializable
        data class Stringed(val s: String) : NestedSealed()

        @Serializable
        data class Complex(val i: Sealed) : NestedSealed()

        @Serializer(forClass = NestedSealed::class)
        companion object : KSerializer<NestedSealed> {
            // serializer
        }
    }
}

kotlinx.serialization.SerializationException: class net.alexwells.ptk.php.parser.Sealed$NestedSealed$Stringed is not registered for polymorphic serialization in the scope of class net.alexwells.ptk.php.parser.Sealed

На каждом шагу какие-то приколы. В чем проблема то? Я для NestedSealed указал кастомный сериалайзер, нахрен он пытается спарсить сабклассы?

ну или я опять что-то не понимаю

а если я сделаю NestedSealed sealed'ом, как было изначально, то SerialName у NestedSealed вообще игнорируется, а он должен быть одинаковым для Stringed и Complex

В Kotlin если я правильно понял паттерн Singleton это ничто иное как companion object?
и больше ничего другого?

Или просто object, да.

Не прошло и дня страданий.. вышел такой говнокод:

@Serializable
    @SerialName("Variable")
    data class Variable(val name: Name) : Node() {
        @Serializable
        sealed class Name {
            @Serializable
            class Stringed(val name: String) : Name()

            @Serializable
            class Expressed(val expr: Expr) : Name()

            @Serializer(forClass = Name::class)
            companion object : UnionTypeSerializer<Name>(Name::class) {
                override fun choose(element: JsonElement): KClass<out Name> = when {
                    element is JsonLiteral && element.isString -> Stringed::class
                    element is JsonObject -> Expressed::class
                    else -> throw SerializationException("Invalid element given")
                }
            }
        }
    }

с рефлекцией, зато без boilerplate'а)

С бойлерплейтом увы

сейчас сижу переделываю на moshi. kotlinx уже в край заебал. Будет чуток вербозней, но зато читабельно и без заебов на которые уходит весь день :/

@Serializer(forClass = ClassName::class)
                companion object : UnionTypeSerializer<ClassName>(ClassName::class) {
                    override fun choose(element: JsonElement): KClass<out ClassName> = when {
                        element is JsonLiteral && element.isString -> Named::class
                        element is JsonObject && element["nodeType"]!!.content == "Stmt_Class" -> Anonymous::class
                        else -> Expr::class
                    }
                }

vs

companion object Adapter {
                    @ToJson
                    fun toJson(name: ClassName): Any = when (name) {
                        is Named -> name.name
                        is Expr -> name.expr
                        is Anonymous -> name.expr
                    }

                    @FromJson
                    fun fromJson(
                            reader: JsonReader,
                            nodeAdapter: JsonAdapter<NodeAbstract>
                    ): ClassName = when (val node = nodeAdapter.fromJson(reader)) {
                        is Name -> Named(node)
                        is Stmt.Class -> Anonymous(node)
                        is NodeAbstract.Expr -> Expr(node)
                        else -> throw JsonDataException("Unexpected node $node")
                    }
                }

дольше, но без заебов, чисто два мапа и все. И то если захотеть, то можно и для moshi магию сделать

Почему не каким-нибудь кодогеном, по датаклассам в принципе в два экрана кода можно всякую лабуду генеритб при наличии AST

потому что мои познания в котлине почти равны нулю. Я уже три дня пытаюсь десеарилизировать этот долбанный json. Не вижу смысла - проще написать 8-10 кастомных адаптеров (как вверху) и все.

Так доку читай, шо ты гонишь