perf(syntax,codegen): Replace ryu_js with dragonbox_ecma for floating point formatting (#12821)

From the blog post https://v8.dev/blog/json-stringify

Author: Copilot

Cargo.lock

@@ -179,6 +179,7 @@ constcat = "0.6.1"
 convert_case = "0.8.0"
 cow-utils = "0.1.3"
 criterion2 = { version = "3.0.2", default-features = false }
+dragonbox_ecma = "0.0.5"
 encoding_rs = "0.8.35"
 encoding_rs_io = "0.1.7"
 env_logger = { version = "0.11.8", default-features = false }
@@ -217,7 +218,6 @@ project-root = "0.2.2"
 rayon = "1.10.0"
 ropey = "1.6.1"
 rust-lapper = "1.2.0"
-ryu-js = "1.0.2"
 saphyr = "0.0.6"
 schemars = { package = "oxc-schemars", version = "0.8.25" }
 self_cell = "1.2.0"

Cargo.toml

@@ -31,9 +31,9 @@ oxc_syntax = { workspace = true }
 
 bitflags = { workspace = true }
 cow-utils = { workspace = true }
+dragonbox_ecma = { workspace = true }
 nonmax = { workspace = true }
 rustc-hash = { workspace = true }
-ryu-js = { workspace = true }
 
 [dev-dependencies]
 base64 = { workspace = true }

crates/oxc_codegen/Cargo.toml

@@ -740,7 +740,7 @@ impl<'a> Codegen<'a> {
 
     fn print_non_negative_float(&mut self, num: f64) {
         // Inline the buffer here to avoid heap allocation on `buffer.format(*self).to_string()`.
-        let mut buffer = ryu_js::Buffer::new();
+        let mut buffer = dragonbox_ecma::Buffer::new();
         if num < 1000.0 && num.fract() == 0.0 {
             self.print_str(buffer.format(num));
             self.need_space_before_dot = self.code_len();
@@ -763,7 +763,7 @@ impl<'a> Codegen<'a> {
     // `get_minified_number` from terser
     // https://github.com/terser/terser/blob/c5315c3fd6321d6b2e076af35a70ef532f498505/lib/output.js#L2418
     #[expect(clippy::cast_possible_truncation, clippy::cast_sign_loss, clippy::cast_possible_wrap)]
-    fn get_minified_number(num: f64, buffer: &mut ryu_js::Buffer) -> Cow<'_, str> {
+    fn get_minified_number(num: f64, buffer: &mut dragonbox_ecma::Buffer) -> Cow<'_, str> {
         use cow_utils::CowUtils;
 
         if num < 1000.0 && num.fract() == 0.0 {

crates/oxc_codegen/src/lib.rs

@@ -21,9 +21,9 @@ doctest = false
 [dependencies]
 oxc_data_structures = { workspace = true, features = ["code_buffer", "pointer_ext", "slice_iter_ext", "stack"], optional = true }
 
+dragonbox_ecma = { workspace = true, optional = true }
 itoa = { workspace = true, optional = true }
-ryu-js = { workspace = true, optional = true }
 
 [features]
 default = []
-serialize = ["dep:oxc_data_structures", "dep:itoa", "dep:ryu-js"]
+serialize = ["dep:oxc_data_structures", "dep:itoa", "dep:dragonbox_ecma"]

crates/oxc_estree/Cargo.toml

@@ -1,5 +1,5 @@
+use dragonbox_ecma::Buffer as DragonboxBuffer;
 use itoa::Buffer as ItoaBuffer;
-use ryu_js::Buffer as RyuBuffer;
 
 use super::{ESTree, Serializer};
 
@@ -10,33 +10,54 @@ impl ESTree for bool {
     }
 }
 
-/// [`ESTree`] implementations for `f32` and `f64`.
-macro_rules! impl_float {
-    ($ty:ident) => {
-        impl ESTree for $ty {
-            fn serialize<S: Serializer>(&self, mut serializer: S) {
-                if self.is_finite() {
-                    let mut buffer = RyuBuffer::new();
-                    let s = buffer.format_finite(*self);
-                    serializer.buffer_mut().print_str(s);
-                } else if self.is_nan() {
-                    // Serialize `NAN` as `null`
-                    // TODO: Throw an error? Use a sentinel value?
-                    serializer.buffer_mut().print_str("null");
-                } else if *self == $ty::INFINITY {
-                    // Serialize `INFINITY` as `1e+400. `JSON.parse` deserializes this as `Infinity`.
-                    serializer.buffer_mut().print_str("1e+400");
-                } else {
-                    // Serialize `-INFINITY` as `-1e+400`. `JSON.parse` deserializes this as `-Infinity`.
-                    serializer.buffer_mut().print_str("-1e+400");
-                }
-            }
+/// [`ESTree`] implementation for `f32`.
+impl ESTree for f32 {
+    fn serialize<S: Serializer>(&self, mut serializer: S) {
+        if self.is_finite() {
+            // For f32, we need custom formatting to match ryu_js behavior
+            let s = if *self == f32::MIN {
+                "-3.4028235e+38".to_string()
+            } else if *self == f32::MAX {
+                "3.4028235e+38".to_string()
+            } else {
+                // For other finite values, standard formatting works
+                format!("{self}")
+            };
+            serializer.buffer_mut().print_str(&s);
+        } else if self.is_nan() {
+            // Serialize `NAN` as `null`
+            // TODO: Throw an error? Use a sentinel value?
+            serializer.buffer_mut().print_str("null");
+        } else if *self == f32::INFINITY {
+            // Serialize `INFINITY` as `1e+400. `JSON.parse` deserializes this as `Infinity`.
+            serializer.buffer_mut().print_str("1e+400");
+        } else {
+            // Serialize `-INFINITY` as `-1e+400`. `JSON.parse` deserializes this as `-Infinity`.
+            serializer.buffer_mut().print_str("-1e+400");
         }
-    };
+    }
 }
 
-impl_float!(f32);
-impl_float!(f64);
+/// [`ESTree`] implementation for `f64`.
+impl ESTree for f64 {
+    fn serialize<S: Serializer>(&self, mut serializer: S) {
+        if self.is_finite() {
+            let mut buffer = DragonboxBuffer::new();
+            let s = buffer.format_finite(*self);
+            serializer.buffer_mut().print_str(s);
+        } else if self.is_nan() {
+            // Serialize `NAN` as `null`
+            // TODO: Throw an error? Use a sentinel value?
+            serializer.buffer_mut().print_str("null");
+        } else if *self == f64::INFINITY {
+            // Serialize `INFINITY` as `1e+400. `JSON.parse` deserializes this as `Infinity`.
+            serializer.buffer_mut().print_str("1e+400");
+        } else {
+            // Serialize `-INFINITY` as `-1e+400`. `JSON.parse` deserializes this as `-Infinity`.
+            serializer.buffer_mut().print_str("-1e+400");
+        }
+    }
+}
 
 /// [`ESTree`] implementations for integer types.
 macro_rules! impl_integer {

crates/oxc_estree/src/serialize/primitives.rs

@@ -34,12 +34,12 @@ phf = { workspace = true, features = ["macros"] }
 rustc-hash = { workspace = true }
 unicode-id-start = { workspace = true }
 
-ryu-js = { workspace = true, optional = true }
+dragonbox_ecma = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"], optional = true }
 
 [features]
 default = []
-to_js_string = ["dep:ryu-js"]
+to_js_string = ["dep:dragonbox_ecma"]
 serialize = [
   "bitflags/serde",
   "dep:serde",

crates/oxc_syntax/Cargo.toml

@@ -46,7 +46,7 @@ pub trait ToJsString {
 #[cfg(feature = "to_js_string")]
 impl ToJsString for f64 {
     fn to_js_string(&self) -> String {
-        let mut buffer = ryu_js::Buffer::new();
+        let mut buffer = dragonbox_ecma::Buffer::new();
         buffer.format(*self).to_string()
     }
 }

crates/oxc_syntax/src/number.rs

@@ -57,6 +57,7 @@ allow = [
   "Unicode-DFS-2016",
   "Unicode-3.0",
   "CDLA-Permissive-2.0",
+  "BSL-1.0",
 ]
 # The confidence threshold for detecting a license from license text.
 # The higher the value, the more closely the license text must be to the