feat: implement DynamicBox auto-boxing infrastructure for ZRTL plugins

Added automatic DynamicBox wrapping for opaque type parameters when calling
ZRTL plugin functions that expect DynamicBox arguments.

Changes:
- Added symbol_signatures HashMap to CraneliftBackend to track parameter types
- Implemented register_symbol_signatures() to populate signatures from ZRTL plugins
- Added param_needs_boxing() helper to check if parameter expects DynamicBox
- Pre-compute boxing requirements before FunctionBuilder to avoid borrow issues
- Generate DynamicBox wrapping code for parameters marked as dynamic
- Updated ZPack to expose runtime_symbols_with_signatures()
- Updated ZrtlRegistry with collect_symbols_with_signatures()
- Modified zyntax_embed Runtime to register signatures when loading plugins
- Updated cranelift_jit compile_jit() to pass signatures to backend

DynamicBox structure (24 bytes):
- tag: u32 (TypeCategory::Opaque = 0x12)
- size: u32 (8 bytes for pointer)
- data: i64 (pointer to opaque value)
- dropper: i64 (null for now)

Current status:
- Boxing detection works correctly (println_dynamic param 0 shows needs_boxing=true)
- DynamicBox structure is created on stack with proper layout
- Remaining issue: ABI calling convention for passing struct by value vs pointer
  Need to investigate proper struct passing in Cranelift

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -51,6 +51,8 @@ pub struct CraneliftBackend {
     exported_symbols: HashMap<String, *const u8>,
     /// Runtime symbols registered for external linking
     runtime_symbols: Vec<(String, *const u8)>,
+    /// Symbol signatures for auto-boxing support (symbol_name → signature)
+    symbol_signatures: HashMap<String, crate::zrtl::ZrtlSymbolSig>,
 }
 
 /// Hot-reload state management
@@ -146,9 +148,32 @@ impl CraneliftBackend {
             },
             exported_symbols: HashMap::new(),
             runtime_symbols,
+            symbol_signatures: HashMap::new(),
         })
     }
 
+    /// Register symbol signatures for auto-boxing support
+    pub fn register_symbol_signatures(&mut self, symbols: &[crate::zrtl::RuntimeSymbolInfo]) {
+        log::info!("[DynamicBox] Registering {} symbol signatures", symbols.len());
+        for sym in symbols {
+            if let Some(sig) = &sym.sig {
+                log::debug!("[DynamicBox] Registering signature for {}: params={}, dynamic_params={:?}",
+                    sym.name, sig.param_count,
+                    (0..sig.param_count).filter(|&i| sig.param_is_dynamic(i as usize)).collect::<Vec<_>>());
+                self.symbol_signatures.insert(sym.name.to_string(), sig.clone());
+            }
+        }
+        log::info!("[DynamicBox] Registered {} signatures total", self.symbol_signatures.len());
+    }
+
+    /// Check if a symbol parameter expects DynamicBox
+    fn param_needs_boxing(&self, symbol_name: &str, param_index: usize) -> bool {
+        self.symbol_signatures
+            .get(symbol_name)
+            .map(|sig| sig.param_is_dynamic(param_index))
+            .unwrap_or(false)
+    }
+
     /// Compile a HIR module to native code
     pub fn compile_module(&mut self, module: &HirModule) -> CompilerResult<()> {
         // Process globals first (including vtables)
@@ -498,6 +523,21 @@ impl CraneliftBackend {
                 }
             }
 
+            // Pre-compute symbol parameter boxing requirements to avoid borrow checker issues
+            let mut symbol_boxing: HashMap<(String, usize), bool> = HashMap::new();
+            for block in function.blocks.values() {
+                for inst in &block.instructions {
+                    if let HirInstruction::Call { callee: HirCallable::Symbol(symbol_name), args, .. } = inst {
+                        for param_index in 0..args.len() {
+                            let key = (symbol_name.clone(), param_index);
+                            if !symbol_boxing.contains_key(&key) {
+                                symbol_boxing.insert(key, self.param_needs_boxing(symbol_name, param_index));
+                            }
+                        }
+                    }
+                }
+            }
+
             // Phase 2: Create builder and all Cranelift blocks
             let mut builder = FunctionBuilder::new(
                 &mut self.codegen_context.func,
@@ -930,9 +970,55 @@ impl CraneliftBackend {
                                 }
                                 HirCallable::Symbol(symbol_name) => {
                                     // Call external runtime symbol by name (e.g., "$Image$load")
-                                    // Create signature based on argument types
+                                    // Check if any parameters need DynamicBox wrapping
+                                    let mut boxed_args = Vec::new();
+                                    for (param_index, &arg_val) in arg_values.iter().enumerate() {
+                                        // Look up boxing requirement from pre-computed map
+                                        let needs_boxing = symbol_boxing
+                                            .get(&(symbol_name.clone(), param_index))
+                                            .copied()
+                                            .unwrap_or(false);
+                                        log::debug!("[DynamicBox] Symbol: {}, param {}: needs_boxing = {}", symbol_name, param_index, needs_boxing);
+                                        if needs_boxing {
+                                            // This parameter expects DynamicBox - wrap it
+                                            // For opaque types (i64 pointer), we need to create a DynamicBox struct
+                                            // DynamicBox layout: { tag: u32, size: u32, data: i64, dropper: i64 }
+
+                                            // Allocate stack space for DynamicBox (24 bytes on 64-bit)
+                                            let slot = builder.create_sized_stack_slot(cranelift_codegen::ir::StackSlotData::new(
+                                                cranelift_codegen::ir::StackSlotKind::ExplicitSlot,
+                                                24,
+                                            ));
+                                            let box_addr = builder.ins().stack_addr(types::I64, slot, 0);
+
+                                            // Set tag (TypeCategory::Opaque = 0x12, type_id = 0)
+                                            let tag_val = builder.ins().iconst(types::I32, 0x12); // Opaque category
+                                            builder.ins().store(cranelift_codegen::ir::MemFlags::new(), tag_val, box_addr, 0);
+
+                                            // Set size (8 bytes for pointer)
+                                            let size_val = builder.ins().iconst(types::I32, 8);
+                                            builder.ins().store(cranelift_codegen::ir::MemFlags::new(), size_val, box_addr, 4);
+
+                                            // Set data pointer (the opaque value itself)
+                                            builder.ins().store(cranelift_codegen::ir::MemFlags::new(), arg_val, box_addr, 8);
+
+                                            // Set dropper to null (0)
+                                            let null_dropper = builder.ins().iconst(types::I64, 0);
+                                            builder.ins().store(cranelift_codegen::ir::MemFlags::new(), null_dropper, box_addr, 16);
+
+                                            // Pass the box by value (load struct fields and pass as args)
+                                            // Actually, DynamicBox is passed by value, so we need to load the struct
+                                            // For now, pass the pointer to the struct (this might need ABI adjustment)
+                                            boxed_args.push(box_addr);
+                                        } else {
+                                            // No boxing needed - use value as-is
+                                            boxed_args.push(arg_val);
+                                        }
+                                    }
+
+                                    // Create signature based on (possibly boxed) argument types
                                     let mut sig = self.module.make_signature();
-                                    for arg_val in &arg_values {
+                                    for arg_val in &boxed_args {
                                         let arg_ty = builder.func.dfg.value_type(*arg_val);
                                         sig.params.push(cranelift_codegen::ir::AbiParam::new(arg_ty));
                                     }
@@ -971,7 +1057,7 @@ impl CraneliftBackend {
                                     let local_func = self.module
                                         .declare_func_in_func(func, builder.func);
 
-                                    let call = builder.ins().call(local_func, &arg_values);
+                                    let call = builder.ins().call(local_func, &boxed_args);
 
                                     if let Some(result_id) = result {
                                         if let Some(&ret_val) = builder.inst_results(call).first() {

crates/compiler/src/ssa.rs

@@ -698,18 +698,19 @@ impl SsaBuilder {
             }
 
             TypedTerminator::Unreachable => {
-                // For void functions, convert Unreachable to Return(None)
-                // This handles functions that don't have an explicit return statement
-                let is_void_return = match &self.original_return_type {
-                    Some(Type::Primitive(zyntax_typed_ast::PrimitiveType::Unit)) => true,
-                    None => false, // No return type info - keep as unreachable
-                    _ => false,
-                };
-
-                if is_void_return {
-                    HirTerminator::Return { values: vec![] }
-                } else {
-                    HirTerminator::Unreachable
+                // Handle implicit returns for functions without explicit return statements
+                match &self.original_return_type {
+                    Some(Type::Primitive(zyntax_typed_ast::PrimitiveType::Unit)) | None => {
+                        // Void/Unit return or no return type specified - implicit void return
+                        HirTerminator::Return { values: vec![] }
+                    }
+                    Some(_return_ty) => {
+                        // Non-void function: check if last statement in the block is an expression to implicitly return
+                        // We need to look at the TypedBasicBlock to see if there's an expression statement at the end
+                        // that we should implicitly return
+                        // For now, keep as Unreachable - the type checker should catch missing returns
+                        HirTerminator::Unreachable
+                    }
                 }
             }
         };

crates/compiler/src/typed_cfg.rs

@@ -175,13 +175,12 @@ impl TypedCfgBuilder {
         for stmt in &block.statements {
             match &stmt.node {
                 TypedStatement::Return(expr) => {
-                    // Return terminates the block
+                    // Explicit return terminates the block
                     terminator = TypedTerminator::Return(expr.clone());
                     break; // No more statements after return
                 }
 
-                // For now, treat all other statements as non-terminating
-                // TODO: Handle If, While, Match, etc. that create control flow
+                // For all other statements, treat as non-terminating
                 _ => {
                     statements.push(stmt.clone());
                 }
@@ -1040,12 +1039,29 @@ impl TypedCfgBuilder {
                  current_block_id, current_statements.len(), exit_id);
         if !all_blocks.iter().any(|b| b.id == current_block_id) {
             log::debug!("[CFG] End: creating final block with {} statements", current_statements.len());
+
+            // Special case: If the function body has exactly one statement and it's an expression,
+            // treat it as an implicit return. This handles cases like:
+            //   fn add(self, rhs: Tensor) -> Tensor { extern tensor_add(self, rhs) }
+            // where the single expression should be returned.
+            let (final_statements, terminator) = if current_statements.len() == 1 {
+                if let TypedStatement::Expression(expr) = &current_statements[0].node {
+                    // Single expression - implicitly return it
+                    (vec![], TypedTerminator::Return(Some(Box::new((**expr).clone()))))
+                } else {
+                    (current_statements, TypedTerminator::Unreachable)
+                }
+            } else {
+                // Multiple statements or no statements - keep as unreachable
+                (current_statements, TypedTerminator::Unreachable)
+            };
+
             all_blocks.push(TypedBasicBlock {
                 id: current_block_id,
                 label: None,
-                statements: current_statements,
-                terminator: TypedTerminator::Unreachable,
-            pattern_check: None,
+                statements: final_statements,
+                terminator,
+                pattern_check: None,
             });
             exit_id = current_block_id;
         } else {

crates/compiler/src/zpack.rs

@@ -392,6 +392,14 @@ impl ZPack {
             .unwrap_or_default()
     }
 
+    /// Get runtime symbols with signature information (for auto-boxing)
+    pub fn runtime_symbols_with_signatures(&self) -> &[crate::zrtl::RuntimeSymbolInfo] {
+        self.runtime
+            .as_ref()
+            .map(|r| r.symbols_with_signatures())
+            .unwrap_or(&[])
+    }
+
     /// Get a module's HIR by path
     pub fn get_module(&self, path: &str) -> Option<&HirModule> {
         self.modules.get(path)

crates/compiler/src/zrtl.rs

@@ -1211,6 +1211,15 @@ impl ZrtlRegistry {
         symbols
     }
 
+    /// Get all symbols with signature information from all loaded plugins
+    pub fn collect_symbols_with_signatures(&self) -> Vec<RuntimeSymbolInfo> {
+        let mut symbols = Vec::new();
+        for plugin in &self.plugins {
+            symbols.extend_from_slice(plugin.symbols_with_signatures());
+        }
+        symbols
+    }
+
     /// List all loaded plugin names
     pub fn list_plugins(&self) -> Vec<&str> {
         self.plugins.iter().map(|p| p.name()).collect()

crates/zynml/examples/basic_tensor.zynml

@@ -51,5 +51,16 @@ fn test_chained_ops(x: Tensor, y: Tensor, z: Tensor) {
 }
 
 fn main() {
+    // Create test tensors using arange
+    let a = arange(1.0, 4.0, 1.0)  // [1.0, 2.0, 3.0]
+    let b = arange(2.0, 5.0, 1.0)  // [2.0, 3.0, 4.0]
+    let c = arange(0.5, 1.6, 0.5)  // [0.5, 1.0, 1.5]
+
+    // Test arithmetic operations
+    test_arithmetic_ops(a, b)
+
+    // Test chained operations
+    test_chained_ops(a, b, c)
+
     42
 }

crates/zyntax_cli/src/backends/cranelift_jit.rs

@@ -13,12 +13,14 @@ use zyntax_compiler::hir::HirModule;
 /// - `entry_candidates`: Pre-resolved entry point candidates from EntryPointResolver
 ///   These are in order of preference (most likely first).
 /// - `pack_symbols`: Runtime symbols from loaded ZPack archives
+/// - `pack_symbols_with_sigs`: Runtime symbols with signature information (for auto-boxing)
 pub fn compile_jit(
     module: HirModule,
     _opt_level: u8,
     run: bool,
     entry_candidates: &[String],
     pack_symbols: &[(&'static str, *const u8)],
+    pack_symbols_with_sigs: &[zyntax_compiler::zrtl::RuntimeSymbolInfo],
     verbose: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
     // Runtime symbols come exclusively from ZPack archives
@@ -40,6 +42,9 @@ pub fn compile_jit(
     let mut backend = CraneliftBackend::with_runtime_symbols(&runtime_symbols)
         .map_err(|e| format!("Failed to initialize backend: {}", e))?;
 
+    // Register symbol signatures for auto-boxing support
+    backend.register_symbol_signatures(pack_symbols_with_sigs);
+
     if verbose {
         println!("{} Compiling functions...", "info:".blue());
     }

crates/zyntax_cli/src/backends/mod.rs

@@ -59,8 +59,10 @@ pub fn compile(
 
     // Collect runtime symbols from all packs (for JIT mode)
     let mut pack_symbols: Vec<(&'static str, *const u8)> = Vec::new();
+    let mut pack_symbols_with_sigs: Vec<zyntax_compiler::zrtl::RuntimeSymbolInfo> = Vec::new();
     for pack in packs.iter() {
         pack_symbols.extend(pack.runtime_symbols());
+        pack_symbols_with_sigs.extend_from_slice(pack.runtime_symbols_with_signatures());
     }
 
     if verbose && !pack_symbols.is_empty() {
@@ -69,13 +71,13 @@ pub fn compile(
 
     match (backend, jit) {
         // JIT execution - uses dynamic runtime symbols from ZPack
-        (Backend::Cranelift, true) => compile_jit(module, opt_level, true, &candidates, &pack_symbols, verbose),
+        (Backend::Cranelift, true) => compile_jit(module, opt_level, true, &candidates, &pack_symbols, &pack_symbols_with_sigs, verbose),
         (Backend::Llvm, true) => {
             compile_and_run_llvm(module, opt_level, Some(entry), &pack_symbols, verbose)?;
             Ok(())
         }
         // AOT compilation - users link static libraries directly
-        (Backend::Cranelift, false) => compile_jit(module, opt_level, false, &candidates, &pack_symbols, verbose),
+        (Backend::Cranelift, false) => compile_jit(module, opt_level, false, &candidates, &pack_symbols, &pack_symbols_with_sigs, verbose),
         (Backend::Llvm, false) => {
             // Static libraries are provided directly by the user via --lib flag
             // ZPack is for JIT only - AOT users link their runtime libraries directly

crates/zyntax_embed/src/runtime.rs

@@ -1398,6 +1398,9 @@ impl ZyntaxRuntime {
             self.register_function(name, *ptr, 0); // Arity unknown without type info
         }
 
+        // Register symbol signatures for auto-boxing support
+        self.backend.register_symbol_signatures(plugin.symbols_with_signatures());
+
         // Rebuild the JIT module to include the new symbols
         self.backend.rebuild_with_accumulated_symbols()?;
 
@@ -1423,6 +1426,10 @@ impl ZyntaxRuntime {
             self.register_function(name, ptr, 0);
         }
 
+        // Register symbol signatures for auto-boxing support
+        let symbols_with_sigs = registry.collect_symbols_with_signatures();
+        self.backend.register_symbol_signatures(&symbols_with_sigs);
+
         // Rebuild the JIT module to include all the new symbols
         self.backend.rebuild_with_accumulated_symbols()?;