Enable Grammar2 JSON parsing path and add CI fmt/clippy checks

Author: darmie

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: Rust CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    name: fmt + clippy
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - name: Cache cargo artifacts
+        uses: Swatinem/rust-cache@v2
+
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+      - name: Run clippy
+        run: cargo clippy --workspace --all-targets

crates/compiler/tests/integration_memory_test.rs

@@ -1,9 +1,9 @@
 use zyntax_compiler::cranelift_backend::CraneliftBackend;
 use zyntax_compiler::hir::{
-    HirConstant, HirFunction, HirFunctionSignature, HirId, HirInstruction, HirParam,
-    HirTerminator, HirType, HirValueKind, ParamAttributes,
+    HirConstant, HirFunction, HirFunctionSignature, HirId, HirInstruction, HirParam, HirTerminator,
+    HirType, HirValueKind, ParamAttributes,
 };
-use zyntax_typed_ast::{InternedString, arena::AstArena};
+use zyntax_typed_ast::{arena::AstArena, InternedString};
 
 /// Helper to create an interned string for tests
 fn create_test_string(s: &str) -> InternedString {
@@ -14,13 +14,14 @@ fn create_test_string(s: &str) -> InternedString {
 /// Compile a HIR function and return the backend + function pointer
 fn compile_and_get_ptr(func: HirFunction) -> (CraneliftBackend, Option<*const u8>) {
     let func_id = func.id;
-    let mut backend = CraneliftBackend::new()
-        .expect("Failed to create Cranelift backend");
-    backend.compile_function(func_id, &func)
+    let mut backend = CraneliftBackend::new().expect("Failed to create Cranelift backend");
+    backend
+        .compile_function(func_id, &func)
         .expect("Failed to compile function");
 
     // Manually finalize and get function pointer
-    backend.finalize_definitions()
+    backend
+        .finalize_definitions()
         .expect("Failed to finalize definitions");
 
     let func_ptr = backend.get_function_ptr(func_id);
@@ -60,7 +61,10 @@ fn test_memory_roundtrip_execution() {
     let param_x = func.create_value(HirType::I32, HirValueKind::Parameter(0));
 
     // Alloca i32
-    let ptr = func.create_value(HirType::Ptr(Box::new(HirType::I32)), HirValueKind::Instruction);
+    let ptr = func.create_value(
+        HirType::Ptr(Box::new(HirType::I32)),
+        HirValueKind::Instruction,
+    );
     let alloca = HirInstruction::Alloca {
         result: ptr,
         ty: HirType::I32,
@@ -90,7 +94,9 @@ fn test_memory_roundtrip_execution() {
     block.add_instruction(alloca);
     block.add_instruction(store);
     block.add_instruction(load);
-    block.set_terminator(HirTerminator::Return { values: vec![result] });
+    block.set_terminator(HirTerminator::Return {
+        values: vec![result],
+    });
 
     let (_backend, func_ptr) = compile_and_get_ptr(func);
     let func_ptr = func_ptr.expect("Failed to get function pointer");
@@ -139,7 +145,10 @@ fn test_memory_i64_execution() {
     let param_x = func.create_value(HirType::I64, HirValueKind::Parameter(0));
 
     // Alloca i64
-    let ptr = func.create_value(HirType::Ptr(Box::new(HirType::I64)), HirValueKind::Instruction);
+    let ptr = func.create_value(
+        HirType::Ptr(Box::new(HirType::I64)),
+        HirValueKind::Instruction,
+    );
     let alloca = HirInstruction::Alloca {
         result: ptr,
         ty: HirType::I64,
@@ -169,7 +178,9 @@ fn test_memory_i64_execution() {
     block.add_instruction(alloca);
     block.add_instruction(store);
     block.add_instruction(load);
-    block.set_terminator(HirTerminator::Return { values: vec![result] });
+    block.set_terminator(HirTerminator::Return {
+        values: vec![result],
+    });
 
     let (_backend, func_ptr) = compile_and_get_ptr(func);
     let func_ptr = func_ptr.expect("Failed to get function pointer");
@@ -218,7 +229,10 @@ fn test_memory_f64_execution() {
     let param_x = func.create_value(HirType::F64, HirValueKind::Parameter(0));
 
     // Alloca f64
-    let ptr = func.create_value(HirType::Ptr(Box::new(HirType::F64)), HirValueKind::Instruction);
+    let ptr = func.create_value(
+        HirType::Ptr(Box::new(HirType::F64)),
+        HirValueKind::Instruction,
+    );
     let alloca = HirInstruction::Alloca {
         result: ptr,
         ty: HirType::F64,
@@ -248,7 +262,9 @@ fn test_memory_f64_execution() {
     block.add_instruction(alloca);
     block.add_instruction(store);
     block.add_instruction(load);
-    block.set_terminator(HirTerminator::Return { values: vec![result] });
+    block.set_terminator(HirTerminator::Return {
+        values: vec![result],
+    });
 
     let (_backend, func_ptr) = compile_and_get_ptr(func);
     let func_ptr = func_ptr.expect("Failed to get function pointer");
@@ -257,7 +273,7 @@ fn test_memory_f64_execution() {
     let func_typed: extern "C" fn(f64) -> f64 = unsafe { std::mem::transmute(func_ptr) };
 
     // Test with various values
-    assert_eq!(func_typed(3.14159), 3.14159);
+    assert_eq!(func_typed(std::f64::consts::PI), std::f64::consts::PI);
     assert_eq!(func_typed(0.0), 0.0);
     assert_eq!(func_typed(-123.456), -123.456);
     assert_eq!(func_typed(f64::MAX), f64::MAX);
@@ -309,7 +325,10 @@ fn test_multiple_allocations_execution() {
     let param_b = func.create_value(HirType::I32, HirValueKind::Parameter(1));
 
     // Alloca for a
-    let ptr_a = func.create_value(HirType::Ptr(Box::new(HirType::I32)), HirValueKind::Instruction);
+    let ptr_a = func.create_value(
+        HirType::Ptr(Box::new(HirType::I32)),
+        HirValueKind::Instruction,
+    );
     let alloca_a = HirInstruction::Alloca {
         result: ptr_a,
         ty: HirType::I32,
@@ -318,7 +337,10 @@ fn test_multiple_allocations_execution() {
     };
 
     // Alloca for b
-    let ptr_b = func.create_value(HirType::Ptr(Box::new(HirType::I32)), HirValueKind::Instruction);
+    let ptr_b = func.create_value(
+        HirType::Ptr(Box::new(HirType::I32)),
+        HirValueKind::Instruction,
+    );
     let alloca_b = HirInstruction::Alloca {
         result: ptr_b,
         ty: HirType::I32,
@@ -431,7 +453,10 @@ fn test_memory_update_execution() {
     let param_x = func.create_value(HirType::I32, HirValueKind::Parameter(0));
 
     // Alloca i32
-    let ptr = func.create_value(HirType::Ptr(Box::new(HirType::I32)), HirValueKind::Instruction);
+    let ptr = func.create_value(
+        HirType::Ptr(Box::new(HirType::I32)),
+        HirValueKind::Instruction,
+    );
     let alloca = HirInstruction::Alloca {
         result: ptr,
         ty: HirType::I32,
@@ -493,7 +518,9 @@ fn test_memory_update_execution() {
     block.add_instruction(add);
     block.add_instruction(store2);
     block.add_instruction(load2);
-    block.set_terminator(HirTerminator::Return { values: vec![result] });
+    block.set_terminator(HirTerminator::Return {
+        values: vec![result],
+    });
 
     let (_backend, func_ptr) = compile_and_get_ptr(func);
     let func_ptr = func_ptr.expect("Failed to get function pointer");

crates/haxe_zyntax_runtime/src/lib.rs

@@ -12,8 +12,8 @@
 
 extern crate libc;
 
-use zyntax_plugin_macros::{runtime_plugin, runtime_export};
-use zyntax_compiler::zrtl::{DynamicValue, TypeId, TypeCategory};
+use zyntax_compiler::zrtl::{DynamicValue, TypeCategory, TypeId};
+use zyntax_plugin_macros::{runtime_export, runtime_plugin};
 
 // Declare this as the Haxe runtime plugin
 runtime_plugin! {
@@ -40,7 +40,7 @@ const HEADER_SIZE: isize = 1;
 /// - value: The string to print (length-prefixed Haxe string)
 /// - pos_info: Optional position info string (e.g., "Test.hx:10:")
 #[runtime_export("$haxe$trace")]
-pub extern "C" fn haxe_trace(value: *const i32, pos_info: *const i32) {
+pub unsafe extern "C" fn haxe_trace(value: *const i32, pos_info: *const i32) {
     unsafe {
         // Print position info if provided
         if !pos_info.is_null() {
@@ -77,13 +77,13 @@ pub extern "C" fn haxe_trace(value: *const i32, pos_info: *const i32) {
 /// Simple trace function - just prints the string with newline
 /// Used when no position info is available
 #[runtime_export("$haxe$trace$simple")]
-pub extern "C" fn haxe_trace_simple(value: *const i32) {
+pub unsafe extern "C" fn haxe_trace_simple(value: *const i32) {
     haxe_trace(value, core::ptr::null());
 }
 
 /// Trace an integer value directly
 #[runtime_export("$haxe$trace$int")]
-pub extern "C" fn haxe_trace_int(value: i32, pos_info: *const i32) {
+pub unsafe extern "C" fn haxe_trace_int(value: i32, pos_info: *const i32) {
     unsafe {
         print_pos_info(pos_info);
         libc::printf(b"%d\n\0".as_ptr() as *const i8, value);
@@ -92,7 +92,7 @@ pub extern "C" fn haxe_trace_int(value: i32, pos_info: *const i32) {
 
 /// Trace a float value directly
 #[runtime_export("$haxe$trace$float")]
-pub extern "C" fn haxe_trace_float(value: f64, pos_info: *const i32) {
+pub unsafe extern "C" fn haxe_trace_float(value: f64, pos_info: *const i32) {
     unsafe {
         print_pos_info(pos_info);
         libc::printf(b"%g\n\0".as_ptr() as *const i8, value);
@@ -101,7 +101,7 @@ pub extern "C" fn haxe_trace_float(value: f64, pos_info: *const i32) {
 
 /// Trace a boolean value directly
 #[runtime_export("$haxe$trace$bool")]
-pub extern "C" fn haxe_trace_bool(value: i32, pos_info: *const i32) {
+pub unsafe extern "C" fn haxe_trace_bool(value: i32, pos_info: *const i32) {
     unsafe {
         print_pos_info(pos_info);
         if value != 0 {
@@ -154,9 +154,9 @@ unsafe fn print_haxe_string(str_ptr: *const i32) {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct HaxeString {
-    pub ptr: *mut u8,   // Pointer to string data (UTF-8)
-    pub len: usize,     // Length in bytes
-    pub cap: usize,     // Capacity in bytes
+    pub ptr: *mut u8, // Pointer to string data (UTF-8)
+    pub len: usize,   // Length in bytes
+    pub cap: usize,   // Capacity in bytes
 }
 
 /// Trace any Dynamic value - dispatches based on runtime type
@@ -168,7 +168,7 @@ pub struct HaxeString {
 /// - dynamic_ptr: Pointer to a DynamicValue struct
 /// - pos_info: Optional position info string (length-prefixed Haxe string)
 #[runtime_export("$haxe$trace$any")]
-pub extern "C" fn haxe_trace_any(dynamic_ptr: *const DynamicValue, pos_info: *const i32) {
+pub unsafe extern "C" fn haxe_trace_any(dynamic_ptr: *const DynamicValue, pos_info: *const i32) {
     unsafe {
         print_pos_info(pos_info);
 
@@ -229,30 +229,28 @@ pub extern "C" fn haxe_trace_any(dynamic_ptr: *const DynamicValue, pos_info: *co
                     }
                 }
             }
-            TypeCategory::UInt => {
-                match type_id {
-                    t if t == TypeId::U8 => {
-                        if let Some(&v) = dynamic.as_ref::<u8>() {
-                            libc::printf(b"%u\n\0".as_ptr() as *const i8, v as u32);
-                        }
+            TypeCategory::UInt => match type_id {
+                t if t == TypeId::U8 => {
+                    if let Some(&v) = dynamic.as_ref::<u8>() {
+                        libc::printf(b"%u\n\0".as_ptr() as *const i8, v as u32);
                     }
-                    t if t == TypeId::U16 => {
-                        if let Some(&v) = dynamic.as_ref::<u16>() {
-                            libc::printf(b"%u\n\0".as_ptr() as *const i8, v as u32);
-                        }
+                }
+                t if t == TypeId::U16 => {
+                    if let Some(&v) = dynamic.as_ref::<u16>() {
+                        libc::printf(b"%u\n\0".as_ptr() as *const i8, v as u32);
                     }
-                    t if t == TypeId::U32 => {
-                        if let Some(&v) = dynamic.as_ref::<u32>() {
-                            libc::printf(b"%u\n\0".as_ptr() as *const i8, v);
-                        }
+                }
+                t if t == TypeId::U32 => {
+                    if let Some(&v) = dynamic.as_ref::<u32>() {
+                        libc::printf(b"%u\n\0".as_ptr() as *const i8, v);
                     }
-                    _ => {
-                        if let Some(&v) = dynamic.as_ref::<u64>() {
-                            libc::printf(b"%llu\n\0".as_ptr() as *const i8, v);
-                        }
+                }
+                _ => {
+                    if let Some(&v) = dynamic.as_ref::<u64>() {
+                        libc::printf(b"%llu\n\0".as_ptr() as *const i8, v);
                     }
                 }
-            }
+            },
             TypeCategory::Float => {
                 if type_id == TypeId::F32 {
                     if let Some(&v) = dynamic.as_ref::<f32>() {
@@ -294,10 +292,7 @@ pub extern "C" fn haxe_trace_any(dynamic_ptr: *const DynamicValue, pos_info: *co
             }
             TypeCategory::Struct | TypeCategory::Class => {
                 // For struct/class, show address
-                libc::printf(
-                    b"<Object@%p>\n\0".as_ptr() as *const i8,
-                    dynamic.value_ptr,
-                );
+                libc::printf(b"<Object@%p>\n\0".as_ptr() as *const i8, dynamic.value_ptr);
             }
             TypeCategory::Enum => {
                 libc::printf(b"[Enum]\n\0".as_ptr() as *const i8);
@@ -313,18 +308,15 @@ pub extern "C" fn haxe_trace_any(dynamic_ptr: *const DynamicValue, pos_info: *co
             }
             _ => {
                 // Unknown type - print address
-                libc::printf(
-                    b"<Dynamic@%p>\n\0".as_ptr() as *const i8,
-                    dynamic.value_ptr,
-                );
+                libc::printf(b"<Dynamic@%p>\n\0".as_ptr() as *const i8, dynamic.value_ptr);
             }
         }
     }
 }
 
 /// Trace any Dynamic value without position info
 #[runtime_export("$haxe$trace$any$simple")]
-pub extern "C" fn haxe_trace_any_simple(dynamic_ptr: *const DynamicValue) {
+pub unsafe extern "C" fn haxe_trace_any_simple(dynamic_ptr: *const DynamicValue) {
     haxe_trace_any(dynamic_ptr, core::ptr::null());
 }
 
@@ -335,8 +327,8 @@ pub extern "C" fn haxe_trace_any_simple(dynamic_ptr: *const DynamicValue) {
 // These exports allow this library to be loaded dynamically as a ZRTL plugin.
 // The `_zrtl_info` and `_zrtl_symbols` are required by the ZrtlPlugin loader.
 
-use zyntax_compiler::zrtl::{ZrtlInfo, ZrtlSymbol, ZRTL_VERSION};
 use std::ffi::c_char;
+use zyntax_compiler::zrtl::{ZrtlInfo, ZrtlSymbol, ZRTL_VERSION};
 
 /// Plugin info - required for ZRTL dynamic loading
 #[no_mangle]

crates/runtime/src/lib.rs

@@ -14,7 +14,7 @@
 
 extern crate libc;
 
-use zyntax_plugin_macros::{runtime_plugin, runtime_export};
+use zyntax_plugin_macros::{runtime_export, runtime_plugin};
 
 // Declare this as the standard library runtime plugin
 runtime_plugin! {
@@ -74,21 +74,19 @@ pub extern "C" fn print_cstr(ptr: *const u8) {
 
 /// Print a string with known length
 #[runtime_export("print_str")]
-pub extern "C" fn print_str(ptr: *const u8, len: i32) {
+pub unsafe extern "C" fn print_str(ptr: *const u8, len: i32) {
     if ptr.is_null() || len < 0 {
         return;
     }
-    unsafe {
-        for i in 0..len {
-            libc::putchar(*ptr.offset(i as isize) as i32);
-        }
-        libc::fflush(core::ptr::null_mut());
+    for i in 0..len {
+        libc::putchar(*ptr.offset(i as isize) as i32);
     }
+    libc::fflush(core::ptr::null_mut());
 }
 
 /// Print a string with newline
 #[runtime_export("println_str")]
-pub extern "C" fn println_str(ptr: *const u8, len: i32) {
+pub unsafe extern "C" fn println_str(ptr: *const u8, len: i32) {
     print_str(ptr, len);
     print_newline();
 }
@@ -99,4 +97,3 @@ pub extern "C" fn println_i32(value: i32) {
     print_i32(value);
     print_newline();
 }
-