Deserialize u128 and i128 as numbers

Author: chipshort

src/de/map.rs

@@ -160,8 +160,7 @@ impl<'de, 'a> de::Deserializer<'de> for MapKey<'a, 'de> {
     where
         V: Visitor<'de>,
     {
-        // default implementation includes string unparsing
-        self.de.deserialize_i128(visitor)
+        deserialize_signed_key!(self, visitor, i128, visit_i128)
     }
 
     fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -196,7 +195,7 @@ impl<'de, 'a> de::Deserializer<'de> for MapKey<'a, 'de> {
     where
         V: Visitor<'de>,
     {
-        self.de.deserialize_u128(visitor)
+        deserialize_unsigned_key!(self, visitor, u128, visit_u128)
     }
 
     fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>

src/de/mod.rs

@@ -358,25 +358,7 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.parse_whitespace().ok_or(Error::EofWhileParsingValue)? {
-            b'"' => self.eat_char(),
-            _ => return Err(Error::InvalidType),
-        };
-
-        let result = match self.peek() {
-            // after rust merged or-patterns feature, these two clause can be merged.
-            // error[E0658]: or-patterns syntax is experimental
-            Some(b'0'..=b'9') => deserialize_signed!(self, visitor, i128, visit_i128),
-            Some(b'-') => deserialize_signed!(self, visitor, i128, visit_i128),
-            _ => return Err(Error::InvalidType),
-        };
-        match self.peek() {
-            Some(b'"') => {
-                self.eat_char();
-                result
-            }
-            _ => Err(Error::InvalidType),
-        }
+        deserialize_signed!(self, visitor, i128, visit_i128)
     }
 
     fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
@@ -411,25 +393,7 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.parse_whitespace().ok_or(Error::EofWhileParsingValue)? {
-            b'"' => {
-                self.eat_char();
-            }
-            _ => return Err(Error::InvalidType),
-        };
-
-        let result = match self.peek() {
-            Some(b'-') => return Err(Error::InvalidNumber),
-            Some(b'0'..=b'9') => deserialize_unsigned!(self, visitor, u128, visit_u128),
-            _ => return Err(Error::InvalidType),
-        };
-        match self.peek() {
-            Some(b'"') => {
-                self.eat_char();
-                result
-            }
-            _ => Err(Error::InvalidType),
-        }
+        deserialize_unsigned!(self, visitor, u128, visit_u128)
     }
 
     fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
@@ -755,43 +719,49 @@ mod tests {
 
     #[test]
     fn integer128() {
-        assert_eq!(from_str::<i128>(r#"0"#), Err(crate::de::Error::InvalidType));
-        assert_eq!(from_str::<i128>(r#""0""#), Ok(0));
-        assert_eq!(from_str::<i128>(r#""1""#), Ok(1));
-        assert_eq!(from_str::<i128>(r#""-1""#), Ok(-1));
+        assert_eq!(
+            from_str::<i128>(r#""0""#),
+            Err(crate::de::Error::InvalidType)
+        );
+        assert_eq!(from_str::<i128>(r#"0"#), Ok(0));
+        assert_eq!(from_str::<i128>(r#"1"#), Ok(1));
+        assert_eq!(from_str::<i128>(r#"-1"#), Ok(-1));
         // max i128
         assert_eq!(
-            from_str::<i128>(r#""170141183460469231731687303715884105727""#),
+            from_str::<i128>(r#"170141183460469231731687303715884105727"#),
             Ok(170141183460469231731687303715884105727)
         );
         assert_eq!(
-            from_str::<i128>(r#""170141183460469231731687303715884105728""#),
+            from_str::<i128>(r#"170141183460469231731687303715884105728"#),
             Err(crate::de::Error::InvalidNumber)
         );
         // min i128
         assert_eq!(
-            from_str::<i128>(r#""-170141183460469231731687303715884105728""#),
+            from_str::<i128>(r#"-170141183460469231731687303715884105728"#),
             Ok(-170141183460469231731687303715884105728)
         );
         assert_eq!(
-            from_str::<i128>(r#""-170141183460469231731687303715884105729""#),
+            from_str::<i128>(r#"-170141183460469231731687303715884105729"#),
             Err(crate::de::Error::InvalidNumber)
         );
 
-        assert_eq!(from_str::<u128>(r#"0"#), Err(crate::de::Error::InvalidType));
-        assert_eq!(from_str::<u128>(r#""0""#), Ok(0));
-        assert_eq!(from_str::<u128>(r#""1""#), Ok(1));
         assert_eq!(
-            from_str::<u128>(r#""-1""#),
+            from_str::<u128>(r#""0""#),
+            Err(crate::de::Error::InvalidType)
+        );
+        assert_eq!(from_str::<u128>(r#"0"#), Ok(0));
+        assert_eq!(from_str::<u128>(r#"1"#), Ok(1));
+        assert_eq!(
+            from_str::<u128>(r#"-1"#),
             Err(crate::de::Error::InvalidNumber)
         );
         // max u128
         assert_eq!(
-            from_str::<u128>(r#""340282366920938463463374607431768211455""#),
+            from_str::<u128>(r#"340282366920938463463374607431768211455"#),
             Ok(340282366920938463463374607431768211455)
         );
         assert_eq!(
-            from_str::<u128>(r#""340282366920938463463374607431768211456""#),
+            from_str::<u128>(r#"340282366920938463463374607431768211456"#),
             Err(crate::de::Error::InvalidNumber)
         )
     }