From 6d08f72639781a04493e348e3fbea5fd4bc798a9 Mon Sep 17 00:00:00 2001
From: Daniel Gallups <dsgallups@protonmail.com>
Date: Mon, 15 Sep 2025 12:36:34 -0400
Subject: [PATCH 1/4] cargo clippy --fix

---
 src/events/attributes.rs | 2 +-
 src/events/mod.rs        | 2 +-
 src/name.rs              | 9 +++------
 src/reader/state.rs      | 4 ++--
 src/writer.rs            | 7 +++----
 5 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/events/attributes.rs b/src/events/attributes.rs
index f98fefb3f..8e5b88bba 100644
--- a/src/events/attributes.rs
+++ b/src/events/attributes.rs
@@ -432,7 +432,7 @@ impl<'a> Attributes<'a> {
 impl<'a> Debug for Attributes<'a> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         f.debug_struct("Attributes")
-            .field("bytes", &Bytes(&self.bytes))
+            .field("bytes", &Bytes(self.bytes))
             .field("state", &self.state)
             .field("decoder", &self.decoder)
             .finish()
diff --git a/src/events/mod.rs b/src/events/mod.rs
index a0546d918..db8768cff 100644
--- a/src/events/mod.rs
+++ b/src/events/mod.rs
@@ -1086,7 +1086,7 @@ impl<'a> BytesPI<'a> {
     #[inline]
     pub fn into_owned(self) -> BytesPI<'static> {
         BytesPI {
-            content: self.content.into_owned().into(),
+            content: self.content.into_owned(),
         }
     }
 
diff --git a/src/name.rs b/src/name.rs
index dc16dd0cc..3f47390f5 100644
--- a/src/name.rs
+++ b/src/name.rs
@@ -609,7 +609,7 @@ impl NamespaceResolver {
         match prefix {
             PrefixDeclaration::Default => {
                 let start = self.buffer.len();
-                self.buffer.extend_from_slice(&namespace.0);
+                self.buffer.extend_from_slice(namespace.0);
                 self.bindings.push(NamespaceBinding {
                     start,
                     prefix_len: 0,
@@ -640,7 +640,7 @@ impl NamespaceResolver {
 
                 let start = self.buffer.len();
                 self.buffer.extend_from_slice(prefix);
-                self.buffer.extend_from_slice(&namespace.0);
+                self.buffer.extend_from_slice(namespace.0);
                 self.bindings.push(NamespaceBinding {
                     start,
                     prefix_len: prefix.len(),
@@ -662,10 +662,7 @@ impl NamespaceResolver {
         // (default namespace) attribute.
         for a in start.attributes().with_checks(false) {
             if let Ok(Attribute { key: k, value: v }) = a {
-                match k.as_namespace_binding() {
-                    Some(prefix) => self.add(prefix, Namespace(&v))?,
-                    None => {}
-                }
+                if let Some(prefix) = k.as_namespace_binding() { self.add(prefix, Namespace(&v))? }
             } else {
                 break;
             }
diff --git a/src/reader/state.rs b/src/reader/state.rs
index c5e6b7c72..656e57cce 100644
--- a/src/reader/state.rs
+++ b/src/reader/state.rs
@@ -156,7 +156,7 @@ impl ReaderState {
                         // We want report error at place where name is expected - this is just
                         // before `>`
                         self.last_error_offset = self.offset - 1;
-                        return Err(Error::IllFormed(IllFormedError::MissingDoctypeName));
+                        Err(Error::IllFormed(IllFormedError::MissingDoctypeName))
                     }
                 }
             }
@@ -239,7 +239,7 @@ impl ReaderState {
     ///
     /// Returns `Decl` or `PI` event
     pub fn emit_question_mark<'b>(&mut self, buf: &'b [u8]) -> Result<Event<'b>> {
-        debug_assert!(buf.len() > 0);
+        debug_assert!(!buf.is_empty());
         debug_assert_eq!(buf[0], b'?');
 
         let len = buf.len();
diff --git a/src/writer.rs b/src/writer.rs
index 5810dfe60..62437cc77 100644
--- a/src/writer.rs
+++ b/src/writer.rs
@@ -233,8 +233,7 @@ impl<W: Write> Writer<W> {
     /// Writes bytes
     #[inline]
     pub(crate) fn write(&mut self, value: &[u8]) -> io::Result<()> {
-        self.writer.write_all(value).map_err(Into::into)
-    }
+        self.writer.write_all(value)}
 
     #[inline]
     fn write_wrapped(&mut self, before: &[u8], value: &[u8], after: &[u8]) -> io::Result<()> {
@@ -497,7 +496,7 @@ impl<'a, W> ElementWriter<'a, W> {
                         self.spaces.resize(indent, b' ');
                     }
                     self.start_tag.push_indent(&self.spaces[..indent]);
-                    self.start_tag.push_attr(attr.into());
+                    self.start_tag.push_attr(attr);
                     AttributeIndent::Spaces(indent)
                 }
                 // .new_line() was not called, but .with_attribute() was.
@@ -511,7 +510,7 @@ impl<'a, W> ElementWriter<'a, W> {
                 // New line was already written
                 AttributeIndent::WriteConfigured(indent) => {
                     self.start_tag.push_indent(i.additional(indent));
-                    self.start_tag.push_attr(attr.into());
+                    self.start_tag.push_attr(attr);
                     AttributeIndent::Configured(indent)
                 }
                 // .new_line() was not called, but .with_attribute() was.

From 9162282fb2a04005eea8ebdf51a1339d7221e99e Mon Sep 17 00:00:00 2001
From: Daniel Gallups <dsgallups@protonmail.com>
Date: Mon, 15 Sep 2025 12:54:39 -0400
Subject: [PATCH 2/4] chore: clean out lints

---
 benches/macrobenches.rs     |  1 +
 benches/microbenches.rs     |  1 +
 examples/flattened_enum.rs  |  2 +-
 src/de/key.rs               | 16 ++++-----
 src/de/map.rs               |  1 -
 src/de/mod.rs               | 60 +++++++++++++++-----------------
 src/de/simple_type.rs       | 31 ++++++-----------
 src/de/text.rs              |  1 -
 src/encoding.rs             |  2 +-
 src/escape.rs               |  2 +-
 src/events/mod.rs           | 14 ++++----
 src/se/content.rs           | 43 ++++++++---------------
 src/se/element.rs           | 69 +++++++++++++------------------------
 src/se/key.rs               |  7 ++--
 src/se/mod.rs               | 23 +++++--------
 src/se/simple_type.rs       | 19 ++++------
 src/se/text.rs              |  7 ++--
 tests/issues.rs             |  5 ++-
 tests/reader-references.rs  | 12 +++----
 tests/serde-de.rs           | 25 ++++----------
 tests/serde-migrated.rs     |  4 +--
 tests/serde-se.rs           | 20 ++++-------
 tests/serde_helpers/mod.rs  |  2 +-
 tests/serde_roundtrip.rs    |  6 +++-
 tests/writer-indentation.rs | 26 +++++++-------
 25 files changed, 153 insertions(+), 246 deletions(-)

diff --git a/benches/macrobenches.rs b/benches/macrobenches.rs
index 9a87f31d7..f78662ee1 100644
--- a/benches/macrobenches.rs
+++ b/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};
diff --git a/benches/microbenches.rs b/benches/microbenches.rs
index f0ae8816c..07f02e1f3 100644
--- a/benches/microbenches.rs
+++ b/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};
diff --git a/examples/flattened_enum.rs b/examples/flattened_enum.rs
index 1019c1de4..c56c2fca1 100644
--- a/examples/flattened_enum.rs
+++ b/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" })] }
 
diff --git a/src/de/key.rs b/src/de/key.rs
index aa190297f..75b82239a 100644
--- a/src/de/key.rs
+++ b/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);
diff --git a/src/de/map.rs b/src/de/map.rs
index 2c1e8953a..3588f1904 100644
--- a/src/de/map.rs
+++ b/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;
 
diff --git a/src/de/mod.rs b/src/de/mod.rs
index 7671985b0..589e7f993 100644
--- a/src/de/mod.rs
+++ b/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;
diff --git a/src/de/simple_type.rs b/src/de/simple_type.rs
index 41db1273f..824286fab 100644
--- a/src/de/simple_type.rs
+++ b/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);
diff --git a/src/de/text.rs b/src/de/text.rs
index a72f3147f..50d384019 100644
--- a/src/de/text.rs
+++ b/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.
diff --git a/src/encoding.rs b/src/encoding.rs
index 1de736059..e62d9823f 100644
--- a/src/encoding.rs
+++ b/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,
     }
diff --git a/src/escape.rs b/src/escape.rs
index b7816d9dc..d75e6569f 100644
--- a/src/escape.rs
+++ b/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);
diff --git a/src/events/mod.rs b/src/events/mod.rs
index db8768cff..7cc607e2d 100644
--- a/src/events/mod.rs
+++ b/src/events/mod.rs
@@ -358,12 +358,12 @@ impl<'a> arbitrary::Arbitrary<'a> for BytesStart<'a> {
             return Err(arbitrary::Error::IncorrectFormat);
         }
         let mut result = Self::new(s);
-        result.extend_attributes(Vec::<(&str, &str)>::arbitrary(u)?.into_iter());
+        result.extend_attributes(Vec::<(&str, &str)>::arbitrary(u)?);
         Ok(result)
     }
 
     fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        return <&str as arbitrary::Arbitrary>::size_hint(depth);
+        <&str as arbitrary::Arbitrary>::size_hint(depth)
     }
 }
 
@@ -483,7 +483,7 @@ impl<'a> arbitrary::Arbitrary<'a> for BytesEnd<'a> {
         Ok(Self::new(<&str>::arbitrary(u)?))
     }
     fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        return <&str as arbitrary::Arbitrary>::size_hint(depth);
+        <&str as arbitrary::Arbitrary>::size_hint(depth)
     }
 }
 
@@ -692,7 +692,7 @@ impl<'a> arbitrary::Arbitrary<'a> for BytesText<'a> {
     }
 
     fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        return <&str as arbitrary::Arbitrary>::size_hint(depth);
+        <&str as arbitrary::Arbitrary>::size_hint(depth)
     }
 }
 
@@ -977,7 +977,7 @@ impl<'a> arbitrary::Arbitrary<'a> for BytesCData<'a> {
         Ok(Self::new(<&str>::arbitrary(u)?))
     }
     fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        return <&str as arbitrary::Arbitrary>::size_hint(depth);
+        <&str as arbitrary::Arbitrary>::size_hint(depth)
     }
 }
 
@@ -1195,7 +1195,7 @@ impl<'a> arbitrary::Arbitrary<'a> for BytesPI<'a> {
         Ok(Self::new(<&str>::arbitrary(u)?))
     }
     fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        return <&str as arbitrary::Arbitrary>::size_hint(depth);
+        <&str as arbitrary::Arbitrary>::size_hint(depth)
     }
 }
 
@@ -1480,7 +1480,7 @@ impl<'a> arbitrary::Arbitrary<'a> for BytesDecl<'a> {
     }
 
     fn size_hint(depth: usize) -> (usize, Option<usize>) {
-        return <&str as arbitrary::Arbitrary>::size_hint(depth);
+        <&str as arbitrary::Arbitrary>::size_hint(depth)
     }
 }
 
diff --git a/src/se/content.rs b/src/se/content.rs
index f27579a2f..0192ae7d2 100644
--- a/src/se/content.rs
+++ b/src/se/content.rs
@@ -7,7 +7,6 @@ use crate::se::{Indent, QuoteLevel, SeError, WriteResult, XmlName};
 use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct, Serializer,
 };
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 macro_rules! write_primitive {
@@ -197,10 +196,8 @@ impl<'w, 'i, W: Write> Serializer for ContentSerializer<'w, 'i, W> {
     write_primitive!(serialize_u32(u32));
     write_primitive!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_primitive!(serialize_i128(i128));
-        write_primitive!(serialize_u128(u128));
-    }
+    write_primitive!(serialize_i128(i128));
+    write_primitive!(serialize_u128(u128));
 
     write_primitive!(serialize_f32(f32));
     write_primitive!(serialize_f64(f64));
@@ -658,10 +655,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000000000usize => "42000000000000", Text);
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
 
         serialize_as!(f32_: 4.2f32 => "4.2", Text);
         serialize_as!(f64_: 4.2f64 => "4.2", Text);
@@ -793,10 +788,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000000000usize => "42000000000000");
 
-            serde_if_integer128! {
-                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             text!(f32_: 4.2f32 => "4.2");
             text!(f64_: 4.2f64 => "4.2");
@@ -918,10 +911,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000000000usize => "42000000000000");
 
-            serde_if_integer128! {
-                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             value!(f32_: 4.2f32 => "4.2");
             value!(f64_: 4.2f64 => "4.2");
@@ -1127,10 +1118,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000000000usize => "42000000000000", Text);
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000", Text);
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000", Text);
 
         serialize_as!(f32_: 4.2f32 => "4.2", Text);
         serialize_as!(f64_: 4.2f64 => "4.2", Text);
@@ -1255,10 +1244,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000000000usize => "42000000000000");
 
-            serde_if_integer128! {
-                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             text!(f32_: 4.2f32 => "4.2");
             text!(f64_: 4.2f64 => "4.2");
@@ -1380,10 +1367,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000000000usize => "42000000000000");
 
-            serde_if_integer128! {
-                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-            }
+            value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+            value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
             value!(f32_: 4.2f32 => "4.2");
             value!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/element.rs b/src/se/element.rs
index f9c430930..6f6a578e4 100644
--- a/src/se/element.rs
+++ b/src/se/element.rs
@@ -10,7 +10,6 @@ use serde::ser::{
     Impossible, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
     SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, Serializer,
 };
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 /// Writes simple type content between [`ElementSerializer::key`] tags.
@@ -88,10 +87,8 @@ impl<'w, 'k, W: Write> Serializer for ElementSerializer<'w, 'k, W> {
     write_primitive!(serialize_u32(u32));
     write_primitive!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_primitive!(serialize_i128(i128));
-        write_primitive!(serialize_u128(u128));
-    }
+    write_primitive!(serialize_i128(i128));
+    write_primitive!(serialize_u128(u128));
 
     write_primitive!(serialize_f32(f32));
     write_primitive!(serialize_f64(f64));
@@ -550,7 +547,7 @@ impl<'w, 'k, W: Write> SerializeMap for Map<'w, 'k, W> {
     where
         T: ?Sized + Serialize,
     {
-        if let Some(_) = self.key.take() {
+        if self.key.take().is_some() {
             return Err(SeError::Custom(
                 "calling `serialize_key` twice without `serialize_value`".to_string(),
             ));
@@ -697,10 +694,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
         serialize_as!(usize_: 42000000000000usize => "<root>42000000000000</root>");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
 
         serialize_as!(f32_: 4.2f32 => "<root>4.2</root>");
         serialize_as!(f64_: 4.2f64 => "<root>4.2</root>");
@@ -799,10 +794,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -924,10 +917,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -1053,10 +1044,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
@@ -1164,10 +1153,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
@@ -1418,10 +1405,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
         serialize_as!(usize_: 42000000000000usize => "<root>42000000000000</root>");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
 
         serialize_as!(f32_: 4.2f32 => "<root>4.2</root>");
         serialize_as!(f64_: 4.2f64 => "<root>4.2</root>");
@@ -1523,10 +1508,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -1649,10 +1632,8 @@ mod tests {
                 text!(u64_:   42000000000000u64   => "42000000000000");
                 text!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                text!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                text!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 text!(f32_: 4.2f32 => "4.2");
                 text!(f64_: 4.2f64 => "4.2");
@@ -1780,10 +1761,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
@@ -1894,10 +1873,8 @@ mod tests {
                 value!(u64_:   42000000000000u64   => "42000000000000");
                 value!(usize_: 42000000000000usize => "42000000000000");
 
-                serde_if_integer128! {
-                    value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-                    value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-                }
+                value!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+                value!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
                 value!(f32_: 4.2f32 => "4.2");
                 value!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/key.rs b/src/se/key.rs
index 1d193ee18..46f53315a 100644
--- a/src/se/key.rs
+++ b/src/se/key.rs
@@ -1,6 +1,5 @@
 use crate::se::SeError;
 use serde::ser::{Impossible, Serialize, Serializer};
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 /// A serializer, that ensures, that only plain types can be serialized,
@@ -242,10 +241,8 @@ mod tests {
     serialize_as!(u64_:   42000000000000u64   => "42000000000000");
     serialize_as!(usize_: 42000000000000usize => "42000000000000");
 
-    serde_if_integer128! {
-        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-    }
+    serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+    serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
     serialize_as!(f32_: 4.2f32 => "4.2");
     serialize_as!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/mod.rs b/src/se/mod.rs
index 7649fe279..e6f29d2d3 100644
--- a/src/se/mod.rs
+++ b/src/se/mod.rs
@@ -25,10 +25,8 @@ macro_rules! write_primitive {
         write_primitive!(serialize_u32(u32));
         write_primitive!(serialize_u64(u64));
 
-        serde_if_integer128! {
-            write_primitive!(serialize_i128(i128));
-            write_primitive!(serialize_u128(u128));
-        }
+        write_primitive!(serialize_i128(i128));
+        write_primitive!(serialize_u128(u128));
 
         write_primitive!(serialize_f32(f32));
         write_primitive!(serialize_f64(f64));
@@ -84,7 +82,6 @@ use self::element::{ElementSerializer, Map, Struct, Tuple};
 use crate::de::TEXT_KEY;
 use crate::writer::{Indentation, ToFmtWrite};
 use serde::ser::{self, Serialize};
-use serde::serde_if_integer128;
 use std::fmt::Write;
 use std::str::from_utf8;
 
@@ -425,7 +422,7 @@ macro_rules! forward {
 ///
 /// <https://www.w3.org/TR/xml11/#NT-NameStartChar>
 const fn is_xml11_name_start_char(ch: char) -> bool {
-    match ch {
+    matches!(ch,
         ':'
         | 'A'..='Z'
         | '_'
@@ -441,9 +438,7 @@ const fn is_xml11_name_start_char(ch: char) -> bool {
         | '\u{3001}'..='\u{D7FF}'
         | '\u{F900}'..='\u{FDCF}'
         | '\u{FDF0}'..='\u{FFFD}'
-        | '\u{10000}'..='\u{EFFFF}' => true,
-        _ => false,
-    }
+        | '\u{10000}'..='\u{EFFFF}')
 }
 /// <https://www.w3.org/TR/xml11/#NT-NameChar>
 const fn is_xml11_name_char(ch: char) -> bool {
@@ -457,7 +452,7 @@ const fn is_xml11_name_char(ch: char) -> bool {
 
 /// Helper struct to self-defense from errors
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub(self) struct XmlName<'n>(&'n str);
+struct XmlName<'n>(&'n str);
 
 impl<'n> XmlName<'n> {
     /// Checks correctness of the XML name according to [XML 1.1 specification]
@@ -626,7 +621,7 @@ impl<'w, 'r, W: Write> Serializer<'w, 'r, W> {
                 allow_primitive: true,
                 expand_empty_elements: false,
             },
-            root_tag: root_tag.map(|tag| XmlName::try_from(tag)).transpose()?,
+            root_tag: root_tag.map(XmlName::try_from).transpose()?,
         })
     }
 
@@ -733,10 +728,8 @@ impl<'w, 'r, W: Write> ser::Serializer for Serializer<'w, 'r, W> {
     forward!(serialize_u32(u32));
     forward!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        forward!(serialize_i128(i128));
-        forward!(serialize_u128(u128));
-    }
+    forward!(serialize_i128(i128));
+    forward!(serialize_u128(u128));
 
     forward!(serialize_f32(f32));
     forward!(serialize_f64(f64));
diff --git a/src/se/simple_type.rs b/src/se/simple_type.rs
index 7ca621b8f..12dddb4b8 100644
--- a/src/se/simple_type.rs
+++ b/src/se/simple_type.rs
@@ -9,7 +9,6 @@ use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
     SerializeTupleVariant, Serializer,
 };
-use serde::serde_if_integer128;
 use std::borrow::Cow;
 use std::fmt::Write;
 
@@ -225,10 +224,8 @@ impl<W: Write> Serializer for AtomicSerializer<W> {
     write_atomic!(serialize_u32(u32));
     write_atomic!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_atomic!(serialize_i128(i128));
-        write_atomic!(serialize_u128(u128));
-    }
+    write_atomic!(serialize_i128(i128));
+    write_atomic!(serialize_u128(u128));
 
     write_atomic!(serialize_f32(f32));
     write_atomic!(serialize_f64(f64));
@@ -965,10 +962,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000");
         serialize_as!(usize_: 42000000000000usize => "42000000000000");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
         serialize_as!(f32_: 4.2f32 => "4.2");
         serialize_as!(f64_: 4.2f64 => "4.2");
@@ -1081,10 +1076,8 @@ mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000");
         serialize_as!(usize_: 42000000000000usize => "42000000000000");
 
-        serde_if_integer128! {
-            serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
-            serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
-        }
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
 
         serialize_as!(f32_: 4.2f32 => "4.2");
         serialize_as!(f64_: 4.2f64 => "4.2");
diff --git a/src/se/text.rs b/src/se/text.rs
index 7094adbaa..600e521a1 100644
--- a/src/se/text.rs
+++ b/src/se/text.rs
@@ -4,7 +4,6 @@ use crate::de::TEXT_KEY;
 use crate::se::simple_type::{SimpleSeq, SimpleTypeSerializer};
 use crate::se::SeError;
 use serde::ser::{Impossible, Serialize, Serializer};
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 macro_rules! write_primitive {
@@ -49,10 +48,8 @@ impl<W: Write> Serializer for TextSerializer<W> {
     write_primitive!(serialize_u32(u32));
     write_primitive!(serialize_u64(u64));
 
-    serde_if_integer128! {
-        write_primitive!(serialize_i128(i128));
-        write_primitive!(serialize_u128(u128));
-    }
+    write_primitive!(serialize_i128(i128));
+    write_primitive!(serialize_u128(u128));
 
     write_primitive!(serialize_f32(f32));
     write_primitive!(serialize_f64(f64));
diff --git a/tests/issues.rs b/tests/issues.rs
index d4fdcbb0d..f96a55cda 100644
--- a/tests/issues.rs
+++ b/tests/issues.rs
@@ -182,9 +182,8 @@ fn issue590() {
     ));
     let mut buf = Vec::new();
     loop {
-        match reader.read_event_into(&mut buf).unwrap() {
-            Event::Eof => break,
-            _ => (),
+        if let Event::Eof = reader.read_event_into(&mut buf).unwrap() {
+            break;
         }
     }
 }
diff --git a/tests/reader-references.rs b/tests/reader-references.rs
index b0f3456e2..9b238f69c 100644
--- a/tests/reader-references.rs
+++ b/tests/reader-references.rs
@@ -34,7 +34,7 @@ mod character_reference {
 
                 assert_eq!(
                     reader.read_event().unwrap(),
-                    PI(BytesPI::new(&format!("&{i};"))),
+                    PI(BytesPI::new(format!("&{i};"))),
                     "Character reference {i}=0x{i:x}: {input}"
                 );
             }
@@ -48,7 +48,7 @@ mod character_reference {
 
                 assert_eq!(
                     reader.read_event().unwrap(),
-                    DocType(BytesText::from_escaped(&format!("&{i};"))),
+                    DocType(BytesText::from_escaped(format!("&{i};"))),
                     "Character reference {i}=0x{i:x}: {input}"
                 );
             }
@@ -62,7 +62,7 @@ mod character_reference {
 
                 assert_eq!(
                     reader.read_event().unwrap(),
-                    Comment(BytesText::from_escaped(&format!("&{i};"))),
+                    Comment(BytesText::from_escaped(format!("&{i};"))),
                     "Character reference {i}=0x{i:x}: {input}"
                 );
             }
@@ -176,7 +176,7 @@ mod character_reference {
 
                 assert_eq!(
                     reader.read_event().unwrap(),
-                    PI(BytesPI::new(&format!("&#{i:x};"))),
+                    PI(BytesPI::new(format!("&#{i:x};"))),
                     "Character reference {i}=0x{i:x}: {input}"
                 );
             }
@@ -190,7 +190,7 @@ mod character_reference {
 
                 assert_eq!(
                     reader.read_event().unwrap(),
-                    DocType(BytesText::from_escaped(&format!("&#{i:x};"))),
+                    DocType(BytesText::from_escaped(format!("&#{i:x};"))),
                     "Character reference {i}=0x{i:x}: {input}"
                 );
             }
@@ -204,7 +204,7 @@ mod character_reference {
 
                 assert_eq!(
                     reader.read_event().unwrap(),
-                    Comment(BytesText::from_escaped(&format!("&#{i:x};"))),
+                    Comment(BytesText::from_escaped(format!("&#{i:x};"))),
                     "Character reference {i}=0x{i:x}: {input}"
                 );
             }
diff --git a/tests/serde-de.rs b/tests/serde-de.rs
index cc82d5f62..3d53993c0 100644
--- a/tests/serde-de.rs
+++ b/tests/serde-de.rs
@@ -5,7 +5,6 @@ use quick_xml::DeError;
 use pretty_assertions::assert_eq;
 
 use serde::de::IgnoredAny;
-use serde::serde_if_integer128;
 use serde::Deserialize;
 
 mod serde_helpers;
@@ -112,10 +111,8 @@ mod trivial {
             eof!(u64_:   u64   = $value);
             eof!(usize_: usize = $value);
 
-            serde_if_integer128! {
                 eof!(u128_: u128 = $value);
                 eof!(i128_: i128 = $value);
-            }
 
             eof!(f32_: f32 = $value);
             eof!(f64_: f64 = $value);
@@ -330,10 +327,8 @@ mod trivial {
         in_struct!(u64_:   u64   = "42000000000000", 42000000000000u64);
         in_struct!(usize_: usize = "42000000000000", 42000000000000usize);
 
-        serde_if_integer128! {
             in_struct!(u128_: u128 = "420000000000000000000000000000", 420000000000000000000000000000u128);
             in_struct!(i128_: i128 = "-420000000000000000000000000000", -420000000000000000000000000000i128);
-        }
 
         in_struct!(f32_: f32 = "4.2", 4.2f32);
         in_struct!(f64_: f64 = "4.2", 4.2f64);
@@ -392,10 +387,8 @@ mod trivial {
         in_struct!(u64_:   u64   = "<![CDATA[42000000000000]]>", 42000000000000u64);
         in_struct!(usize_: usize = "<![CDATA[42000000000000]]>", 42000000000000usize);
 
-        serde_if_integer128! {
             in_struct!(u128_: u128 = "<![CDATA[420000000000000000000000000000]]>", 420000000000000000000000000000u128);
             in_struct!(i128_: i128 = "<![CDATA[-420000000000000000000000000000]]>", -420000000000000000000000000000i128);
-        }
 
         in_struct!(f32_: f32 = "<![CDATA[4.2]]>", 4.2f32);
         in_struct!(f64_: f64 = "<![CDATA[4.2]]>", 4.2f64);
@@ -1216,10 +1209,8 @@ mod xml_schema_lists {
         list!(u32_: u32 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
         list!(u64_: u64 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
 
-        serde_if_integer128! {
-            list!(i128_: i128 = r#"<root list="1 -2  3"/>"# => vec![1, -2, 3]);
-            list!(u128_: u128 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
-        }
+        list!(i128_: i128 = r#"<root list="1 -2  3"/>"# => vec![1, -2, 3]);
+        list!(u128_: u128 = r#"<root list="1 2  3"/>"# => vec![1, 2, 3]);
 
         list!(f32_: f32 = r#"<root list="1.23 -4.56  7.89"/>"# => vec![1.23, -4.56, 7.89]);
         list!(f64_: f64 = r#"<root list="1.23 -4.56  7.89"/>"# => vec![1.23, -4.56, 7.89]);
@@ -1264,10 +1255,8 @@ mod xml_schema_lists {
             list!(u32_: u32 = "<root>1 2  3</root>" => vec![1, 2, 3]);
             list!(u64_: u64 = "<root>1 2  3</root>" => vec![1, 2, 3]);
 
-            serde_if_integer128! {
-                list!(i128_: i128 = "<root>1 -2  3</root>" => vec![1, -2, 3]);
-                list!(u128_: u128 = "<root>1 2  3</root>" => vec![1, 2, 3]);
-            }
+            list!(i128_: i128 = "<root>1 -2  3</root>" => vec![1, -2, 3]);
+            list!(u128_: u128 = "<root>1 2  3</root>" => vec![1, 2, 3]);
 
             list!(f32_: f32 = "<root>1.23 -4.56  7.89</root>" => vec![1.23, -4.56, 7.89]);
             list!(f64_: f64 = "<root>1.23 -4.56  7.89</root>" => vec![1.23, -4.56, 7.89]);
@@ -1303,10 +1292,8 @@ mod xml_schema_lists {
             list!(u32_: u32 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
             list!(u64_: u64 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
 
-            serde_if_integer128! {
-                list!(i128_: i128 = "<root><![CDATA[1 -2  3]]></root>" => vec![1, -2, 3]);
-                list!(u128_: u128 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
-            }
+            list!(i128_: i128 = "<root><![CDATA[1 -2  3]]></root>" => vec![1, -2, 3]);
+            list!(u128_: u128 = "<root><![CDATA[1 2  3]]></root>" => vec![1, 2, 3]);
 
             list!(f32_: f32 = "<root><![CDATA[1.23 -4.56  7.89]]></root>" => vec![1.23, -4.56, 7.89]);
             list!(f64_: f64 = "<root><![CDATA[1.23 -4.56  7.89]]></root>" => vec![1.23, -4.56, 7.89]);
diff --git a/tests/serde-migrated.rs b/tests/serde-migrated.rs
index 7dd196b14..26e952f65 100644
--- a/tests/serde-migrated.rs
+++ b/tests/serde-migrated.rs
@@ -15,9 +15,9 @@ struct Simple {
 }
 
 #[track_caller]
-fn test_parse_ok<'a, T: std::fmt::Debug>(errors: &[(&'a str, T)])
+fn test_parse_ok<'a, T>(errors: &[(&'a str, T)])
 where
-    T: PartialEq + Debug + ser::Serialize + for<'de> de::Deserialize<'de>,
+    T: std::fmt::Debug + PartialEq + Debug + ser::Serialize + for<'de> de::Deserialize<'de>,
 {
     for (i, &(s, ref value)) in errors.iter().enumerate() {
         match from_str::<T>(s) {
diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index 051e47c9c..67124fac2 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -2,7 +2,7 @@ use quick_xml::de::from_str;
 use quick_xml::se::{SeError, Serializer};
 use quick_xml::utils::Bytes;
 
-use serde::{serde_if_integer128, Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 #[derive(Debug, PartialEq, Deserialize, Serialize)]
@@ -258,10 +258,8 @@ mod without_root {
     err!(u64_:   42000000000000u64   => Unsupported("cannot serialize `u64` without defined root tag"));
     err!(usize_: 42000000000000usize => Unsupported("cannot serialize `u64` without defined root tag"));
 
-    serde_if_integer128! {
-        err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
-        err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
-    }
+    err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
+    err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
 
     err!(f32_: 4.2f32 => Unsupported("cannot serialize `f32` without defined root tag"));
     err!(f64_: 4.2f64 => Unsupported("cannot serialize `f64` without defined root tag"));
@@ -1304,10 +1302,8 @@ mod without_root {
         err!(u64_:   42000000000000u64   => Unsupported("cannot serialize `u64` without defined root tag"));
         err!(usize_: 42000000000000usize => Unsupported("cannot serialize `u64` without defined root tag"));
 
-        serde_if_integer128! {
-            err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
-            err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
-        }
+        err!(i128_: -420000000000000000000000000000i128 => Unsupported("cannot serialize `i128` without defined root tag"));
+        err!(u128_:  420000000000000000000000000000u128 => Unsupported("cannot serialize `u128` without defined root tag"));
 
         err!(f32_: 4.2f32 => Unsupported("cannot serialize `f32` without defined root tag"));
         err!(f64_: 4.2f64 => Unsupported("cannot serialize `f64` without defined root tag"));
@@ -1854,10 +1850,8 @@ mod with_root {
     serialize_as!(u64_:   42000000000000u64   => "<root>42000000000000</root>");
     serialize_as!(usize_: 42000000000000usize => "<root>42000000000000</root>");
 
-    serde_if_integer128! {
-        serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
-        serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
-    }
+    serialize_as!(i128_: -420000000000000000000000000000i128 => "<root>-420000000000000000000000000000</root>");
+    serialize_as!(u128_:  420000000000000000000000000000u128 => "<root>420000000000000000000000000000</root>");
 
     serialize_as!(f32_: 4.2f32 => "<root>4.2</root>");
     serialize_as!(f64_: 4.2f64 => "<root>4.2</root>");
diff --git a/tests/serde_helpers/mod.rs b/tests/serde_helpers/mod.rs
index 0d5143ab8..637e732bf 100644
--- a/tests/serde_helpers/mod.rs
+++ b/tests/serde_helpers/mod.rs
@@ -17,7 +17,7 @@ where
     let result = T::deserialize(&mut de);
 
     // If type was deserialized, the whole XML document should be consumed
-    if let Ok(_) = result {
+    if result.is_ok() {
         de.check_eof_reached();
     }
 
diff --git a/tests/serde_roundtrip.rs b/tests/serde_roundtrip.rs
index c14eaaf54..06bd24de1 100644
--- a/tests/serde_roundtrip.rs
+++ b/tests/serde_roundtrip.rs
@@ -6,7 +6,11 @@ use pretty_assertions::assert_eq;
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
 enum Node {
     Boolean(bool),
-    Identifier { value: String, index: u32 },
+    Identifier {
+        value: String,
+        index: u32,
+    },
+    #[allow(clippy::upper_case_acronyms)]
     EOF,
 }
 
diff --git a/tests/writer-indentation.rs b/tests/writer-indentation.rs
index baabd9678..4e23bbc68 100644
--- a/tests/writer-indentation.rs
+++ b/tests/writer-indentation.rs
@@ -9,7 +9,7 @@ fn self_closed() {
     let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
 
     let tag = BytesStart::new("self-closed")
-        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")]);
     writer
         .write_event(Event::Empty(tag))
         .expect("write tag failed");
@@ -25,8 +25,8 @@ fn empty_paired() {
     let mut buffer = Vec::new();
     let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
 
-    let start = BytesStart::new("paired")
-        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+    let start =
+        BytesStart::new("paired").with_attributes(vec![("attr1", "value1"), ("attr2", "value2")]);
     let end = start.to_end();
     writer
         .write_event(Event::Start(start.clone()))
@@ -47,8 +47,8 @@ fn paired_with_inner() {
     let mut buffer = Vec::new();
     let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
 
-    let start = BytesStart::new("paired")
-        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+    let start =
+        BytesStart::new("paired").with_attributes(vec![("attr1", "value1"), ("attr2", "value2")]);
     let end = start.to_end();
     let inner = BytesStart::new("inner");
 
@@ -75,8 +75,8 @@ fn paired_with_text() {
     let mut buffer = Vec::new();
     let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
 
-    let start = BytesStart::new("paired")
-        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+    let start =
+        BytesStart::new("paired").with_attributes(vec![("attr1", "value1"), ("attr2", "value2")]);
     let end = start.to_end();
     let text = BytesText::new("text");
 
@@ -101,8 +101,8 @@ fn mixed_content() {
     let mut buffer = Vec::new();
     let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
 
-    let start = BytesStart::new("paired")
-        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+    let start =
+        BytesStart::new("paired").with_attributes(vec![("attr1", "value1"), ("attr2", "value2")]);
     let end = start.to_end();
     let text = BytesText::new("text");
     let inner = BytesStart::new("inner");
@@ -132,8 +132,8 @@ fn nested() {
     let mut buffer = Vec::new();
     let mut writer = Writer::new_with_indent(&mut buffer, b' ', 4);
 
-    let start = BytesStart::new("paired")
-        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+    let start =
+        BytesStart::new("paired").with_attributes(vec![("attr1", "value1"), ("attr2", "value2")]);
     let end = start.to_end();
     let inner = BytesStart::new("inner");
 
@@ -199,8 +199,8 @@ fn serializable() {
         val: "foo".to_owned(),
     };
 
-    let start = BytesStart::new("paired")
-        .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
+    let start =
+        BytesStart::new("paired").with_attributes(vec![("attr1", "value1"), ("attr2", "value2")]);
     let end = start.to_end();
 
     writer

From 7e04a1a5e80442e49a235d3660339bd653e6714c Mon Sep 17 00:00:00 2001
From: Daniel Gallups <dsgallups@protonmail.com>
Date: Fri, 26 Sep 2025 12:17:35 -0400
Subject: [PATCH 3/4] chore: format

---
 src/name.rs   | 4 +++-
 src/writer.rs | 3 ++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/name.rs b/src/name.rs
index 3f47390f5..b6f66eff4 100644
--- a/src/name.rs
+++ b/src/name.rs
@@ -662,7 +662,9 @@ impl NamespaceResolver {
         // (default namespace) attribute.
         for a in start.attributes().with_checks(false) {
             if let Ok(Attribute { key: k, value: v }) = a {
-                if let Some(prefix) = k.as_namespace_binding() { self.add(prefix, Namespace(&v))? }
+                if let Some(prefix) = k.as_namespace_binding() {
+                    self.add(prefix, Namespace(&v))?
+                }
             } else {
                 break;
             }
diff --git a/src/writer.rs b/src/writer.rs
index 62437cc77..770a7585d 100644
--- a/src/writer.rs
+++ b/src/writer.rs
@@ -233,7 +233,8 @@ impl<W: Write> Writer<W> {
     /// Writes bytes
     #[inline]
     pub(crate) fn write(&mut self, value: &[u8]) -> io::Result<()> {
-        self.writer.write_all(value)}
+        self.writer.write_all(value)
+    }
 
     #[inline]
     fn write_wrapped(&mut self, before: &[u8], value: &[u8], after: &[u8]) -> io::Result<()> {

From a2eda8d84a34db615de89ffbdc1f12af9913d9a7 Mon Sep 17 00:00:00 2001
From: dsgallups <dsgallups@protonmail.com>
Date: Mon, 29 Sep 2025 09:33:15 -0400
Subject: [PATCH 4/4] fix: readd lost comment

---
 src/de/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/de/mod.rs b/src/de/mod.rs
index 589e7f993..1d23a23b1 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -2812,6 +2812,7 @@ where
     fn skip(&mut self) -> Result<(), DeError> {
         let event = self.next()?;
         self.skip_event(event)?;
+        // Skip all subtree, if we skip a start event
         if let Some(DeEvent::Start(e)) = self.write.back() {
             let end = e.name().as_ref().to_owned();
             let mut depth = 0;