fix(ssa): autounbox values read from Type::Any struct fields

Counterpart to the autobox-on-store fix in `1f438e8`. When user
code accesses a field whose declared type is `Type::Any` AND the
use-site has a concrete target type (let binding annotation,
function parameter, return statement, …), the field-load now
routes through the matching `zyntax_box_get_X` runtime helper so
the user gets the stored value back instead of the raw `*mut
DynamicBox` pointer.

Together with the autobox-on-store side this closes the round-trip
loop: `let bag = Bag { payload: 1.5 } ; let v: f64 = bag.payload`
now does the right thing — `Bag` literal boxes `1.5` via
`zyntax_box_f64`, field read uses `zyntax_box_get_f64` because the
let binding constrains the use-site type. Before this commit, the
read returned an i64 box pointer that the user would have to
manually unwrap, which was — to use the technical term — silly.

Runtime side: added the missing getter helpers
`zyntax_box_get_{i32,f32,f64,bool}` in `zrtl.rs` mirroring the
existing `_i64` shape. Sizes are read from the box's `size` field
so source values that were narrower than the requested type widen
losslessly (i8 → i32, f32 → f64 etc.).

Test: new `bench_any_field` kernel exercises 1M round-trips of
storing f64 1.5 through an `Any` field and reading back as f64,
sums them, and asserts `Int(1500000)`. The bench harness's value
gate catches any regression that would re-introduce silent
miscompiles.

Existing kernels unchanged — none use `Any` fields, so both the
autobox and autounbox helpers are no-ops for them.

Author: darmie

crates/compiler/src/ssa.rs

@@ -4405,7 +4405,17 @@ impl SsaBuilder {
                                 },
                             );
                             self.add_use(field_ptr, load_result);
-                            return Ok(load_result);
+                            // Unbox if the field is `Type::Any` and the
+                            // use-site has a concrete target type. See
+                            // `maybe_unbox_for_any_field` for the
+                            // `zyntax_box_get_X` selection table.
+                            return Ok(self.maybe_unbox_for_any_field(
+                                block_id,
+                                load_result,
+                                &object_type,
+                                field_index as usize,
+                                &expr.ty,
+                            ));
                         }
                     }
                 }
@@ -4510,7 +4520,15 @@ impl SsaBuilder {
                 self.add_instruction(block_id, inst);
                 self.add_use(object_val, result);
 
-                Ok(result)
+                // Unbox if the declared field type is `Type::Any` and
+                // the use-site has a concrete target type.
+                Ok(self.maybe_unbox_for_any_field(
+                    block_id,
+                    result,
+                    &object_type,
+                    field_index as usize,
+                    &expr.ty,
+                ))
             }
 
             TypedExpression::Index(index_expr) => {
@@ -7481,6 +7499,68 @@ impl SsaBuilder {
         boxed
     }
 
+    /// Counterpart to [`maybe_box_for_any_field`]: when reading a
+    /// field whose DECLARED type is `Type::Any` and the use-site's
+    /// inferred type (`use_site_ty`) is a concrete primitive, emit a
+    /// `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,
+        boxed_value: HirId,
+        object_ty: &Type,
+        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())
+            .map(|t| matches!(t, Type::Any))
+            .unwrap_or(false);
+        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.
+        use zyntax_typed_ast::PrimitiveType;
+        let (get_symbol, result_hir_ty) = match use_site_ty {
+            Type::Primitive(PrimitiveType::I8)
+            | Type::Primitive(PrimitiveType::I16)
+            | Type::Primitive(PrimitiveType::I32)
+            | Type::Primitive(PrimitiveType::U8)
+            | Type::Primitive(PrimitiveType::U16)
+            | Type::Primitive(PrimitiveType::U32) => ("zyntax_box_get_i32", HirType::I32),
+            Type::Primitive(PrimitiveType::I64) | Type::Primitive(PrimitiveType::U64) => {
+                ("zyntax_box_get_i64", HirType::I64)
+            }
+            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,
+        };
+        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()),
+                args: vec![boxed_value],
+                type_args: vec![],
+                const_args: vec![],
+                is_tail: false,
+            },
+        );
+        self.add_use(boxed_value, unboxed);
+        unboxed
+    }
+
     /// Convert frontend type to HIR type
     fn convert_type(&self, ty: &Type) -> HirType {
         use zyntax_typed_ast::PrimitiveType;

crates/compiler/src/zrtl.rs

@@ -1587,6 +1587,64 @@ pub unsafe extern "C" fn zyntax_box_get_i64(boxed: *const DynamicBoxRepr) -> i64
     }
 }
 
+/// Get the value from a DynamicBox as i32. Reads through the box's
+/// `data` pointer using the recorded `size` so source values stored
+/// as i8/i16 widen losslessly. Returns 0 on null box.
+#[no_mangle]
+pub unsafe extern "C" fn zyntax_box_get_i32(boxed: *const DynamicBoxRepr) -> i32 {
+    if boxed.is_null() || (*boxed).data.is_null() {
+        return 0;
+    }
+    match (*boxed).size {
+        1 => *((*boxed).data as *const i8) as i32,
+        2 => *((*boxed).data as *const i16) as i32,
+        4 => *((*boxed).data as *const i32),
+        _ => 0,
+    }
+}
+
+/// Get the value from a DynamicBox as f32. Source f64 narrows.
+#[no_mangle]
+pub unsafe extern "C" fn zyntax_box_get_f32(boxed: *const DynamicBoxRepr) -> f32 {
+    if boxed.is_null() || (*boxed).data.is_null() {
+        return 0.0;
+    }
+    match (*boxed).size {
+        4 => *((*boxed).data as *const f32),
+        8 => *((*boxed).data as *const f64) as f32,
+        _ => 0.0,
+    }
+}
+
+/// Get the value from a DynamicBox as f64. Source f32 widens.
+#[no_mangle]
+pub unsafe extern "C" fn zyntax_box_get_f64(boxed: *const DynamicBoxRepr) -> f64 {
+    if boxed.is_null() || (*boxed).data.is_null() {
+        return 0.0;
+    }
+    match (*boxed).size {
+        4 => *((*boxed).data as *const f32) as f64,
+        8 => *((*boxed).data as *const f64),
+        _ => 0.0,
+    }
+}
+
+/// Get the value from a DynamicBox as bool (returned as i32 for FFI).
+#[no_mangle]
+pub unsafe extern "C" fn zyntax_box_get_bool(boxed: *const DynamicBoxRepr) -> i32 {
+    if boxed.is_null() || (*boxed).data.is_null() {
+        return 0;
+    }
+    if (*boxed).size == 0 {
+        return 0;
+    }
+    if *((*boxed).data as *const u8) != 0 {
+        1
+    } else {
+        0
+    }
+}
+
 /// Get the TypeTag from a DynamicBox
 #[no_mangle]
 pub unsafe extern "C" fn zyntax_box_get_tag(boxed: *const DynamicBoxRepr) -> u32 {

crates/zynml/examples/bench_any_field.zynml

@@ -0,0 +1,29 @@
+// Type::Any field roundtrip — autobox-on-store + unbox-on-read.
+//
+// Stores an f64 into an `Any` field via `zyntax_box_f64`, then reads
+// it back with use-site type `f64` (the let binding annotation) so
+// the lowering inserts `zyntax_box_get_f64`. A clean round-trip
+// gets you the stored value; a broken pipeline either crashes at
+// codegen (the i32 case used to LLVM-panic on bitcast i32→i64) or
+// silently returns the box pointer cast to i64.
+//
+// The loop body re-creates the box and unboxes 1M times — a noisy
+// per-iteration heap allocation, so this benchmarks malloc churn
+// more than arithmetic. The point isn't the number, it's the
+// correctness gate.
+
+struct Bag {
+    payload: Any
+}
+
+def main(): i64 {
+    let mut sum: f64 = 0.0
+    let mut i: i64 = 0
+    while i < 1000000 {
+        let bag = Bag { payload: 1.5 }
+        let v: f64 = bag.payload
+        sum = sum + v
+        i = i + 1
+    }
+    return sum as i64
+}

crates/zynml/examples/bench_runner.rs

@@ -196,6 +196,7 @@ const KERNELS: &[(&str, &str)] = &[
     // → sum 210000000.
     ("bench_op_overload", "Int(210000000)"),
     ("bench_op_overload_ref", "Int(21000000)"),
+    ("bench_any_field", "Int(1500000)"),
 ];
 
 /// Each target produces one [`TargetResult`] per kernel.