clippy fixes

src/error.rs

@@ -142,6 +142,7 @@ pub struct PrimitiveError {
 }
 
 #[derive(Error, Debug, Clone)]
+#[allow(clippy::enum_variant_names)]
 pub enum PrimitiveErrorKind {
     #[error("Invalid boolean literal: {0}")]
     InvalidBoolLiteral(#[from] ParseBoolError),

src/lib.rs

@@ -24,7 +24,6 @@
 //!
 //! ```rust
 //! use php_literal_parser::from_str;
-//! # use serde_derive::Deserialize;
 //! use serde::Deserialize;
 //! # use std::fmt::Debug;
 //! # use std::error::Error;
@@ -306,7 +305,7 @@ impl Display for Value {
             Value::Float(val) => write!(f, "{}", val),
             Value::String(val) => write!(f, "{}", val),
             Value::Array(val) => {
-                write!(f, "[\n")?;
+                writeln!(f, "[")?;
                 for (key, value) in val.iter() {
                     write!(f, "\t{} => {},", key, value)?;
                 }

src/num.rs

@@ -43,7 +43,7 @@ pub fn parse_int(src: &str) -> Result<i64, ParseIntError> {
     let (radix, digits) = match digits {
         [b'0', b'x', tail @ ..] => (16, tail),
         [b'0', b'b', tail @ ..] => (2, tail),
-        [b'0', tail @ ..] if tail.len() > 0 => (8, tail),
+        [b'0', tail @ ..] if !tail.is_empty() => (8, tail),
         tail => (10, tail),
     };
 

src/serde_impl.rs

@@ -87,7 +87,7 @@ impl<'de> Deserializer<'de> {
         let token = self
             .next_token()
             .expect_token(&[Token::Bool], self.source())?;
-        Ok(self.parser.parse_bool_token(token)?)
+        self.parser.parse_bool_token(token)
     }
 
     fn push_peeked(&mut self, peeked: SpannedToken<'de>) {
@@ -119,22 +119,22 @@ impl<'de> Deserializer<'de> {
             .next_token()
             .expect_token(&[Token::Integer], self.source())?;
         let span = token.span.clone();
-        Ok(T::try_from(self.parser.parse_int_token(token)?)
+        T::try_from(self.parser.parse_int_token(token)?)
-            .or_else(|_| Err(ParseIntError::Overflow).with_span(span, self.source()))?)
+            .or_else(|_| Err(ParseIntError::Overflow).with_span(span, self.source()))
     }
 
     fn parse_float(&mut self) -> Result<f64> {
         let token = self
             .next_token()
             .expect_token(&[Token::Float], self.source())?;
-        Ok(self.parser.parse_float_token(token)?)
+        self.parser.parse_float_token(token)
     }
 
     fn parse_string(&mut self) -> Result<String> {
         let token = self
             .next_token()
             .expect_token(&[Token::LiteralString], self.source())?;
-        Ok(self.parser.parse_string_token(token)?)
+        self.parser.parse_string_token(token)
     }
 }
 
@@ -348,7 +348,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         visitor.visit_newtype_struct(self)
     }
 
-    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
@@ -365,7 +365,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             _ => unreachable!(),
         };
 
-        let value = visitor.visit_seq(ArrayWalker::new(&mut self, syntax))?;
+        let value = visitor.visit_seq(ArrayWalker::new(self, syntax))?;
         Ok(value)
     }
 
@@ -388,7 +388,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         self.deserialize_seq(visitor)
     }
 
-    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
@@ -405,7 +405,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             _ => unreachable!(),
         };
 
-        let value = visitor.visit_map(ArrayWalker::new(&mut self, syntax))?;
+        let value = visitor.visit_map(ArrayWalker::new(self, syntax))?;
         Ok(value)
     }
 
@@ -528,7 +528,7 @@ impl<'de, 'a> SeqAccess<'de> for ArrayWalker<'de, 'a> {
             self.source(),
         )?;
 
-        let value_token = match next.token.clone() {
+        let value_token = match next.token {
             Token::Comma => token,
             Token::Arrow => {
                 let span = token.span.clone();

src/string.rs

@@ -31,7 +31,10 @@ impl UnescapeState {
 
     fn push_raw(&mut self, c: u32) -> UnescapeResult<()> {
         match std::char::from_u32(c) {
-            Some(c) => Ok(self.push_char(c)),
+            Some(c) => {
+                self.push_char(c);
+                Ok(())
+            },
             None => Err(UnescapeError),
         }
     }
@@ -193,7 +196,7 @@ impl<'a> PeekableBytes<'a> {
         self.slice.get(self.pos).copied()
     }
 
-    pub fn as_slice(self) -> &'a [u8] {
+    pub fn as_slice(&self) -> &'a [u8] {
         &self.slice[self.pos..]
     }
 }
@@ -205,7 +208,7 @@ pub fn is_array_key_numeric(string: &str) -> bool {
         return false;
     }
 
-    bytes.all(|byte| matches!(byte, b'0'..=b'9'))
+    bytes.all(|byte| byte.is_ascii_digit())
 }
 
 #[cfg(test)]
@@ -214,19 +217,19 @@ mod tests {
 
     #[test]
     fn test_is_numeric() {
-        assert_eq!(true, is_array_key_numeric("123"));
+        assert!(is_array_key_numeric("123"));
-        assert_eq!(true, is_array_key_numeric("-123"));
+        assert!(is_array_key_numeric("-123"));
-        assert_eq!(true, is_array_key_numeric("0"));
+        assert!(is_array_key_numeric("0"));
-        assert_eq!(false, is_array_key_numeric("0123"));
+        assert!(!is_array_key_numeric("0123"));
-        assert_eq!(false, is_array_key_numeric("123asd"));
+        assert!(!is_array_key_numeric("123asd"));
-        assert_eq!(false, is_array_key_numeric("+123"));
+        assert!(!is_array_key_numeric("+123"));
     }
 
     #[test]
     fn test_unescape_single() {
-        assert_eq!(unescape::<SingleQuoteString>(&r#"abc"#), Ok("abc".into()));
+        assert_eq!(unescape::<SingleQuoteString>(r#"abc"#), Ok("abc".into()));
         assert_eq!(
-            unescape::<SingleQuoteString>(&r#"ab\nc"#),
+            unescape::<SingleQuoteString>(r#"ab\nc"#),
             Ok("ab\\nc".into())
         );
         assert_eq!(
@@ -256,9 +259,9 @@ mod tests {
 
     #[test]
     fn test_unescape_double() {
-        assert_eq!(unescape::<DoubleQuoteString>(&r#"abc"#), Ok("abc".into()));
+        assert_eq!(unescape::<DoubleQuoteString>(r#"abc"#), Ok("abc".into()));
         assert_eq!(
-            unescape::<DoubleQuoteString>(&r#"ab\nc"#),
+            unescape::<DoubleQuoteString>(r#"ab\nc"#),
             Ok("ab\nc".into())
         );
         assert_eq!(