Clean up all usage of serde_if_integer128

serde/src/de/ignored_any.rs

@@ -129,13 +129,11 @@ impl<'de> Visitor<'de> for IgnoredAny {
         Ok(IgnoredAny)
     }
 
-    serde_if_integer128! {
     #[inline]
     fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
         let _ = x;
         Ok(IgnoredAny)
     }
-    }
 
     #[inline]
     fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
@@ -143,13 +141,11 @@ impl<'de> Visitor<'de> for IgnoredAny {
         Ok(IgnoredAny)
     }
 
-    serde_if_integer128! {
     #[inline]
     fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
         let _ = x;
         Ok(IgnoredAny)
     }
-    }
 
     #[inline]
     fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {

serde/src/de/impls.rs

@@ -364,8 +364,7 @@ impl_deserialize_num! {
     num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
 }
 
-serde_if_integer128! {
+macro_rules! num_128 {
-    macro_rules! num_128 {
     ($ty:ident : $visit:ident) => {
         fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
         where
@@ -405,23 +404,22 @@ serde_if_integer128! {
             }
         }
     };
-    }
+}
 
-    impl_deserialize_num! {
+impl_deserialize_num! {
     i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128
     num_self!(i128:visit_i128);
     num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
     num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
     num_128!(u128:visit_u128);
-    }
+}
 
-    impl_deserialize_num! {
+impl_deserialize_num! {
     u128, NonZeroU128, deserialize_u128
     num_self!(u128:visit_u128);
     num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
     int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
     num_128!(i128:visit_i128);
-    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////

serde/src/de/mod.rs

@@ -948,19 +948,16 @@ pub trait Deserializer<'de>: Sized {
     where
         V: Visitor<'de>;
 
-    serde_if_integer128! {
     /// Hint that the `Deserialize` type is expecting an `i128` value.
     ///
-        /// This method is available only on Rust compiler versions >=1.26. The
+    /// The default behavior unconditionally returns an error.
-        /// default behavior unconditionally returns an error.
     fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
-            V: Visitor<'de>
+        V: Visitor<'de>,
     {
         let _ = visitor;
         Err(Error::custom("i128 is not supported"))
     }
-    }
 
     /// Hint that the `Deserialize` type is expecting a `u8` value.
     fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -982,19 +979,16 @@ pub trait Deserializer<'de>: Sized {
     where
         V: Visitor<'de>;
 
-    serde_if_integer128! {
     /// Hint that the `Deserialize` type is expecting an `u128` value.
     ///
-        /// This method is available only on Rust compiler versions >=1.26. The
+    /// The default behavior unconditionally returns an error.
-        /// default behavior unconditionally returns an error.
     fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
-            V: Visitor<'de>
+        V: Visitor<'de>,
     {
         let _ = visitor;
         Err(Error::custom("u128 is not supported"))
     }
-    }
 
     /// Hint that the `Deserialize` type is expecting a `f32` value.
     fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -1365,11 +1359,9 @@ pub trait Visitor<'de>: Sized {
         Err(Error::invalid_type(Unexpected::Signed(v), &self))
     }
 
-    serde_if_integer128! {
     /// The input contains a `i128`.
     ///
-        /// This method is available only on Rust compiler versions >=1.26. The
+    /// The default implementation fails with a type error.
-        /// default implementation fails with a type error.
     fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
     where
         E: Error,
@@ -1377,8 +1369,10 @@ pub trait Visitor<'de>: Sized {
         let mut buf = [0u8; 58];
         let mut writer = format::Buf::new(&mut buf);
         fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
-            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
+        Err(Error::invalid_type(
-        }
+            Unexpected::Other(writer.as_str()),
+            &self,
+        ))
     }
 
     /// The input contains a `u8`.
@@ -1427,11 +1421,9 @@ pub trait Visitor<'de>: Sized {
         Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
     }
 
-    serde_if_integer128! {
     /// The input contains a `u128`.
     ///
-        /// This method is available only on Rust compiler versions >=1.26. The
+    /// The default implementation fails with a type error.
-        /// default implementation fails with a type error.
     fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
     where
         E: Error,
@@ -1439,8 +1431,10 @@ pub trait Visitor<'de>: Sized {
         let mut buf = [0u8; 57];
         let mut writer = format::Buf::new(&mut buf);
         fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
-            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
+        Err(Error::invalid_type(
-        }
+            Unexpected::Other(writer.as_str()),
+            &self,
+        ))
     }
 
     /// The input contains an `f32`.

serde/src/de/value.rs

@@ -292,20 +292,17 @@ primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
 primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
 primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
 primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
+primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
 primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
 primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
 primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
 primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
+primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
 primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
 primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
 primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
 primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
 
-serde_if_integer128! {
-    primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
-    primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
-}
-
 /// A deserializer holding a `u32`.
 pub struct U32Deserializer<E> {
     value: u32,

serde/src/macros.rs

@@ -154,9 +154,7 @@ macro_rules! forward_to_deserialize_any_helper {
         forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
     };
     (i128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
         forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
-        }
     };
     (u8<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
@@ -171,9 +169,7 @@ macro_rules! forward_to_deserialize_any_helper {
         forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
     };
     (u128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
         forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
-        }
     };
     (f32<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}

serde/src/ser/fmt.rs

@@ -52,10 +52,12 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         serialize_i16: i16,
         serialize_i32: i32,
         serialize_i64: i64,
+        serialize_i128: i128,
         serialize_u8: u8,
         serialize_u16: u16,
         serialize_u32: u32,
         serialize_u64: u64,
+        serialize_u128: u128,
         serialize_f32: f32,
         serialize_f64: f64,
         serialize_char: char,
@@ -63,13 +65,6 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         serialize_unit_struct: &'static str,
     }
 
-    serde_if_integer128! {
-        fmt_primitives! {
-            serialize_i128: i128,
-            serialize_u128: u128,
-        }
-    }
-
     fn serialize_unit_variant(
         self,
         _name: &'static str,

serde/src/ser/impls.rs

@@ -24,20 +24,17 @@ primitive_impl!(i8, serialize_i8);
 primitive_impl!(i16, serialize_i16);
 primitive_impl!(i32, serialize_i32);
 primitive_impl!(i64, serialize_i64);
+primitive_impl!(i128, serialize_i128);
 primitive_impl!(usize, serialize_u64 as u64);
 primitive_impl!(u8, serialize_u8);
 primitive_impl!(u16, serialize_u16);
 primitive_impl!(u32, serialize_u32);
 primitive_impl!(u64, serialize_u64);
+primitive_impl!(u128, serialize_u128);
 primitive_impl!(f32, serialize_f32);
 primitive_impl!(f64, serialize_f64);
 primitive_impl!(char, serialize_char);
 
-serde_if_integer128! {
-    primitive_impl!(i128, serialize_i128);
-    primitive_impl!(u128, serialize_u128);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 impl Serialize for str {
@@ -553,6 +550,7 @@ nonzero_integers! {
     NonZeroU16,
     NonZeroU32,
     NonZeroU64,
+    NonZeroU128,
     NonZeroUsize,
 }
 
@@ -562,20 +560,8 @@ nonzero_integers! {
     NonZeroI16,
     NonZeroI32,
     NonZeroI64,
-    NonZeroIsize,
-}
-
-// Currently 128-bit integers do not work on Emscripten targets so we need an
-// additional `#[cfg]`
-serde_if_integer128! {
-    nonzero_integers! {
-        NonZeroU128,
-    }
-
-    #[cfg(not(no_num_nonzero_signed))]
-    nonzero_integers! {
     NonZeroI128,
-    }
+    NonZeroIsize,
 }
 
 impl<T> Serialize for Cell<T>

serde/src/ser/mod.rs

@@ -488,7 +488,6 @@ pub trait Serializer: Sized {
     /// ```
     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
 
-    serde_if_integer128! {
     /// Serialize an `i128` value.
     ///
     /// ```edition2021
@@ -506,13 +505,11 @@ pub trait Serializer: Sized {
     /// }
     /// ```
     ///
-        /// This method is available only on Rust compiler versions >=1.26. The
+    /// The default behavior unconditionally returns an error.
-        /// default behavior unconditionally returns an error.
     fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
         let _ = v;
         Err(Error::custom("i128 is not supported"))
     }
-    }
 
     /// Serialize a `u8` value.
     ///
@@ -598,7 +595,6 @@ pub trait Serializer: Sized {
     /// ```
     fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
 
-    serde_if_integer128! {
     /// Serialize a `u128` value.
     ///
     /// ```edition2021
@@ -616,13 +612,11 @@ pub trait Serializer: Sized {
     /// }
     /// ```
     ///
-        /// This method is available only on Rust compiler versions >=1.26. The
+    /// The default behavior unconditionally returns an error.
-        /// default behavior unconditionally returns an error.
     fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
         let _ = v;
         Err(Error::custom("u128 is not supported"))
     }
-    }
 
     /// Serialize an `f32` value.
     ///