Merge pull request #2600 from dtolnay/oldemscripten

Remove support for emscripten targets on rustc older than 1.40

serde/build.rs

@@ -27,13 +27,6 @@ fn main() {
         println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
     }
 
-    // Disabled on Emscripten targets before Rust 1.40 since
-    // Emscripten did not support 128-bit integers until Rust 1.40
-    // (https://github.com/rust-lang/rust/pull/65251)
-    if emscripten && minor < 40 {
-        println!("cargo:rustc-cfg=no_integer128");
-    }
-
     // Current minimum supported version of serde_derive crate is Rust 1.56.
     if minor < 56 {
         println!("cargo:rustc-cfg=no_serde_derive");

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,7 +364,6 @@ 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 {
     ($ty:ident : $visit:ident) => {
         fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
@@ -422,7 +421,6 @@ serde_if_integer128! {
     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

@@ -118,7 +118,6 @@ use crate::lib::*;
 
 pub mod value;
 
-#[cfg(not(no_integer128))]
 mod format;
 mod ignored_any;
 mod impls;
@@ -949,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>
@@ -983,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>
@@ -1366,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,
@@ -1378,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`.
@@ -1428,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,
@@ -1440,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/integer128.rs

@@ -1,82 +1,9 @@
-/// Conditional compilation depending on whether Serde is built with support for
+// No longer used. Old versions of serde used this macro for supporting targets
-/// 128-bit integers.
+// that did not yet have 128-bit integer support.
-///
-/// Data formats that wish to support Rust compiler versions older than 1.26
-/// (or targets that lack 128-bit integers) may place the i128 / u128 methods
-/// of their Serializer and Deserializer behind this macro.
-///
-/// Data formats that require a minimum Rust compiler version of at least 1.26,
-/// or do not target platforms that lack 128-bit integers, do not need to
-/// bother with this macro and may assume support for 128-bit integers.
-///
-/// ```edition2021
-/// # use serde::__private::doc::Error;
-/// #
-/// # struct MySerializer;
-/// #
-/// use serde::{serde_if_integer128, Serializer};
-///
-/// impl Serializer for MySerializer {
-///     type Ok = ();
-///     type Error = Error;
-///
-///     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
-///         /* ... */
-/// #         unimplemented!()
-///     }
-///
-///     /* ... */
-///
-///     serde_if_integer128! {
-///         fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///
-///         fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///     }
-/// #
-/// #     serde::__serialize_unimplemented! {
-/// #         bool i8 i16 i32 u8 u16 u32 u64 f32 f64 char str bytes none some
-/// #         unit unit_struct unit_variant newtype_struct newtype_variant seq
-/// #         tuple tuple_struct tuple_variant map struct struct_variant
-/// #     }
-/// }
-/// ```
-///
-/// When Serde is built with support for 128-bit integers, this macro expands
-/// transparently into just the input tokens.
-///
-/// ```edition2021
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {
-///         $($tt)*
-///     };
-/// }
-/// ```
-///
-/// When built without support for 128-bit integers, this macro expands to
-/// nothing.
-///
-/// ```edition2021
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {};
-/// }
-/// ```
-#[cfg(not(no_integer128))]
 #[macro_export]
+#[doc(hidden)]
 macro_rules! serde_if_integer128 {
     ($($tt:tt)*) => {
         $($tt)*
     };
 }
-
-#[cfg(no_integer128)]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! serde_if_integer128 {
-    ($($tt:tt)*) => {};
-}

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.
     ///