Fix error triggered by 'consume leading class discriminator' polymorphic parsing optimization: (#2362)

In case of an empty object, no exception should be thrown, it should be treated as missing class discriminator.
peekString() correctly handles this case.

Also fixes misplaced calls in lenient vs non-lenient mode.

Fixes #2353

Author: sandwwraith

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

@@ -143,4 +143,42 @@ class PolymorphismTest : JsonTestBase() {
         val s = json.encodeToString(Wrapper.serializer(), obj, jsonTestingMode)
         assertEquals("""{"polyBase1":{"type":"even","parity":"even"},"polyBase2":{"type":"odd","parity":"odd"}}""", s)
     }
+
+    @Serializable
+    sealed class Conf {
+        @Serializable
+        @SerialName("empty")
+        object Empty : Conf() // default
+
+        @Serializable
+        @SerialName("simple")
+        data class Simple(val value: String) : Conf()
+    }
+
+    private val jsonForConf = Json {
+        isLenient = false
+        ignoreUnknownKeys = true
+        serializersModule = SerializersModule {
+            polymorphicDefaultDeserializer(Conf::class) { Conf.Empty.serializer() }
+        }
+    }
+
+    @Test
+    fun defaultSerializerWithEmptyBodyTest() = parametrizedTest { mode ->
+        assertEquals(Conf.Simple("123"), jsonForConf.decodeFromString<Conf>("""{"type": "simple", "value": "123"}""", mode))
+        assertEquals(Conf.Empty, jsonForConf.decodeFromString<Conf>("""{"type": "default"}""", mode))
+        assertEquals(Conf.Empty, jsonForConf.decodeFromString<Conf>("""{"unknown": "Meow"}""", mode))
+        assertEquals(Conf.Empty, jsonForConf.decodeFromString<Conf>("""{}""", mode))
+    }
+
+    @Test
+    fun testTypeKeysInLenientMode() = parametrizedTest { mode ->
+        val json = Json(jsonForConf) { isLenient = true }
+
+        assertEquals(Conf.Simple("123"), json.decodeFromString<Conf>("""{type: simple, value: 123}""", mode))
+        assertEquals(Conf.Empty, json.decodeFromString<Conf>("""{type: default}""", mode))
+        assertEquals(Conf.Empty, json.decodeFromString<Conf>("""{unknown: Meow}""", mode))
+        assertEquals(Conf.Empty, json.decodeFromString<Conf>("""{}""", mode))
+
+    }
 }

formats/json/commonMain/src/kotlinx/serialization/json/internal/StreamingJsonDecoder.kt

@@ -71,7 +71,7 @@ internal open class StreamingJsonDecoder(
             }
 
             val discriminator = deserializer.descriptor.classDiscriminator(json)
-            val type = lexer.consumeLeadingMatchingValue(discriminator, configuration.isLenient)
+            val type = lexer.peekLeadingMatchingValue(discriminator, configuration.isLenient)
             var actualSerializer: DeserializationStrategy<Any>? = null
             if (type != null) {
                 actualSerializer = deserializer.findPolymorphicSerializerOrNull(this, type)

formats/json/commonMain/src/kotlinx/serialization/json/internal/lexer/AbstractJsonLexer.kt

@@ -286,7 +286,7 @@ internal abstract class AbstractJsonLexer {
         return current
     }
 
-    abstract fun consumeLeadingMatchingValue(keyToMatch: String, isLenient: Boolean): String?
+    abstract fun peekLeadingMatchingValue(keyToMatch: String, isLenient: Boolean): String?
 
     fun peekString(isLenient: Boolean): String? {
         val token = peekNextToken()
@@ -301,6 +301,10 @@ internal abstract class AbstractJsonLexer {
         return string
     }
 
+    fun discardPeeked() {
+        peekedString = null
+    }
+
     open fun indexOf(char: Char, startPos: Int) = source.indexOf(char, startPos)
     open fun substring(startPos: Int, endPos: Int) =  source.substring(startPos, endPos)
 

formats/json/commonMain/src/kotlinx/serialization/json/internal/lexer/JsonLexer.kt

@@ -179,7 +179,7 @@ internal class ReaderJsonLexer(
     }
 
     // Can be carefully implemented but postponed for now
-    override fun consumeLeadingMatchingValue(keyToMatch: String, isLenient: Boolean): String? = null
+    override fun peekLeadingMatchingValue(keyToMatch: String, isLenient: Boolean): String? = null
 
     fun release() {
         CharArrayPoolBatchSize.release(buffer)

formats/json/commonMain/src/kotlinx/serialization/json/internal/lexer/StringJsonLexer.kt

@@ -101,21 +101,20 @@ internal class StringJsonLexer(override val source: String) : AbstractJsonLexer(
         (if (isLenient) consumeStringLenient() else consumeString()).chunked(BATCH_SIZE).forEach(consumeChunk)
     }
 
-    override fun consumeLeadingMatchingValue(keyToMatch: String, isLenient: Boolean): String? {
+    override fun peekLeadingMatchingValue(keyToMatch: String, isLenient: Boolean): String? {
         val positionSnapshot = currentPosition
         try {
-            // Malformed JSON, bailout
-            if (consumeNextToken() != TC_BEGIN_OBJ) return null
-            val firstKey = if (isLenient) consumeKeyString() else consumeStringLenientNotNull()
-            if (firstKey == keyToMatch) {
-                if (consumeNextToken() != TC_COLON) return null
-                val result = if (isLenient) consumeString() else consumeStringLenientNotNull()
-                return result
-            }
-            return null
+            if (consumeNextToken() != TC_BEGIN_OBJ) return null // Malformed JSON, bailout
+            val firstKey = peekString(isLenient)
+            if (firstKey != keyToMatch) return null
+            discardPeeked() // consume firstKey
+            if (consumeNextToken() != TC_COLON) return null
+            return peekString(isLenient)
         } finally {
             // Restore the position
             currentPosition = positionSnapshot
+            discardPeeked()
         }
     }
 }
+