float inf nan

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")
     }
 

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(())