float inf nan (#64)

* serialize non-finite numbers as null

* they are not valid JSON numbers
* this behavior matches serde-json

* de: serialize JSON null as f32/f64 NAN

* this is not what serde_json does (it errors instead)
* but it makes ser/de somewhat symmetric

* fix a clippy lint

* add tests, changelog entries

Author: jordens

CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+
+- Changed serialization of `f32`/`f64` that are `!is_finite()` (i.e. `NAN`, `INFINITY`,
+  `NEG_INFINITY`) to result in JSON `null`. This matches `serde_json` behavior.
+- Changed deserialization of JSON `null` where `f32`/`f64` is expected to result in
+  the respective `NAN`.
+
 ## [v0.4.0] - 2021-05-08
 
 ### Added

src/de/mod.rs

@@ -311,23 +311,32 @@ macro_rules! deserialize_signed {
 
 macro_rules! deserialize_fromstr {
     ($self:ident, $visitor:ident, $typ:ident, $visit_fn:ident, $pattern:expr) => {{
-        let start = $self.index;
-        while $self.peek().is_some() {
-            let c = $self.peek().unwrap();
-            if $pattern.iter().find(|&&d| d == c).is_some() {
+        match $self.parse_whitespace().ok_or(Error::EofWhileParsingValue)? {
+            b'n' => {
                 $self.eat_char();
-            } else {
-                break;
+                $self.parse_ident(b"ull")?;
+                $visitor.$visit_fn($typ::NAN)
             }
-        }
+            _ => {
+                let start = $self.index;
+                while $self.peek().is_some() {
+                    let c = $self.peek().unwrap();
+                    if $pattern.iter().find(|&&d| d == c).is_some() {
+                        $self.eat_char();
+                    } else {
+                        break;
+                    }
+                }
 
-        // Note(unsafe): We already checked that it only contains ascii. This is only true if the
-        // caller has guaranteed that `pattern` contains only ascii characters.
-        let s = unsafe { str::from_utf8_unchecked(&$self.slice[start..$self.index]) };
+                // Note(unsafe): We already checked that it only contains ascii. This is only true if the
+                // caller has guaranteed that `pattern` contains only ascii characters.
+                let s = unsafe { str::from_utf8_unchecked(&$self.slice[start..$self.index]) };
 
-        let v = $typ::from_str(s).or(Err(Error::InvalidNumber))?;
+                let v = $typ::from_str(s).or(Err(Error::InvalidNumber))?;
 
-        $visitor.$visit_fn(v)
+                $visitor.$visit_fn(v)
+            }
+        }
     }};
 }
 
@@ -423,15 +432,13 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        self.parse_whitespace().ok_or(Error::EofWhileParsingValue)?;
         deserialize_fromstr!(self, visitor, f32, visit_f32, b"0123456789+-.eE")
     }
 
     fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.parse_whitespace().ok_or(Error::EofWhileParsingValue)?;
         deserialize_fromstr!(self, visitor, f64, visit_f64, b"0123456789+-.eE")
     }
 
@@ -941,11 +948,17 @@ mod tests {
             ))
         );
 
+        // NaNs will always compare unequal.
+        let (r, n): (Temperature, usize) = crate::from_str(r#"{ "temperature": null }"#).unwrap();
+        assert!(r.temperature.is_nan());
+        assert_eq!(n, 23);
+
         assert!(crate::from_str::<Temperature>(r#"{ "temperature": 1e1e1 }"#).is_err());
         assert!(crate::from_str::<Temperature>(r#"{ "temperature": -2-2 }"#).is_err());
         assert!(crate::from_str::<Temperature>(r#"{ "temperature": 1 1 }"#).is_err());
         assert!(crate::from_str::<Temperature>(r#"{ "temperature": 0.0. }"#).is_err());
         assert!(crate::from_str::<Temperature>(r#"{ "temperature": ä }"#).is_err());
+        assert!(crate::from_str::<Temperature>(r#"{ "temperature": None }"#).is_err());
     }
 
     #[test]

src/ser/mod.rs

@@ -230,11 +230,19 @@ impl<'a, 'b: 'a> ser::Serializer for &'a mut Serializer<'b> {
     }
 
     fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
-        serialize_ryu!(self, v)
+        if v.is_finite() {
+            serialize_ryu!(self, v)
+        } else {
+            self.serialize_none()
+        }
     }
 
     fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
-        serialize_ryu!(self, v)
+        if v.is_finite() {
+            serialize_ryu!(self, v)
+        } else {
+            self.serialize_none()
+        }
     }
 
     fn serialize_char(self, _v: char) -> Result<Self::Ok> {
@@ -345,7 +353,7 @@ impl<'a, 'b: 'a> ser::Serializer for &'a mut Serializer<'b> {
     }
 
     fn serialize_newtype_variant<T: ?Sized>(
-        mut self,
+        self,
         _name: &'static str,
         _variant_index: u32,
         variant: &'static str,
@@ -355,7 +363,7 @@ impl<'a, 'b: 'a> ser::Serializer for &'a mut Serializer<'b> {
         T: ser::Serialize,
     {
         self.push(b'{')?;
-        let mut s = SerializeStruct::new(&mut self);
+        let mut s = SerializeStruct::new(self);
         s.serialize_field(variant, value)?;
         s.end()?;
         Ok(())
@@ -700,6 +708,22 @@ mod tests {
             .unwrap(),
             r#"{"temperature":-2.3456788e-23}"#
         );
+
+        assert_eq!(
+            &*crate::to_string::<_, N>(&Temperature {
+                temperature: f32::NAN
+            })
+            .unwrap(),
+            r#"{"temperature":null}"#
+        );
+
+        assert_eq!(
+            &*crate::to_string::<_, N>(&Temperature {
+                temperature: f32::NEG_INFINITY
+            })
+            .unwrap(),
+            r#"{"temperature":null}"#
+        );
     }
 
     #[test]