Fix shadowed struct elements

mirai-core-qqandroid/src/commonMain/kotlin/net/mamoe/mirai/qqandroid/io/serialization/jce/JceDecoder.kt

@@ -181,9 +181,9 @@ internal class JceDecoder(
 
     companion object {
         @Suppress("MemberVisibilityCanBePrivate")
-        val debuggingMode: Boolean by lazy { false }
+        var debuggingMode: Boolean = false
 
-        private var structureHierarchy: Int = 0
+        var structureHierarchy: Int = 0
 
         inline fun println(value: () -> String) {
             if (debuggingMode) {
@@ -258,7 +258,10 @@ internal class JceDecoder(
 
     override fun decodeSequentially(): Boolean = false
     override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
-        var jceHead = jce.currentHeadOrNull ?: return CompositeDecoder.READ_DONE
+        var jceHead = jce.currentHeadOrNull ?: kotlin.run {
+            println("decodeElementIndex: currentHead == null")
+            return CompositeDecoder.READ_DONE
+        }
 
         println { "decodeElementIndex: ${jce.currentHead}" }
         while (!jce.input.endOfInput) {

mirai-core-qqandroid/src/commonMain/kotlin/net/mamoe/mirai/qqandroid/io/serialization/jce/JceInput.kt

@@ -116,53 +116,58 @@ internal class JceInput(
 
     @OptIn(ExperimentalUnsignedTypes::class)
     @PublishedApi
-    internal fun skipField(type: Byte): Unit = when (type) {
+    internal fun skipField(type: Byte): Unit {
+        JceDecoder.println { "skipping ${JceHead.findJceTypeName(type)}" }
+        when (type) {
             Jce.BYTE -> this.input.discardExact(1)
             Jce.SHORT -> this.input.discardExact(2)
-        Jce.INT -> this.input.discardExact(4)
+            Jce.INT -> println("readInt=" + this.input.readInt())
             Jce.LONG -> this.input.discardExact(8)
             Jce.FLOAT -> this.input.discardExact(4)
             Jce.DOUBLE -> this.input.discardExact(8)
             Jce.STRING1 -> this.input.discardExact(this.input.readUByte().toInt())
             Jce.STRING4 -> this.input.discardExact(this.input.readInt())
             Jce.MAP -> { // map
-            //println("skip map!")
+                JceDecoder.structureHierarchy++
-            nextHead()
+                var count: Int = 0
+                nextHead() // avoid shadowing, don't remove
                 repeat(skipToHeadAndUseIfPossibleOrFail(0, message = { "tag 0 not found when skipping map" }) {
-                readJceIntValue(it)
+                    readJceIntValue(it).also { count = it * 2 }
                 } * 2) {
-                val currentHead = currentHead
-                prepareNextHead()
                     skipField(currentHead.type)
+                    if (it != count - 1) { // don't read last head
+                        nextHead()
                     }
                 }
+                JceDecoder.structureHierarchy--
+            }
             Jce.LIST -> { // list
-            JceDecoder.println {"skip list!"}
+                JceDecoder.structureHierarchy++
-            nextHead()
+                var count: Int = 0
-            repeat(skipToHeadAndUseIfPossibleOrFail(0, message = { "tag 0 not found when skipping list" }) {
+                nextHead() // avoid shadowing, don't remove
-                readJceIntValue(it)
+                repeat(skipToHeadAndUseIfPossibleOrFail(0, message = { "tag 0 not found when skipping list" }) { head ->
+                    readJceIntValue(head).also { count = it }
                 }) {
-                val currentHead = currentHead
-                prepareNextHead()
                     skipField(currentHead.type)
+                    if (it != count - 1) { // don't read last head
+                        nextHead()
                     }
                 }
+                JceDecoder.structureHierarchy--
+            }
             Jce.STRUCT_BEGIN -> {
-            JceDecoder.println {"skip struct!"}
+                JceDecoder.structureHierarchy++
-            fun skipToStructEnd() {
                 var head: JceHead
                 do {
                     head = nextHead()
                     skipField(head.type)
                 } while (head.type != Jce.STRUCT_END)
-            }
+                JceDecoder.structureHierarchy--
-            skipToStructEnd()
             }
             Jce.STRUCT_END, Jce.ZERO_TYPE -> {
-            Unit
             }
             Jce.SIMPLE_LIST -> {
-            JceDecoder.println { "skip simple list!" }
+                JceDecoder.structureHierarchy++
                 var head = nextHead()
                 check(head.type == Jce.BYTE) { "bad simple list element type: " + head.type }
                 check(head.tag == 0) { "simple list element tag must be 0, but was ${head.tag}" }
@@ -170,9 +175,11 @@ internal class JceInput(
                 head = nextHead()
                 check(head.tag == 0) { "tag for size for simple list must be 0, but was ${head.tag}" }
                 this.input.discardExact(readJceIntValue(head))
+                JceDecoder.structureHierarchy--
             }
             else -> error("invalid type: $type")
         }
+    }
 
     // region readers
     fun readJceIntValue(head: JceHead): Int {

mirai-core-qqandroid/src/commonTest/kotlin/net.mamoe.mirai.qqandroid.io.serialization/JceInputTest.kt

@@ -8,10 +8,7 @@ import kotlinx.io.core.writeFully
 import kotlinx.serialization.MissingFieldException
 import kotlinx.serialization.Serializable
 import net.mamoe.mirai.qqandroid.io.JceStruct
-import net.mamoe.mirai.qqandroid.io.serialization.jce.Jce
+import net.mamoe.mirai.qqandroid.io.serialization.jce.*
-import net.mamoe.mirai.qqandroid.io.serialization.jce.JceId
-import net.mamoe.mirai.qqandroid.io.serialization.jce.JceInput
-import net.mamoe.mirai.qqandroid.io.serialization.jce.writeJceHead
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
@@ -42,6 +39,9 @@ internal const val ZERO_TYPE: Byte = 12
  */
 @Suppress("INVISIBLE_MEMBER") // bug
 internal class JceInputTest {
+    init {
+        JceDecoder.debuggingMode = true
+    }
 
     @Test
     fun testIntToStructMap() {
@@ -109,8 +109,9 @@ internal class JceInputTest {
         val input = buildPacket {
             writeJceHead(MAP, 0) // TestSerializableClassB
             writeJceHead(BYTE, 0)
-            writeByte(1)
+            writeByte(1);
 
+            {
                 writeJceHead(STRUCT_BEGIN, 0);
                 {
                     writeJceHead(INT, 0)
@@ -134,6 +135,7 @@ internal class JceInputTest {
                     writeInt(123123)
                 }()
                 writeJceHead(STRUCT_END, 0)
+            }()
 
             writeJceHead(STRING1, 1)
             writeByte(1)