wip: Async state machine compilation with SSA value tracking

- Fix grammar fold_binary to properly capture operators for expressions
- Track SSA parameter value IDs (distinct from declaration IDs) for captures
- Skip copying Parameter values to async wrapper (loaded from state machine)
- Fix call_async to look up {name}_new and {name}_poll functions
- Add async_test.zyn grammar for testing async/await functionality
- Add comprehensive async runtime tests

Note: Current implementation uses _new/_poll naming convention which
needs refactoring to return Promise objects directly from async functions.

Author: darmie

crates/compiler/src/async_support.rs

@@ -287,7 +287,10 @@ impl CraneliftBackend {
             self.function_map.insert(id, func_id);
         } else {
             // Regular functions use Export linkage with unique name
-            let unique_name = format!("{}__{:?}", function.name.to_string(), id);
+            // Use resolve_global to get the actual function name
+            let base_name = function.name.resolve_global()
+                .unwrap_or_else(|| format!("{:?}", function.name));
+            let unique_name = format!("{}__{:?}", base_name, id);
             let func_id = self.module.declare_function(
                 &unique_name,
                 Linkage::Export,
@@ -454,6 +457,8 @@ impl CraneliftBackend {
         }
 
         // Build function body
+        eprintln!("[Cranelift] Building function body with signature:");
+        eprintln!("[Cranelift]   sig.returns = {:?}", sig.returns);
         self.codegen_context.func = cranelift_codegen::ir::Function::with_name_signature(
             UserFuncName::user(0, func_id.as_u32()),
             sig.clone(),
@@ -466,11 +471,21 @@ impl CraneliftBackend {
 
             // Phase 1: Analyze function structure
             let block_order = self.compute_block_order(function);
-            log::debug!("[Cranelift] Block order: {:?} blocks", block_order.len());
-            log::debug!("[Cranelift] Entry block: {:?}", function.entry_block);
-            log::debug!("[Cranelift] Total blocks in function: {:?}", function.blocks.len());
+            eprintln!("[Cranelift] Compiling function: {:?}", function.name);
+            eprintln!("[Cranelift] Block order: {:?} blocks", block_order.len());
+            eprintln!("[Cranelift] Entry block: {:?}", function.entry_block);
+            eprintln!("[Cranelift] Total blocks in function: {:?}", function.blocks.len());
+            eprintln!("[Cranelift] Values count: {:?}", function.values.len());
             for (i, block_id) in block_order.iter().enumerate() {
-                log::debug!("[Cranelift]   [{}] {:?}", i, block_id);
+                if let Some(block) = function.blocks.get(block_id) {
+                    eprintln!("[Cranelift]   [{}] {:?} - {} instructions, terminator: {:?}",
+                        i, block_id, block.instructions.len(), block.terminator);
+                    for (j, inst) in block.instructions.iter().enumerate() {
+                        eprintln!("[Cranelift]     inst[{}]: {:?}", j, inst);
+                    }
+                } else {
+                    eprintln!("[Cranelift]   [{}] {:?} - MISSING!", i, block_id);
+                }
             }
             let predecessor_map = self.build_predecessor_map(function);
 
@@ -542,7 +557,9 @@ impl CraneliftBackend {
             }
 
             // Map all constant values (needs active block for instruction creation)
+            eprintln!("[Cranelift] Processing {} values", function.values.len());
             for value in function.values.values() {
+                eprintln!("[Cranelift]   Value {:?} kind={:?}", value.id, value.kind);
                 if let HirValueKind::Constant(constant) = &value.kind {
                     let cranelift_val = match constant {
                         // For narrow integer types, Cranelift expects zero-extended values, not sign-extended
@@ -1598,6 +1615,30 @@ impl CraneliftBackend {
                             }
                         }
 
+                        HirInstruction::Cast { result, ty, op, operand } => {
+                            // Cast instruction: convert between types
+                            let val = self.value_map.get(operand).copied()
+                                .unwrap_or_else(|| panic!("Cast operand {:?} not in value_map", operand));
+                            // Use type_cache directly - types should be pre-cached
+                            let target_ty = type_cache.get(ty).copied().unwrap_or(types::I64);
+
+                            let cast_val = match op {
+                                crate::hir::CastOp::Bitcast => val,
+                                crate::hir::CastOp::ZExt => builder.ins().uextend(target_ty, val),
+                                crate::hir::CastOp::SExt => builder.ins().sextend(target_ty, val),
+                                crate::hir::CastOp::Trunc => builder.ins().ireduce(target_ty, val),
+                                crate::hir::CastOp::FpToSi => builder.ins().fcvt_to_sint(target_ty, val),
+                                crate::hir::CastOp::FpToUi => builder.ins().fcvt_to_uint(target_ty, val),
+                                crate::hir::CastOp::SiToFp => builder.ins().fcvt_from_sint(target_ty, val),
+                                crate::hir::CastOp::UiToFp => builder.ins().fcvt_from_uint(target_ty, val),
+                                crate::hir::CastOp::FpExt => builder.ins().fpromote(target_ty, val),
+                                crate::hir::CastOp::FpTrunc => builder.ins().fdemote(target_ty, val),
+                                _ => val, // PtrToInt, IntToPtr handled as bitcasts for now
+                            };
+
+                            self.value_map.insert(*result, cast_val);
+                        }
+
                         _ => {
                             // Other instructions not yet implemented
                             // This will cause values to be unmapped, leading to verifier errors
@@ -1609,9 +1650,17 @@ impl CraneliftBackend {
                 // Process terminator (inline to avoid borrow checker)
                 match &hir_block.terminator {
                     HirTerminator::Return { values } => {
+                        eprintln!("[Cranelift] Return terminator with values: {:?}", values);
                         let cranelift_vals: Vec<_> = values.iter()
-                            .filter_map(|v| self.value_map.get(v).copied())
+                            .filter_map(|v| {
+                                let result = self.value_map.get(v).copied();
+                                if result.is_none() {
+                                    eprintln!("[Cranelift ERROR] Return value {:?} not in value_map", v);
+                                }
+                                result
+                            })
                             .collect();
+                        eprintln!("[Cranelift] Returning {} values", cranelift_vals.len());
                         builder.ins().return_(&cranelift_vals);
                     }
 
@@ -1705,6 +1754,7 @@ impl CraneliftBackend {
                             let target_block = self.block_map[target];
 
                             // Create constant value for comparison
+                            // Handle both signed and unsigned integer types
                             let const_val = match constant {
                                 HirConstant::I8(v) => {
                                     let extended = (*v as u8) as i64;
@@ -1719,6 +1769,17 @@ impl CraneliftBackend {
                                     builder.ins().iconst(types::I32, extended)
                                 }
                                 HirConstant::I64(v) => builder.ins().iconst(types::I64, *v),
+                                // Unsigned integer types
+                                HirConstant::U8(v) => {
+                                    builder.ins().iconst(types::I8, *v as i64)
+                                }
+                                HirConstant::U16(v) => {
+                                    builder.ins().iconst(types::I16, *v as i64)
+                                }
+                                HirConstant::U32(v) => {
+                                    builder.ins().iconst(types::I32, *v as i64)
+                                }
+                                HirConstant::U64(v) => builder.ins().iconst(types::I64, *v as i64),
                                 _ => continue, // Skip non-integer constants
                             };
 
@@ -1895,12 +1956,13 @@ impl CraneliftBackend {
         }
 
         // Debug: Print IR after finalize
-        log::debug!("[Cranelift] IR after finalize (inside compile_function_body):\n{}", self.codegen_context.func);
+        eprintln!("[Cranelift] IR after finalize (inside compile_function_body):\n{}", self.codegen_context.func);
 
         // Debug: Uncomment to dump IR for all functions
         // self.dump_cranelift_ir(&function.name.to_string());
 
         // Compile the function
+        eprintln!("[Cranelift] About to call define_function for {:?}", function.name);
         let code = self.module.define_function(
             func_id,
             &mut self.codegen_context,
@@ -2012,6 +2074,10 @@ impl CraneliftBackend {
 
     /// Translate function signature
     pub fn translate_signature(&self, function: &HirFunction) -> CompilerResult<Signature> {
+        eprintln!("[Cranelift] translate_signature for function {:?}", function.name);
+        eprintln!("[Cranelift]   params: {:?}", function.signature.params.len());
+        eprintln!("[Cranelift]   returns: {:?}", function.signature.returns);
+
         let mut cranelift_sig = self.module.make_signature();
 
         // Set calling convention
@@ -3180,9 +3246,12 @@ impl CraneliftBackend {
             }
 
             HirInstruction::Cast { result, ty, op, operand } => {
-                let val = self.value_map[operand];
+                eprintln!("[Cranelift Cast] operand={:?}, op={:?}, target_ty={:?}", operand, op, ty);
+                let val = self.value_map.get(operand).copied()
+                    .unwrap_or_else(|| panic!("Cast operand {:?} not in value_map", operand));
                 let target_ty = self.translate_type(ty)?;
-                
+                eprintln!("[Cranelift Cast] val={:?}, target_ty={:?}", val, target_ty);
+
                 let cast_val = match op {
                     crate::hir::CastOp::Bitcast => {
                         // Bitcast - just return the value for now
@@ -3192,7 +3261,10 @@ impl CraneliftBackend {
                         builder.ins().uextend(target_ty, val)
                     }
                     crate::hir::CastOp::SExt => {
-                        builder.ins().sextend(target_ty, val)
+                        eprintln!("[Cranelift Cast] Doing sextend from val={:?} to target_ty={:?}", val, target_ty);
+                        let result = builder.ins().sextend(target_ty, val);
+                        eprintln!("[Cranelift Cast] sextend result={:?}", result);
+                        result
                     }
                     crate::hir::CastOp::Trunc => {
                         builder.ins().ireduce(target_ty, val)

crates/compiler/src/cranelift_backend.rs

@@ -230,6 +230,7 @@ pub fn compile_to_hir(
                 let wrapper_func = async_compiler.generate_async_wrapper_with_arena(
                     &state_machine,
                     &mut *lowering_ctx.arena.lock().unwrap(),
+                    &original_func,
                 )?;
 
                 // Replace the original async function with the state machine wrapper

crates/compiler/src/lib.rs

@@ -639,6 +639,23 @@ impl LoweringContext {
         let mut typed_cfg_builder = crate::typed_cfg::TypedCfgBuilder::new();
         let typed_cfg = typed_cfg_builder.build_from_block(body, hir_func.entry_block)?;
 
+        // Debug: check TypedCFG
+        eprintln!("[LOWERING DEBUG] TypedCFG for function {:?} (is_async={}):", func.name, func.is_async);
+        eprintln!("[LOWERING DEBUG]   Entry block: {:?}", hir_func.entry_block);
+        eprintln!("[LOWERING DEBUG]   CFG nodes: {}", typed_cfg.graph.node_count());
+        eprintln!("[LOWERING DEBUG]   CFG edges: {}", typed_cfg.graph.edge_count());
+        for node in typed_cfg.graph.node_indices() {
+            let block = &typed_cfg.graph[node];
+            let pred_count = typed_cfg.graph.edges_directed(node, petgraph::Direction::Incoming).count();
+            eprintln!("[LOWERING DEBUG]   CFG Block {:?}: {} statements, {} predecessors", block.id, block.statements.len(), pred_count);
+        }
+        if func.is_async {
+            eprintln!("[LOWERING DEBUG]   Body statements: {:?}", body.statements.len());
+            for stmt in &body.statements {
+                eprintln!("[LOWERING DEBUG]   Statement: {:?}", stmt);
+            }
+        }
+
         // Convert to SSA form, processing TypedStatements to emit HIR instructions
         let ssa_builder = SsaBuilder::new(
             hir_func,
@@ -648,6 +665,15 @@ impl LoweringContext {
         ).with_return_type(func.return_type.clone());
         let ssa = ssa_builder.build_from_typed_cfg(&typed_cfg)?;
 
+        // Debug: check SSA result
+        if func.is_async {
+            eprintln!("[LOWERING DEBUG] After SSA build for async function {:?}:", func.name);
+            eprintln!("[LOWERING DEBUG]   SSA blocks: {}", ssa.function.blocks.len());
+            for (bid, block) in &ssa.function.blocks {
+                eprintln!("[LOWERING DEBUG]   SSA Block {:?}: {} instructions", bid, block.instructions.len());
+            }
+        }
+
         // Verify SSA properties
         ssa.verify()?;
 
@@ -682,6 +708,20 @@ impl LoweringContext {
 
         // Gap 6 Phase 2: Transform async functions to state machines
         if func.is_async {
+            eprintln!("[LOWERING DEBUG] Before transform_async_function:");
+            eprintln!("[LOWERING DEBUG]   Function: {:?}", hir_func.name);
+            eprintln!("[LOWERING DEBUG]   Values: {} entries", hir_func.values.len());
+            for (vid, val) in &hir_func.values {
+                eprintln!("[LOWERING DEBUG]     {:?} -> {:?}", vid, val.kind);
+            }
+            eprintln!("[LOWERING DEBUG]   Blocks: {}", hir_func.blocks.len());
+            for (bid, block) in &hir_func.blocks {
+                eprintln!("[LOWERING DEBUG]   Block {:?}: {} instructions, terminator = {:?}",
+                    bid, block.instructions.len(), block.terminator);
+                for (i, inst) in block.instructions.iter().enumerate() {
+                    eprintln!("[LOWERING DEBUG]     inst[{}]: {:?}", i, inst);
+                }
+            }
             hir_func = self.transform_async_function(hir_func)?;
         }
 
@@ -722,7 +762,8 @@ impl LoweringContext {
             // 2. Generate the poll() wrapper that implements Future::poll
             let poll_wrapper = async_compiler.generate_async_wrapper_with_arena(
                 &state_machine,
-                &mut *arena
+                &mut *arena,
+                &original_func,
             )?;
 
             // 3. Generate the constructor function