Simplified EscapedStr, propegating unescaping errors upwards

Author: sammhicks

src/de/mod.rs

@@ -499,7 +499,7 @@ impl<'a, 'de, 's> de::Deserializer<'de> for &'a mut Deserializer<'de, 's> {
             if escaped_string.as_bytes().contains(&b'\\') {
                 let mut string_unescape_buffer_write_position = 0;
 
-                for fragment in crate::str::unescape_fragments(escaped_string) {
+                for fragment in crate::str::EscapedStr(escaped_string).fragments() {
                     let char_encode_buffer = &mut [0; 4];
 
                     let unescaped_bytes = match fragment? {
@@ -1047,7 +1047,7 @@ mod tests {
     fn escaped_str() {
         assert_eq!(
             crate::from_str(r#""Hello\nWorld""#),
-            Ok((crate::str::EscapedStr::new(r#"Hello\nWorld"#).unwrap(), 14))
+            Ok((crate::str::EscapedStr(r#"Hello\nWorld"#), 14))
         );
     }
 

src/ser/mod.rs

@@ -831,8 +831,7 @@ mod tests {
     #[test]
     fn escaped_str() {
         assert_eq!(
-            crate::to_string::<_, N>(&crate::str::EscapedStr::new(r#"Hello\\nWorld"#).unwrap())
-                .unwrap(),
+            crate::to_string::<_, N>(&crate::str::EscapedStr(r#"Hello\\nWorld"#)).unwrap(),
             r#""Hello\\nWorld""#
         );
     }

src/str.rs

@@ -55,51 +55,14 @@ fn unescape_next_fragment(
     })
 }
 
-pub(crate) fn unescape_fragments(
-    mut escaped_string: &str,
-) -> impl Iterator<Item = Result<EscapedStringFragment<'_>, StringUnescapeError>> {
-    core::iter::from_fn(move || {
-        if escaped_string.is_empty() {
-            None
-        } else {
-            Some(
-                unescape_next_fragment(escaped_string).map(|(fragment, rest)| {
-                    escaped_string = rest;
-                    fragment
-                }),
-            )
-        }
-    })
-}
-
 /// A borrowed escaped string
 #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 #[serde(rename = "__serde_json_core_escaped_string__")]
-pub struct EscapedStr<'a>(&'a str);
+pub struct EscapedStr<'a>(pub &'a str);
 
 impl<'a> EscapedStr<'a> {
     pub(crate) const NAME: &'static str = "__serde_json_core_escaped_string__";
 
-    /// Create a new EscapedString, verifying that it's correctly escaped
-    pub fn new(escaped_string: &'a str) -> Result<Self, StringUnescapeError> {
-        // Check that all fragments are valid
-        for fragment in unescape_fragments(escaped_string) {
-            fragment?;
-        }
-
-        // SAFETY: we've just checked that all fragments are valid
-        unsafe { Ok(Self::new_unchecked(escaped_string)) }
-    }
-
-    /// Create a new EscapedString without verifying that it's correctly escaped
-    ///
-    /// # Safety
-    ///
-    /// escaped_string must be a correctly escaped JSON string without the surrounding quotes.
-    pub unsafe fn new_unchecked(escaped_string: &'a str) -> Self {
-        Self(escaped_string)
-    }
-
     pub fn fragments(&self) -> EscapedStringFragmentIter<'a> {
         EscapedStringFragmentIter(self.0)
     }
@@ -114,26 +77,17 @@ impl<'a> EscapedStringFragmentIter<'a> {
 }
 
 impl<'a> Iterator for EscapedStringFragmentIter<'a> {
-    type Item = EscapedStringFragment<'a>;
+    type Item = Result<EscapedStringFragment<'a>, StringUnescapeError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.0.is_empty() {
             return None;
         }
 
-        let fragment_result = unescape_next_fragment(self.0);
-
-        debug_assert!(
-            fragment_result.is_ok(),
-            "{:?} must be valid",
-            fragment_result
-        );
-
-        // In release, if there's been a logic error, return early as it's better than panicing
-        let (fragment, rest) = fragment_result.ok()?;
-
-        self.0 = rest;
+        Some(unescape_next_fragment(self.0).map(|(fragment, rest)| {
+            self.0 = rest;
 
-        Some(fragment)
+            fragment
+        }))
     }
 }