Merge pull request #1965 from serde-rs/int

Reduce post-macro-expansion code in integer deserialize impls

serde/src/de/from_primitive.rs

@@ -1,260 +0,0 @@
-use lib::*;
-
-macro_rules! int_to_int {
-    ($dst:ident, $n:ident) => {
-        if $dst::min_value() as i64 <= $n as i64 && $n as i64 <= $dst::max_value() as i64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-macro_rules! int_to_uint {
-    ($dst:ident, $n:ident) => {
-        if 0 <= $n && $n as u64 <= $dst::max_value() as u64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-macro_rules! uint_to {
-    ($dst:ident, $n:ident) => {
-        if $n as u64 <= $dst::max_value() as u64 {
-            Some($n as $dst)
-        } else {
-            None
-        }
-    };
-}
-
-pub trait FromPrimitive: Sized {
-    fn from_i8(n: i8) -> Option<Self>;
-    fn from_i16(n: i16) -> Option<Self>;
-    fn from_i32(n: i32) -> Option<Self>;
-    fn from_i64(n: i64) -> Option<Self>;
-    fn from_u8(n: u8) -> Option<Self>;
-    fn from_u16(n: u16) -> Option<Self>;
-    fn from_u32(n: u32) -> Option<Self>;
-    fn from_u64(n: u64) -> Option<Self>;
-}
-
-macro_rules! impl_from_primitive_for_int {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                int_to_int!($t, n)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                uint_to!($t, n)
-            }
-        }
-    };
-}
-
-macro_rules! impl_from_primitive_for_uint {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                int_to_uint!($t, n)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                uint_to!($t, n)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                uint_to!($t, n)
-            }
-        }
-    };
-}
-
-macro_rules! impl_from_primitive_for_float {
-    ($t:ident) => {
-        impl FromPrimitive for $t {
-            #[inline]
-            fn from_i8(n: i8) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i16(n: i16) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i32(n: i32) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_i64(n: i64) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u8(n: u8) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u16(n: u16) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u32(n: u32) -> Option<Self> {
-                Some(n as Self)
-            }
-            #[inline]
-            fn from_u64(n: u64) -> Option<Self> {
-                Some(n as Self)
-            }
-        }
-    };
-}
-
-impl_from_primitive_for_int!(isize);
-impl_from_primitive_for_int!(i8);
-impl_from_primitive_for_int!(i16);
-impl_from_primitive_for_int!(i32);
-impl_from_primitive_for_int!(i64);
-impl_from_primitive_for_uint!(usize);
-impl_from_primitive_for_uint!(u8);
-impl_from_primitive_for_uint!(u16);
-impl_from_primitive_for_uint!(u32);
-impl_from_primitive_for_uint!(u64);
-impl_from_primitive_for_float!(f32);
-impl_from_primitive_for_float!(f64);
-
-serde_if_integer128! {
-    impl FromPrimitive for i128 {
-        #[inline]
-        fn from_i8(n: i8) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i16(n: i16) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i32(n: i32) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_i64(n: i64) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u8(n: u8) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u16(n: u16) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u32(n: u32) -> Option<Self> {
-            Some(n as i128)
-        }
-        #[inline]
-        fn from_u64(n: u64) -> Option<Self> {
-            Some(n as i128)
-        }
-    }
-
-    impl FromPrimitive for u128 {
-        #[inline]
-        fn from_i8(n: i8) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i16(n: i16) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i32(n: i32) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_i64(n: i64) -> Option<Self> {
-            if n >= 0 {
-                Some(n as u128)
-            } else {
-                None
-            }
-        }
-        #[inline]
-        fn from_u8(n: u8) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u16(n: u16) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u32(n: u32) -> Option<Self> {
-            Some(n as u128)
-        }
-        #[inline]
-        fn from_u64(n: u64) -> Option<Self> {
-            Some(n as u128)
-        }
-    }
-}

serde/src/de/impls.rs

@@ -8,7 +8,6 @@ use de::{
 use de::MapAccess;
 
 use __private::de::InPlaceSeed;
-use de::from_primitive::FromPrimitive;
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 use __private::de::size_hint;
@@ -81,38 +80,8 @@ impl<'de> Deserialize<'de> for bool {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-macro_rules! visit_integer_method {
-    ($src_ty:ident, $method:ident, $from_method:ident, $group:ident, $group_ty:ident) => {
-        #[inline]
-        fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            match FromPrimitive::$from_method(v) {
-                Some(v) => Ok(v),
-                None => Err(Error::invalid_value(
-                    Unexpected::$group(v as $group_ty),
-                    &self,
-                )),
-            }
-        }
-    };
-}
-
-macro_rules! visit_float_method {
-    ($src_ty:ident, $method:ident) => {
-        #[inline]
-        fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(v as Self::Value)
-        }
-    };
-}
-
 macro_rules! impl_deserialize_num {
-    ($ty:ident, $method:ident, $($visit:ident),*) => {
+    ($ty:ident, $deserialize:ident $($methods:tt)*) => {
         impl<'de> Deserialize<'de> for $ty {
             #[inline]
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -128,74 +97,191 @@ macro_rules! impl_deserialize_num {
                         formatter.write_str(stringify!($ty))
                     }
 
-                    $(
+                    $($methods)*
-                        impl_deserialize_num!($visit);
-                    )*
                 }
 
-                deserializer.$method(PrimitiveVisitor)
+                deserializer.$deserialize(PrimitiveVisitor)
             }
         }
     };
-
-    (integer) => {
-        visit_integer_method!(i8, visit_i8, from_i8, Signed, i64);
-        visit_integer_method!(i16, visit_i16, from_i16, Signed, i64);
-        visit_integer_method!(i32, visit_i32, from_i32, Signed, i64);
-        visit_integer_method!(i64, visit_i64, from_i64, Signed, i64);
-
-        visit_integer_method!(u8, visit_u8, from_u8, Unsigned, u64);
-        visit_integer_method!(u16, visit_u16, from_u16, Unsigned, u64);
-        visit_integer_method!(u32, visit_u32, from_u32, Unsigned, u64);
-        visit_integer_method!(u64, visit_u64, from_u64, Unsigned, u64);
-    };
-
-    (float) => {
-        visit_float_method!(f32, visit_f32);
-        visit_float_method!(f64, visit_f64);
-    };
 }
 
-impl_deserialize_num!(i8, deserialize_i8, integer);
+macro_rules! num_self {
-impl_deserialize_num!(i16, deserialize_i16, integer);
+    ($ty:ident : $visit:ident) => {
-impl_deserialize_num!(i32, deserialize_i32, integer);
-impl_deserialize_num!(i64, deserialize_i64, integer);
-impl_deserialize_num!(isize, deserialize_i64, integer);
-
-impl_deserialize_num!(u8, deserialize_u8, integer);
-impl_deserialize_num!(u16, deserialize_u16, integer);
-impl_deserialize_num!(u32, deserialize_u32, integer);
-impl_deserialize_num!(u64, deserialize_u64, integer);
-impl_deserialize_num!(usize, deserialize_u64, integer);
-
-impl_deserialize_num!(f32, deserialize_f32, integer, float);
-impl_deserialize_num!(f64, deserialize_f64, integer, float);
-
-serde_if_integer128! {
-    impl<'de> Deserialize<'de> for i128 {
         #[inline]
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            D: Deserializer<'de>,
-        {
-            struct PrimitiveVisitor;
-
-            impl<'de> Visitor<'de> for PrimitiveVisitor {
-                type Value = i128;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("i128")
-                }
-
-                impl_deserialize_num!(integer);
-
-                #[inline]
-                fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
         where
             E: Error,
         {
             Ok(v)
         }
+    };
+}
+
+macro_rules! num_as_self {
+    ($($ty:ident : $visit:ident)*) => {
+        $(
+            #[inline]
+            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                Ok(v as Self::Value)
+            }
+        )*
+    };
+}
+
+macro_rules! int_to_int {
+    ($($ty:ident : $visit:ident)*) => {
+        $(
+            #[inline]
+            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                if Self::Value::min_value() as i64 <= v as i64 && v as i64 <= Self::Value::max_value() as i64 {
+                    Ok(v as Self::Value)
+                } else {
+                    Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! int_to_uint {
+    ($($ty:ident : $visit:ident)*) => {
+        $(
+            #[inline]
+            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                if 0 <= v && v as u64 <= Self::Value::max_value() as u64 {
+                    Ok(v as Self::Value)
+                } else {
+                    Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! uint_to_self {
+    ($($ty:ident : $visit:ident)*) => {
+        $(
+            #[inline]
+            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                if v as u64 <= Self::Value::max_value() as u64 {
+                    Ok(v as Self::Value)
+                } else {
+                    Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
+                }
+            }
+        )*
+    };
+}
+
+impl_deserialize_num! {
+    i8, deserialize_i8
+    num_self!(i8:visit_i8);
+    int_to_int!(i16:visit_i16 i32:visit_i32 i64:visit_i64);
+    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    i16, deserialize_i16
+    num_self!(i16:visit_i16);
+    num_as_self!(i8:visit_i8);
+    int_to_int!(i32:visit_i32 i64:visit_i64);
+    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    i32, deserialize_i32
+    num_self!(i32:visit_i32);
+    num_as_self!(i8:visit_i8 i16:visit_i16);
+    int_to_int!(i64:visit_i64);
+    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    i64, deserialize_i64
+    num_self!(i64:visit_i64);
+    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32);
+    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    isize, deserialize_i64
+    num_as_self!(i8:visit_i8 i16:visit_i16);
+    int_to_int!(i32:visit_i32 i64:visit_i64);
+    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    u8, deserialize_u8
+    num_self!(u8:visit_u8);
+    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+    uint_to_self!(u16:visit_u16 u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    u16, deserialize_u16
+    num_self!(u16:visit_u16);
+    num_as_self!(u8:visit_u8);
+    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+    uint_to_self!(u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    u32, deserialize_u32
+    num_self!(u32:visit_u32);
+    num_as_self!(u8:visit_u8 u16:visit_u16);
+    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+    uint_to_self!(u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    u64, deserialize_u64
+    num_self!(u64:visit_u64);
+    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32);
+    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+}
+
+impl_deserialize_num! {
+    usize, deserialize_u64
+    num_as_self!(u8:visit_u8 u16:visit_u16);
+    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+    uint_to_self!(u32:visit_u32 u64:visit_u64);
+}
+
+impl_deserialize_num! {
+    f32, deserialize_f32
+    num_self!(f32:visit_f32);
+    num_as_self!(f64:visit_f64);
+    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);
+}
+
+impl_deserialize_num! {
+    f64, deserialize_f64
+    num_self!(f64:visit_f64);
+    num_as_self!(f32:visit_f32);
+    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);
+}
+
+serde_if_integer128! {
+    impl_deserialize_num! {
+        i128, 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);
 
         #[inline]
         fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
@@ -210,50 +296,23 @@ serde_if_integer128! {
         }
     }
 
-            deserializer.deserialize_i128(PrimitiveVisitor)
+    impl_deserialize_num! {
-        }
+        u128, deserialize_u128
-    }
+        num_self!(u128:visit_u128);
-
+        num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-    impl<'de> Deserialize<'de> for u128 {
+        int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-        #[inline]
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct PrimitiveVisitor;
-
-            impl<'de> Visitor<'de> for PrimitiveVisitor {
-                type Value = u128;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("u128")
-                }
-
-                impl_deserialize_num!(integer);
 
         #[inline]
         fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
         where
             E: Error,
         {
-                    if v >= 0 {
+            if 0 <= v {
                 Ok(v as u128)
             } else {
                 Err(Error::invalid_value(Unexpected::Other("i128"), &self))
             }
         }
-
-                #[inline]
-                fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    Ok(v)
-                }
-            }
-
-            deserializer.deserialize_u128(PrimitiveVisitor)
-        }
     }
 }
 

serde/src/de/mod.rs

@@ -118,7 +118,6 @@ use lib::*;
 
 pub mod value;
 
-mod from_primitive;
 mod ignored_any;
 mod impls;
 mod utf8;