use rowan::{GreenNode, NodeCache};
use crate::{
kind::CppSyntaxKind,
parser::{MarkEvent, NO_FORWARD_PARENT},
};
use super::cpp_green_builder::CppGreenNodeBuilder;
#[derive(Debug)]
pub struct CppTreeBuilder<'a> {
text: &'a str,
events: Vec<MarkEvent>,
green_builder: CppGreenNodeBuilder<'a>,
}
impl<'a> CppTreeBuilder<'a> {
pub fn new(
text: &'a str,
events: Vec<MarkEvent>,
node_cache: Option<&'a mut NodeCache>,
) -> Self {
match node_cache {
Some(cache) => CppTreeBuilder {
text,
events,
green_builder: CppGreenNodeBuilder::with_cache(cache),
},
None => CppTreeBuilder {
text,
events,
green_builder: CppGreenNodeBuilder::new(),
},
}
}
pub fn build(&mut self) {
balance_events(&mut self.events);
let event_count = self.events.len();
let mut parents: Vec<CppSyntaxKind> = Vec::new();
for i in 0..self.events.len() {
match std::mem::replace(&mut self.events[i], MarkEvent::none()) {
MarkEvent::NodeStart {
kind: CppSyntaxKind::None,
..
}
| MarkEvent::Trivia => {}
MarkEvent::NodeStart { kind, parent } => {
parents.push(kind);
let mut parent_position = parent;
let mut guard = 0usize;
while parent_position != NO_FORWARD_PARENT {
guard += 1;
assert!(
guard <= event_count,
"cyclic `parent` chain in marker events; the parser produced \
inconsistent forward references"
);
match std::mem::replace(
&mut self.events[parent_position],
MarkEvent::none(),
) {
MarkEvent::NodeStart { kind, parent } => {
parents.push(kind);
parent_position = parent;
}
other => unreachable!(
"forward parent must point at a NodeStart, found {other:?}"
),
}
}
for kind in parents.drain(..).rev() {
self.green_builder.start_node(kind);
}
}
MarkEvent::NodeEnd => {
self.green_builder.finish_node();
}
MarkEvent::EatToken { kind, range } => {
self.green_builder.token(kind, range);
}
}
}
}
pub fn finish(self) -> GreenNode {
self.green_builder.finish(self.text)
}
}
fn balance_events(events: &mut Vec<MarkEvent>) {
let mut stack: Vec<usize> = Vec::new();
let mut keep: Vec<bool> = events
.iter()
.map(|event| {
!matches!(
event,
MarkEvent::NodeStart {
kind: CppSyntaxKind::None,
..
} | MarkEvent::Trivia
)
})
.collect();
for index in 0..events.len() {
match &events[index] {
MarkEvent::NodeStart {
kind: CppSyntaxKind::None,
..
} => {}
MarkEvent::NodeStart { .. } => stack.push(index),
MarkEvent::NodeEnd => {
if let Some(start) = stack.pop() {
if start + 1 == index {
keep[start] = false;
keep[index] = false;
}
} else {
keep[index] = false;
}
}
MarkEvent::EatToken { .. } | MarkEvent::Trivia => {}
}
}
for index in 0..events.len() {
if !keep[index] {
events[index] = MarkEvent::Trivia;
}
}
for _ in 0..stack.len() {
events.push(MarkEvent::NodeEnd);
}
}