Macro tree 

macro_rules! tree {
    (@o $b:ident,) => { ... };
    (@o $b:ident, ($expr:expr, ($start:expr, $end:expr)) $(,)?) => { ... };
    (@o $b:ident, ($expr:expr, $len:expr) $(,)?) => { ... };
    (@o $b:ident, ($expr:expr, ($start:expr, $end:expr)), $($rest:tt)*) => { ... };
    (@o $b:ident, ($expr:expr, $len:expr), $($rest:tt)*) => { ... };
    (@o $b:ident, $expr:expr $(,)?) => { ... };
    (@o $b:ident, $expr:expr, $($rest:tt)*) => { ... };
    (@o $b:ident, ($expr:expr, ($start:expr, $end:expr)) => { $($tt:tt)* } $(,)?) => { ... };
    (@o $b:ident, $expr:expr => { $($tt:tt)* } $(,)?) => { ... };
    (@o $b:ident, ($expr:expr, ($start:expr, $end:expr)) => { $($tt:tt)* }, $($rest:tt)*) => { ... };
    (@o $b:ident, $expr:expr => { $($tt:tt)* }, $($rest:tt)*) => { ... };
    ($($tt:tt)*) => { ... };
}

Helper macro for building a tree in place.

The tree is built with Builder::new, so it uses the default flavor. Use tree_with! to build a tree of another flavor.

Each element is one of:

• value a token with an empty span, see Builder::token_empty.
• (value, len) a token of length len, see Builder::token.
• (value, (start, end)) a token with an explicit span, see Builder::token_with.
• value => { .. } a node whose span covers its children, see Builder::open.
• (value, (start, end)) => { .. } a node with an explicit span, see Builder::open_with.

Elements are separated by commas. The macro expands to builder calls followed by ?, so it can only be used in a function (or doctest) returning a Result whose error type implements From<Error<F::Error>>, where F is the flavor of the tree.

Examples

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Syntax {
    Root,
    Number,
    Lit,
    Whitespace,
}

let mut tree = syntree::Builder::new();

tree.open(Syntax::Root)?;

tree.open(Syntax::Number)?;
tree.token(Syntax::Lit, 1)?;
tree.close()?;

tree.token(Syntax::Whitespace, 3)?;

tree.open(Syntax::Number)?;
tree.token(Syntax::Lit, 2)?;
tree.token_empty(Syntax::Lit)?;
tree.close()?;

tree.close()?;

let tree = tree.build()?;

let expected = syntree::tree! {
    Syntax::Root => {
        Syntax::Number => {
            (Syntax::Lit, 1)
        },
        (Syntax::Whitespace, 3),
        Syntax::Number => {
            (Syntax::Lit, 2),
            Syntax::Lit
        }
    }
};

assert_eq!(expected, tree);

Explicit spans:

use syntree::Span;

let tree = syntree::tree! {
    ("root", (0, 10)) => {
        ("token", (2, 5)),
    }
};

let root = tree.first().ok_or("missing root")?;
assert_eq!(root.span(), Span::new(0, 10));

let token = root.first().ok_or("missing token")?;
assert_eq!(token.span(), Span::new(2, 5));