From 6bdd2ef18aa46bd88b7dd874b50708c018c8c988 Mon Sep 17 00:00:00 2001 From: janis Date: Fri, 31 Oct 2025 15:48:53 +0100 Subject: [PATCH] export display/debug impls for ast to ast_debug.rs --- lang/tests/ast.rs | 176 +-------------------------------- lang/tests/shared/ast_debug.rs | 174 ++++++++++++++++++++++++++++++++ 2 files changed, 177 insertions(+), 173 deletions(-) create mode 100644 lang/tests/shared/ast_debug.rs diff --git a/lang/tests/ast.rs b/lang/tests/ast.rs index df27ab3..29c0603 100644 --- a/lang/tests/ast.rs +++ b/lang/tests/ast.rs @@ -3,6 +3,9 @@ #[path = "shared/shared.rs"] mod util; +#[path = "shared/ast_debug.rs"] +mod ast_debug; + unsafe extern "C" { unsafe fn bump_init(); @@ -100,176 +103,3 @@ return *y; |ast| unsafe { parse_func(ast) }, ); } - -impl std::fmt::Display for AstNode { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - use util::defs::{ - BinaryExpr, AST_ADDRESS_OF, AST_ARG, AST_ASSIGNMENT, AST_BINARY_OP, AST_BLOCK, - AST_DEREF, AST_FUNCTION, AST_NUMBER, AST_PLACE_TO_VALUE, AST_RETURN_STATEMENT, - AST_VALUE_TO_PLACE, AST_VAR_DECL, AST_VAR_REF, - }; - match self.kind { - AST_NUMBER => { - write!(f, "Number({})", self.data as usize) - } - AST_DEREF => { - write!(f, "Deref(expr: {})", self.data as usize) - } - AST_ADDRESS_OF => { - write!(f, "AddressOf(expr: {})", self.data as usize) - } - AST_ARG => { - let arg = unsafe { self.data.cast::().read() }; - write!( - f, - "Arg(name: {:?}, arg_type: {})", - unsafe { - std::str::from_utf8(std::slice::from_raw_parts(arg.name, arg.name_len)) - }, - arg.arg_type, - ) - } - AST_VAR_REF => { - let var_ref = unsafe { self.data.cast::().read() }; - if var_ref.resolved != u64::MAX { - write!(f, "VarRef({})", var_ref.resolved) - } else { - write!(f, "VarRef(name: {:?})", unsafe { - std::str::from_utf8(std::slice::from_raw_parts( - var_ref.name, - var_ref.name_len, - )) - },) - } - } - AST_VAR_DECL => { - let var_decl = unsafe { self.data.cast::().read() }; - write!( - f, - "VarDecl(name: {:?}, var_type: {})", - unsafe { - std::str::from_utf8(std::slice::from_raw_parts( - var_decl.name, - var_decl.name_len, - )) - }, - var_decl.var_type, - ) - } - AST_ASSIGNMENT => { - write!( - f, - "Assignment(dest: {}, src: {})", - self.data as usize, self.extra - ) - } - AST_BINARY_OP => { - let BinaryExpr { - left, - operator, - right, - } = unsafe { self.data.cast::().read() }; - write!( - f, - "BinaryOp(op: {}, left: {}, right: {})", - operator, left, right - ) - } - AST_RETURN_STATEMENT => { - let return_expr_id = self.data as usize; - write!(f, "ReturnStatement(expr: {})", return_expr_id) - } - AST_FUNCTION => { - let func = unsafe { self.data.cast::().read() }; - write!( - f, - "Function(name: {:?}, args: {:?}, return_type: {}, body: {})", - unsafe { - std::str::from_utf8(std::slice::from_raw_parts(func.name, func.name_len)) - }, - unsafe { - std::slice::from_raw_parts(func.args.cast::(), func.args_len as usize) - }, - func.return_type, - func.body - ) - } - AST_BLOCK => { - write!(f, "Block(statements: {:?})", unsafe { - std::slice::from_raw_parts(self.data.cast::(), self.extra as usize) - }) - } - AST_PLACE_TO_VALUE => { - write!(f, "PlaceToValue(place: {})", self.data as usize) - } - AST_VALUE_TO_PLACE => { - write!(f, "ValueToPlace(value: {})", self.data as usize) - } - kind => write!(f, "UnknownNode(kind: {kind})"), - } - } -} - -impl core::fmt::Display for Ast { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - writeln!(f, "[")?; - for (i, item) in self.nodes.as_slice().iter().enumerate() { - if i > 0 { - writeln!(f, ", ")?; - } - write!(f, "\t{i}: {}", item)?; - } - writeln!(f, "\n]") - } -} - -impl core::fmt::Display for util::defs::SymEntry { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - f.debug_struct("SymEntry") - .field_with("key", |f| { - f.debug_struct("Key") - .field_with("kind", |f| { - f.write_str(match self.key.kind { - util::defs::SYM_KEY_SCOPE => "Scope", - util::defs::SYM_KEY_SCOPE_NAME => "ScopeName", - util::defs::SYM_KEY_PARENT_SCOPE => "ParentScope", - util::defs::SYM_KEY_ARG => "Argument", - util::defs::SYM_KEY_VAR => "Variable", - _ => "Unknown", - }) - }) - .field("scope", &self.key.scope_index) - .field("span", &self.key.span) - .field_with("ident", |f| { - f.write_str(unsafe { - &core::str::from_utf8_unchecked(core::slice::from_raw_parts( - self.key.ident, - self.key.ident_len, - )) - }) - }) - .finish() - }) - .field_with("value", |f| { - let stct = &mut f.debug_struct("Value"); - if self.extra == 0 { - stct.field("ast_index", &self.index).finish() - } else if self.index != 0 { - stct.field_with("ident", |f| { - f.write_str(unsafe { - core::str::from_utf8_unchecked(core::slice::from_raw_parts( - self.index as *const u8, - self.extra as usize, - )) - }) - }) - .finish() - } else { - stct.field("index", &self.index) - .field("extra", &self.extra) - .finish() - } - }) - .finish() - } -} diff --git a/lang/tests/shared/ast_debug.rs b/lang/tests/shared/ast_debug.rs new file mode 100644 index 0000000..81dc2b1 --- /dev/null +++ b/lang/tests/shared/ast_debug.rs @@ -0,0 +1,174 @@ +use super::util; + +impl core::fmt::Display for util::defs::AstNode { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + use util::defs::{ + BinaryExpr, AST_ADDRESS_OF, AST_ARG, AST_ASSIGNMENT, AST_BINARY_OP, AST_BLOCK, + AST_DEREF, AST_FUNCTION, AST_NUMBER, AST_PLACE_TO_VALUE, AST_RETURN_STATEMENT, + AST_VALUE_TO_PLACE, AST_VAR_DECL, AST_VAR_REF, + }; + match self.kind { + AST_NUMBER => { + write!(f, "Number({})", self.data as usize) + } + AST_DEREF => { + write!(f, "Deref(expr: {})", self.data as usize) + } + AST_ADDRESS_OF => { + write!(f, "AddressOf(expr: {})", self.data as usize) + } + AST_ARG => { + let arg = unsafe { self.data.cast::().read() }; + write!( + f, + "Arg(name: {:?}, arg_type: {})", + unsafe { + std::str::from_utf8(std::slice::from_raw_parts(arg.name, arg.name_len)) + }, + arg.arg_type, + ) + } + AST_VAR_REF => { + let var_ref = unsafe { self.data.cast::().read() }; + if var_ref.resolved != u64::MAX { + write!(f, "VarRef({})", var_ref.resolved) + } else { + write!(f, "VarRef(name: {:?})", unsafe { + std::str::from_utf8(std::slice::from_raw_parts( + var_ref.name, + var_ref.name_len, + )) + },) + } + } + AST_VAR_DECL => { + let var_decl = unsafe { self.data.cast::().read() }; + write!( + f, + "VarDecl(name: {:?}, var_type: {})", + unsafe { + std::str::from_utf8(std::slice::from_raw_parts( + var_decl.name, + var_decl.name_len, + )) + }, + var_decl.var_type, + ) + } + AST_ASSIGNMENT => { + write!( + f, + "Assignment(dest: {}, src: {})", + self.data as usize, self.extra + ) + } + AST_BINARY_OP => { + let BinaryExpr { + left, + operator, + right, + } = unsafe { self.data.cast::().read() }; + write!( + f, + "BinaryOp(op: {}, left: {}, right: {})", + operator, left, right + ) + } + AST_RETURN_STATEMENT => { + let return_expr_id = self.data as usize; + write!(f, "ReturnStatement(expr: {})", return_expr_id) + } + AST_FUNCTION => { + let func = unsafe { self.data.cast::().read() }; + write!( + f, + "Function(name: {:?}, args: {:?}, return_type: {}, body: {})", + unsafe { + std::str::from_utf8(std::slice::from_raw_parts(func.name, func.name_len)) + }, + unsafe { + std::slice::from_raw_parts(func.args.cast::(), func.args_len as usize) + }, + func.return_type, + func.body + ) + } + AST_BLOCK => { + write!(f, "Block(statements: {:?})", unsafe { + std::slice::from_raw_parts(self.data.cast::(), self.extra as usize) + }) + } + AST_PLACE_TO_VALUE => { + write!(f, "PlaceToValue(place: {})", self.data as usize) + } + AST_VALUE_TO_PLACE => { + write!(f, "ValueToPlace(value: {})", self.data as usize) + } + kind => write!(f, "UnknownNode(kind: {kind})"), + } + } +} + +impl core::fmt::Display for util::defs::Ast { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + writeln!(f, "[")?; + for (i, item) in self.nodes.as_slice().iter().enumerate() { + if i > 0 { + writeln!(f, ", ")?; + } + write!(f, "\t{i}: {}", item)?; + } + writeln!(f, "\n]") + } +} + +impl core::fmt::Display for util::defs::SymEntry { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.debug_struct("SymEntry") + .field_with("key", |f| { + f.debug_struct("Key") + .field_with("kind", |f| { + f.write_str(match self.key.kind { + util::defs::SYM_KEY_SCOPE => "Scope", + util::defs::SYM_KEY_SCOPE_NAME => "ScopeName", + util::defs::SYM_KEY_PARENT_SCOPE => "ParentScope", + util::defs::SYM_KEY_ARG => "Argument", + util::defs::SYM_KEY_VAR => "Variable", + _ => "Unknown", + }) + }) + .field("scope", &self.key.scope_index) + .field("span", &self.key.span) + .field_with("ident", |f| { + f.write_str(unsafe { + &core::str::from_utf8_unchecked(core::slice::from_raw_parts( + self.key.ident, + self.key.ident_len, + )) + }) + }) + .finish() + }) + .field_with("value", |f| { + let stct = &mut f.debug_struct("Value"); + if self.extra == 0 { + stct.field("ast_index", &self.index).finish() + } else if self.index != 0 { + stct.field_with("ident", |f| { + f.write_str(unsafe { + core::str::from_utf8_unchecked(core::slice::from_raw_parts( + self.index as *const u8, + self.extra as usize, + )) + }) + }) + .finish() + } else { + stct.field("index", &self.index) + .field("extra", &self.extra) + .finish() + } + }) + .finish() + } +}