fix: register zyntax_box_* runtime symbols + correct LLVM Call::Symbol return type

When the SSA-lowering autobox / autounbox path for `Type::Any`
fields emits `Call::Symbol("zyntax_box_X")` or `..._get_X`, two
things had to be in place that weren't:

1. The runtime had to know those symbols. `ZyntaxRuntime::new`
   already registers `__zyntax_effect_*` up front; mirror that
   for the box helpers in a new `register_box_runtime_symbols`
   in `effect_runtime.rs`. Each symbol goes to (a) the
   Cranelift backend's runtime-symbol table via
   `register_function_typed`, (b) the plugin-signatures table
   (so the LLVMBackend's per-symbol boxing decisions see the
   right param types), and (c) the BC interp's FFI table via
   `register_zrtl_symbols`. Without (c) the interp tier panicked
   with "unknown function 'zyntax_box_X'" the moment a hot path
   resolved through it. Plus added the missing
   `zyntax_box_get_{i32,f32,f64,bool}` runtime helpers in
   `zrtl.rs` alongside the existing `_i64`.

2. The LLVMBackend's `Call::Symbol` path defaulted to
   `void(args) → i32 0` whenever the symbol's signature wasn't
   in `symbol_signatures` — and the interp_runtime LLVM install
   path only forwarded the raw symbol pointers, not the
   signatures. Two changes:
   - `install_jit_with` now calls
     `be.register_symbol_signatures(&box_infos)` so the LLVM
     JIT sees the box helpers' real types.
   - `LLVMBackend::compile_call`'s Symbol arm now respects
     `sig_info.return_type` when present — picks an LLVM scalar
     type matching the `TypeTag` category/size (mirrors
     `type_tag_to_cranelift_type`). Without this, unboxing an
     f64 still surfaced an "i32 0" placeholder that crashed
     downstream FAdd / FSub.

`bench_any_field` round-trips an f64 through an `Any` field 1M
times under the LLVM tier and returns the correct `Int(1500000)`.
All other kernels unchanged.

Followup: explicit `X as Any` / `Any as T` cast plumbing is a
separate piece — wired the helpers but the typed-AST surfacing
of `cast.expr.ty` made it double-convert in the current shape.
The field-load autobox/autounbox already covers the
`let v: T = b.payload` ergonomic the user actually hits.

Author: darmie

crates/compiler/src/llvm_backend.rs

@@ -3235,19 +3235,71 @@ impl<'ctx> LLVMBackend<'ctx> {
                     })
                     .collect();
 
-                // Declare the function (assume void return for now)
-                let fn_type = self.context.void_type().fn_type(&param_types, false);
+                // Pick the return type from the registered signature
+                // when present. Without this the function declaration
+                // defaulted to `void(args)` and the caller — which had
+                // already typed the call result based on the SSA value
+                // type — would consume an "i32 0" dummy and panic the
+                // first time it tried to use the result as an f64 /
+                // f32 / bool. Mirrors `type_tag_to_cranelift_type` in
+                // the Cranelift backend.
+                let returns_void = sig_info
+                    .as_ref()
+                    .map(|s| matches!(s.return_type.category(), crate::zrtl::TypeCategory::Void))
+                    .unwrap_or(true);
+                let call_name = if returns_void { "" } else { symbol_name };
+                let fn_type = if let Some(ref sig) = sig_info {
+                    use crate::zrtl::{PrimitiveSize, TypeCategory};
+                    let bits = sig.return_type.type_id();
+                    match sig.return_type.category() {
+                        TypeCategory::Void => self.context.void_type().fn_type(&param_types, false),
+                        TypeCategory::Bool => self.context.bool_type().fn_type(&param_types, false),
+                        TypeCategory::Int | TypeCategory::UInt => {
+                            if bits == PrimitiveSize::Bits8 as u16 {
+                                self.context.i8_type().fn_type(&param_types, false)
+                            } else if bits == PrimitiveSize::Bits16 as u16 {
+                                self.context.i16_type().fn_type(&param_types, false)
+                            } else if bits == PrimitiveSize::Bits32 as u16 {
+                                self.context.i32_type().fn_type(&param_types, false)
+                            } else {
+                                self.context.i64_type().fn_type(&param_types, false)
+                            }
+                        }
+                        TypeCategory::Float => {
+                            if bits == PrimitiveSize::Bits32 as u16 {
+                                self.context.f32_type().fn_type(&param_types, false)
+                            } else {
+                                self.context.f64_type().fn_type(&param_types, false)
+                            }
+                        }
+                        // Pointers / opaques / closures: ptr return.
+                        _ => self
+                            .context
+                            .ptr_type(AddressSpace::default())
+                            .fn_type(&param_types, false),
+                    }
+                } else {
+                    self.context.void_type().fn_type(&param_types, false)
+                };
                 let func = self
                     .module
                     .get_function(symbol_name)
                     .unwrap_or_else(|| self.module.add_function(symbol_name, fn_type, None));
 
                 // Build call
-                self.builder
-                    .build_call(func, &final_arg_values, symbol_name)?;
-
-                // Return a dummy value (void functions don't return anything meaningful)
-                Ok(self.context.i32_type().const_zero().into())
+                let call_site = self
+                    .builder
+                    .build_call(func, &final_arg_values, call_name)?;
+                if returns_void {
+                    Ok(self.context.i32_type().const_zero().into())
+                } else {
+                    match call_site.try_as_basic_value() {
+                        ValueKind::Basic(val) => Ok(val),
+                        ValueKind::Instruction(_) => {
+                            Ok(self.context.i32_type().const_zero().into())
+                        }
+                    }
+                }
             }
             HirCallable::FuncRef(_) => Err(CompilerError::CodeGen(
                 "HirCallable::FuncRef is not callable directly — \

crates/compiler/src/ssa.rs

@@ -4470,7 +4470,7 @@ impl SsaBuilder {
                     if let Some(field_hir_ty) = field_ty {
                         let object_hir_ty =
                             self.function.values.get(&object_val).map(|v| v.ty.clone());
-                        if object_hir_ty.as_ref() != Some(&field_hir_ty) {
+                        let raw = if object_hir_ty.as_ref() != Some(&field_hir_ty) {
                             // Rebind with the field's HirType via Bitcast.
                             let rebind =
                                 self.create_value(field_hir_ty.clone(), HirValueKind::Instruction);
@@ -4484,10 +4484,23 @@ impl SsaBuilder {
                                 },
                             );
                             self.add_use(object_val, rebind);
-                            return Ok(rebind);
-                        }
-                        // Types already match — no rebind needed.
-                        return Ok(object_val);
+                            rebind
+                        } else {
+                            object_val
+                        };
+                        // Even on the single-field shortcut, the field
+                        // may be declared `Type::Any` (box-pointer
+                        // slot) — apply the same autounbox the
+                        // ExtractValue path does so
+                        // `let v: f64 = b.payload` round-trips when
+                        // `b` is a single-field struct.
+                        return Ok(self.maybe_unbox_for_any_field(
+                            block_id,
+                            raw,
+                            &object_type,
+                            field_index as usize,
+                            &expr.ty,
+                        ));
                     }
                     // Fall through to ExtractValue when we couldn't resolve
                     // the field type.
@@ -7505,10 +7518,6 @@ impl SsaBuilder {
     /// `zyntax_box_get_X` call to unwrap the box pointer. Leaves
     /// boxes intact when the use-site is also `Type::Any` (the box
     /// pointer flows through as-is to whatever next consumes it).
-    ///
-    /// Pairs with the autobox-on-store rule so that
-    /// `let x: f64 = b.value` round-trips a stored f64 cleanly
-    /// instead of leaving the user holding a raw `*mut DynamicBox`.
     fn maybe_unbox_for_any_field(
         &mut self,
         block_id: HirId,
@@ -7517,7 +7526,6 @@ impl SsaBuilder {
         field_index: usize,
         use_site_ty: &Type,
     ) -> HirId {
-        // Field-side gate: only act on fields declared `Type::Any`.
         let field_is_any = self
             .get_field_typed_types(object_ty)
             .and_then(|fs| fs.get(field_index).cloned())
@@ -7526,11 +7534,24 @@ impl SsaBuilder {
         if !field_is_any {
             return boxed_value;
         }
-        // Use-site gate: only unbox when there's a concrete target
-        // type. If the surrounding context also wants `Any`, the box
-        // pointer is exactly the right thing to forward unchanged.
+        self.try_emit_any_downcast(block_id, boxed_value, use_site_ty)
+            .unwrap_or(boxed_value)
+    }
+
+    /// Emit a `zyntax_box_get_X` call to downcast a `*mut DynamicBox`
+    /// (HIR i64) to the requested concrete primitive type. Returns
+    /// `Some(unboxed)` when the target type has a matching getter,
+    /// `None` otherwise (caller falls through to whatever default
+    /// it had). Shared between the Field-load unbox path and the
+    /// explicit-cast (`X as T`) unbox path.
+    fn try_emit_any_downcast(
+        &mut self,
+        block_id: HirId,
+        boxed_value: HirId,
+        target_ty: &Type,
+    ) -> Option<HirId> {
         use zyntax_typed_ast::PrimitiveType;
-        let (get_symbol, result_hir_ty) = match use_site_ty {
+        let (symbol, result_hir_ty) = match target_ty {
             Type::Primitive(PrimitiveType::I8)
             | Type::Primitive(PrimitiveType::I16)
             | Type::Primitive(PrimitiveType::I32)
@@ -7543,22 +7564,22 @@ impl SsaBuilder {
             Type::Primitive(PrimitiveType::F32) => ("zyntax_box_get_f32", HirType::F32),
             Type::Primitive(PrimitiveType::F64) => ("zyntax_box_get_f64", HirType::F64),
             Type::Primitive(PrimitiveType::Bool) => ("zyntax_box_get_bool", HirType::Bool),
-            _ => return boxed_value,
+            _ => return None,
         };
         let unboxed = self.create_value(result_hir_ty, HirValueKind::Instruction);
         self.add_instruction(
             block_id,
             HirInstruction::Call {
                 result: Some(unboxed),
-                callee: crate::hir::HirCallable::Symbol(get_symbol.to_string()),
+                callee: crate::hir::HirCallable::Symbol(symbol.to_string()),
                 args: vec![boxed_value],
                 type_args: vec![],
                 const_args: vec![],
                 is_tail: false,
             },
         );
         self.add_use(boxed_value, unboxed);
-        unboxed
+        Some(unboxed)
     }
 
     /// Convert frontend type to HIR type

crates/compiler/src/zrtl.rs

@@ -1760,6 +1760,32 @@ pub fn type_tag_for_hir_type(ty: &crate::hir::HirType) -> TypeTag {
     }
 }
 
+/// Return the list of `zyntax_box_*` runtime helpers as `(name, fn
+/// pointer, arity)` triples. The runtime (BC interp + Cranelift JIT
+/// + LLVM AOT) registers these by default so any module that
+/// reaches the autobox / autounbox code paths in SSA lowering finds
+/// the symbol resolved.
+///
+/// Mirrors the per-symbol `register_function_typed` shape that the
+/// effect-runtime registration uses, but flat — the box helpers are
+/// pure FFI with no effect bookkeeping needed.
+pub fn box_runtime_symbols() -> Vec<(&'static str, *const u8, u8)> {
+    vec![
+        ("zyntax_box_i32", zyntax_box_i32 as *const u8, 1),
+        ("zyntax_box_i64", zyntax_box_i64 as *const u8, 1),
+        ("zyntax_box_f32", zyntax_box_f32 as *const u8, 1),
+        ("zyntax_box_f64", zyntax_box_f64 as *const u8, 1),
+        ("zyntax_box_bool", zyntax_box_bool as *const u8, 1),
+        ("zyntax_box_free", zyntax_box_free as *const u8, 1),
+        ("zyntax_box_get_i32", zyntax_box_get_i32 as *const u8, 1),
+        ("zyntax_box_get_i64", zyntax_box_get_i64 as *const u8, 1),
+        ("zyntax_box_get_f32", zyntax_box_get_f32 as *const u8, 1),
+        ("zyntax_box_get_f64", zyntax_box_get_f64 as *const u8, 1),
+        ("zyntax_box_get_bool", zyntax_box_get_bool as *const u8, 1),
+        ("zyntax_box_get_tag", zyntax_box_get_tag as *const u8, 1),
+    ]
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;