fix: should checking the ending when deserialize seq

cloudwego · Apr 22, 2024 · 6a0e766 · 6a0e766
1 parent 0df9e30
commit 6a0e766
Show file tree

Hide file tree

Showing 2 changed files with 53 additions and 10 deletions.
diff --git a/src/serde/de.rs b/src/serde/de.rs
@@ -572,6 +572,7 @@ impl<'de, 'a, R: Reader<'de>> de::Deserializer<'de> for &'a mut Deserializer<R>
                     let _ = DepthGuard::guard(self);
                     visitor.visit_seq(SeqAccess::new(self))
                 };
+                self.parser.parse_array_end()?;
                 ret
             }
             _ => return Err(self.peek_invalid_type(peek, &visitor)),
@@ -586,9 +587,7 @@ impl<'de, 'a, R: Reader<'de>> de::Deserializer<'de> for &'a mut Deserializer<R>
     where
         V: de::Visitor<'de>,
     {
-        let ret = self.deserialize_seq(visitor)?;
-        self.parser.parse_array_end()?;
-        Ok(ret)
+        self.deserialize_seq(visitor)
     }
 
     fn deserialize_tuple_struct<V>(
@@ -600,9 +599,7 @@ impl<'de, 'a, R: Reader<'de>> de::Deserializer<'de> for &'a mut Deserializer<R>
     where
         V: de::Visitor<'de>,
     {
-        let ret = self.deserialize_seq(visitor)?;
-        self.parser.parse_array_end()?;
-        Ok(ret)
+        self.deserialize_seq(visitor)
     }
 
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
@@ -866,10 +863,7 @@ impl<'de, 'a, R: Reader<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a,
     where
         V: de::Visitor<'de>,
     {
-        let parser = &mut self.de.parser as *mut Parser<R>;
-        let ret = de::Deserializer::deserialize_seq(self.de, visitor)?;
-        unsafe { (*parser).parse_array_end()? };
-        Ok(ret)
+        de::Deserializer::deserialize_seq(self.de, visitor)
     }
 
     fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>

diff --git a/src/serde/mod.rs b/src/serde/mod.rs
@@ -353,4 +353,53 @@ mod test {
         test_struct!(Bytes, &b"[]"[..]);
         test_struct!(Data, &br#"{"content":[1,2,3,4,5]}"#[..]);
     }
+
+    use std::{
+        fmt::{Formatter, Result as FmtResult},
+        result::Result as StdResult,
+    };
+
+    fn my_deseirlize_seq<'de, D>(deserializer: D) -> StdResult<(i64, i64), D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        struct TupleVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for TupleVisitor {
+            type Value = (i64, i64);
+
+            fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
+                formatter.write_str("expect an array")
+            }
+
+            fn visit_seq<S>(self, mut seq: S) -> StdResult<Self::Value, S::Error>
+            where
+                S: serde::de::SeqAccess<'de>,
+            {
+                let x = seq
+                    .next_element::<i64>()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(0, &self))?;
+                let y = seq
+                    .next_element::<i64>()?
+                    .ok_or_else(|| serde::de::Error::invalid_length(1, &self))?;
+                Ok((x, y))
+            }
+        }
+
+        deserializer.deserialize_seq(TupleVisitor)
+    }
+
+    #[derive(serde::Deserialize, Eq, PartialEq)]
+    struct MyTuple {
+        #[serde(deserialize_with = "my_deseirlize_seq")]
+        data: (i64, i64),
+    }
+
+    #[test]
+    fn test_serde_with_seq() {
+        let json = r#"{"data":[1, 2]}"#;
+        let expect: MyTuple = serde_json::from_str(json).unwrap();
+        let got: MyTuple = from_str(json).unwrap();
+        assert_eq!(expect.data, got.data);
+    }
 }