ast: correctly resolves var refs

lang/tests/ast.rs

@@ -29,22 +29,31 @@ fn main() {
             eprintln!("Parsed expression ID: {}", expr_id);
             println!("{:#}", &ast);
 
-            // unsafe extern "C" fn visit_node(_this: *mut (), ast: *mut Ast, node_id: u64) {
+            // unsafe extern "C" fn visit_node(
+            //     _this: *mut (),
+            //     ast: *mut Ast,
+            //     node_id: u64,
+            //     scope: u64,
+            // ) {
             //     let ast = unsafe { &*ast };
             //     let node = ast.nodes.get(node_id as usize).unwrap();
-            //     eprintln!("Visiting node {node_id}: {node}");
+            //     eprintln!("{scope}: Visiting node {node_id}: {node}");
             // }
 
             // util::defs::ast_walk_for_each(&mut ast, expr_id, core::ptr::null_mut(), visit_node);
 
             let mut symtable = core::mem::MaybeUninit::<util::defs::SymbolTable>::uninit();
             util::defs::ast_build_symtable(&mut ast, expr_id, &mut symtable);
-            let symtable = symtable.assume_init();
+            let mut symtable = symtable.assume_init();
             use util::DisplayedSliceExt;
             println!(
                 "Symbol Table: {:#?}",
                 symtable.symtable.as_slice().displayed()
             );
+
+            util::defs::ast_resolve_var_refs(&mut ast, &mut symtable, expr_id);
+
+            println!("{:#}", &ast);
         };
     }
 
@@ -66,14 +75,14 @@ fn main() {
     // print_ast(b"fn main() -> void { let x: u32 = 4; }", |ast| unsafe {
     //     parse_func(ast)
     // });
-    print_ast(
+    // print_ast(
-        b"fn main(a: u32) -> void { let x: u32 = a + 4; }",
+    //     b"fn main(a: u32) -> void { let x: u32 = a + 4; }",
-        |ast| unsafe { parse_func(ast) },
+    //     |ast| unsafe { parse_func(ast) },
-    );
+    // );
     print_ast(
         b"fn main(a: u32) -> void {
-let x: u32 = a + 4;
+let y: u32 = a + 4;
-let y: *u32 = &x;
+let y: *u32 = &y;
 return *y;
 }",
         |ast| unsafe { parse_func(ast) },
@@ -110,7 +119,7 @@ impl std::fmt::Display for AstNode {
             }
             AST_VAR_REF => {
                 let var_ref = unsafe { self.data.cast::<util::defs::AstVarRef>().read() };
-                if var_ref.resolved != 0 {
+                if var_ref.resolved != u64::MAX {
                     write!(f, "VarRef({})", var_ref.resolved)
                 } else {
                     write!(f, "VarRef(name: {:?})", unsafe {
@@ -184,7 +193,7 @@ impl std::fmt::Display for AstNode {
             AST_VALUE_TO_PLACE => {
                 write!(f, "ValueToPlace(value: {})", self.data as usize)
             }
-            _ => write!(f, "UnknownNode"),
+            kind => write!(f, "UnknownNode(kind: {kind})"),
         }
     }
 }

lang/tests/shared/defs.rs

@@ -15,8 +15,8 @@ unsafe extern "C" {
     pub unsafe fn ast_parse_let(ast: *mut Ast) -> (u64, bool);
     pub unsafe fn symkey_cmp(a: *const SymKey, b: *const SymKey) -> i32;
     pub unsafe fn ast_build_symtable(ast: *mut Ast, root_index: u64, symtable: *mut core::mem::MaybeUninit<SymbolTable>);
-    pub unsafe fn ast_walk_for_each(ast: *mut Ast, start_index: u64, ctx: *mut (), for_each: unsafe extern "C" fn(ctx: *mut (), *mut Ast, node_index: u64));
+    pub unsafe fn ast_walk_for_each(ast: *mut Ast, start_index: u64, ctx: *mut (), for_each: unsafe extern "C" fn(ctx: *mut (), *mut Ast, node_index: u64, scope: u64));
-    pub unsafe fn ast_resolve_var_refs(ast: *mut Ast);
+    pub unsafe fn ast_resolve_var_refs(ast: *mut Ast, ctx: *mut SymbolTable, root_index: u64);
 }
 
 pub const AST_FUNCTION: u8 = 1;
@@ -106,6 +106,7 @@ pub struct AstNode {
     pub kind: u8,
     pub data: *const (),
     pub extra: usize,
+    pub span: u64,
 }
 
 #[repr(C)]