perf(stable-api): inline dbl2num flonum encode for MRI stable versions (#734)

When the double is representable as a flonum tagged immediate, encode it
in pure Rust (rotate-left-3 + tag) without calling rb_float_new. Falls
back to rb_float_new for out-of-range doubles and on non-flonum builds.
Mirrors the existing flonum decode fast path in num2dbl.

Rust: 3 instructions  C (DBL2NUM): 3 instructions

Author: ianks

crates/rb-sys-tests/src/stable_api_test.rs

@@ -1608,6 +1608,60 @@ fn test_dbl2num_and_num2dbl_roundtrip() {
     }
 }
 
+// Parity tests for dbl2num: flonum-range values encode as tagged immediates,
+// so both Rust and C produce identical VALUE representations (no heap pointer).
+parity_test!(
+    name: test_dbl2num_in_flonum_range,
+    func: dbl2num,
+    data_factory: { 1.5f64 }
+);
+
+parity_test!(
+    name: test_dbl2num_positive_zero,
+    func: dbl2num,
+    data_factory: { 0.0f64 }
+);
+
+// Out-of-flonum-range values heap-allocate; verify via roundtrip not pointer equality.
+#[rb_sys_test_helpers::ruby_test]
+fn test_dbl2num_out_of_flonum_range() {
+    unsafe {
+        let val = 1e300f64;
+        let rust_obj = stable_api::get_default().dbl2num(val);
+        let recovered = stable_api::get_default().num2dbl(rust_obj);
+        assert!(
+            (val - recovered).abs() < f64::EPSILON,
+            "roundtrip failed: {} != {}",
+            val,
+            recovered
+        );
+
+        // Also confirm parity with compiled C by decoding both
+        let c_obj = stable_api::get_compiled().dbl2num(val);
+        let c_recovered = stable_api::get_default().num2dbl(c_obj);
+        assert!(
+            (val - c_recovered).abs() < f64::EPSILON,
+            "C roundtrip failed: {} != {}",
+            val,
+            c_recovered
+        );
+    }
+}
+
+#[rb_sys_test_helpers::ruby_test]
+fn test_dbl2num_infinity() {
+    unsafe {
+        let inf_obj = ruby_eval!("Float::INFINITY");
+        let recovered = stable_api::get_default().num2dbl(inf_obj);
+        assert!(recovered.is_infinite() && recovered > 0.0);
+
+        // Verify our dbl2num produces a value that num2dbl can round-trip
+        let encoded = stable_api::get_default().dbl2num(f64::INFINITY);
+        let decoded = stable_api::get_default().num2dbl(encoded);
+        assert!(decoded.is_infinite() && decoded > 0.0);
+    }
+}
+
 parity_test!(
     name: test_rhash_size_empty,
     func: rhash_size,

crates/rb-sys/src/stable_api/ruby_2_7.rs

@@ -517,9 +517,22 @@ impl StableApiDefinition for Definition {
         }
     }
 
-    #[inline]
+    #[inline(always)]
     fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
-        // Call the C function rb_float_new to create a Float VALUE
+        #[cfg(ruby_use_flonum = "true")]
+        {
+            let bits = val.to_bits() as VALUE;
+            let exp_bits = (bits >> 60) & 0x7;
+            // Flonum-representable: exponent top-3 bits are 011 or 100
+            if bits != 0x3000_0000_0000_0000 && (exp_bits == 3 || exp_bits == 4) {
+                return (bits.rotate_left(3) & !0x01) | 0x02;
+            }
+            // +0.0 special case
+            if bits == 0 {
+                return 0x8000_0000_0000_0002;
+            }
+        }
+        // Out-of-flonum-range or flonum disabled: heap allocate
         unsafe { crate::rb_float_new(val) }
     }
 

crates/rb-sys/src/stable_api/ruby_3_0.rs

@@ -520,9 +520,22 @@ impl StableApiDefinition for Definition {
         }
     }
 
-    #[inline]
+    #[inline(always)]
     fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
-        // Call the C function rb_float_new to create a Float VALUE
+        #[cfg(ruby_use_flonum = "true")]
+        {
+            let bits = val.to_bits() as VALUE;
+            let exp_bits = (bits >> 60) & 0x7;
+            // Flonum-representable: exponent top-3 bits are 011 or 100
+            if bits != 0x3000_0000_0000_0000 && (exp_bits == 3 || exp_bits == 4) {
+                return (bits.rotate_left(3) & !0x01) | 0x02;
+            }
+            // +0.0 special case
+            if bits == 0 {
+                return 0x8000_0000_0000_0002;
+            }
+        }
+        // Out-of-flonum-range or flonum disabled: heap allocate
         unsafe { crate::rb_float_new(val) }
     }
 

crates/rb-sys/src/stable_api/ruby_3_1.rs

@@ -513,9 +513,22 @@ impl StableApiDefinition for Definition {
         }
     }
 
-    #[inline]
+    #[inline(always)]
     fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
-        // Call the C function rb_float_new to create a Float VALUE
+        #[cfg(ruby_use_flonum = "true")]
+        {
+            let bits = val.to_bits() as VALUE;
+            let exp_bits = (bits >> 60) & 0x7;
+            // Flonum-representable: exponent top-3 bits are 011 or 100
+            if bits != 0x3000_0000_0000_0000 && (exp_bits == 3 || exp_bits == 4) {
+                return (bits.rotate_left(3) & !0x01) | 0x02;
+            }
+            // +0.0 special case
+            if bits == 0 {
+                return 0x8000_0000_0000_0002;
+            }
+        }
+        // Out-of-flonum-range or flonum disabled: heap allocate
         unsafe { crate::rb_float_new(val) }
     }
 

crates/rb-sys/src/stable_api/ruby_3_2.rs

@@ -511,9 +511,22 @@ impl StableApiDefinition for Definition {
         }
     }
 
-    #[inline]
+    #[inline(always)]
     fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
-        // Call the C function rb_float_new to create a Float VALUE
+        #[cfg(ruby_use_flonum = "true")]
+        {
+            let bits = val.to_bits() as VALUE;
+            let exp_bits = (bits >> 60) & 0x7;
+            // Flonum-representable: exponent top-3 bits are 011 or 100
+            if bits != 0x3000_0000_0000_0000 && (exp_bits == 3 || exp_bits == 4) {
+                return (bits.rotate_left(3) & !0x01) | 0x02;
+            }
+            // +0.0 special case
+            if bits == 0 {
+                return 0x8000_0000_0000_0002;
+            }
+        }
+        // Out-of-flonum-range or flonum disabled: heap allocate
         unsafe { crate::rb_float_new(val) }
     }
 

crates/rb-sys/src/stable_api/ruby_3_3.rs

@@ -523,9 +523,22 @@ impl StableApiDefinition for Definition {
         }
     }
 
-    #[inline]
+    #[inline(always)]
     fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
-        // Call the C function rb_float_new to create a Float VALUE
+        #[cfg(ruby_use_flonum = "true")]
+        {
+            let bits = val.to_bits() as VALUE;
+            let exp_bits = (bits >> 60) & 0x7;
+            // Flonum-representable: exponent top-3 bits are 011 or 100
+            if bits != 0x3000_0000_0000_0000 && (exp_bits == 3 || exp_bits == 4) {
+                return (bits.rotate_left(3) & !0x01) | 0x02;
+            }
+            // +0.0 special case
+            if bits == 0 {
+                return 0x8000_0000_0000_0002;
+            }
+        }
+        // Out-of-flonum-range or flonum disabled: heap allocate
         unsafe { crate::rb_float_new(val) }
     }
 

crates/rb-sys/src/stable_api/ruby_3_4.rs

@@ -537,7 +537,20 @@ impl StableApiDefinition for Definition {
 
     #[inline(always)]
     fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
-        // Call the C function rb_float_new to create a Float VALUE
+        #[cfg(ruby_use_flonum = "true")]
+        {
+            let bits = val.to_bits() as VALUE;
+            let exp_bits = (bits >> 60) & 0x7;
+            // Flonum-representable: exponent top-3 bits are 011 or 100
+            if bits != 0x3000_0000_0000_0000 && (exp_bits == 3 || exp_bits == 4) {
+                return (bits.rotate_left(3) & !0x01) | 0x02;
+            }
+            // +0.0 special case
+            if bits == 0 {
+                return 0x8000_0000_0000_0002;
+            }
+        }
+        // Out-of-flonum-range or flonum disabled: heap allocate
         unsafe { crate::rb_float_new(val) }
     }
 

crates/rb-sys/src/stable_api/ruby_4_0.rs

@@ -533,7 +533,20 @@ impl StableApiDefinition for Definition {
 
     #[inline(always)]
     fn dbl2num(&self, val: std::os::raw::c_double) -> VALUE {
-        // Call the C function rb_float_new to create a Float VALUE
+        #[cfg(ruby_use_flonum = "true")]
+        {
+            let bits = val.to_bits() as VALUE;
+            let exp_bits = (bits >> 60) & 0x7;
+            // Flonum-representable: exponent top-3 bits are 011 or 100
+            if bits != 0x3000_0000_0000_0000 && (exp_bits == 3 || exp_bits == 4) {
+                return (bits.rotate_left(3) & !0x01) | 0x02;
+            }
+            // +0.0 special case
+            if bits == 0 {
+                return 0x8000_0000_0000_0002;
+            }
+        }
+        // Out-of-flonum-range or flonum disabled: heap allocate
         unsafe { crate::rb_float_new(val) }
     }
 

script/show-asm

@@ -302,6 +302,15 @@ FUNCTIONS = [
     ruby_source: "include/ruby/internal/arithmetic/long.h:RB_ULONG2NUM"
   },
 
+  # Float conversion operations
+  {
+    name: "dbl2num",
+    rust: {unsafe: false, ret: "VALUE",
+           expr: "{ let api = rb_sys::stable_api::get_default(); api.dbl2num(1.5f64) }"},
+    c: {expr: "DBL2NUM(1.5)", ret: "VALUE"},
+    ruby_source: "include/ruby/internal/arithmetic/double.h:DBL2NUM"
+  },
+
   # GC guard (macro, not StableApiDefinition method)
   # Uses a realistic pattern: extract pointer, call function that might GC, use guard
   {