Merge pull request #908 from Mingun/remove-serde_if_integer128

Remove usage of deprecated serde_if_integer128 and bump serde dependecy

Author: Mingun

Cargo.toml

@@ -22,7 +22,9 @@ include = ["src/*", "LICENSE-MIT.md", "README.md"]
 arbitrary = { version = "1", features = ["derive"], optional = true }
 document-features = { version = "0.2", optional = true }
 encoding_rs = { version = "0.8", optional = true }
-serde = { version = ">=1.0.139", optional = true }
+# 1.0.180 is the first version that requires compiler with integer128 support (1.26)
+# Because serde_if_integer128 is deprecated since 1.0.221, we do not use it anymore
+serde = { version = ">=1.0.180", optional = true }
 tokio = { version = "1.10", optional = true, default-features = false, features = ["io-util"] }
 memchr = "2.1"
 

Changelog.md

@@ -20,6 +20,10 @@
 
 ### Misc Changes
 
+- [#908]: Increase minimal supported `serde` version from 1.0.139 to 1.0.180.
+
+[#908]: https://github.com/tafia/quick-xml/pull/908
+
 
 ## 0.38.4 -- 2025-11-??
 

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 {
@@ -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

@@ -14,7 +14,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

@@ -1973,10 +1973,6 @@
 //! [quick-xml#586]: https://github.com/tafia/quick-xml/issues/586
 //! [`impl_deserialize_for_internally_tagged_enum!`]: crate::impl_deserialize_for_internally_tagged_enum
 
-// 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! forward_to_simple_type {
     ($deserialize:ident, $($mut:tt)?) => {
         #[inline]
@@ -2003,10 +1999,8 @@ macro_rules! deserialize_primitives {
         forward_to_simple_type!(deserialize_u32, $($mut)?);
         forward_to_simple_type!(deserialize_u64, $($mut)?);
 
-        serde_if_integer128! {
-            forward_to_simple_type!(deserialize_i128, $($mut)?);
-            forward_to_simple_type!(deserialize_u128, $($mut)?);
-        }
+        forward_to_simple_type!(deserialize_i128, $($mut)?);
+        forward_to_simple_type!(deserialize_u128, $($mut)?);
 
         forward_to_simple_type!(deserialize_f32, $($mut)?);
         forward_to_simple_type!(deserialize_f64, $($mut)?);

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;
 
@@ -172,10 +171,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);
@@ -633,10 +630,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);
@@ -984,10 +979,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);
@@ -1182,10 +1175,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);
@@ -1272,10 +1263,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

@@ -5,7 +5,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/se/content.rs

@@ -7,7 +7,6 @@ use crate::se::{Indent, QuoteLevel, SeError, TextFormat, WriteResult, XmlName};
 use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct, Serializer,
 };
-use serde::serde_if_integer128;
 use std::fmt::Write;
 
 macro_rules! write_primitive {
@@ -202,10 +201,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));
@@ -665,10 +662,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000usize       => "42000000", 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);
@@ -800,10 +795,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000usize       => "42000000");
 
-            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");
@@ -925,10 +918,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000usize       => "42000000");
 
-            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");
@@ -1136,10 +1127,8 @@ pub(super) mod tests {
         serialize_as!(u64_:   42000000000000u64   => "42000000000000", Text);
         serialize_as!(usize_: 42000000usize       => "42000000", 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);
@@ -1264,10 +1253,8 @@ pub(super) mod tests {
             text!(u64_:   42000000000000u64   => "42000000000000");
             text!(usize_: 42000000usize       => "42000000");
 
-            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");
@@ -1389,10 +1376,8 @@ pub(super) mod tests {
             value!(u64_:   42000000000000u64   => "42000000000000");
             value!(usize_: 42000000usize => "42000000");
 
-            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");