fix: Handle nested Block expressions in While loops and void function returns

This fixes two issues with Haxe/Reflaxe compilation:

1. CFG builder: Handle Expression(Block) in while loop bodies
   - Haxe generates While body as Expression(Block(...)) instead of
     direct statements
   - Added flattening logic in typed_cfg.rs to recursively process
     inner Block statements

2. Cranelift backend: Void functions now return instead of trap
   - Functions with Void return type that fall through without explicit
     return now emit `return_(&[])` instead of `trap unreachable`
   - This fixes Haxe main() functions which return Void

Tested with SimpleWhileTest.hx which computes sum 0+1+2+3+4 = 10 using
a while loop - generates correct Cranelift IR with proper phi nodes.

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -1737,7 +1737,14 @@ impl CraneliftBackend {
                     }
 
                     HirTerminator::Unreachable => {
-                        builder.ins().trap(cranelift_codegen::ir::TrapCode::UnreachableCodeReached);
+                        // For void-returning functions, emit a return instead of trap
+                        // This handles Haxe/other languages where main() returns Void and has no explicit return
+                        if function.signature.returns.is_empty() ||
+                           function.signature.returns.iter().all(|r| matches!(r, HirType::Void)) {
+                            builder.ins().return_(&[]);
+                        } else {
+                            builder.ins().trap(cranelift_codegen::ir::TrapCode::UnreachableCodeReached);
+                        }
                     }
 
                     _ => {

crates/compiler/src/typed_cfg.rs

@@ -782,6 +782,22 @@ impl TypedCfgBuilder {
                     exit_id = block_exit;
                 }
 
+                TypedStatement::Expression(expr) => {
+                    // Check if expression is a Block - if so, flatten it
+                    if let TypedExpression::Block(block) = &expr.node {
+                        log::debug!("[CFG] Expression(Block): flattening block with {} statements", block.statements.len());
+                        // Recursively process the block's statements
+                        let (block_blocks, _block_entry, block_exit) = self.split_at_control_flow(block, current_block_id)?;
+                        all_blocks.extend(block_blocks);
+                        current_statements = Vec::new();
+                        current_block_id = block_exit;
+                        exit_id = block_exit;
+                    } else {
+                        // Regular expression - add as statement
+                        current_statements.push(stmt.clone());
+                    }
+                }
+
                 TypedStatement::Break(value_opt) => {
                     // Break jumps to loop exit
                     if let Some(&(_header_id, exit_id)) = self.loop_stack.last() {

reflaxe.zyntax/extraParams.hxml

@@ -7,6 +7,9 @@
 # Define Zyntax target for conditional compilation
 -D zyntax
 
+# Enable Zyntax runtime transformers (StringOperatorTransformer, TraceTransformer)
+-D zyntax_runtime
+
 # Initialize the Zyntax compiler
 --macro zyntax.ZyntaxCompilerInit.Start()
 

reflaxe.zyntax/test/SimpleWhileTest.hx

@@ -0,0 +1,17 @@
+class SimpleWhileTest {
+    public static function calculate():Int {
+        // Simple while loop that returns a value
+        var sum = 0;
+        var i = 0;
+        while (i < 5) {
+            sum = sum + i;
+            i = i + 1;
+        }
+        return sum;  // Should return 0+1+2+3+4 = 10
+    }
+
+    public static function main():Void {
+        var result = calculate();
+        // result is 10
+    }
+}

reflaxe.zyntax/test/build_simple_while.hxml

@@ -0,0 +1,4 @@
+-lib reflaxe.zyntax
+-main SimpleWhileTest
+-D zyntax-output=output
+--macro exclude('haxe.Log')