Use ? operator instead of map_err

src/de/mod.rs

@@ -624,7 +624,7 @@ where
         allow_start: bool,
     ) -> Result<BytesCData<'de>, DeError> {
         match self.next()? {
-            DeEvent::Text(e) if unescape => e.unescape().map_err(|e| DeError::InvalidXml(e.into())),
+            DeEvent::Text(e) if unescape => e.unescape().map_err(Into::into),
             DeEvent::Text(e) => Ok(BytesCData::new(e.into_inner())),
             DeEvent::CData(e) => Ok(e),
             DeEvent::Start(e) if allow_start => {

src/errors.rs

@@ -4,6 +4,7 @@ use crate::escape::EscapeError;
 use crate::events::attributes::AttrError;
 use crate::utils::write_byte_string;
 use std::str::Utf8Error;
+use std::string::FromUtf8Error;
 
 /// The error type used by this crate.
 #[derive(Debug)]
@@ -53,6 +54,14 @@ impl From<Utf8Error> for Error {
     }
 }
 
+impl From<FromUtf8Error> for Error {
+    /// Creates a new `Error::Utf8` from the given error
+    #[inline]
+    fn from(error: FromUtf8Error) -> Error {
+        error.utf8_error().into()
+    }
+}
+
 impl From<EscapeError> for Error {
     /// Creates a new `Error::EscapeError` from the given error
     #[inline]
@@ -227,6 +236,7 @@ pub mod serialize {
     }
 
     impl From<Error> for DeError {
+        #[inline]
         fn from(e: Error) -> Self {
             Self::InvalidXml(e)
         }
@@ -239,15 +249,17 @@ pub mod serialize {
         }
     }
 
-    impl From<ParseIntError> for DeError {
-        fn from(e: ParseIntError) -> Self {
-            Self::InvalidInt(e)
+    impl From<Utf8Error> for DeError {
+        #[inline]
+        fn from(e: Utf8Error) -> Self {
+            Self::InvalidXml(e.into())
         }
     }
 
-    impl From<ParseFloatError> for DeError {
-        fn from(e: ParseFloatError) -> Self {
-            Self::InvalidFloat(e)
+    impl From<FromUtf8Error> for DeError {
+        #[inline]
+        fn from(e: FromUtf8Error) -> Self {
+            Self::InvalidXml(e.into())
         }
     }
 
@@ -257,4 +269,18 @@ pub mod serialize {
             Self::InvalidXml(e.into())
         }
     }
+
+    impl From<ParseIntError> for DeError {
+        #[inline]
+        fn from(e: ParseIntError) -> Self {
+            Self::InvalidInt(e)
+        }
+    }
+
+    impl From<ParseFloatError> for DeError {
+        #[inline]
+        fn from(e: ParseFloatError) -> Self {
+            Self::InvalidFloat(e)
+        }
+    }
 }

src/events/attributes.rs

@@ -119,9 +119,8 @@ impl<'a> Attribute<'a> {
         #[cfg(not(feature = "encoding"))]
         let decoded = reader.decoder().decode(&*self.value)?;
 
-        let unescaped =
-            do_unescape(decoded.as_bytes(), custom_entities).map_err(Error::EscapeError)?;
-        String::from_utf8(unescaped.into_owned()).map_err(|e| Error::Utf8(e.utf8_error()))
+        let unescaped = do_unescape(decoded.as_bytes(), custom_entities)?;
+        Ok(String::from_utf8(unescaped.into_owned())?)
     }
 }
 

src/events/mod.rs

@@ -323,9 +323,8 @@ impl<'a> BytesStart<'a> {
         #[cfg(not(feature = "encoding"))]
         let decoded = reader.decoder().decode(&*self)?;
 
-        let unescaped =
-            do_unescape(decoded.as_bytes(), custom_entities).map_err(Error::EscapeError)?;
-        String::from_utf8(unescaped.into_owned()).map_err(|e| Error::Utf8(e.utf8_error()))
+        let unescaped = do_unescape(decoded.as_bytes(), custom_entities)?;
+        Ok(String::from_utf8(unescaped.into_owned())?)
     }
 
     /// Edit the name of the BytesStart in-place
@@ -512,7 +511,7 @@ impl<'a> BytesDecl<'a> {
             Some(Ok(a)) if a.key.as_ref() == b"version" => Ok(a.value),
             // first attribute was not "version"
             Some(Ok(a)) => {
-                let found = from_utf8(a.key.as_ref()).map_err(Error::Utf8)?.to_string();
+                let found = from_utf8(a.key.as_ref())?.to_string();
                 Err(Error::XmlDeclWithoutVersion(Some(found)))
             }
             // error parsing attributes
@@ -887,9 +886,8 @@ impl<'a> BytesText<'a> {
         #[cfg(not(feature = "encoding"))]
         let decoded = reader.decoder().decode(&*self)?;
 
-        let unescaped =
-            do_unescape(decoded.as_bytes(), custom_entities).map_err(Error::EscapeError)?;
-        String::from_utf8(unescaped.into_owned()).map_err(|e| Error::Utf8(e.utf8_error()))
+        let unescaped = do_unescape(decoded.as_bytes(), custom_entities)?;
+        Ok(String::from_utf8(unescaped.into_owned())?)
     }
 
     /// Gets escaped content.

src/reader.rs

@@ -1444,7 +1444,7 @@ impl Decoder {
     ///
     /// If you instead want to use XML declared encoding, use the `encoding` feature
     pub fn decode<'c>(&self, bytes: &'c [u8]) -> Result<&'c str> {
-        from_utf8(bytes).map_err(Error::Utf8)
+        Ok(from_utf8(bytes)?)
     }
 
     /// Decodes a slice regardless of XML declaration with BOM removal if
@@ -1454,11 +1454,12 @@ impl Decoder {
     ///
     /// If you instead want to use XML declared encoding, use the `encoding` feature
     pub fn decode_with_bom_removal<'b>(&self, bytes: &'b [u8]) -> Result<&'b str> {
-        if bytes.starts_with(b"\xEF\xBB\xBF") {
-            from_utf8(&bytes[3..]).map_err(Error::Utf8)
+        let bytes = if bytes.starts_with(b"\xEF\xBB\xBF") {
+            &bytes[3..]
         } else {
-            from_utf8(bytes).map_err(Error::Utf8)
-        }
+            bytes
+        };
+        self.decode(bytes)
     }
 }
 

src/se/mod.rs

@@ -23,8 +23,7 @@ pub fn to_writer<W: Write, S: Serialize>(writer: W, value: &S) -> Result<(), DeE
 pub fn to_string<S: Serialize>(value: &S) -> Result<String, DeError> {
     let mut writer = Vec::new();
     to_writer(&mut writer, value)?;
-    let s = String::from_utf8(writer).map_err(|e| crate::errors::Error::Utf8(e.utf8_error()))?;
-    Ok(s)
+    Ok(String::from_utf8(writer)?)
 }
 
 /// A Serializer