fix: wrong line number when json has escaped chars

Author: liuq19

.github/PULL_REQUEST_TEMPLATE.md

@@ -501,10 +501,6 @@ fn starts_with_digit(slice: &str) -> bool {
     }
 }
 
-pub(crate) fn invalid_utf8(json: &[u8], index: usize) -> Error {
-    Error::syntax(ErrorCode::InvalidUTF8, json, index)
-}
-
 #[cfg(test)]
 mod test {
     use crate::{from_slice, from_str, Deserialize};

src/error.rs

@@ -18,7 +18,7 @@ use sonic_simd::{i8x32, m8x32, u8x32, u8x64, Mask, Simd};
 use crate::{
     config::DeserializeCfg,
     error::{
-        invalid_utf8, Error,
+        Error,
         ErrorCode::{self, *},
         Result,
     },
@@ -283,7 +283,7 @@ where
             reason = EofWhileParsing;
             index = len;
         }
-        Error::syntax(reason, self.read.as_u8_slice(), index)
+        Error::syntax(reason, self.read.origin_input(), index)
     }
 
     // maybe error in generated in visitor, so we need fix the position.
@@ -802,7 +802,11 @@ where
         }
 
         if !allowed {
-            Err(invalid_utf8(self.read.as_u8_slice(), invalid))
+            Err(Error::syntax(
+                ErrorCode::InvalidUTF8,
+                self.read.origin_input(),
+                invalid,
+            ))
         } else {
             // this space is allowed, should update the next invalid utf8 position
             self.read.check_invalid_utf8();
@@ -852,10 +856,10 @@ where
             Ok((((point1 - 0xd800) << 10) | low_bit).wrapping_add(0x10000))
         } else if (0xDC00..0xE000).contains(&point1) {
             if self.cfg.utf8_lossy {
-                return Ok(0xFFFD);
+                Ok(0xFFFD)
             } else {
                 // invalid surrogate
-                return perr!(self, InvalidSurrogateUnicodeCodePoint);
+                perr!(self, InvalidSurrogateUnicodeCodePoint)
             }
         } else {
             Ok(point1)

src/parser.rs

@@ -3,11 +3,11 @@ use std::{marker::PhantomData, pin::Pin, ptr::NonNull};
 use faststr::FastStr;
 
 use crate::{
-    error::invalid_utf8,
+    error::ErrorCode,
     input::JsonSlice,
     parser::as_str,
     util::{private::Sealed, utf8::from_utf8},
-    JsonInput, Result,
+    Error, JsonInput, Result,
 };
 
 pub(crate) struct Position {
@@ -71,6 +71,10 @@ pub trait Reader<'de>: Sealed {
     fn check_invalid_utf8(&mut self);
 
     fn slice_ref(&self, subset: &'de [u8]) -> JsonSlice<'de>;
+
+    fn origin_input(&self) -> &'de [u8] {
+        self.as_u8_slice()
+    }
 }
 
 enum PinnedInput<'a> {
@@ -267,12 +271,16 @@ impl<'a> Reader<'a> for Read<'a> {
         if self.next_invalid_utf8 == usize::MAX {
             Ok(())
         } else {
-            Err(invalid_utf8(self.slice(), self.next_invalid_utf8))
+            Err(Error::syntax(
+                ErrorCode::InvalidUTF8,
+                self.origin_input(),
+                self.next_invalid_utf8,
+            ))
         }
     }
 
     fn check_invalid_utf8(&mut self) {
-        self.next_invalid_utf8 = match from_utf8(&self.slice()[self.index..]) {
+        self.next_invalid_utf8 = match from_utf8(&self.origin_input()[self.index..]) {
             Ok(_) => usize::MAX,
             Err(e) => self.index + e.offset(),
         };
@@ -287,17 +295,19 @@ pub(crate) struct PaddedSliceRead<'a> {
     base: NonNull<u8>,
     cur: NonNull<u8>,
     len: usize,
+    origin: &'a [u8],
     _life: PhantomData<&'a mut [u8]>,
 }
 
 impl<'a> PaddedSliceRead<'a> {
     const PADDING_SIZE: usize = 64;
-    pub fn new(slice: &'a mut [u8]) -> Self {
-        let base = unsafe { NonNull::new_unchecked(slice.as_mut_ptr()) };
+    pub fn new(buffer: &'a mut [u8], json: &'a [u8]) -> Self {
+        let base = unsafe { NonNull::new_unchecked(buffer.as_mut_ptr()) };
         Self {
             base,
             cur: base,
-            len: slice.len() - Self::PADDING_SIZE,
+            len: buffer.len() - Self::PADDING_SIZE,
+            origin: json,
             _life: PhantomData,
         }
     }
@@ -400,6 +410,11 @@ impl<'a> Reader<'a> for PaddedSliceRead<'a> {
     fn check_utf8_final(&self) -> Result<()> {
         Ok(())
     }
+
+    #[inline(always)]
+    fn origin_input(&self) -> &'a [u8] {
+        self.origin
+    }
 }
 
 #[cfg(test)]

src/reader.rs

@@ -1313,7 +1313,7 @@ impl Value {
         buffer.extend_from_slice(&[0; 61]);
 
         let smut = Arc::get_mut(&mut shared).unwrap();
-        let slice = PaddedSliceRead::new(buffer.as_mut_slice());
+        let slice = PaddedSliceRead::new(buffer.as_mut_slice(), json);
         let mut parser = Parser::new(slice).with_config(cfg);
         let mut vis = DocumentVisitor::new(json.len(), smut);
         parser.parse_dom(&mut vis)?;
@@ -2068,4 +2068,16 @@ mod test {
 
         assert_eq!(obj, obj2);
     }
+
+    #[test]
+    fn test_issue_179_line_column() {
+        let json = r#"
+        {
+            "key\nwith\nnewlines": "value",
+            "another_key": [, 1, 2, 3]
+        }
+        "#;
+        let err = crate::from_str::<Value>(json).unwrap_err();
+        assert_eq!(err.line(), 4);
+    }
 }