Allow calling SerialDescriptor(name, original) when original.kind is PrimitiveKind

[lukellmann]

What is your use-case and why do you need this feature?

This section of the Kotlin Serialization Guide recommends that delegating serializers should not reuse the descriptor of the serializer they are delegating to but instead wrap it with SerialDescriptor("OtherName", delegate.descriptor). This works fine if delegate.descriptor.kind is not PrimitiveKind. But for serializers that have a primitive descriptor, this will throw an exception.

This can cause problems if the delegated serializer just happens to have a primitive serial descriptor as an implementation detail.

An example for this is this serializer which delegates to JsonPrimitive.serializer(). However when writing this serializer, one shouldn't have to know what the serial descriptor for JsonPrimitive looks like if all that one wants to do is delegate serialization to JsonPrimitive.serializer(). Ideally you should always be able to call SerialDescriptor("OtherName", delegate.descriptor) to implement KSerializer.descriptor for a serializer that just delegates to delegate.

Describe the solution you'd like

Change the code for SerialDescriptor() to not throw when given a primitive descriptor. This could be done by simply delegating to PrimitiveSerialDescriptor():

public fun SerialDescriptor(serialName: String, original: SerialDescriptor): SerialDescriptor {
    require(serialName.isNotBlank()) { "..." }
    require(serialName != original.serialName) { "..." }

    val kind = original.kind
    return if (kind is PrimitiveKind) {
        PrimitiveSerialDescriptor(serialName, kind)
    } else {
        WrappedSerialDescriptor(serialName, original)
    }
}

[lukellmann]

I'd be happy to implement this if it's accepted.

[sandwwraith]

Yes, I think this is logical and will make writing delegating serializers easier. I'll be happy to receive your PR!

[lukellmann]

I stumbled accross the situation where a primitive descriptor is nullable: this won't be copied over to the wrapped serializer by the code shown above. So it isn't as easy as I thought it would be.

[sandwwraith]

You can use .nullable

kotlinx.serialization/core/commonMain/src/kotlinx/serialization/descriptors/SerialDescriptors.kt

Line 220 in 06aabd2

public val SerialDescriptor.nullable: SerialDescriptor

to wrap it if original.isNullable

[lukellmann]

Thanks for implementing this @sandwwraith :)