chore: clean out lints

Author: dsgallups

benches/macrobenches.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::incompatible_msrv)]
 use criterion::{self, criterion_group, criterion_main, Criterion, Throughput};
 use quick_xml::events::Event;
 use quick_xml::reader::{NsReader, Reader};

benches/microbenches.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::incompatible_msrv)]
 use criterion::{self, criterion_group, criterion_main, Criterion};
 use pretty_assertions::assert_eq;
 use quick_xml::escape::{escape, unescape};

examples/flattened_enum.rs

@@ -129,7 +129,7 @@ fn main() {
 </model>
 "#;
 
-    let model: Model = from_str(&x).unwrap();
+    let model: Model = from_str(x).unwrap();
     println!("{:?}", model);
     // Model { elem: [Foo(Foo { a: "1", subfoo: SubFoo { a1: "2", a2: "42", a3: "1337" } }), Bar(Bar { b: "22" })] }
 

src/de/key.rs

@@ -5,7 +5,7 @@ use crate::events::BytesStart;
 use crate::name::QName;
 use crate::utils::CowRef;
 use serde::de::{DeserializeSeed, Deserializer, EnumAccess, Visitor};
-use serde::{forward_to_deserialize_any, serde_if_integer128};
+use serde::forward_to_deserialize_any;
 use std::borrow::Cow;
 
 macro_rules! deserialize_num {
@@ -96,7 +96,7 @@ impl<'i, 'd> QNameDeserializer<'i, 'd> {
             // can apper only in this literal form, as `xml` prefix cannot be redeclared or unbound
             let (local, prefix_opt) = name.decompose();
             if prefix_opt.map_or(false, |prefix| prefix.is_xml()) {
-                decoder.decode_into(&name.into_inner(), key_buf)?;
+                decoder.decode_into(name.into_inner(), key_buf)?;
             } else {
                 decoder.decode_into(local.into_inner(), key_buf)?;
             }
@@ -155,10 +155,8 @@ impl<'de, 'd> Deserializer<'de> for QNameDeserializer<'de, 'd> {
     deserialize_num!(deserialize_u32, visit_u32);
     deserialize_num!(deserialize_u64, visit_u64);
 
-    serde_if_integer128! {
-        deserialize_num!(deserialize_i128, visit_i128);
-        deserialize_num!(deserialize_u128, visit_u128);
-    }
+    deserialize_num!(deserialize_i128, visit_i128);
+    deserialize_num!(deserialize_u128, visit_u128);
 
     deserialize_num!(deserialize_f32, visit_f32);
     deserialize_num!(deserialize_f64, visit_f64);
@@ -389,10 +387,8 @@ mod tests {
     deserialized_to!(u32_: u32 = "3" => 3);
     deserialized_to!(u64_: u64 = "3" => 3);
 
-    serde_if_integer128! {
-        deserialized_to!(i128_: i128 = "-2" => -2);
-        deserialized_to!(u128_: u128 = "2" => 2);
-    }
+    deserialized_to!(i128_: i128 = "-2" => -2);
+    deserialized_to!(u128_: u128 = "2" => 2);
 
     deserialized_to!(f32_: f32 = "1.23" => 1.23);
     deserialized_to!(f64_: f64 = "1.23" => 1.23);

src/de/map.rs

@@ -15,7 +15,6 @@ use crate::{
 };
 use serde::de::value::BorrowedStrDeserializer;
 use serde::de::{self, DeserializeSeed, Deserializer as _, MapAccess, SeqAccess, Visitor};
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 use std::ops::Range;
 

src/de/mod.rs

@@ -1975,7 +1975,6 @@
 
 // Macros should be defined before the modules that using them
 // Also, macros should be imported before using them
-use serde::serde_if_integer128;
 
 macro_rules! deserialize_num {
     ($deserialize:ident => $visit:ident, $($mut:tt)?) => {
@@ -2010,10 +2009,8 @@ macro_rules! deserialize_primitives {
         deserialize_num!(deserialize_u32 => visit_u32, $($mut)?);
         deserialize_num!(deserialize_u64 => visit_u64, $($mut)?);
 
-        serde_if_integer128! {
-            deserialize_num!(deserialize_i128 => visit_i128, $($mut)?);
-            deserialize_num!(deserialize_u128 => visit_u128, $($mut)?);
-        }
+        deserialize_num!(deserialize_i128 => visit_i128, $($mut)?);
+        deserialize_num!(deserialize_u128 => visit_u128, $($mut)?);
 
         deserialize_num!(deserialize_f32 => visit_f32, $($mut)?);
         deserialize_num!(deserialize_f64 => visit_f64, $($mut)?);
@@ -2815,35 +2812,32 @@ where
     fn skip(&mut self) -> Result<(), DeError> {
         let event = self.next()?;
         self.skip_event(event)?;
-        match self.write.back() {
-            // Skip all subtree, if we skip a start event
-            Some(DeEvent::Start(e)) => {
-                let end = e.name().as_ref().to_owned();
-                let mut depth = 0;
-                loop {
-                    let event = self.next()?;
-                    match event {
-                        DeEvent::Start(ref e) if e.name().as_ref() == end => {
-                            self.skip_event(event)?;
-                            depth += 1;
-                        }
-                        DeEvent::End(ref e) if e.name().as_ref() == end => {
-                            self.skip_event(event)?;
-                            if depth == 0 {
-                                break;
-                            }
-                            depth -= 1;
-                        }
-                        DeEvent::Eof => {
-                            self.skip_event(event)?;
+        if let Some(DeEvent::Start(e)) = self.write.back() {
+            let end = e.name().as_ref().to_owned();
+            let mut depth = 0;
+            loop {
+                let event = self.next()?;
+                match event {
+                    DeEvent::Start(ref e) if e.name().as_ref() == end => {
+                        self.skip_event(event)?;
+                        depth += 1;
+                    }
+                    DeEvent::End(ref e) if e.name().as_ref() == end => {
+                        self.skip_event(event)?;
+                        if depth == 0 {
                             break;
                         }
-                        _ => self.skip_event(event)?,
+                        depth -= 1;
+                    }
+                    DeEvent::Eof => {
+                        self.skip_event(event)?;
+                        break;
                     }
+                    _ => self.skip_event(event)?,
                 }
             }
-            _ => (),
         }
+
         Ok(())
     }
 
@@ -3214,7 +3208,7 @@ where
     }
 }
 
-impl<'de, 'a, R, E> de::Deserializer<'de> for &'a mut Deserializer<'de, R, E>
+impl<'de, R, E> de::Deserializer<'de> for &mut Deserializer<'de, R, E>
 where
     R: XmlRead<'de>,
     E: EntityResolver,
@@ -3330,7 +3324,7 @@ where
             DeEvent::Text(t) if t.is_empty() => visitor.visit_none(),
             DeEvent::Eof => visitor.visit_none(),
             // if the `xsi:nil` attribute is set to true we got a none value
-            DeEvent::Start(start) if self.reader.reader.has_nil_attr(&start) => {
+            DeEvent::Start(start) if self.reader.reader.has_nil_attr(start) => {
                 self.skip_next_tree()?;
                 visitor.visit_none()
             }
@@ -3354,7 +3348,7 @@ where
 ///
 /// Technically, multiple top-level elements violates XML rule of only one top-level
 /// element, but we consider this as several concatenated XML documents.
-impl<'de, 'a, R, E> SeqAccess<'de> for &'a mut Deserializer<'de, R, E>
+impl<'de, R, E> SeqAccess<'de> for &mut Deserializer<'de, R, E>
 where
     R: XmlRead<'de>,
     E: EntityResolver,
@@ -3381,7 +3375,7 @@ where
     }
 }
 
-impl<'de, 'a, R, E> IntoDeserializer<'de, DeError> for &'a mut Deserializer<'de, R, E>
+impl<'de, R, E> IntoDeserializer<'de, DeError> for &mut Deserializer<'de, R, E>
 where
     R: XmlRead<'de>,
     E: EntityResolver,
@@ -4508,6 +4502,7 @@ mod tests {
             use super::*;
 
             /// <tag1><tag2>...
+            #[allow(clippy::module_inception)]
             mod start {
                 use super::*;
                 use pretty_assertions::assert_eq;
@@ -4980,6 +4975,7 @@ mod tests {
                 }
             }
 
+            #[allow(clippy::module_inception)]
             mod cdata {
                 use super::*;
                 use pretty_assertions::assert_eq;

src/de/simple_type.rs

@@ -13,7 +13,6 @@ use serde::de::value::UnitDeserializer;
 use serde::de::{
     DeserializeSeed, Deserializer, EnumAccess, IntoDeserializer, SeqAccess, VariantAccess, Visitor,
 };
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 use std::ops::Range;
 
@@ -159,10 +158,8 @@ impl<'de, 'a> Deserializer<'de> for AtomicDeserializer<'de, 'a> {
     deserialize_num!(deserialize_u32 => visit_u32);
     deserialize_num!(deserialize_u64 => visit_u64);
 
-    serde_if_integer128! {
-        deserialize_num!(deserialize_i128 => visit_i128);
-        deserialize_num!(deserialize_u128 => visit_u128);
-    }
+    deserialize_num!(deserialize_i128 => visit_i128);
+    deserialize_num!(deserialize_u128 => visit_u128);
 
     deserialize_num!(deserialize_f32 => visit_f32);
     deserialize_num!(deserialize_f64 => visit_f64);
@@ -603,10 +600,8 @@ impl<'de, 'a> Deserializer<'de> for SimpleTypeDeserializer<'de, 'a> {
     deserialize_primitive!(deserialize_u32);
     deserialize_primitive!(deserialize_u64);
 
-    serde_if_integer128! {
-        deserialize_primitive!(deserialize_i128);
-        deserialize_primitive!(deserialize_u128);
-    }
+    deserialize_primitive!(deserialize_i128);
+    deserialize_primitive!(deserialize_u128);
 
     deserialize_primitive!(deserialize_f32);
     deserialize_primitive!(deserialize_f64);
@@ -986,10 +981,8 @@ mod tests {
         deserialized_to!(u32_: u32 = "3" => 3);
         deserialized_to!(u64_: u64 = "3" => 3);
 
-        serde_if_integer128! {
-            deserialized_to!(i128_: i128 = "-2" => -2);
-            deserialized_to!(u128_: u128 = "2" => 2);
-        }
+        deserialized_to!(i128_: i128 = "-2" => -2);
+        deserialized_to!(u128_: u128 = "2" => 2);
 
         deserialized_to!(f32_: f32 = "1.23" => 1.23);
         deserialized_to!(f64_: f64 = "1.23" => 1.23);
@@ -1184,10 +1177,8 @@ mod tests {
         simple!(utf8, u32_: u32 = "3" => 3);
         simple!(utf8, u64_: u64 = "3" => 3);
 
-        serde_if_integer128! {
-            simple!(utf8, i128_: i128 = "-2" => -2);
-            simple!(utf8, u128_: u128 = "2" => 2);
-        }
+        simple!(utf8, i128_: i128 = "-2" => -2);
+        simple!(utf8, u128_: u128 = "2" => 2);
 
         simple!(utf8, f32_: f32 = "1.23" => 1.23);
         simple!(utf8, f64_: f64 = "1.23" => 1.23);
@@ -1274,10 +1265,8 @@ mod tests {
         utf16!(u32_: u32 = "3" => 3);
         utf16!(u64_: u64 = "3" => 3);
 
-        serde_if_integer128! {
-            utf16!(i128_: i128 = "-2" => -2);
-            utf16!(u128_: u128 = "2" => 2);
-        }
+        utf16!(i128_: i128 = "-2" => -2);
+        utf16!(u128_: u128 = "2" => 2);
 
         utf16!(f32_: f32 = "1.23" => 1.23);
         utf16!(f64_: f64 = "1.23" => 1.23);

src/de/text.rs

@@ -6,7 +6,6 @@ use crate::{
 };
 use serde::de::value::BorrowedStrDeserializer;
 use serde::de::{DeserializeSeed, Deserializer, EnumAccess, VariantAccess, Visitor};
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 
 /// A deserializer for a single text node of a mixed sequence of tags and text.

src/encoding.rs

@@ -257,7 +257,7 @@ pub fn detect_encoding(bytes: &[u8]) -> Option<(&'static Encoding, usize)> {
         // without BOM
         _ if bytes.starts_with(&[0x00, b'<', 0x00, b'?']) => Some((UTF_16BE, 0)), // Some BE encoding, for example, UTF-16 or ISO-10646-UCS-2
         _ if bytes.starts_with(&[b'<', 0x00, b'?', 0x00]) => Some((UTF_16LE, 0)), // Some LE encoding, for example, UTF-16 or ISO-10646-UCS-2
-        _ if bytes.starts_with(&[b'<', b'?', b'x', b'm']) => Some((UTF_8, 0)), // Some ASCII compatible
+        _ if bytes.starts_with(b"<?xm") => Some((UTF_8, 0)), // Some ASCII compatible
 
         _ => None,
     }

src/escape.rs

@@ -2181,7 +2181,7 @@ mod normalization {
                     if ch == '\u{0085}' {
                         assert_eq!(normalize_xml11_eols(input), "\n", "{}", description);
                     } else {
-                        let mut expected = utf8.clone();
+                        let mut expected = utf8;
                         expected[0] = b'\n';
                         let expected = std::str::from_utf8(&expected).expect(&description);
                         assert_eq!(normalize_xml11_eols(input), expected, "{}", description);