Drop use of serde::serde_if_integer128!

Author: paolobarbolini

src/deserializer.rs

@@ -7,7 +7,6 @@ use serde::{
         Error as SerdeError, IntoDeserializer, MapAccess, SeqAccess,
         Unexpected, VariantAccess, Visitor,
     },
-    serde_if_integer128,
 };
 
 use crate::{
@@ -206,22 +205,18 @@ impl<'r> DeRecord<'r> for DeStringRecord<'r> {
     ) -> Result<V::Value, DeserializeError> {
         let x = self.next_field()?;
         if x == "true" {
-            return visitor.visit_bool(true);
+            visitor.visit_bool(true)
         } else if x == "false" {
-            return visitor.visit_bool(false);
+            visitor.visit_bool(false)
         } else if let Some(n) = try_positive_integer64(x) {
-            return visitor.visit_u64(n);
+            visitor.visit_u64(n)
         } else if let Some(n) = try_negative_integer64(x) {
-            return visitor.visit_i64(n);
-        }
-        serde_if_integer128! {
-            if let Some(n) = try_positive_integer128(x) {
-                return visitor.visit_u128(n);
-            } else if let Some(n) = try_negative_integer128(x) {
-                return visitor.visit_i128(n);
-            }
-        }
-        if let Some(n) = try_float(x) {
+            visitor.visit_i64(n)
+        } else if let Some(n) = try_positive_integer128(x) {
+            visitor.visit_u128(n)
+        } else if let Some(n) = try_negative_integer128(x) {
+            visitor.visit_i128(n)
+        } else if let Some(n) = try_float(x) {
             visitor.visit_f64(n)
         } else {
             visitor.visit_str(x)
@@ -297,22 +292,18 @@ impl<'r> DeRecord<'r> for DeByteRecord<'r> {
     ) -> Result<V::Value, DeserializeError> {
         let x = self.next_field_bytes()?;
         if x == b"true" {
-            return visitor.visit_bool(true);
+            visitor.visit_bool(true)
         } else if x == b"false" {
-            return visitor.visit_bool(false);
+            visitor.visit_bool(false)
         } else if let Some(n) = try_positive_integer64_bytes(x) {
-            return visitor.visit_u64(n);
+            visitor.visit_u64(n)
         } else if let Some(n) = try_negative_integer64_bytes(x) {
-            return visitor.visit_i64(n);
-        }
-        serde_if_integer128! {
-            if let Some(n) = try_positive_integer128_bytes(x) {
-                return visitor.visit_u128(n);
-            } else if let Some(n) = try_negative_integer128_bytes(x) {
-                return visitor.visit_i128(n);
-            }
-        }
-        if let Some(n) = try_float_bytes(x) {
+            visitor.visit_i64(n)
+        } else if let Some(n) = try_positive_integer128_bytes(x) {
+            visitor.visit_u128(n)
+        } else if let Some(n) = try_negative_integer128_bytes(x) {
+            visitor.visit_i128(n)
+        } else if let Some(n) = try_float_bytes(x) {
             visitor.visit_f64(n)
         } else if let Ok(s) = str::from_utf8(x) {
             visitor.visit_str(s)
@@ -366,16 +357,12 @@ impl<'a, 'de: 'a, T: DeRecord<'de>> Deserializer<'de>
     deserialize_int!(deserialize_u16, visit_u16, u16);
     deserialize_int!(deserialize_u32, visit_u32, u32);
     deserialize_int!(deserialize_u64, visit_u64, u64);
-    serde_if_integer128! {
-        deserialize_int!(deserialize_u128, visit_u128, u128);
-    }
+    deserialize_int!(deserialize_u128, visit_u128, u128);
     deserialize_int!(deserialize_i8, visit_i8, i8);
     deserialize_int!(deserialize_i16, visit_i16, i16);
     deserialize_int!(deserialize_i32, visit_i32, i32);
     deserialize_int!(deserialize_i64, visit_i64, i64);
-    serde_if_integer128! {
-        deserialize_int!(deserialize_i128, visit_i128, i128);
-    }
+    deserialize_int!(deserialize_i128, visit_i128, i128);
 
     fn deserialize_f32<V: Visitor<'de>>(
         self,
@@ -747,14 +734,12 @@ impl DeserializeErrorKind {
     }
 }
 
-serde_if_integer128! {
-    fn try_positive_integer128(s: &str) -> Option<u128> {
-        s.parse().ok()
-    }
+fn try_positive_integer128(s: &str) -> Option<u128> {
+    s.parse().ok()
+}
 
-    fn try_negative_integer128(s: &str) -> Option<i128> {
-        s.parse().ok()
-    }
+fn try_negative_integer128(s: &str) -> Option<i128> {
+    s.parse().ok()
 }
 
 fn try_positive_integer64(s: &str) -> Option<u64> {
@@ -777,14 +762,12 @@ fn try_negative_integer64_bytes(s: &[u8]) -> Option<i64> {
     str::from_utf8(s).ok().and_then(|s| s.parse().ok())
 }
 
-serde_if_integer128! {
-    fn try_positive_integer128_bytes(s: &[u8]) -> Option<u128> {
-        str::from_utf8(s).ok().and_then(|s| s.parse().ok())
-    }
+fn try_positive_integer128_bytes(s: &[u8]) -> Option<u128> {
+    str::from_utf8(s).ok().and_then(|s| s.parse().ok())
+}
 
-    fn try_negative_integer128_bytes(s: &[u8]) -> Option<i128> {
-        str::from_utf8(s).ok().and_then(|s| s.parse().ok())
-    }
+fn try_negative_integer128_bytes(s: &[u8]) -> Option<i128> {
+    str::from_utf8(s).ok().and_then(|s| s.parse().ok())
 }
 
 fn try_float_bytes(s: &[u8]) -> Option<f64> {
@@ -797,7 +780,7 @@ mod tests {
 
     use {
         bstr::BString,
-        serde::{de::DeserializeOwned, serde_if_integer128, Deserialize},
+        serde::{de::DeserializeOwned, Deserialize},
     };
 
     use crate::{
@@ -946,12 +929,10 @@ mod tests {
         assert_eq!(got, 42);
     }
 
-    serde_if_integer128! {
-        #[test]
-        fn one_field_128() {
-            let got: i128 = de(&["2010223372036854775808"]).unwrap();
-            assert_eq!(got, 2010223372036854775808);
-        }
+    #[test]
+    fn one_field_128() {
+        let got: i128 = de(&["2010223372036854775808"]).unwrap();
+        assert_eq!(got, 2010223372036854775808);
     }
 
     #[test]

src/serializer.rs

@@ -1,12 +1,9 @@
 use std::{fmt, io, mem};
 
-use serde::{
-    ser::{
-        Error as SerdeError, Serialize, SerializeMap, SerializeSeq,
-        SerializeStruct, SerializeStructVariant, SerializeTuple,
-        SerializeTupleStruct, SerializeTupleVariant, Serializer,
-    },
-    serde_if_integer128,
+use serde::ser::{
+    Error as SerdeError, Serialize, SerializeMap, SerializeSeq,
+    SerializeStruct, SerializeStructVariant, SerializeTuple,
+    SerializeTupleStruct, SerializeTupleVariant, Serializer,
 };
 
 use crate::{
@@ -66,11 +63,9 @@ impl<'a, 'w, W: io::Write> Serializer for &'a mut SeRecord<'w, W> {
         self.wtr.write_field(buffer.format(v))
     }
 
-    serde_if_integer128! {
-        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-            let mut buffer = itoa::Buffer::new();
-            self.wtr.write_field(buffer.format(v))
-        }
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+        let mut buffer = itoa::Buffer::new();
+        self.wtr.write_field(buffer.format(v))
     }
 
     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
@@ -93,11 +88,9 @@ impl<'a, 'w, W: io::Write> Serializer for &'a mut SeRecord<'w, W> {
         self.wtr.write_field(buffer.format(v))
     }
 
-    serde_if_integer128! {
-        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-            let mut buffer = itoa::Buffer::new();
-            self.wtr.write_field(buffer.format(v))
-        }
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+        let mut buffer = itoa::Buffer::new();
+        self.wtr.write_field(buffer.format(v))
     }
 
     fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
@@ -524,10 +517,8 @@ impl<'a, 'w, W: io::Write> Serializer for &'a mut SeHeader<'w, W> {
         self.handle_scalar(v)
     }
 
-    serde_if_integer128! {
-        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-            self.handle_scalar(v)
-        }
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+        self.handle_scalar(v)
     }
 
     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
@@ -546,10 +537,8 @@ impl<'a, 'w, W: io::Write> Serializer for &'a mut SeHeader<'w, W> {
         self.handle_scalar(v)
     }
 
-    serde_if_integer128! {
-        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-            self.handle_scalar(v)
-        }
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+        self.handle_scalar(v)
     }
 
     fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
@@ -820,10 +809,7 @@ impl<'a, 'w, W: io::Write> SerializeStructVariant for &'a mut SeHeader<'w, W> {
 
 #[cfg(test)]
 mod tests {
-    use {
-        bstr::ByteSlice,
-        serde::{serde_if_integer128, Serialize},
-    };
+    use {bstr::ByteSlice, serde::Serialize};
 
     use crate::{
         error::{Error, ErrorKind},
@@ -879,24 +865,22 @@ mod tests {
         assert_eq!(got, "");
     }
 
-    serde_if_integer128! {
-        #[test]
-        fn integer_u128() {
-            let got = serialize(i128::max_value() as u128 + 1);
-            assert_eq!(got, "170141183460469231731687303715884105728\n");
-            let (wrote, got) = serialize_header(12345);
-            assert!(!wrote);
-            assert_eq!(got, "");
-        }
+    #[test]
+    fn integer_u128() {
+        let got = serialize(i128::max_value() as u128 + 1);
+        assert_eq!(got, "170141183460469231731687303715884105728\n");
+        let (wrote, got) = serialize_header(12345);
+        assert!(!wrote);
+        assert_eq!(got, "");
+    }
 
-        #[test]
-        fn integer_i128() {
-            let got = serialize(i128::max_value());
-            assert_eq!(got, "170141183460469231731687303715884105727\n");
-            let (wrote, got) = serialize_header(12345);
-            assert!(!wrote);
-            assert_eq!(got, "");
-        }
+    #[test]
+    fn integer_i128() {
+        let got = serialize(i128::max_value());
+        assert_eq!(got, "170141183460469231731687303715884105727\n");
+        let (wrote, got) = serialize_header(12345);
+        assert!(!wrote);
+        assert_eq!(got, "");
     }
 
     #[test]
@@ -1146,23 +1130,21 @@ mod tests {
         assert_eq!(got, "true,5,hi\n");
     }
 
-    serde_if_integer128! {
-        #[test]
-        fn struct_no_headers_128() {
-            #[derive(Serialize)]
-            struct Foo {
-                x: i128,
-                y: u128,
-            }
+    #[test]
+    fn struct_no_headers_128() {
+        #[derive(Serialize)]
+        struct Foo {
+            x: i128,
+            y: u128,
+        }
 
-            let got =
-                serialize(Foo { x: i128::max_value(), y: u128::max_value() });
-            assert_eq!(
-                got,
-                "170141183460469231731687303715884105727,\
+        let got =
+            serialize(Foo { x: i128::max_value(), y: u128::max_value() });
+        assert_eq!(
+            got,
+            "170141183460469231731687303715884105727,\
                  340282366920938463463374607431768211455\n"
-            );
-        }
+        );
     }
 
     #[test]

src/writer.rs

@@ -1216,7 +1216,7 @@ impl Buffer {
 mod tests {
     use std::io::{self, Write};
 
-    use serde::{serde_if_integer128, Serialize};
+    use serde::Serialize;
 
     use crate::{
         byte_record::ByteRecord, error::ErrorKind, string_record::StringRecord,
@@ -1415,25 +1415,24 @@ mod tests {
         assert_eq!(wtr_as_string(wtr), "42,42.5,true\n");
     }
 
-    serde_if_integer128! {
-        #[test]
-        fn serialize_no_headers_128() {
-            #[derive(Serialize)]
-            struct Row {
-                foo: i128,
-                bar: f64,
-                baz: bool,
-            }
-
-            let mut wtr =
-                WriterBuilder::new().has_headers(false).from_writer(vec![]);
-            wtr.serialize(Row {
-                foo: 9_223_372_036_854_775_808,
-                bar: 42.5,
-                baz: true,
-            }).unwrap();
-            assert_eq!(wtr_as_string(wtr), "9223372036854775808,42.5,true\n");
+    #[test]
+    fn serialize_no_headers_128() {
+        #[derive(Serialize)]
+        struct Row {
+            foo: i128,
+            bar: f64,
+            baz: bool,
         }
+
+        let mut wtr =
+            WriterBuilder::new().has_headers(false).from_writer(vec![]);
+        wtr.serialize(Row {
+            foo: 9_223_372_036_854_775_808,
+            bar: 42.5,
+            baz: true,
+        })
+        .unwrap();
+        assert_eq!(wtr_as_string(wtr), "9223372036854775808,42.5,true\n");
     }
 
     #[test]