feat: Add LLVM JIT runtime symbol linking and TypedAST JSON support

- Add runtime symbol registration to LLVM JIT backend using add_global_mapping()
- Fix Void type translation in LLVM backend (use empty struct as unit type)
- Fix SSA builder infinite recursion in read_variable_recursive
- Add plugin registry integration for runtime symbols (stdlib + Haxe plugins)
- Improve TypedAST JSON parsing with While loop support
- Add Reflaxe/Haxe for-loop iterator test infrastructure

Author: darmie

crates/compiler/src/llvm_backend.rs

@@ -2745,6 +2745,10 @@ impl<'ctx> LLVMBackend<'ctx> {
         use HirType::*;
 
         let result = match ty {
+            Void => {
+                // Void/Unit is represented as an empty struct (zero-sized type)
+                self.context.struct_type(&[], false).into()
+            }
             I8 => self.context.i8_type().into(),
             I16 => self.context.i16_type().into(),
             I32 => self.context.i32_type().into(),

crates/compiler/src/llvm_jit_backend.rs

@@ -26,7 +26,6 @@ use inkwell::{
     execution_engine::ExecutionEngine,
     targets::{InitializationConfig, Target},
 };
-
 use crate::{CompilerError, CompilerResult};
 use crate::hir::{HirModule, HirFunction, HirId};
 use crate::llvm_backend::LLVMBackend;
@@ -47,6 +46,10 @@ pub struct LLVMJitBackend<'ctx> {
 
     /// Optimization level
     opt_level: OptimizationLevel,
+
+    /// Runtime symbols to register with the execution engine
+    /// Maps function name to function pointer address
+    runtime_symbols: IndexMap<String, usize>,
 }
 
 impl<'ctx> LLVMJitBackend<'ctx> {
@@ -69,9 +72,24 @@ impl<'ctx> LLVMJitBackend<'ctx> {
             execution_engine: None,
             function_pointers: IndexMap::new(),
             opt_level,
+            runtime_symbols: IndexMap::new(),
         })
     }
 
+    /// Register a runtime symbol that will be available to JIT-compiled code
+    ///
+    /// Call this before `compile_module` to make external functions available.
+    pub fn register_symbol(&mut self, name: impl Into<String>, ptr: *const u8) {
+        self.runtime_symbols.insert(name.into(), ptr as usize);
+    }
+
+    /// Register multiple runtime symbols at once
+    pub fn register_symbols(&mut self, symbols: &[(&str, *const u8)]) {
+        for (name, ptr) in symbols {
+            self.runtime_symbols.insert((*name).to_string(), *ptr as usize);
+        }
+    }
+
     /// Compile a full HIR module
     ///
     /// Translates all functions to LLVM IR and JIT compiles them.
@@ -84,21 +102,46 @@ impl<'ctx> LLVMJitBackend<'ctx> {
         let mut backend = LLVMBackend::new(self.context, "zyntax_jit");
         let _llvm_ir = backend.compile_module(hir_module)?;
 
-        // Step 2: Create execution engine from the FULLY POPULATED module
-        // This is critical - MCJIT takes ownership of the module and compiles it
-        let execution_engine = backend.into_module()
+        // Step 2: Collect external function declarations from the module BEFORE consuming it
+        // We need the function values for add_global_mapping
+        let mut external_functions: Vec<(String, inkwell::values::FunctionValue<'ctx>)> = Vec::new();
+        for (_, function) in &hir_module.functions {
+            if function.is_external {
+                if let Some(name) = function.name.resolve_global() {
+                    if let Some(llvm_func) = backend.module().get_function(&name) {
+                        external_functions.push((name, llvm_func));
+                    }
+                }
+            }
+        }
+
+        // Step 3: Consume the module and create execution engine
+        let module = backend.into_module();
+        let execution_engine = module
             .create_jit_execution_engine(self.opt_level)
             .map_err(|e| CompilerError::Backend(format!("Failed to create JIT execution engine: {}", e)))?;
 
-        // Step 3: Extract function pointers from the execution engine
+        // Step 4: Register runtime symbols with the execution engine using add_global_mapping
+        for (name, llvm_func) in &external_functions {
+            if let Some(addr) = self.runtime_symbols.get(name) {
+                execution_engine.add_global_mapping(llvm_func, *addr);
+                log::debug!("Registered runtime symbol '{}' at address 0x{:x}", name, addr);
+            }
+        }
+
+        // Step 5: Extract function pointers from the execution engine
         for (id, function) in &hir_module.functions {
+            // Skip external functions - they don't have compiled code in this module
+            if function.is_external {
+                continue;
+            }
+
             // Must match naming logic in llvm_backend.rs:
-            // - External functions use their actual name for linking
             // - Main function uses actual name for entry point
             // - Other functions use mangled name with HirId
             let actual_name = function.name.resolve_global()
                 .unwrap_or_else(|| format!("{:?}", function.name));
-            let fn_name = if function.is_external || actual_name == "main" {
+            let fn_name = if actual_name == "main" {
                 actual_name
             } else {
                 format!("func_{:?}", id)

crates/compiler/src/ssa.rs

@@ -1982,19 +1982,39 @@ impl SsaBuilder {
             // After IDF placement, don't create new phis
             // Instead, try to read from predecessors to find the value
             if self.idf_placement_done {
-                // Try reading from each predecessor
+                // CRITICAL: Create a temporary placeholder phi to break cycles in loops
+                // Without this, while loop CFG (header -> body -> header) causes infinite recursion
+                let ty = self.var_types.get(&var).cloned().unwrap_or(HirType::I64);
+                let placeholder = self.create_value(ty.clone(), HirValueKind::Instruction);
+
+                // Write the placeholder to break cycles
+                self.write_variable(var, block, placeholder);
+
+                // Now try reading from each predecessor
+                let mut found_value = None;
                 for pred in &predecessors {
                     let val = self.read_variable(var, *pred);
-                    // Check if it's not undef
-                    if let Some(v) = self.function.values.get(&val) {
-                        if !matches!(v.kind, HirValueKind::Undef) {
-                            return val;
+                    // Check if it's not undef and not our placeholder
+                    if val != placeholder {
+                        if let Some(v) = self.function.values.get(&val) {
+                            if !matches!(v.kind, HirValueKind::Undef) {
+                                found_value = Some(val);
+                                break;
+                            }
                         }
                     }
                 }
-                // All predecessors returned undef - variable is truly undefined
-                let ty = self.var_types.get(&var).cloned().unwrap_or(HirType::I64);
-                return self.create_undef(ty);
+
+                if let Some(val) = found_value {
+                    // Found a real value - update definition to use it
+                    self.write_variable(var, block, val);
+                    return val;
+                }
+
+                // All predecessors returned undef or placeholder - variable is truly undefined
+                let undef = self.create_undef(ty);
+                self.write_variable(var, block, undef);
+                return undef;
             }
 
             let ty = self.var_types.get(&var).cloned()

crates/typed_ast/src/type_registry.rs

@@ -766,9 +766,10 @@ pub enum Mutability {
 }
 
 /// Visibility annotation
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
 pub enum Visibility {
     Public,
+    #[default]
     Private,
     Protected,
     Internal,

crates/typed_ast/src/typed_ast.rs

@@ -60,16 +60,24 @@ pub enum TypedDeclaration {
 }
 
 /// Function declaration
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
 pub struct TypedFunction {
+    #[serde(default)]
     pub name: InternedString,
+    #[serde(default)]
     pub type_params: Vec<TypedTypeParam>,  // Generic type parameters
+    #[serde(default)]
     pub params: Vec<TypedParameter>,
+    #[serde(default)]
     pub return_type: Type,
     pub body: Option<TypedBlock>,  // None for extern functions
+    #[serde(default)]
     pub visibility: Visibility,
+    #[serde(default)]
     pub is_async: bool,
+    #[serde(default)]
     pub is_external: bool,  // True for extern/foreign functions
+    #[serde(default)]
     pub calling_convention: CallingConvention,  // Calling convention (C, Rust, System, etc.)
     pub link_name: Option<InternedString>,  // Override symbol name for linking
 }

crates/zyntax_cli/src/backends/llvm_aot.rs

@@ -161,6 +161,31 @@ pub fn compile_and_run_llvm(
         info!("Initializing LLVM JIT backend...");
     }
 
+    // Create plugin registry and register all available runtime plugins
+    let mut registry = zyntax_compiler::plugin::PluginRegistry::new();
+
+    // Register standard library plugin (generic I/O functions)
+    registry.register(zyntax_runtime::get_plugin())
+        .map_err(|e| format!("Failed to register stdlib plugin: {}", e))?;
+
+    // Register Haxe plugin (frontend-specific runtime)
+    registry.register(haxe_zyntax_runtime::get_plugin())
+        .map_err(|e| format!("Failed to register Haxe plugin: {}", e))?;
+
+    if verbose {
+        info!("Registered plugins: {:?}", registry.list_plugins());
+    }
+
+    // Collect all runtime symbols from registered plugins
+    let runtime_symbols = registry.collect_symbols();
+
+    if verbose {
+        info!("Collected {} runtime symbols", runtime_symbols.len());
+        for (name, _) in &runtime_symbols {
+            debug!("  - {}", name);
+        }
+    }
+
     // Create LLVM context
     let context = Context::create();
 
@@ -176,6 +201,11 @@ pub fn compile_and_run_llvm(
     let mut backend = LLVMJitBackend::with_opt_level(&context, llvm_opt)
         .map_err(|e| format!("Failed to create JIT backend: {}", e))?;
 
+    // Register runtime symbols with the LLVM JIT backend
+    for (name, ptr) in &runtime_symbols {
+        backend.register_symbol(*name, *ptr);
+    }
+
     if verbose {
         info!("Compiling module with LLVM JIT...");
     }