feat(native-jit): generalize mutual recursion to scalar Float (Int/Bool/Float)

Applies the Phase-2 self-recursion treatment to the mutual-recursion group path,
removing the last narrow-Int recursion remnant. Mutual recursion's fallback is
already the full interpreter, so this is purely a widening — no fallback-selection
logic.

- native_recursive_int_group → native_recursive_group: keeps SCC/cycle discovery
  (>= 2 members) but DROPS the bespoke per-member Int/Bool analysis. Per-member
  eligibility is now the general translate_to_native_jit_with_calls verdict in the
  compile loop — so the group admits Int/Bool/Float bodies (and members that also
  call inlinable leaves), not just the Int-arith whitelist.
- try_native_mutual_recursive_int: caches (CompiledId, param_tys, ret) per member
  (was (CompiledId, returns_bool)); accepts scalar Int/Bool/Float params+return
  (non-scalar declines); marshals each arg by its compiled NativeTy (Float via
  to_bits) and wraps the i64 result per ret (Float via from_bits) — identical to
  try_native_self_recursive.
- mutual_recursive_native cache type updated accordingly.

Verify (Docker dev): differential 33/0, runtime 396/0 (new
native_mutual_recursion_float_runs_native + all 15 recursion tests green),
reg_vm lib 31/0 default, default+native builds and clippy clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/reg_vm/mod.rs

@@ -2208,12 +2208,14 @@ struct NativeState {
     /// not natively self-recursion-compilable (fall back to the tier-0 i64 executor
     /// for i64-only bodies, or the full interpreter for non-i64 bodies).
     self_recursive_native: HashMap<usize, Option<(vm_jit::CompiledId, Vec<NativeTy>, NativeTy)>>,
-    /// Native mutual-recursion cache (native-call-ABI slice 4): per-function
-    /// (`*const RegFunction` key) compiled group-member `(CompiledId, returns_bool)`,
-    /// where `returns_bool` wraps the native `i64` result as `Bool` vs `Int`.
-    /// Compiling any member of a recursive cycle compiles+caches the whole group.
-    /// `None` = known not a natively-compilable mutual-recursion member (interpreter).
-    mutual_recursive_native: HashMap<usize, Option<(vm_jit::CompiledId, bool)>>,
+    /// Native mutual-recursion cache (native-call-ABI slice 4; generalized to scalar
+    /// Float in the Phase 2 follow-up): per-function (`*const RegFunction` key)
+    /// compiled group-member `(CompiledId, param_tys, ret)`. The dispatcher marshals
+    /// each scalar arg (Int/Bool/Float) and wraps the `i64` result per `ret`, exactly
+    /// like the self-recursion cache. Compiling any member of a recursive cycle
+    /// compiles+caches the whole group. `None` = known not a natively-compilable
+    /// mutual-recursion member (interpreter).
+    mutual_recursive_native: HashMap<usize, Option<(vm_jit::CompiledId, Vec<NativeTy>, NativeTy)>>,
     /// Reusable per-call marshalling scratch buffers (TV2 arg/len words and the
     /// flat-list `Rc` keep-alive set). Held here and `mem::take`n into the call
     /// frame so a hot per-iteration native dispatch (e.g. a tiny leaf/closure

crates/rsscript/src/reg_vm/tier.rs

@@ -2679,12 +2679,15 @@ impl RegVm {
         }
     }
 
-    /// Native mutual recursion (native-call-ABI slice 4): if `function_id` is part of
-    /// a mutually-recursive scalar-`Int` cycle, compile the whole group together
-    /// (declare the cycle, then define each) and dispatch the called member natively.
-    /// Returns the result on a clean completion, or `None` to fall back to the
-    /// interpreter (not eligible, or a deopt incl. the entry depth-cap bail). The
-    /// group is compiled once and every member cached.
+    /// Native mutual recursion (native-call-ABI slice 4; generalized to scalar Float):
+    /// if `function_id` is part of a mutually-recursive cycle of scalar functions,
+    /// compile the whole group together (declare the cycle, then define each) and
+    /// dispatch the called member natively. Arg/return marshalling follows each
+    /// member's compiled scalar parameter/return `NativeTy`s (Int/Bool/Float — Float
+    /// via `to_bits`/`from_bits`), exactly like `try_native_self_recursive`. Returns
+    /// the result on a clean completion, or `None` to fall back to the interpreter
+    /// (not eligible, non-scalar param/return, or a deopt incl. the depth-cap bail).
+    /// The group is compiled once and every member cached.
     #[cfg(feature = "native-jit")]
     pub(super) fn try_native_mutual_recursive_int(
         &mut self,
@@ -2698,10 +2701,10 @@ impl RegVm {
             return None;
         }
         let key = Rc::as_ptr(func) as usize;
-        // Resolve the called member's native id and its return kind (Int → wrap the
-        // result `i64` as `VmValue::Int`, Bool → as `VmValue::Bool`). Cached per
-        // member; compiling any member compiles the whole group.
-        let (id, returns_bool) = {
+        // Resolve the called member's native id, its parameter types (to marshal each
+        // scalar arg) and its return type (to wrap the i64 result). Cached per member;
+        // compiling any member compiles the whole group.
+        let (id, param_tys, ret) = {
             let native = self.native.as_mut()?;
             if native.force_bail
                 || native.forced_safepoint.is_some()
@@ -2710,17 +2713,19 @@ impl RegVm {
                 return None;
             }
             if let Some(cached) = native.mutual_recursive_native.get(&key) {
-                (*cached)?
+                cached.clone()?
             } else {
-                let group = native_recursive_int_group(unit, function_id);
+                let group = native_recursive_group(unit, function_id);
+                let is_scalar =
+                    |t: &NativeTy| matches!(t, NativeTy::Int | NativeTy::Bool | NativeTy::Float);
                 let compiled = group.as_ref().and_then(|scc| {
                     let index_of: std::collections::HashMap<usize, u32> = scc
                         .iter()
                         .enumerate()
                         .map(|(i, &fid)| (fid, i as u32))
                         .collect();
                     let mut jit_funcs = Vec::with_capacity(scc.len());
-                    let mut member_returns_bool = Vec::with_capacity(scc.len());
+                    let mut member_sigs = Vec::with_capacity(scc.len());
                     for &member in scc {
                         let mfunc = unit.functions.get(member)?;
                         let group_call_sites: std::collections::HashMap<usize, u32> = mfunc
@@ -2736,32 +2741,34 @@ impl RegVm {
                                 _ => None,
                             })
                             .collect();
-                        let (jit_fn, ret, _p, _l, _pr) = translate_to_native_jit_with_calls(
+                        let (jit_fn, ret, param_tys, _l, _pr) = translate_to_native_jit_with_calls(
                             unit,
                             mfunc,
                             &std::collections::HashMap::new(),
                             &std::collections::HashSet::new(),
                             &group_call_sites,
                         )?;
-                        // i64-scalar returns only: Int or Bool (both wrap from i64).
-                        let returns_bool = match ret {
-                            NativeTy::Int => false,
-                            NativeTy::Bool => true,
-                            _ => return None,
-                        };
-                        member_returns_bool.push(returns_bool);
+                        // Scalar-only ABI: params and return must be Int/Bool/Float
+                        // (each wraps to/from an i64 slot). Heap params/returns decline.
+                        if !is_scalar(&ret) || !param_tys.iter().all(is_scalar) {
+                            return None;
+                        }
+                        member_sigs.push((param_tys, ret));
                         jit_funcs.push(jit_fn);
                     }
                     let ids = native.module.compile_recursive_group(&jit_funcs).ok()?;
-                    Some((ids, member_returns_bool))
+                    Some((ids, member_sigs))
                 });
                 match (group, compiled) {
-                    (Some(scc), Some((ids, member_returns_bool))) if ids.len() == scc.len() => {
+                    (Some(scc), Some((ids, member_sigs))) if ids.len() == scc.len() => {
                         let mut mine = None;
                         for (i, &member) in scc.iter().enumerate() {
                             let mkey = Rc::as_ptr(&unit.functions[member]) as usize;
-                            let entry = (ids[i], member_returns_bool[i]);
-                            native.mutual_recursive_native.insert(mkey, Some(entry));
+                            let (param_tys, ret) = member_sigs[i].clone();
+                            let entry = (ids[i], param_tys, ret);
+                            native
+                                .mutual_recursive_native
+                                .insert(mkey, Some(entry.clone()));
                             if member == function_id {
                                 mine = Some(entry);
                             }
@@ -2786,12 +2793,20 @@ impl RegVm {
                 }
             }
         };
+        if param_tys.len() != args.len() {
+            return None;
+        }
         let mut int_args = Vec::with_capacity(args.len());
-        for &arg in args {
-            // Scalar value args marshal to `i64` (Bool as 0/1, like the native ABI).
-            let bits = match self.reg(caller_base + arg) {
-                VmValue::Int(value) => *value,
-                VmValue::Bool(value) => *value as i64,
+        for (&arg, pty) in args.iter().zip(param_tys.iter()) {
+            // Scalar value args marshal to an i64 slot, driven by the compiled
+            // parameter type (Float reinterpreted via `to_bits`; an Int value for a
+            // Float param converted first) — identical to the self-recursion path.
+            let bits = match (pty, self.reg(caller_base + arg)) {
+                (NativeTy::Float, VmValue::Float(f)) => f.to_bits() as i64,
+                (NativeTy::Float, VmValue::Int(i)) => (*i as f64).to_bits() as i64,
+                (_, VmValue::Int(i)) => *i,
+                (_, VmValue::Bool(b)) => i64::from(*b),
+                (_, VmValue::Float(f)) => f.to_bits() as i64,
                 _ => return None,
             };
             int_args.push(bits);
@@ -2812,10 +2827,10 @@ impl RegVm {
                 {
                     native.stats.native_calls += 1;
                 }
-                Some(if returns_bool {
-                    VmValue::Bool(bits != 0)
-                } else {
-                    VmValue::Int(bits)
+                Some(match ret {
+                    NativeTy::Float => VmValue::Float(f64::from_bits(bits as u64)),
+                    NativeTy::Bool => VmValue::Bool(bits != 0),
+                    _ => VmValue::Int(bits),
                 })
             }
             _ => {
@@ -3304,11 +3319,14 @@ fn compute_recursive_int_member_inner(
 }
 
 /// The mutually-recursive group (call-graph SCC) containing `function_id`, if it is
-/// a cycle of >= 2 all-scalar-`Int` functions whose every `CallKnown` targets a
-/// group member (native-call-ABI slice 4). Returned sorted; `None` for non-cyclic
-/// functions and pure self-recursion (handled by the self-recursive path).
+/// a cycle of >= 2 functions (native-call-ABI slice 4). Returned sorted; `None` for
+/// non-cyclic functions and pure self-recursion (handled by the self-recursive
+/// path). Per-member native eligibility (scalar params/return, native-subset body)
+/// is NOT decided here — the caller's `translate_to_native_jit_with_calls` per member
+/// is the single eligibility gate, so the group admits any cycle the general native
+/// path can compile (Int/Bool/Float bodies, members that also call inlinable leaves).
 #[cfg(feature = "native-jit")]
-fn native_recursive_int_group(unit: &RegUnit, function_id: usize) -> Option<Vec<usize>> {
+fn native_recursive_group(unit: &RegUnit, function_id: usize) -> Option<Vec<usize>> {
     use std::collections::HashSet;
     let callees = |fid: usize| -> Vec<usize> {
         unit.functions.get(fid).map_or_else(Vec::new, |f| {
@@ -3347,15 +3365,6 @@ fn native_recursive_int_group(unit: &RegUnit, function_id: usize) -> Option<Vec<
     if scc.len() < 2 {
         return None;
     }
-    let group: HashSet<usize> = scc.iter().copied().collect();
-    for &member in &scc {
-        // Mutual recursion falls back to the full interpreter (not the i64 tier-0
-        // executor), so any scalar value return kind (Int or Bool) is admissible.
-        match compute_recursive_int_member_inner(unit, member, &group) {
-            Some(ScalarSlotKind::Int | ScalarSlotKind::Bool) => {}
-            _ => return None,
-        }
-    }
     Some(scc)
 }
 

crates/rsscript/tests/jit_acceptance.rs

@@ -4759,6 +4759,44 @@ fn main() -> Unit {
     );
 }
 
+/// Mutual recursion generalized to scalar Float (the Phase-2 treatment applied to
+/// the group path): a FLOAT-returning mutually-recursive cycle now runs natively via
+/// the co-compiled group, with Float params/return marshalled via to_bits/from_bits.
+/// Before, the group analysis admitted only Int/Bool members. Byte-identical to the
+/// interpreter (incl. float formatting) and `native_calls > 0`.
+#[cfg(feature = "native-jit")]
+#[test]
+fn native_mutual_recursion_float_runs_native() {
+    let source = "\
+fn fa(n: Int) -> Float {
+    if n <= 0 { return 1.0 }
+    return 1.5 + fb(n: n - 1)
+}
+fn fb(n: Int) -> Float {
+    if n <= 0 { return 2.0 }
+    return 0.5 + fa(n: n - 1)
+}
+fn main() -> Unit {
+    Log.write(message: read Float.to_string(value: read fa(n: 11)))
+    Log.write(message: read Float.to_string(value: read fb(n: 10)))
+    return Unit
+}
+";
+    let interp = common::run_vm_source("native-mutual-float.rss", source, &[]).expect("interp");
+    let exe = rsscript::reg_vm_compile_source("native-mutual-float.rss", source).expect("compile");
+    let (out, stats) = exe
+        .eval_main_with_args_native_with_stats(std::iter::empty::<String>())
+        .expect("native run");
+    assert_eq!(
+        interp.stdout, out.stdout,
+        "Float mutual recursion native must be byte-identical to the interpreter"
+    );
+    assert!(
+        stats.native_calls > 0,
+        "Float mutual recursion should run via the native group path: {stats:?}",
+    );
+}
+
 /// Native-call ABI (slice 4): MUTUAL recursion `is_even`/`is_odd` runs NATIVELY via
 /// the co-compiled group (CallGroup), byte-identical to the interpreter.
 /// `native_calls > 0` proves the native group path executed.