Add an encodeCollection extension

core/api/kotlinx-serialization-core.api

@@ -513,6 +513,8 @@ public final class kotlinx/serialization/encoding/Encoder$DefaultImpls {
 }
 
 public final class kotlinx/serialization/encoding/EncodingKt {
+	public static final fun encodeCollection (Lkotlinx/serialization/encoding/Encoder;Lkotlinx/serialization/descriptors/SerialDescriptor;ILkotlin/jvm/functions/Function1;)V
+	public static final fun encodeCollection (Lkotlinx/serialization/encoding/Encoder;Lkotlinx/serialization/descriptors/SerialDescriptor;Ljava/util/Collection;Lkotlin/jvm/functions/Function3;)V
 	public static final fun encodeStructure (Lkotlinx/serialization/encoding/Encoder;Lkotlinx/serialization/descriptors/SerialDescriptor;Lkotlin/jvm/functions/Function1;)V
 }
 

core/commonMain/src/kotlinx/serialization/encoding/Encoding.kt

@@ -473,16 +473,41 @@ public interface CompositeEncoder {
 /**
  * Begins a structure, encodes it using the given [block] and ends it.
  */
-public inline fun Encoder.encodeStructure(descriptor: SerialDescriptor, block: CompositeEncoder.() -> Unit) {
-    val composite = beginStructure(descriptor)
-    var ex: Throwable? = null
-    try {
-        composite.block()
-    } catch (e: Throwable) {
-        ex = e
-        throw e
-    } finally {
-        // End structure only if there is no exception, otherwise it can be swallowed
-        if (ex == null) composite.endStructure(descriptor)
+public inline fun Encoder.encodeStructure(
+    descriptor: SerialDescriptor,
+    crossinline block: CompositeEncoder.() -> Unit
+) {
+    with(beginStructure(descriptor)) {
+        block()
+        endStructure(descriptor)
+    }
+}
+
+/**
+ * Begins a collection, encodes it using the given [block] and ends it.
+ */
+public inline fun Encoder.encodeCollection(
+    descriptor: SerialDescriptor,
+    collectionSize: Int,
+    crossinline block: CompositeEncoder.() -> Unit
+) {
+    with(beginCollection(descriptor, collectionSize)) {
+        block()
+        endStructure(descriptor)
+    }
+}
+
+/**
+ * Begins a collection, calls [block] with each item and ends the collections.
+ */
+public inline fun <E> Encoder.encodeCollection(
+    descriptor: SerialDescriptor,
+    collection: Collection<E>,
+    crossinline block: CompositeEncoder.(index: Int, E) -> Unit
+) {
+    encodeCollection(descriptor, collection.size) {
+        collection.forEachIndexed { index, e ->
+            block(index, e)
+        }
     }
 }

core/commonMain/src/kotlinx/serialization/internal/CollectionSerializers.kt

@@ -63,11 +63,11 @@ internal sealed class ListLikeSerializer<Element, Collection, Builder>(
 
     override fun serialize(encoder: Encoder, value: Collection) {
         val size = value.collectionSize()
-        val composite = encoder.beginCollection(descriptor, size)
-        val iterator = value.collectionIterator()
-        for (index in 0 until size)
-            composite.encodeSerializableElement(descriptor, index, elementSerializer, iterator.next())
-        composite.endStructure(descriptor)
+        encoder.encodeCollection(descriptor, size) {
+            val iterator = value.collectionIterator()
+            for (index in 0 until size)
+                encodeSerializableElement(descriptor, index, elementSerializer, iterator.next())
+        }
     }
 
     protected final override fun readAll(decoder: CompositeDecoder, builder: Builder, startIndex: Int, size: Int) {
@@ -115,14 +115,14 @@ public sealed class MapLikeSerializer<Key, Value, Collection, Builder : MutableM
 
     override fun serialize(encoder: Encoder, value: Collection) {
         val size = value.collectionSize()
-        val composite = encoder.beginCollection(descriptor, size)
-        val iterator = value.collectionIterator()
-        var index = 0
-        iterator.forEach { (k, v) ->
-            composite.encodeSerializableElement(descriptor, index++, keySerializer, k)
-            composite.encodeSerializableElement(descriptor, index++, valueSerializer, v)
+        encoder.encodeCollection(descriptor, size) {
+            val iterator = value.collectionIterator()
+            var index = 0
+            iterator.forEach { (k, v) ->
+                encodeSerializableElement(descriptor, index++, keySerializer, k)
+                encodeSerializableElement(descriptor, index++, valueSerializer, v)
+            }
         }
-        composite.endStructure(descriptor)
     }
 }
 
@@ -171,9 +171,9 @@ internal abstract class PrimitiveArraySerializer<Element, Array, Builder
 
     final override fun serialize(encoder: Encoder, value: Array) {
         val size = value.collectionSize()
-        val composite = encoder.beginCollection(descriptor, size)
-        writeContent(composite, value, size)
-        composite.endStructure(descriptor)
+        encoder.encodeCollection(descriptor, size) {
+            writeContent(this, value, size)
+        }
     }
 
     final override fun deserialize(decoder: Decoder): Array = merge(decoder, null)

formats/json/commonTest/src/kotlinx/serialization/EncodingCollectionsTest.kt

@@ -0,0 +1,27 @@
+package kotlinx.serialization
+
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+import kotlinx.serialization.json.*
+import kotlin.test.*
+
+class EncodingCollectionsTest {
+    object ListSerializer : KSerializer<List<String>> {
+        override val descriptor: SerialDescriptor = ListSerializer(String.serializer()).descriptor
+
+        override fun serialize(encoder: Encoder, value: List<String>) {
+            encoder.encodeCollection(descriptor, value) { index, item ->
+                encodeStringElement(descriptor, index, item)
+            }
+        }
+
+        override fun deserialize(decoder: Decoder): List<String> = throw NotImplementedError()
+    }
+
+    @Test
+    fun testEncoding() {
+        assertEquals("""["Hello","World!"]""", Json.encodeToString(ListSerializer, listOf("Hello", "World!")))
+    }
+}