use rowan::{GreenNode, GreenToken, TextRange, TextSize, TokenAtOffset};
use crate::parser::diagnostics::DIAGNOSTIC_STREAMS;
use crate::parser::{ParseDiagnostic, ParseOptions};
use crate::parser::tree_builder::syntax_kind_for;
use crate::syntax::{SyntaxKind, SyntaxNode, SyntaxToken};
pub use super::edit::{Edit, apply_edits, diff_edit, try_apply_edits};
pub fn fingerprint(node: &SyntaxNode) -> String {
use std::fmt::Write;
let mut out = String::new();
for el in node.descendants_with_tokens() {
let text = el
.as_token()
.map(|t| t.text().to_string())
.unwrap_or_default();
let _ = writeln!(out, "{:?}@{:?} {:?}", el.kind(), el.text_range(), text);
}
out
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum ReparseTier {
Token,
Block,
TopLevel,
}
#[derive(Debug, Clone)]
pub struct Reparsed {
pub green: GreenNode,
pub diagnostics: Vec<ParseDiagnostic>,
pub tier: ReparseTier,
}
fn reparse_same_options(
options: ParseOptions,
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
new_text: &str,
) -> Option<Reparsed> {
if !fits(prev_text, edit) {
return None;
}
let result = reparse_impl(options, prev_text, prev_green, prev_diags, edit, new_text)?;
assert_matches_full_parse(options, &result, new_text);
Some(result)
}
fn reparse_edits_same_options(
options: ParseOptions,
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edits: &[Edit],
new_text: &str,
) -> Option<Reparsed> {
if edits.is_empty() {
return None;
}
if let [edit] = edits {
if !fits(prev_text, edit) {
return None;
}
let suffix = new_text
.strip_prefix(&prev_text[..edit.range.start])?
.strip_prefix(&edit.insert)?;
if suffix != &prev_text[edit.range.end..] {
return None;
}
return reparse_same_options(options, prev_text, prev_green, prev_diags, edit, new_text);
}
let mut text = prev_text.to_string();
let mut green = prev_green.clone();
let mut diagnostics = prev_diags.to_vec();
let mut tier = ReparseTier::Token;
for edit in edits {
if !fits(&text, edit) {
return None;
}
let next = edit.apply(&text);
let step = reparse_impl(options, &text, &green, &diagnostics, edit, &next)?;
tier = tier.max(step.tier);
text = next;
green = step.green;
diagnostics = step.diagnostics;
}
if text != new_text {
return None;
}
let result = Reparsed {
green,
diagnostics,
tier,
};
assert_matches_full_parse(options, &result, new_text);
Some(result)
}
#[cfg(debug_assertions)]
fn assert_matches_full_parse(options: ParseOptions, result: &Reparsed, new_text: &str) {
let full = crate::parser::parse_with_options(new_text, options);
debug_assert_eq!(
fingerprint(&SyntaxNode::new_root(result.green.clone())),
fingerprint(&full.cst),
"Tenet 4: reparse ({:?}) tree differs from full parse",
result.tier,
);
debug_assert_eq!(
result.diagnostics, full.diagnostics,
"Tenet 4: reparse ({:?}) diagnostics differ from full parse",
result.tier,
);
}
#[cfg(not(debug_assertions))]
fn assert_matches_full_parse(_options: ParseOptions, _result: &Reparsed, _new_text: &str) {}
fn fits(text: &str, edit: &Edit) -> bool {
edit.range.start <= edit.range.end
&& edit.range.end <= text.len()
&& text.is_char_boundary(edit.range.start)
&& text.is_char_boundary(edit.range.end)
}
fn reparse_impl(
options: ParseOptions,
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
new_text: &str,
) -> Option<Reparsed> {
reparse_token(options, prev_text, prev_green, prev_diags, edit)
.or_else(|| reparse_block(options, prev_text, prev_green, prev_diags, edit, new_text))
.or_else(|| reparse_toplevel(options, prev_text, prev_green, prev_diags, edit, new_text))
}
const TOKEN_REPARSE_KINDS: &[SyntaxKind] = &[
SyntaxKind::IDENT,
SyntaxKind::COMMENT,
SyntaxKind::BLOCK_COMMENT,
SyntaxKind::WHITESPACE,
];
const STRING_LITERAL_KINDS: &[SyntaxKind] = &[
SyntaxKind::STRING_LITERAL,
SyntaxKind::CMD_LITERAL,
SyntaxKind::NONSTANDARD_IDENTIFIER,
];
const CONTEXTUAL_IDENTS: &[&str] = &[
"as", "abstract", "primitive", "type", "typegroup", "public", "var", "in", "∈", "isa", "doc", "outer", ];
fn reparse_token(
options: ParseOptions,
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
) -> Option<Reparsed> {
let root = SyntaxNode::new_root(prev_green.clone());
let (s, e) = (edit.range.start, edit.range.end);
let mut candidates: Vec<SyntaxToken> = Vec::with_capacity(2);
if s == e {
match root.token_at_offset(TextSize::new(s as u32)) {
TokenAtOffset::None => return None,
TokenAtOffset::Single(t) => candidates.push(t),
TokenAtOffset::Between(l, r) => candidates.extend([l, r]),
}
} else {
let range = TextRange::new(TextSize::new(s as u32), TextSize::new(e as u32));
candidates.push(root.covering_element(range).into_token()?);
}
candidates
.into_iter()
.find_map(|token| try_splice_token(options, prev_text, prev_diags, edit, &token))
}
fn try_splice_token(
options: ParseOptions,
prev_text: &str,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
token: &SyntaxToken,
) -> Option<Reparsed> {
match token.kind() {
SyntaxKind::STRING_CONTENT => {
try_splice_string_content(options, prev_text, prev_diags, edit, token)
}
kind if TOKEN_REPARSE_KINDS.contains(&kind) => {
try_splice_plain_token(options, prev_text, prev_diags, edit, token)
}
_ => None,
}
}
fn try_splice_plain_token(
options: ParseOptions,
prev_text: &str,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
token: &SyntaxToken,
) -> Option<Reparsed> {
if edit.insert.contains(['\n', '\r']) || prev_text[edit.range.clone()].contains(['\n', '\r']) {
return None;
}
let tr = token.text_range();
let (t0, t1) = (usize::from(tr.start()), usize::from(tr.end()));
let mut new_leaf = token.text().to_string();
new_leaf.replace_range((edit.range.start - t0)..(edit.range.end - t0), &edit.insert);
let relexed = lex_for_options(options, &new_leaf);
let [only] = relexed.as_slice() else {
return None;
};
if only.start != 0 || only.end != new_leaf.len() || syntax_kind_for(only.kind) != token.kind() {
return None;
}
if token.kind() == SyntaxKind::IDENT
&& (CONTEXTUAL_IDENTS.contains(&token.text())
|| CONTEXTUAL_IDENTS.contains(&new_leaf.as_str()))
{
return None;
}
let next_char = prev_text[t1..].chars().next().unwrap_or('\n');
let mut probe = new_leaf.clone();
probe.push(next_char);
let first = lex_for_options(options, &probe).into_iter().next()?;
if first.end != new_leaf.len() || syntax_kind_for(first.kind) != token.kind() {
return None;
}
if let Some(prev) = token.prev_token() {
let mut probe = prev.text().to_string();
let boundary = probe.len();
probe.push_str(&new_leaf);
let relexed = lex_for_options(options, &probe);
let [a, b] = relexed.as_slice() else {
return None;
};
if a.end != boundary
|| syntax_kind_for(a.kind) != prev.kind()
|| b.end != probe.len()
|| syntax_kind_for(b.kind) != token.kind()
{
return None;
}
}
if prev_diags.iter().any(|d| d.start <= t1 && d.end >= t0) {
return None;
}
let delta = edit.delta();
let shift = |pos: usize| (pos as isize + delta) as usize;
let diagnostics = prev_diags
.iter()
.map(|d| {
let mut d = d.clone();
if d.start >= t1 {
d.start = shift(d.start);
d.end = shift(d.end);
}
d
})
.collect();
let green = token.replace_with(GreenToken::new(token.kind().into(), &new_leaf));
Some(Reparsed {
green,
diagnostics,
tier: ReparseTier::Token,
})
}
fn edited_slice(text: &str, base: usize, edit: &Edit) -> String {
let mut out = text.to_string();
out.replace_range(
(edit.range.start - base)..(edit.range.end - base),
&edit.insert,
);
out
}
fn literal_token_ends(node: &SyntaxNode) -> Vec<(SyntaxKind, usize)> {
let base = usize::from(node.text_range().start());
node.descendants_with_tokens()
.filter_map(|el| el.into_token())
.map(|t| (t.kind(), usize::from(t.text_range().end()) - base))
.collect()
}
fn relex_matches(
options: ParseOptions,
text: &str,
expected: &[(SyntaxKind, usize)],
grown: Option<(usize, isize)>,
) -> bool {
let tokens = lex_for_options(options, text);
if tokens.len() != expected.len() {
return false;
}
for (i, (got, &(kind, end))) in tokens.iter().zip(expected).enumerate() {
let shift = match grown {
Some((from, delta)) if i >= from => delta,
_ => 0,
};
let Ok(want) = usize::try_from(end as isize + shift) else {
return false;
};
if syntax_kind_for(got.kind) != kind || got.end != want {
return false;
}
}
tokens.last().is_some_and(|t| t.end == text.len())
}
fn try_splice_string_content(
options: ParseOptions,
prev_text: &str,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
token: &SyntaxToken,
) -> Option<Reparsed> {
let node = token.parent()?;
if !STRING_LITERAL_KINDS.contains(&node.kind()) {
return None;
}
let nr = node.text_range();
let (n0, n1) = (usize::from(nr.start()), usize::from(nr.end()));
if prev_diags.iter().any(|d| d.start <= n1 && d.end >= n0) {
return None;
}
let expected = literal_token_ends(&node);
let tr = token.text_range();
let (t0, t1) = (usize::from(tr.start()), usize::from(tr.end()));
let leaf = expected
.iter()
.position(|&(kind, end)| kind == SyntaxKind::STRING_CONTENT && end == t1 - n0)?;
let close = if node.kind() == SyntaxKind::CMD_LITERAL {
SyntaxKind::CMD_DELIM_CLOSE
} else {
SyntaxKind::STRING_DELIM_CLOSE
};
if !expected[leaf + 1..].iter().any(|&(kind, _)| kind == close) {
return None;
}
let old_node_text = &prev_text[n0..n1];
if !relex_matches(options, old_node_text, &expected, None) {
return None;
}
let delta = edit.delta();
let edited = edited_slice(old_node_text, n0, edit);
if !relex_matches(options, &edited, &expected, Some((leaf, delta))) {
return None;
}
let new_leaf = &edited[(t0 - n0)..((t1 - n0) as isize + delta) as usize];
let shift = |pos: usize| (pos as isize + delta) as usize;
let diagnostics = prev_diags
.iter()
.map(|d| {
let mut d = d.clone();
if d.start >= n1 {
d.start = shift(d.start);
d.end = shift(d.end);
}
d
})
.collect();
let green = token.replace_with(GreenToken::new(SyntaxKind::STRING_CONTENT.into(), new_leaf));
Some(Reparsed {
green,
diagnostics,
tier: ReparseTier::Token,
})
}
fn is_trivia_kind(kind: SyntaxKind) -> bool {
matches!(
kind,
SyntaxKind::WHITESPACE
| SyntaxKind::NEWLINE
| SyntaxKind::COMMENT
| SyntaxKind::BLOCK_COMMENT
)
}
fn is_significant_child(el: &crate::syntax::SyntaxElement) -> bool {
match el {
rowan::NodeOrToken::Node(n) => !n.text_range().is_empty(),
rowan::NodeOrToken::Token(t) => !is_trivia_kind(t.kind()),
}
}
const REGION_ALWAYS_TRY_BYTES: usize = 4 * 1024;
const REGION_MAX_FILE_DIVISOR: usize = 4;
fn region_is_too_wide(region_len: usize, text_len: usize) -> bool {
region_len > REGION_ALWAYS_TRY_BYTES && region_len > text_len / REGION_MAX_FILE_DIVISOR
}
struct Region {
first: usize,
last: usize,
start: usize,
end: usize,
first_is_node: bool,
last_is_node: bool,
}
fn select_region(root: &SyntaxNode, edit: &Edit) -> Option<Region> {
let (s, e) = (edit.range.start, edit.range.end);
let children: Vec<_> = root.children_with_tokens().collect();
let touches = |el: &crate::syntax::SyntaxElement| {
let r = el.text_range();
usize::from(r.start()) <= e && usize::from(r.end()) >= s
};
let mut first = children.iter().position(touches)?;
let last = children.len() - 1 - children.iter().rev().position(touches)?;
let start = usize::from(children[first].text_range().start());
while first > 0
&& children[first - 1].text_range() == TextRange::empty(TextSize::new(start as u32))
{
first -= 1;
}
if first == 0 && last == children.len() - 1 {
return None;
}
Some(Region {
first,
last,
start,
end: usize::from(children[last].text_range().end()),
first_is_node: children[first].as_node().is_some(),
last_is_node: children[last].as_node().is_some(),
})
}
fn sibling_nodes(root: &SyntaxNode, region: &Region) -> (Option<SyntaxNode>, Option<SyntaxNode>) {
let positive_node =
|el: crate::syntax::SyntaxElement| el.into_node().filter(|n| !n.text_range().is_empty());
let prev = root
.children_with_tokens()
.take(region.first)
.filter_map(positive_node)
.last();
let next = root
.children_with_tokens()
.skip(region.last + 1)
.find_map(positive_node);
(prev, next)
}
fn no_straddle(cst: &SyntaxNode, seam: usize) -> bool {
let seam = TextSize::new(seam as u32);
cst.children_with_tokens().all(|el| {
let r = el.text_range();
!(r.start() < seam && seam < r.end())
})
}
fn splice_diagnostics(
prev_diags: &[ParseDiagnostic],
frag_diags: &[ParseDiagnostic],
region: &Region,
delta: isize,
) -> Option<Vec<ParseDiagnostic>> {
enum Class {
Before,
Drop,
After,
}
let classify = |d: &ParseDiagnostic| -> Option<Class> {
let (rs, re) = (region.start, region.end);
if d.start == d.end && d.start == rs {
return Some(if region.first_is_node {
Class::Drop
} else {
Class::Before
});
}
if d.start == d.end && d.start == re {
return Some(if region.last_is_node {
Class::Drop
} else {
Class::After
});
}
if d.end <= rs {
return Some(Class::Before);
}
if d.start >= re {
return Some(Class::After);
}
if d.start >= rs && d.end <= re {
return Some(Class::Drop);
}
None
};
let mut before: [Vec<ParseDiagnostic>; DIAGNOSTIC_STREAMS] = Default::default();
let mut after: [Vec<ParseDiagnostic>; DIAGNOSTIC_STREAMS] = Default::default();
for d in prev_diags {
let class = classify(d)?;
let stream = d.kind.stream();
if stream >= DIAGNOSTIC_STREAMS {
debug_assert!(false, "diagnostic stream {stream} is out of range");
return None;
}
match class {
Class::Before => before[stream].push(d.clone()),
Class::Drop => {}
Class::After => {
let mut d = d.clone();
d.start = (d.start as isize + delta) as usize;
d.end = (d.end as isize + delta) as usize;
after[stream].push(d);
}
}
}
let mut out = Vec::with_capacity(prev_diags.len() + frag_diags.len());
for stream in 0..DIAGNOSTIC_STREAMS {
out.append(&mut before[stream]);
out.extend(
frag_diags
.iter()
.filter(|d| d.kind.stream() == stream)
.map(|d| {
let mut d = d.clone();
d.start += region.start;
d.end += region.start;
d
}),
);
out.append(&mut after[stream]);
}
Some(out)
}
fn reparse_toplevel(
options: ParseOptions,
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
new_text: &str,
) -> Option<Reparsed> {
let root = SyntaxNode::new_root(prev_green.clone());
reparse_statements(options, prev_text, prev_diags, edit, new_text, &root, None)
}
fn reparse_block(
options: ParseOptions,
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
new_text: &str,
) -> Option<Reparsed> {
let root = SyntaxNode::new_root(prev_green.clone());
let range = TextRange::new(
TextSize::try_from(edit.range.start).ok()?,
TextSize::try_from(edit.range.end).ok()?,
);
let covering = root.covering_element(range);
let node = match covering {
rowan::NodeOrToken::Node(node) => node,
rowan::NodeOrToken::Token(token) => token.parent()?,
};
let statement = node
.ancestors()
.find(|n| n.parent().is_some_and(|p| p.kind() == SyntaxKind::ROOT))?;
let extent = statement.text_range();
if prev_diags.iter().any(|d| {
d.kind.stream() == 0
&& d.start >= usize::from(extent.start())
&& d.start <= usize::from(extent.end())
}) {
return None;
}
for block in node.ancestors().filter(|n| n.kind() == SyntaxKind::BLOCK) {
let owner = block.parent()?.kind();
if let Some(result) = reparse_statements(
options,
prev_text,
prev_diags,
edit,
new_text,
&block,
Some(owner),
) {
return Some(result);
}
}
None
}
#[allow(clippy::too_many_arguments)]
fn reparse_statements(
options: ParseOptions,
prev_text: &str,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
new_text: &str,
root: &SyntaxNode,
owner: Option<SyntaxKind>,
) -> Option<Reparsed> {
let parse_fragment = |text: &str| match owner {
Some(kind) => super::core::parse_block_fragment(text, kind, options),
None => Some(crate::parser::parse_with_options(text, options)),
};
let selection;
let edit_region = if owner.is_some() {
let start = usize::from(root.text_range().start());
let end = usize::from(root.text_range().end());
let line_start = prev_text[start..edit.range.start]
.rfind('\n')
.map_or(start, |at| start + at + 1);
let line_end = prev_text[edit.range.end..end]
.find('\n')
.map_or(end, |at| edit.range.end + at);
selection = Edit {
range: line_start..line_end,
insert: String::new(),
};
&selection
} else {
edit
};
let region = select_region(root, edit_region)?;
if region_is_too_wide(region.end - region.start, prev_text.len()) {
return None;
}
let delta = edit.delta();
let frag_end = (region.end as isize + delta) as usize;
let fragment = &new_text[region.start..frag_end];
let (prev_node, next_node) = sibling_nodes(root, ®ion);
if owner.is_some() {
prev_node.as_ref()?;
next_node.as_ref()?;
let old = parse_fragment(&prev_text[region.start..region.end])?;
let expected: Vec<_> = root
.green()
.children()
.skip(region.first)
.take(region.last + 1 - region.first)
.map(|child| child.to_owned())
.collect();
let actual: Vec<_> = old
.cst
.green()
.children()
.map(|child| child.to_owned())
.collect();
if expected != actual {
return None;
}
}
let frag = parse_fragment(fragment)?;
let positive_nodes = |node: &SyntaxNode| {
node.children_with_tokens()
.filter_map(|el| el.into_node())
.filter(|n| !n.text_range().is_empty())
};
let prev_significant_end = root
.children_with_tokens()
.take(region.first)
.filter(is_significant_child)
.last()
.map(|el| usize::from(el.text_range().end()));
if let Some(from) = prev_significant_end {
let anchor = frag
.cst
.children_with_tokens()
.find(is_significant_child)
.map(|el| usize::from(el.text_range().start()))
.unwrap_or(fragment.len());
if !new_text[from..region.start + anchor].contains('\n') {
return None;
}
}
if let Some(next) = &next_node {
let anchor = frag
.cst
.children_with_tokens()
.filter(is_significant_child)
.last()
.map(|el| usize::from(el.text_range().end()))
.unwrap_or(0);
let to = (usize::from(next.text_range().start()) as isize + delta) as usize;
if !new_text[region.start + anchor..to].contains('\n') {
return None;
}
let old_anchor = root
.children_with_tokens()
.skip(region.first)
.take(region.last + 1 - region.first)
.filter(is_significant_child)
.last()
.map(|el| usize::from(el.text_range().end()))
.or(prev_significant_end)
.unwrap_or(0);
if !prev_text[old_anchor..usize::from(next.text_range().start())].contains('\n') {
return None;
}
}
if !frag
.cst
.children_with_tokens()
.any(|el| is_significant_child(&el))
&& let (Some(prev), Some(next)) = (&prev_node, &next_node)
{
let back_gap = &prev_text[usize::from(prev.text_range().end())..region.start];
let fwd_gap = &prev_text[region.end..usize::from(next.text_range().start())];
let guard = format!(
"{}{}{}{}{}",
prev.text(),
back_gap,
fragment,
fwd_gap,
next.text()
);
let back_seam = usize::from(prev.text_range().len()) + back_gap.len();
let fwd_seam = back_seam + fragment.len();
let parsed = parse_fragment(&guard)?;
if !no_straddle(&parsed.cst, back_seam) || !no_straddle(&parsed.cst, fwd_seam) {
return None;
}
}
let frag_starts_with_node = frag
.cst
.children_with_tokens()
.next()
.is_some_and(|el| el.as_node().is_some());
let frag_ends_with_node = frag
.cst
.children_with_tokens()
.last()
.is_some_and(|el| el.as_node().is_some());
if let Some(prev) = &prev_node {
let back_gap = &prev_text[usize::from(prev.text_range().end())..region.start];
let guard = format!("{}{}{}", prev.text(), back_gap, fragment);
let seam = guard.len() - fragment.len();
let parsed = parse_fragment(&guard)?;
if !no_straddle(&parsed.cst, seam) {
return None;
}
let guard_frag: Vec<ParseDiagnostic> = parsed
.diagnostics
.iter()
.filter(|d| {
d.start > seam
|| (d.start == seam && d.end > seam)
|| (d.start == seam && d.end == seam && frag_starts_with_node)
})
.map(|d| {
let mut d = d.clone();
d.start -= seam;
d.end -= seam;
d
})
.collect();
if guard_frag != frag.diagnostics {
return None;
}
}
let tail = match &next_node {
Some(next) => {
let gap = &prev_text[region.end..usize::from(next.text_range().start())];
format!("{}{}", gap, next.text())
}
None => prev_text[region.end..usize::from(root.text_range().end())].to_string(),
};
if !tail.is_empty() {
let guard = format!("{fragment}{tail}");
let seam = fragment.len();
let parsed = parse_fragment(&guard)?;
if !no_straddle(&parsed.cst, seam) {
return None;
}
let signature = |el: crate::syntax::SyntaxElement| {
(
usize::from(el.text_range().start()),
el.as_node().is_some(),
el.kind(),
usize::from(el.text_range().len()),
)
};
let frag_sig: Vec<_> = frag.cst.children_with_tokens().map(signature).collect();
let pre_seam: Vec<_> = parsed
.cst
.children_with_tokens()
.filter(|el| {
let r = el.text_range();
usize::from(r.end()) <= seam && !(r.is_empty() && usize::from(r.start()) == seam)
})
.map(signature)
.collect();
if pre_seam != frag_sig {
return None;
}
let guard_frag: Vec<ParseDiagnostic> = parsed
.diagnostics
.iter()
.filter(|d| {
d.end < seam
|| (d.end == seam && d.start < seam)
|| (d.start == seam && d.end == seam && frag_ends_with_node)
})
.cloned()
.collect();
if guard_frag != frag.diagnostics {
return None;
}
if let Some(next) = &next_node {
let gap_len = usize::from(next.text_range().start()) - region.end;
let reparsed_next =
positive_nodes(&parsed.cst).find(|n| usize::from(n.text_range().start()) >= seam);
let intact = reparsed_next.is_some_and(|n| {
usize::from(n.text_range().start()) == seam + gap_len
&& n.kind() == next.kind()
&& n.text_range().len() == next.text_range().len()
});
if !intact {
return None;
}
}
}
let diagnostics = splice_diagnostics(prev_diags, &frag.diagnostics, ®ion, delta)?;
let frag_green = frag.cst.green();
let green = root.green().splice_children(
region.first..=region.last,
frag_green.children().map(|c| c.to_owned()),
);
Some(Reparsed {
green: root.replace_with(green),
diagnostics,
tier: if owner.is_some() {
ReparseTier::Block
} else {
ReparseTier::TopLevel
},
})
}
#[derive(Clone, Copy)]
pub struct ReparseBase<'a> {
pub text: &'a str,
pub green: &'a GreenNode,
pub diagnostics: &'a [ParseDiagnostic],
pub options: ParseOptions,
}
pub fn reparse(
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edit: &Edit,
new_text: &str,
) -> Option<Reparsed> {
let options = ParseOptions::default();
reparse_with_options(
ReparseBase {
text: prev_text,
green: prev_green,
diagnostics: prev_diags,
options,
},
edit,
new_text,
options,
)
}
pub fn reparse_with_options(
base: ReparseBase<'_>,
edit: &Edit,
new_text: &str,
options: ParseOptions,
) -> Option<Reparsed> {
if base.options != options {
return None;
}
reparse_same_options(
options,
base.text,
base.green,
base.diagnostics,
edit,
new_text,
)
}
pub fn reparse_edits(
prev_text: &str,
prev_green: &GreenNode,
prev_diags: &[ParseDiagnostic],
edits: &[Edit],
new_text: &str,
) -> Option<Reparsed> {
let options = ParseOptions::default();
reparse_edits_with_options(
ReparseBase {
text: prev_text,
green: prev_green,
diagnostics: prev_diags,
options,
},
edits,
new_text,
options,
)
}
pub fn reparse_edits_with_options(
base: ReparseBase<'_>,
edits: &[Edit],
new_text: &str,
options: ParseOptions,
) -> Option<Reparsed> {
if base.options != options {
return None;
}
reparse_edits_same_options(
options,
base.text,
base.green,
base.diagnostics,
edits,
new_text,
)
}
fn lex_for_options(options: ParseOptions, text: &str) -> Vec<super::lexer::Token<'_>> {
super::core::lex_for_options(text, options)
}
#[cfg(test)]
mod tests {
use super::*;
fn edit(range: std::ops::Range<usize>, insert: &str) -> Edit {
Edit {
range,
insert: insert.to_string(),
}
}
#[test]
fn every_contextual_ident_is_listed() {
fn words_after(haystack: &str, marker: &str) -> Vec<String> {
let mut out = Vec::new();
for tail in haystack.split(marker).skip(1) {
let stop = tail.find([';', '{', '}']).unwrap_or(tail.len());
let mut rest = &tail[..stop];
while let Some(open) = rest.find('"') {
let Some(close) = rest[open + 1..].find('"') else {
break;
};
out.push(rest[open + 1..open + 1 + close].to_string());
rest = &rest[open + 1 + close + 1..];
}
}
out
}
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/parser");
let mut found: Vec<String> = Vec::new();
for name in ["expr.rs", "structural.rs", "core.rs", "recovery.rs"] {
let src = std::fs::read_to_string(dir.join(name))
.unwrap_or_else(|e| panic!("read {name}: {e}"));
found.extend(words_after(&src, "t.text =="));
found.extend(words_after(&src, "t.text,"));
found.extend(words_after(&src, "next.text =="));
}
assert!(
!found.is_empty(),
"the scan matched nothing — the grammar's `Ident`-text comparisons \
have been rewritten, and this guard is no longer guarding anything"
);
for word in &found {
assert!(
CONTEXTUAL_IDENTS.contains(&word.as_str()),
"the grammar branches on the identifier text {word:?}, so an \
edit into or out of it can reshape the tree under an unchanged \
token kind. Add it to CONTEXTUAL_IDENTS.",
);
}
for expected in ["as", "abstract", "primitive", "type", "typegroup", "public"] {
assert!(
found.iter().any(|w| w == expected),
"the scan no longer finds the {expected:?} comparison",
);
}
}
#[test]
fn fingerprint_is_stable_and_discriminating() {
let a1 = fingerprint(&crate::parser::parse("x = 1\n").cst);
let a2 = fingerprint(&crate::parser::parse("x = 1\n").cst);
let b = fingerprint(&crate::parser::parse("x = 2\n").cst);
assert_eq!(a1, a2);
assert_ne!(a1, b);
}
#[test]
fn a_number_edit_in_a_lone_statement_falls_back() {
let parsed = crate::parser::parse("x = 1\n");
let green = parsed.cst.green().to_owned();
let e = diff_edit("x = 1\n", "x = 2\n");
assert!(reparse("x = 1\n", &green, &parsed.diagnostics, &e, "x = 2\n").is_none());
}
#[test]
fn a_docstring_body_edit_stays_at_the_token_tier() {
let old = "\"\"\"\ndoc\n\"\"\"\nfunction f(x)\n x + 1\nend\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
let e = edit(5..5, "s");
let new = e.apply(old);
let out = reparse(old, &green, &parsed.diagnostics, &e, &new)
.expect("a docstring body edit is spliceable");
assert_eq!(out.tier, ReparseTier::Token);
}
#[test]
fn a_content_edit_in_an_unterminated_literal_falls_back() {
let old = "x = 1\ny = \"abc\nz = 2\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
let token = SyntaxNode::new_root(green.clone())
.token_at_offset(TextSize::new(12))
.right_biased()
.expect("a leaf at offset 12");
assert_eq!(token.kind(), SyntaxKind::STRING_CONTENT);
let e = edit(12..13, "X");
let new = e.apply(old);
assert!(
try_splice_string_content(
ParseOptions::default(),
old,
&parsed.diagnostics,
&e,
&token
)
.is_none()
);
let tier = reparse(old, &green, &parsed.diagnostics, &e, &new).map(|r| r.tier);
assert_ne!(tier, Some(ReparseTier::Token));
}
#[test]
fn reparse_rejects_an_edit_that_does_not_fit() {
let old = "α = 1\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
let run = |e: Edit| reparse(old, &green, &parsed.diagnostics, &e, old);
assert!(run(edit(99..99, "x")).is_none());
assert!(run(edit(1..1, "x")).is_none());
let inverted = Edit {
range: std::ops::Range { start: 4, end: 2 },
insert: "x".to_string(),
};
assert!(run(inverted).is_none());
}
#[test]
fn a_region_covering_most_of_a_large_file_is_declined() {
let mut old = String::new();
for i in 0..2000 {
old.push_str(&format!("var_{i} = {i}\n"));
}
let parsed = crate::parser::parse(&old);
let green = parsed.cst.green().to_owned();
let narrow = edit(old.len()..old.len(), "tail = 1\n");
assert!(
reparse(
&old,
&green,
&parsed.diagnostics,
&narrow,
&narrow.apply(&old)
)
.is_some()
);
let scattered = vec![edit(4..4, "X"), edit(old.len() - 11..old.len() - 11, "X")];
let new = apply_edits(&old, &scattered);
let collapsed = diff_edit(&old, &new);
assert!(collapsed.range.len() > old.len() / 2, "{collapsed:?}");
assert!(reparse(&old, &green, &parsed.diagnostics, &collapsed, &new).is_none());
let out = reparse_edits(&old, &green, &parsed.diagnostics, &scattered, &new)
.expect("the precise chain is unaffected");
assert_eq!(out.tier, ReparseTier::Token);
}
#[test]
fn the_region_width_guard_leaves_small_files_alone() {
assert!(!region_is_too_wide(4 * 1024, 4 * 1024));
assert!(!region_is_too_wide(64 * 1024, 1024 * 1024));
assert!(region_is_too_wide(64 * 1024, 128 * 1024));
}
#[test]
fn reparse_edits_chains_scattered_edits() {
let old = "alpha = 1\nfiller = 2\nomega = 3\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
let edits = vec![edit(5..5, "X"), edit(27..27, "X")];
let new = apply_edits(old, &edits);
assert_eq!(new, "alphaX = 1\nfiller = 2\nomegaX = 3\n");
let collapsed = diff_edit(old, &new);
assert!(collapsed.range.len() > 20, "{collapsed:?} should be coarse");
let via_diff = reparse(old, &green, &parsed.diagnostics, &collapsed, &new)
.expect("the whole-file region is still spliceable at this size");
assert_eq!(via_diff.tier, ReparseTier::TopLevel);
let out = reparse_edits(old, &green, &parsed.diagnostics, &edits, &new)
.expect("two identifier edits should chain");
assert_eq!(out.tier, ReparseTier::Token);
assert_eq!(
fingerprint(&SyntaxNode::new_root(out.green)),
fingerprint(&crate::parser::parse(&new).cst),
);
}
#[test]
fn reparse_edits_reports_the_max_tier() {
let old = "alpha = 1\nfiller = 2\nomega = 3\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
let edits = vec![edit(5..5, "X"), edit(32..32, "beta = 4\n")];
let new = apply_edits(old, &edits);
let out = reparse_edits(old, &green, &parsed.diagnostics, &edits, &new)
.expect("ident edit plus a new statement should chain");
assert_eq!(out.tier, ReparseTier::TopLevel);
}
#[test]
fn reparse_edits_declines_an_empty_chain() {
let old = "alpha = 1\nomega = 3\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
assert!(reparse_edits(old, &green, &parsed.diagnostics, &[], old).is_none());
}
#[test]
fn reparse_edits_accepts_a_single_verified_edit() {
let old = "alpha = 1\nfiller = 2\nomega = 3\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
for change in [
edit(5..5, "β"),
edit(0..5, "β"),
edit(4..5, ""),
edit(0..0, "beta = 4\n"),
edit(old.len()..old.len(), "beta = 4\n"),
] {
let new = change.apply(old);
let out = reparse_edits(old, &green, &parsed.diagnostics, &[change], &new)
.expect("a single verified edit should reparse");
let full = crate::parser::parse(&new);
let root = SyntaxNode::new_root(out.green);
assert_eq!(root.to_string(), new);
assert_eq!(fingerprint(&root), fingerprint(&full.cst));
assert_eq!(out.diagnostics, full.diagnostics);
}
}
#[test]
fn reparse_edits_rejects_a_stale_or_invalid_single_edit() {
let old = "α = 1\nomega = 3\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
for (change, actual) in [
(edit(2..2, "X"), "βX = 1\nomega = 3\n"),
(edit(2..2, "X"), "αY = 1\nomega = 3\n"),
(edit(2..2, "X"), "αX = 1\nomega = 4\n"),
(edit(2..2, "X"), ""),
(edit(2..2, "X"), "α"),
(edit(2..2, "X"), "αX"),
(edit(500..500, "X"), old),
(edit(std::ops::Range { start: 2, end: 1 }, "X"), old),
(edit(1..2, "X"), old),
(edit(0..1, "X"), old),
] {
assert!(
reparse_edits(
old,
&green,
&parsed.diagnostics,
std::slice::from_ref(&change),
actual,
)
.is_none(),
"must reject {change:?} targeting {actual:?}"
);
}
}
#[test]
fn reparse_edits_rejects_a_stale_chain() {
let old = "alpha = 1\nfiller = 2\nomega = 3\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
let edits = vec![edit(5..5, "X"), edit(26..26, "X")];
let elsewhere = "alphaX = 1\nfiller = 2\nomegaX = 3\nextra = 4\n";
assert!(reparse_edits(old, &green, &parsed.diagnostics, &edits, elsewhere).is_none());
let past_end = vec![edit(500..500, "X"), edit(501..501, "X")];
assert!(reparse_edits(old, &green, &parsed.diagnostics, &past_end, old).is_none());
}
#[test]
fn reparse_edits_aborts_on_an_unhandleable_step() {
let old = "alpha = 1\nfiller = 2\nomega = 3\n";
let parsed = crate::parser::parse(old);
let green = parsed.cst.green().to_owned();
let edits = vec![edit(5..5, "X"), edit(26..26, "\"")];
let new = apply_edits(old, &edits);
assert!(reparse_edits(old, &green, &parsed.diagnostics, &edits, &new).is_none());
}
}