use std::collections::HashMap;
use crate::Span;
use crate::language::{
CommentForm, CommentRow, CommentSlot, DiagnosticRow, DirectiveRow, LanguageError, MentionKind,
MentionRow, NodeKind, NodeRow, NodeTable, RegionRow,
};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum DuplicatePolicy {
#[default]
LastValue,
FirstValue,
Keep,
Error,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Put {
pub entry: u32,
pub repeat: bool,
}
#[derive(Clone, Debug, Default)]
pub struct RowWriter {
table: NodeTable,
first: Vec<Option<u32>>,
next: Vec<Option<u32>>,
last: Vec<Option<u32>>,
keyed: HashMap<(u32, String), u32>,
}
impl RowWriter {
pub fn new() -> Self {
Self::default()
}
pub fn add(&mut self, row: NodeRow) -> u32 {
let parent = row.parent;
let id = self.table.push(row);
self.first.push(None);
self.next.push(None);
self.last.push(None);
if let Some(p) = parent {
self.append(p, id);
}
id
}
pub fn row(&self, id: u32) -> &NodeRow {
&self.table.rows[id as usize]
}
pub fn row_mut(&mut self, id: u32) -> &mut NodeRow {
&mut self.table.rows[id as usize]
}
pub fn first_child(&self, id: u32) -> Option<u32> {
self.first[id as usize]
}
pub fn next_sibling(&self, id: u32) -> Option<u32> {
self.next[id as usize]
}
pub fn len(&self) -> usize {
self.table.rows.len()
}
pub fn is_empty(&self) -> bool {
self.table.rows.is_empty()
}
pub fn append(&mut self, parent: u32, child: u32) {
match self.last[parent as usize] {
None => self.first[parent as usize] = Some(child),
Some(prev) => self.next[prev as usize] = Some(child),
}
self.next[child as usize] = None;
self.last[parent as usize] = Some(child);
self.table.rows[child as usize].parent = Some(parent);
}
pub fn set_first(&mut self, id: u32, child: Option<u32>) {
self.first[id as usize] = child;
if child.is_none() {
self.last[id as usize] = None;
}
}
pub fn set_next(&mut self, id: u32, next: Option<u32>) {
self.next[id as usize] = next;
}
pub fn put(
&mut self,
map: u32,
key: u32,
value: u32,
policy: DuplicatePolicy,
) -> Result<Put, LanguageError> {
let name = self.row(key).text.clone();
let existing = name
.as_ref()
.and_then(|n| self.keyed.get(&(map, n.clone())).copied());
if let Some(kv) = existing {
match policy {
DuplicatePolicy::LastValue => {
let k = self.first[kv as usize].expect("an entry put here has its key");
self.next[k as usize] = Some(value);
self.next[value as usize] = None;
self.last[kv as usize] = Some(value);
self.table.rows[value as usize].parent = Some(kv);
return Ok(Put {
entry: kv,
repeat: true,
});
}
DuplicatePolicy::FirstValue => {
return Ok(Put {
entry: kv,
repeat: true,
});
}
DuplicatePolicy::Error => {
let message = format!("duplicate key `{}`", name.unwrap_or_default());
return Err(match self.row(key).span {
Some(s) => LanguageError::at(message, s.start),
None => LanguageError::new(message),
});
}
DuplicatePolicy::Keep => {}
}
}
let span = match (self.row(key).span, self.row(value).span) {
(Some(k), Some(v)) => Span::from(k.start..v.end),
_ => Span::from(0..0),
};
let mut row = NodeRow::new(NodeKind::KeyValue, Some(map), span);
if self.row(key).span.is_none() {
row.span = None;
}
let kv = self.add(row);
self.append(kv, key);
self.append(kv, value);
if let (Some(n), None) = (name, existing) {
self.keyed.insert((map, n), kv);
}
Ok(Put {
entry: kv,
repeat: existing.is_some(),
})
}
pub fn put_entry(&mut self, map: u32, kv: u32, policy: DuplicatePolicy) -> Result<Put, LanguageError> {
let key = self.first[kv as usize].expect("an entry has its key");
let value = self.next[key as usize].expect("an entry has its value");
let name = self.row(key).text.clone();
let existing = name.as_ref().and_then(|n| self.keyed.get(&(map, n.clone())).copied());
if let Some(e) = existing {
match policy {
DuplicatePolicy::LastValue => {
let k = self.first[e as usize].expect("an entry put here has its key");
self.next[k as usize] = Some(value);
self.next[value as usize] = None;
self.last[e as usize] = Some(value);
self.table.rows[value as usize].parent = Some(e);
return Ok(Put { entry: e, repeat: true });
}
DuplicatePolicy::FirstValue => return Ok(Put { entry: e, repeat: true }),
DuplicatePolicy::Error => {
let message = format!("duplicate key `{}`", name.unwrap_or_default());
return Err(match self.row(key).span {
Some(s) => LanguageError::at(message, s.start),
None => LanguageError::new(message),
});
}
DuplicatePolicy::Keep => {}
}
}
self.append(map, kv);
if let (Some(n), None) = (name, existing) {
self.keyed.insert((map, n), kv);
}
Ok(Put {
entry: kv,
repeat: existing.is_some(),
})
}
pub fn child_by_key(&self, map: u32, key: &str) -> Option<u32> {
let mut e = self.first[map as usize];
let mut steps = 0;
while let Some(id) = e {
if steps > self.len() {
break;
}
steps += 1;
if self.row(id).kind == NodeKind::KeyValue
&& let Some(k) = self.first[id as usize]
&& self.row(k).text.as_deref() == Some(key)
{
return Some(id);
}
e = self.next[id as usize];
}
None
}
pub fn comment(
&mut self,
node: u32,
slot: CommentSlot,
style: CommentForm,
text: impl Into<String>,
) {
self.table
.comments
.push(CommentRow::new(node, slot, style, text));
}
pub fn region(&mut self, node: u32, span: Span) {
self.table.regions.push(RegionRow::new(node, span));
}
pub fn mention(&mut self, node: u32, span: Span, kind: MentionKind) {
self.table.mentions.push(MentionRow::new(node, span, kind));
}
pub fn directive(&mut self, row: DirectiveRow) {
self.table.directives.push(row);
}
pub fn diagnostic(&mut self, row: DiagnosticRow) {
self.table.diagnostics.push(row);
}
pub fn finish(self, root: u32) -> NodeTable {
let RowWriter {
table, first, next, ..
} = self;
let n = table.rows.len();
let mut place: Vec<Option<u32>> = vec![None; n];
let mut order: Vec<(u32, Option<u32>)> = Vec::with_capacity(n);
let mut stack: Vec<(u32, Option<u32>)> = vec![(root, None)];
while let Some((id, parent)) = stack.pop() {
if place[id as usize].is_some() {
continue;
}
if parent.is_some()
&& let Some(sib) = next[id as usize]
{
stack.push((sib, parent));
}
place[id as usize] = Some(order.len() as u32);
order.push((id, parent));
let kind = table.rows[id as usize].kind;
if matches!(
kind,
NodeKind::Mapping | NodeKind::Sequence | NodeKind::KeyValue
) && let Some(f) = first[id as usize]
{
stack.push((f, Some(id)));
}
}
let NodeTable {
rows,
regions,
mentions,
comments,
directives,
diagnostics,
..
} = table;
let mut old: Vec<Option<NodeRow>> = rows.into_iter().map(Some).collect();
let mut out = NodeTable::new();
for (id, parent) in order {
let mut r = old[id as usize].take().expect("a row is written once");
r.parent = parent.and_then(|p| place[p as usize]);
out.rows.push(r);
}
let moved = |node: u32| place.get(node as usize).copied().flatten();
let slot = |s: CommentSlot| match s {
CommentSlot::Leading => 0,
CommentSlot::Trailing => 1,
CommentSlot::Dangling => 2,
};
let mut cs: Vec<CommentRow> = comments
.into_iter()
.filter_map(|mut c| {
c.node = moved(c.node)?;
Some(c)
})
.collect();
cs.sort_by_key(|c| (c.node, slot(c.slot)));
let mut kept = Vec::with_capacity(cs.len());
for (i, c) in cs.iter().enumerate() {
let replaced = c.slot == CommentSlot::Trailing
&& cs
.get(i + 1)
.is_some_and(|d| d.node == c.node && d.slot == CommentSlot::Trailing);
if !replaced {
kept.push(c.clone());
}
}
out.comments = kept;
out.regions = regions
.into_iter()
.filter_map(|mut r| {
r.node = moved(r.node)?;
Some(r)
})
.collect();
out.regions.sort_by_key(|r| r.node);
out.mentions = mentions
.into_iter()
.filter_map(|mut m| {
m.node = moved(m.node)?;
Some(m)
})
.collect();
out.mentions.sort_by_key(|m| m.node);
out.directives = directives;
out.diagnostics = diagnostics;
out
}
}