use rowan::GreenNodeBuilder;
use crate::parser::events::Event;
use crate::parser::lexer::{TokKind, Token};
use crate::syntax::{SyntaxKind, SyntaxNode};
use crate::tokens::token_table;
pub(crate) fn build_tree(tokens: &[Token], events: &[Event]) -> SyntaxNode {
#[cfg(debug_assertions)]
debug_assert_balanced(events);
let mut builder = GreenNodeBuilder::new();
builder.start_node(SyntaxKind::ROOT.into());
for event in events {
match *event {
Event::Start(kind) => builder.start_node(kind.into()),
Event::Tok(idx) => push_token(&mut builder, &tokens[idx]),
Event::Finish => builder.finish_node(),
}
}
builder.finish_node();
let green = builder.finish();
SyntaxNode::new_root(green)
}
fn push_token(builder: &mut GreenNodeBuilder<'_>, tok: &Token) {
builder.token(syntax_kind_for(tok.kind).into(), tok.text);
}
#[cfg(debug_assertions)]
fn debug_assert_balanced(events: &[Event]) {
let mut depth: i32 = 0;
for (i, event) in events.iter().enumerate() {
match event {
Event::Start(_) => depth += 1,
Event::Finish => {
depth -= 1;
assert!(
depth >= 0,
"unbalanced parser events: `Finish` at index {i} with no open node"
);
}
Event::Tok(_) => {}
}
}
assert_eq!(
depth, 0,
"unbalanced parser events: {depth} node(s) left open at end of stream"
);
}
macro_rules! define_syntax_kind_for {
($($(#[$meta:meta])* $tok:ident $syn:ident,)*) => {
pub(crate) fn syntax_kind_for(kind: TokKind) -> SyntaxKind {
match kind {
$(TokKind::$tok => SyntaxKind::$syn,)*
TokKind::UniArrow
| TokKind::UniComparison
| TokKind::UniColon
| TokKind::UniPlus
| TokKind::UniTimes
| TokKind::UniPower => SyntaxKind::UNICODE_OP,
}
}
};
}
token_table!(define_syntax_kind_for);