1 files changed, 15 insertions, 24 deletions

diff --git a/src/value/ser.rs b/src/value/ser.rs
index 835fa90..a29814e 100644
--- a/src/value/ser.rs
+++ b/src/value/ser.rs
@@ -1,9 +1,12 @@
 use crate::error::{Error, ErrorCode, Result};
 use crate::map::Map;
+use crate::number::Number;
 use crate::value::{to_value, Value};
 use alloc::borrow::ToOwned;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
+#[cfg(not(feature = "arbitrary_precision"))]
+use core::convert::TryFrom;
 use core::fmt::Display;
 use core::result;
 use serde::ser::{Impossible, Serialize};
@@ -146,13 +149,13 @@ impl serde::Serializer for Serializer {
     }
 
     #[inline]
-    fn serialize_f32(self, float: f32) -> Result<Value> {
-        Ok(Value::from(float))
+    fn serialize_f32(self, value: f32) -> Result<Value> {
+        self.serialize_f64(value as f64)
     }
 
     #[inline]
-    fn serialize_f64(self, float: f64) -> Result<Value> {
-        Ok(Value::from(float))
+    fn serialize_f64(self, value: f64) -> Result<Value> {
+        Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
     }
 
     #[inline]
@@ -449,10 +452,6 @@ fn key_must_be_a_string() -> Error {
     Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
 }
 
-fn float_key_must_be_finite() -> Error {
-    Error::syntax(ErrorCode::FloatKeyMustBeFinite, 0, 0)
-}
-
 impl serde::Serializer for MapKeySerializer {
     type Ok = String;
     type Error = Error;
@@ -483,8 +482,8 @@ impl serde::Serializer for MapKeySerializer {
         value.serialize(self)
     }
 
-    fn serialize_bool(self, value: bool) -> Result<String> {
-        Ok(value.to_string())
+    fn serialize_bool(self, _value: bool) -> Result<String> {
+        Err(key_must_be_a_string())
     }
 
     fn serialize_i8(self, value: i8) -> Result<String> {
@@ -519,20 +518,12 @@ impl serde::Serializer for MapKeySerializer {
         Ok(value.to_string())
     }
 
-    fn serialize_f32(self, value: f32) -> Result<String> {
-        if value.is_finite() {
-            Ok(ryu::Buffer::new().format_finite(value).to_owned())
-        } else {
-            Err(float_key_must_be_finite())
-        }
+    fn serialize_f32(self, _value: f32) -> Result<String> {
+        Err(key_must_be_a_string())
     }
 
-    fn serialize_f64(self, value: f64) -> Result<String> {
-        if value.is_finite() {
-            Ok(ryu::Buffer::new().format_finite(value).to_owned())
-        } else {
-            Err(float_key_must_be_finite())
-        }
+    fn serialize_f64(self, _value: f64) -> Result<String> {
+        Err(key_must_be_a_string())
     }
 
     #[inline]
@@ -650,7 +641,7 @@ impl serde::ser::SerializeStruct for SerializeMap {
             #[cfg(feature = "arbitrary_precision")]
             SerializeMap::Number { out_value } => {
                 if key == crate::number::TOKEN {
-                    *out_value = Some(tri!(value.serialize(NumberValueEmitter)));
+                    *out_value = Some(value.serialize(NumberValueEmitter)?);
                     Ok(())
                 } else {
                     Err(invalid_number())
@@ -659,7 +650,7 @@ impl serde::ser::SerializeStruct for SerializeMap {
             #[cfg(feature = "raw_value")]
             SerializeMap::RawValue { out_value } => {
                 if key == crate::raw::TOKEN {
-                    *out_value = Some(tri!(value.serialize(RawValueEmitter)));
+                    *out_value = Some(value.serialize(RawValueEmitter)?);
                     Ok(())
                 } else {
                     Err(invalid_raw_value())