Create an implementation that allows automatically registering the sealed children of a class for polymorphic serialization of a shared (non-sealed) type.

Author: pdvrieze

core/commonMain/src/kotlinx/serialization/SealedSerializer.kt

@@ -115,7 +115,7 @@ public class SealedClassSerializer<T : Any>(
         }
     }
 
-    private val class2Serializer: Map<KClass<out T>, KSerializer<out T>>
+    internal val class2Serializer: Map<KClass<out T>, KSerializer<out T>>
     private val serialName2Serializer: Map<String, KSerializer<out T>>
 
     init {

core/commonMain/src/kotlinx/serialization/modules/PolymorphicModuleBuilder.kt

@@ -27,7 +27,16 @@ public class PolymorphicModuleBuilder<in Base : Any> @PublishedApi internal cons
      * Registers a [subclass] [serializer] in the resulting module under the [base class][Base].
      */
     public fun <T : Base> subclass(subclass: KClass<T>, serializer: KSerializer<T>) {
-        subclasses.add(subclass to serializer)
+
+        if (serializer is SealedClassSerializer) {
+            for ((subsubclass, subserializer) in serializer.class2Serializer.entries) {
+                @Suppress("UNCHECKED_CAST")
+                // We don't know the type here, but it matches if correct in the sealed serializer.
+                subclass(subsubclass as KClass<T>, subserializer as KSerializer<T>)
+            }
+        } else {
+            subclasses.add(subclass to serializer)
+        }
     }
 
     /**

docs/polymorphism.md

@@ -408,6 +408,11 @@ fun main() {
 {"type":"owned","name":"kotlinx.coroutines","owner":"kotlin"}
 ```
 
+### Registering sealed children as subclasses
+A sealed parent interface or class can be directly registered as subclass. This will expose all children that would
+be available when serializing the parent directly, but now as sealed. Please note that this is will remain open
+serialization, and the sealed parent serializer will not be used in serialization.
+
 <!--- TEST LINES_START -->
 
 ### Property of an interface type

formats/json-tests/commonTest/src/kotlinx/serialization/features/PolymorphicSealedChildTest.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2017-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.serialization.features
+
+import kotlinx.serialization.*
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.modules.*
+import kotlinx.serialization.test.assertStringFormAndRestored
+import kotlin.test.Test
+
+class PolymorphicSealedChildTest {
+
+    @Serializable
+    data class FooHolder(
+        val someMetadata: Int,
+        val payload: List<@Polymorphic FooBase>
+    )
+
+    @Serializable
+    abstract class FooBase
+
+    @Serializable
+    @SerialName("Foo")
+    sealed class Foo: FooBase() {
+        @Serializable
+        @SerialName("Bar")
+        data class Bar(val bar: Int) : Foo()
+        @Serializable
+        @SerialName("Baz")
+        data class Baz(val baz: String) : Foo()
+    }
+
+    val sealedModule = SerializersModule {
+        polymorphic(FooBase::class) {
+            subclass(Foo.serializer())
+        }
+    }
+
+    val json = Json { serializersModule = sealedModule }
+
+    @Test
+    fun testSaveSealedClassesList() {
+        assertStringFormAndRestored(
+            """{"someMetadata":42,"payload":[
+            |{"type":"Bar","bar":1},
+            |{"type":"Baz","baz":"2"}]}""".trimMargin().replace("\n", ""),
+            FooHolder(42, listOf(Foo.Bar(1), Foo.Baz("2"))),
+            FooHolder.serializer(),
+            json,
+            printResult = true
+        )
+    }
+
+    @Test
+    fun testCanSerializeSealedClassPolymorphicallyOnTopLevel() {
+        assertStringFormAndRestored(
+            """{"type":"Bar","bar":1}""",
+            Foo.Bar(1),
+            PolymorphicSerializer(FooBase::class),
+            json
+        )
+    }
+}