Function syntax_fmt 

pub fn syntax_fmt<'e, E>(elem: &'e E) -> SyntaxDisplay<'static, 'e, (), E>

Formats a syntax tree.

Returns a SyntaxDisplay wrapper that implements Display, allowing it to be used with format!, println!, and other formatting macros.

By default, uses () as the state. Chain with .state() or .state_mut() to provide custom state. Chain with .pretty() to enable pretty printing mode and .indent() to customize the indentation string (default is four spaces).

Arguments

• elem - The syntax tree to format

Examples

use syntaxfmt::{SyntaxFmt, syntax_fmt};

#[derive(SyntaxFmt)]
struct Expr<'src> {
    #[syntax(pre = ["(", "( "], suf = [")", " )"])]
    value: &'src str,
}

let expr = Expr { value: "42" };
assert_eq!(format!("{}", syntax_fmt(&expr)), "(42)");
assert_eq!(format!("{}", syntax_fmt(&expr).pretty()), "( 42 )");

With custom state

use syntaxfmt::{Mode, SyntaxFmt, SyntaxFormatter, syntax_fmt};

struct Counter {
    count: usize,
}

impl Counter {
    pub fn next(&mut self) -> usize {
        let count = self.count;
        self.count += 1;
        count
    }
}

struct Item;

impl SyntaxFmt<Counter> for Item {
    fn syntax_fmt(&self, f: &mut SyntaxFormatter<Counter>) -> std::fmt::Result {
        let count = f.state_mut().next();
        if f.mode() == Mode::Pretty {
            write!(f, "pretty_item_{}", count)
        } else {
            write!(f, "item_{}", count)
        }
    }
}

let mut state = Counter { count: 0 };
let item = Item;
assert_eq!(format!("{}", syntax_fmt(&item).state_mut(&mut state)), "item_0");
assert_eq!(state.count, 1);
assert_eq!(format!("{}", syntax_fmt(&item).state_mut(&mut state).pretty()), "pretty_item_1");
assert_eq!(state.count, 2);

Examples found in repository

examples/comprehensive.rs (line 146)

fn main() {
    // Create example AST
    let func = Function {
        name: "calculate",
        params: vec![
            Parameter { name: "x", ty: Some("i32") },
            Parameter { name: "y", ty: Some("i32") },
        ],
        return_type: Some("i32"),
        body: Block {
            statements: vec![
                Statement::Expr(Expr::Call(FunctionCall {
                    name: "println",
                    args: vec![Expr::Literal(42)],
                })),
                Statement::Return {
                    value: Some(Expr::Binary {
                        left: Box::new(Expr::Literal(1)),
                        op: "+",
                        right: Box::new(Expr::Literal(2)),
                    }),
                },
            ],
        },
    };

    let config = TypeConfig { show_types: true };

    println!("Normal - with types:");
    println!("{}", syntax_fmt(&func).state(&config));
    println!();

    println!("Pretty - with types:");
    println!("{}", syntax_fmt(&func).state(&config).pretty());
    println!();

    let config_no_types = TypeConfig { show_types: false };

    println!("Normal - without types:");
    println!("{}", syntax_fmt(&func).state(&config_no_types));
    println!();

    println!("Pretty - without types:");
    println!("{}", syntax_fmt(&func).state(&config_no_types).pretty());
}