Contextual serializers do not work for derived classes

[martinraison]

Describe the bug

It seems contextual serializers only work for concrete classes currently.

To Reproduce

Example setup:

@Serializable
abstract class Message

@Serializable
class SimpleMessage(val body: String) : Message()

@Serializable
class Holder(@Contextual val message: Message)

// A custom serializer for Message
object MessageAsStringSerializer : KSerializer<Message> {
    override val descriptor: SerialDescriptor =
        PrimitiveSerialDescriptor("kotlinx.serialization.MessageAsStringSerializer", PrimitiveKind.STRING)

    override fun serialize(encoder: Encoder, value: Message) {
        // dummy serializer that assumes Message is always SimpleMessage
        check(value is SimpleMessage)
        encoder.encodeString(value.body)
    }

    override fun deserialize(decoder: Decoder): Message {
        return SimpleMessage(decoder.decodeString())
    }
}

val module = SerializersModule {
    contextual(MessageAsStringSerializer)
}
val format = Json { serializersModule = module }

Now when we try to do this

val data = Holder(SimpleMessage("hello"))
println(format.encodeToString(data))

we get the following error:

Class 'SimpleMessage' is not registered for polymorphic serialization in the scope of 'Message'.
Mark the base class as 'sealed' or register the serializer explicitly.
kotlinx.serialization.SerializationException: Class 'SimpleMessage' is not registered for polymorphic serialization in the scope of 'Message'.
Mark the base class as 'sealed' or register the serializer explicitly.

Expected behavior

In the scenario above, the message field of the Holder class should be serialized using MessageAsStringSerializer.

Environment

• Kotlin version: 1.4.20
• Library version: 1.0.1
• Kotlin platforms: JVM
• Gradle version: 6.7.1

[shanshin]

In your example, you can try using an external serializer for the Message class:

@Serializable(with = MessageAsStringSerializer::class)
abstract class Message

@Serializable
class SimpleMessage(val body: String) : Message()

@Serializable
class Holder(val message: Message)

and encode instance without contextual serializer

val format = Json
val data = Holder(SimpleMessage("hello"))
println(format.encodeToString(data))

In this solution properties with Message type will serialize/deserialize by MessageAsStringSerializer

[martinraison]

Thanks for taking a look! I'm afraid my real-world use-case is a bit more involved, I simplified it to make the problem more clear.

In particular, what if contextual serialization is necessary? (as per the documentation: You might need to change the serialization strategy for objects deep in the serialized object tree at run-time, with the strategy being selected in a context-dependent way). Also, I do not control the abstract class definition.

According to the docs, I believe my setup above (with contextual serializer) should work, but doesn't due to an implementation detail. What do you think of #1277 ? It seems to solve the issue.

[shanshin]

If the Message is an external class and you have an inheritance, is a polymorphic serialization suitable for you?

[pdvrieze]

When looking at this, polymorphic serialization is triggered here without an explicit @Polymorphic annotation. Probably this is due to the fact that Message is an abstract class (and therefore can only be handled polymorphically). The way to handle this is to have a custom serializer for Holder, not for Message. What you are actually doing is saying that the message should be serialized only based upon its body property (it could be any property/method).

Remember the semantics of inheritance. The whole point is that there could be many implementations of Message. They all need to abide by the Message contract, but could have different serializations. If they all need to be serialised indistinguishably you need to transform the message into that actual serial format (be it String or some specific type). That is different than what you are doing. In the case you use something more specific than String you can use the context on that type, and look it up in the custom serializer/deserializer for Holder.