512 lines
18 KiB
Rust
512 lines
18 KiB
Rust
use std::ops::Range;
|
|
|
|
use super::{
|
|
is_newline, parse, reparse_code_block, reparse_content_block,
|
|
reparse_markup_elements, Span, SyntaxKind, SyntaxNode,
|
|
};
|
|
|
|
/// Refresh the given syntax node with as little parsing as possible.
|
|
///
|
|
/// Takes the new source, the range in the old source that was replaced and the
|
|
/// length of the replacement.
|
|
///
|
|
/// Returns the range in the new source that was ultimately reparsed.
|
|
pub fn reparse(
|
|
root: &mut SyntaxNode,
|
|
text: &str,
|
|
replaced: Range<usize>,
|
|
replacement_len: usize,
|
|
) -> Range<usize> {
|
|
let change = Change { text, replaced, replacement_len };
|
|
if let Some(range) = try_reparse(&change, root, 0, true, true) {
|
|
return range;
|
|
}
|
|
|
|
let id = root.span().source();
|
|
*root = parse(text);
|
|
root.numberize(id, Span::FULL).unwrap();
|
|
0..text.len()
|
|
}
|
|
|
|
/// Try to reparse inside the given node.
|
|
fn try_reparse(
|
|
change: &Change,
|
|
node: &mut SyntaxNode,
|
|
mut offset: usize,
|
|
outermost: bool,
|
|
safe_to_replace: bool,
|
|
) -> Option<Range<usize>> {
|
|
let is_markup = matches!(node.kind(), SyntaxKind::Markup { .. });
|
|
let original_count = node.children().len();
|
|
let original_offset = offset;
|
|
|
|
let mut search = SearchState::default();
|
|
let mut ahead: Option<Ahead> = None;
|
|
|
|
// Whether the first node that should be replaced is at start.
|
|
let mut at_start = true;
|
|
|
|
// Whether the last searched child is the outermost child.
|
|
let mut child_outermost = false;
|
|
|
|
// Find the the first child in the range of children to reparse.
|
|
for (i, child) in node.children().enumerate() {
|
|
let pos = NodePos { idx: i, offset };
|
|
let child_span = offset..offset + child.len();
|
|
child_outermost = outermost && i + 1 == original_count;
|
|
|
|
match search {
|
|
SearchState::NoneFound => {
|
|
// The edit is contained within the span of the current element.
|
|
if child_span.contains(&change.replaced.start)
|
|
&& child_span.end >= change.replaced.end
|
|
{
|
|
// In Markup mode, we want to consider a non-whitespace
|
|
// neighbor if the edit is on the node boundary.
|
|
search = if is_markup && child_span.end == change.replaced.end {
|
|
SearchState::RequireNonTrivia(pos)
|
|
} else {
|
|
SearchState::Contained(pos)
|
|
};
|
|
} else if child_span.contains(&change.replaced.start) {
|
|
search = SearchState::Inside(pos);
|
|
} else if child_span.end == change.replaced.start
|
|
&& change.replaced.start == change.replaced.end
|
|
&& child_outermost
|
|
{
|
|
search = SearchState::SpanFound(pos, pos);
|
|
} else {
|
|
// Update compulsary state of `ahead_nontrivia`.
|
|
if let Some(ahead_nontrivia) = ahead.as_mut() {
|
|
if let SyntaxKind::Space { newlines: (1..) } = child.kind() {
|
|
ahead_nontrivia.newline();
|
|
}
|
|
}
|
|
|
|
// We look only for non spaces, non-semicolon and also
|
|
// reject text that points to the special case for URL
|
|
// evasion and line comments.
|
|
if !child.kind().is_space()
|
|
&& child.kind() != &SyntaxKind::Semicolon
|
|
&& child.kind() != &SyntaxKind::Text('/'.into())
|
|
&& (ahead.is_none() || change.replaced.start > child_span.end)
|
|
&& !ahead.map_or(false, Ahead::is_compulsory)
|
|
{
|
|
ahead = Some(Ahead::new(pos, at_start, is_bounded(child.kind())));
|
|
}
|
|
|
|
at_start = next_at_start(child.kind(), at_start);
|
|
}
|
|
}
|
|
SearchState::Inside(start) => {
|
|
if child_span.end == change.replaced.end {
|
|
search = SearchState::RequireNonTrivia(start);
|
|
} else if child_span.end > change.replaced.end {
|
|
search = SearchState::SpanFound(start, pos);
|
|
}
|
|
}
|
|
SearchState::RequireNonTrivia(start) => {
|
|
if !child.kind().is_trivia() {
|
|
search = SearchState::SpanFound(start, pos);
|
|
}
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
|
|
offset += child.len();
|
|
|
|
if search.done().is_some() {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we were looking for a non-whitespace element and hit the end of
|
|
// the file here, we instead use EOF as the end of the span.
|
|
if let SearchState::RequireNonTrivia(start) = search {
|
|
search = SearchState::SpanFound(
|
|
start,
|
|
NodePos {
|
|
idx: node.children().len() - 1,
|
|
offset: offset - node.children().last().unwrap().len(),
|
|
},
|
|
)
|
|
}
|
|
|
|
if let SearchState::Contained(pos) = search {
|
|
// Do not allow replacement of elements inside of constructs whose
|
|
// opening and closing brackets look the same.
|
|
let safe_inside = is_bounded(node.kind());
|
|
let child = &mut node.children_mut()[pos.idx];
|
|
let prev_len = child.len();
|
|
let prev_descendants = child.descendants();
|
|
|
|
if !child.is_leaf() {
|
|
if let Some(range) =
|
|
try_reparse(change, child, pos.offset, child_outermost, safe_inside)
|
|
{
|
|
let new_len = child.len();
|
|
let new_descendants = child.descendants();
|
|
node.update_parent(prev_len, new_len, prev_descendants, new_descendants);
|
|
return Some(range);
|
|
}
|
|
}
|
|
|
|
let superseded_span = pos.offset..pos.offset + prev_len;
|
|
let func: Option<ReparseMode> = match child.kind() {
|
|
SyntaxKind::CodeBlock => Some(ReparseMode::Code),
|
|
SyntaxKind::ContentBlock => Some(ReparseMode::Content),
|
|
_ => None,
|
|
};
|
|
|
|
// Return if the element was reparsable on its own, otherwise try to
|
|
// treat it as a markup element.
|
|
if let Some(func) = func {
|
|
if let Some(result) = replace(
|
|
change,
|
|
node,
|
|
func,
|
|
pos.idx..pos.idx + 1,
|
|
superseded_span,
|
|
outermost,
|
|
) {
|
|
return Some(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure this is a markup node and that we may replace. If so, save
|
|
// the current indent.
|
|
let min_indent = match node.kind() {
|
|
SyntaxKind::Markup { min_indent } if safe_to_replace => *min_indent,
|
|
_ => return None,
|
|
};
|
|
|
|
let (mut start, end) = search.done()?;
|
|
if let Some(ahead) = ahead {
|
|
if start.offset == change.replaced.start || ahead.is_compulsory() {
|
|
start = ahead.pos;
|
|
at_start = ahead.at_start;
|
|
}
|
|
} else {
|
|
start = NodePos { idx: 0, offset: original_offset };
|
|
}
|
|
|
|
let superseded_span =
|
|
start.offset..end.offset + node.children().as_slice()[end.idx].len();
|
|
|
|
replace(
|
|
change,
|
|
node,
|
|
ReparseMode::MarkupElements { at_start, min_indent },
|
|
start.idx..end.idx + 1,
|
|
superseded_span,
|
|
outermost,
|
|
)
|
|
}
|
|
|
|
/// Reparse the superseded nodes and replace them.
|
|
fn replace(
|
|
change: &Change,
|
|
node: &mut SyntaxNode,
|
|
mode: ReparseMode,
|
|
superseded_idx: Range<usize>,
|
|
superseded_span: Range<usize>,
|
|
outermost: bool,
|
|
) -> Option<Range<usize>> {
|
|
let superseded_start = superseded_idx.start;
|
|
|
|
let differential: isize =
|
|
change.replacement_len as isize - change.replaced.len() as isize;
|
|
let newborn_end = (superseded_span.end as isize + differential) as usize;
|
|
let newborn_span = superseded_span.start..newborn_end;
|
|
|
|
let mut prefix = "";
|
|
for (i, c) in change.text[..newborn_span.start].char_indices().rev() {
|
|
if is_newline(c) {
|
|
break;
|
|
}
|
|
prefix = &change.text[i..newborn_span.start];
|
|
}
|
|
|
|
let (newborns, terminated, amount) = match mode {
|
|
ReparseMode::Code => reparse_code_block(
|
|
prefix,
|
|
&change.text[newborn_span.start..],
|
|
newborn_span.len(),
|
|
),
|
|
ReparseMode::Content => reparse_content_block(
|
|
prefix,
|
|
&change.text[newborn_span.start..],
|
|
newborn_span.len(),
|
|
),
|
|
ReparseMode::MarkupElements { at_start, min_indent } => reparse_markup_elements(
|
|
prefix,
|
|
&change.text[newborn_span.start..],
|
|
newborn_span.len(),
|
|
differential,
|
|
&node.children().as_slice()[superseded_start..],
|
|
at_start,
|
|
min_indent,
|
|
),
|
|
}?;
|
|
|
|
// Do not accept unclosed nodes if the old node wasn't at the right edge
|
|
// of the tree.
|
|
if !outermost && !terminated {
|
|
return None;
|
|
}
|
|
|
|
node.replace_children(superseded_start..superseded_start + amount, newborns)
|
|
.ok()?;
|
|
|
|
Some(newborn_span)
|
|
}
|
|
|
|
/// A description of a change.
|
|
struct Change<'a> {
|
|
/// The new source code, with the change applied.
|
|
text: &'a str,
|
|
/// Which range in the old source file was changed.
|
|
replaced: Range<usize>,
|
|
/// How many characters replaced the text in `replaced`.
|
|
replacement_len: usize,
|
|
}
|
|
|
|
/// Encodes the state machine of the search for the nodes are pending for
|
|
/// replacement.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
enum SearchState {
|
|
/// Neither an end nor a start have been found as of now.
|
|
/// The latest non-trivia child is continually saved.
|
|
NoneFound,
|
|
/// The search has concluded by finding a node that fully contains the
|
|
/// modifications.
|
|
Contained(NodePos),
|
|
/// The search has found the start of the modified nodes.
|
|
Inside(NodePos),
|
|
/// The search has found the end of the modified nodes but the change
|
|
/// touched its boundries so another non-trivia node is needed.
|
|
RequireNonTrivia(NodePos),
|
|
/// The search has concluded by finding a start and an end index for nodes
|
|
/// with a pending reparse.
|
|
SpanFound(NodePos, NodePos),
|
|
}
|
|
|
|
impl Default for SearchState {
|
|
fn default() -> Self {
|
|
Self::NoneFound
|
|
}
|
|
}
|
|
|
|
impl SearchState {
|
|
fn done(self) -> Option<(NodePos, NodePos)> {
|
|
match self {
|
|
Self::NoneFound => None,
|
|
Self::Contained(s) => Some((s, s)),
|
|
Self::Inside(_) => None,
|
|
Self::RequireNonTrivia(_) => None,
|
|
Self::SpanFound(s, e) => Some((s, e)),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The position of a syntax node.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
struct NodePos {
|
|
/// The index in the parent node.
|
|
idx: usize,
|
|
/// The byte offset in the string.
|
|
offset: usize,
|
|
}
|
|
|
|
/// An ahead node with an index and whether it is `at_start`.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
struct Ahead {
|
|
/// The position of the node.
|
|
pos: NodePos,
|
|
/// The `at_start` before this node.
|
|
at_start: bool,
|
|
/// The kind of ahead node.
|
|
kind: AheadKind,
|
|
}
|
|
|
|
/// The kind of ahead node.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
enum AheadKind {
|
|
/// A normal non-trivia child has been found.
|
|
Normal,
|
|
/// An unbounded child has been found. The boolean indicates whether it was
|
|
/// on the current line, in which case adding it to the reparsing range is
|
|
/// compulsory.
|
|
Unbounded(bool),
|
|
}
|
|
|
|
impl Ahead {
|
|
fn new(pos: NodePos, at_start: bool, bounded: bool) -> Self {
|
|
Self {
|
|
pos,
|
|
at_start,
|
|
kind: if bounded { AheadKind::Normal } else { AheadKind::Unbounded(true) },
|
|
}
|
|
}
|
|
|
|
fn newline(&mut self) {
|
|
if let AheadKind::Unbounded(current_line) = &mut self.kind {
|
|
*current_line = false;
|
|
}
|
|
}
|
|
|
|
fn is_compulsory(self) -> bool {
|
|
matches!(self.kind, AheadKind::Unbounded(true))
|
|
}
|
|
}
|
|
|
|
/// Which reparse function to choose for a span of elements.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
enum ReparseMode {
|
|
/// Reparse a code block, including its braces.
|
|
Code,
|
|
/// Reparse a content block, including its square brackets.
|
|
Content,
|
|
/// Reparse elements of the markup. Also specified the initial `at_start`
|
|
/// state for the reparse and the minimum indent of the reparsed nodes.
|
|
MarkupElements { at_start: bool, min_indent: usize },
|
|
}
|
|
|
|
/// Whether changes _inside_ this node are safely encapsulated, so that only
|
|
/// this node must be reparsed.
|
|
fn is_bounded(kind: &SyntaxKind) -> bool {
|
|
matches!(
|
|
kind,
|
|
SyntaxKind::CodeBlock
|
|
| SyntaxKind::ContentBlock
|
|
| SyntaxKind::Linebreak
|
|
| SyntaxKind::SmartQuote { .. }
|
|
| SyntaxKind::BlockComment
|
|
| SyntaxKind::Space { .. }
|
|
| SyntaxKind::Escape(_)
|
|
| SyntaxKind::Shorthand(_)
|
|
)
|
|
}
|
|
|
|
/// Whether `at_start` would still be true after this node given the
|
|
/// previous value of the property.
|
|
fn next_at_start(kind: &SyntaxKind, prev: bool) -> bool {
|
|
match kind {
|
|
SyntaxKind::Space { newlines: (1..) } => true,
|
|
SyntaxKind::Space { .. } | SyntaxKind::LineComment | SyntaxKind::BlockComment => {
|
|
prev
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[rustfmt::skip]
|
|
mod tests {
|
|
use super::*;
|
|
use super::super::{parse, Source};
|
|
use super::super::tests::check;
|
|
|
|
#[track_caller]
|
|
fn test(prev: &str, range: Range<usize>, with: &str, goal: Range<usize>) {
|
|
let mut source = Source::detached(prev);
|
|
let range = source.edit(range, with);
|
|
check(source.text(), source.root(), &parse(source.text()));
|
|
assert_eq!(range, goal);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_incremental_simple_replacements() {
|
|
test("hello world", 7 .. 12, "walkers", 0 .. 14);
|
|
test("some content", 0..12, "", 0..0);
|
|
test("", 0..0, "do it", 0..5);
|
|
test("a d e", 1 .. 3, " b c d", 0 .. 9);
|
|
test("*~ *", 2..2, "*", 0..5);
|
|
test("_1_\n2a\n3", 5..5, "4", 4..7);
|
|
test("_1_\n2a\n3~", 8..8, "4", 4..10);
|
|
test("_1_ 2 3a\n4", 7..7, "5", 0..9);
|
|
test("* {1+2} *", 5..6, "3", 2..7);
|
|
test("a #f() e", 1 .. 6, " b c d", 0 .. 9);
|
|
test("a\nb\nc\nd\ne\n", 5 .. 5, "c", 2 .. 7);
|
|
test("a\n\nb\n\nc\n\nd\n\ne\n", 7 .. 7, "c", 3 .. 10);
|
|
test("a\nb\nc *hel a b lo* d\nd\ne", 13..13, "c ", 4..20);
|
|
test("~~ {a} ~~", 4 .. 5, "b", 3 .. 6);
|
|
test("{(0, 1, 2)}", 5 .. 6, "11pt", 0..14);
|
|
test("\n= A heading", 4 .. 4, "n evocative", 0 .. 23);
|
|
test("for~your~thing", 9 .. 9, "a", 0 .. 15);
|
|
test("a your thing a", 6 .. 7, "a", 0 .. 14);
|
|
test("{call(); abc}", 7 .. 7, "[]", 0 .. 15);
|
|
test("#call() abc", 7 .. 7, "[]", 0 .. 10);
|
|
test("hi[\n- item\n- item 2\n - item 3]", 11 .. 11, " ", 2 .. 35);
|
|
test("hi\n- item\nno item\n - item 3", 10 .. 10, "- ", 3..19);
|
|
test("#grid(columns: (auto, 1fr, 40%), [*plonk*], rect(width: 100%, height: 1pt, fill: conifer), [thing])", 16 .. 20, "none", 0..99);
|
|
test("#grid(columns: (auto, 1fr, 40%), [*plonk*], rect(width: 100%, height: 1pt, fill: conifer), [thing])", 33 .. 42, "[_gronk_]", 33..42);
|
|
test("#grid(columns: (auto, 1fr, 40%), [*plonk*], rect(width: 100%, height: 1pt, fill: conifer), [thing])", 34 .. 41, "_bar_", 33 .. 40);
|
|
test("{let i=1; for x in range(5) {i}}", 6 .. 6, " ", 0 .. 33);
|
|
test("{let i=1; for x in range(5) {i}}", 13 .. 14, " ", 0 .. 33);
|
|
test("hello~~{x}", 7 .. 10, "#f()", 0 .. 11);
|
|
test("this~is -- in my opinion -- spectacular", 8 .. 10, "---", 0 .. 25);
|
|
test("understanding `code` is complicated", 15 .. 15, "C ", 0 .. 22);
|
|
test("{ let x = g() }", 10 .. 12, "f(54", 0 .. 17);
|
|
test(r#"a ```typst hello``` b"#, 16 .. 17, "", 0 .. 18);
|
|
test(r#"a ```typst hello```"#, 16 .. 17, "", 0 .. 18);
|
|
test("#for", 4 .. 4, "//", 0 .. 6);
|
|
test("#show f: a => b..", 16..16, "c", 0..18);
|
|
test("a\n#let \nb", 7 .. 7, "i", 2 .. 9);
|
|
test("a\n#for i \nb", 9 .. 9, "in", 2 .. 12);
|
|
test("a~https://fun/html", 13..14, "n", 0..18);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_incremental_whitespace_invariants() {
|
|
test("hello \\ world", 7 .. 8, "a ", 0 .. 14);
|
|
test("hello \\ world", 7 .. 8, " a", 0 .. 14);
|
|
test("x = y", 1 .. 1, " + y", 0 .. 6);
|
|
test("x = y", 1 .. 1, " + y\n", 0 .. 7);
|
|
test("abc\n= a heading\njoke", 3 .. 4, "\nmore\n\n", 0 .. 21);
|
|
test("abc\n= a heading\njoke", 3 .. 4, "\nnot ", 0 .. 19);
|
|
test("#let x = (1, 2 + ;~ Five\r\n\r", 20 .. 23, "2.", 0 .. 23);
|
|
test("hey #myfriend", 4 .. 4, "\\", 0 .. 14);
|
|
test("hey #myfriend", 4 .. 4, "\\", 0 .. 6);
|
|
test("= foo\nbar\n - a\n - b", 6 .. 9, "", 0 .. 11);
|
|
test("= foo\n bar\n baz", 6 .. 8, "", 0 .. 9);
|
|
test(" // hi", 1 .. 1, " ", 0 .. 7);
|
|
test("- \nA", 2..3, "", 0..3);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_incremental_type_invariants() {
|
|
test("a #for x in array {x}", 18 .. 21, "[#x]", 0 .. 22);
|
|
test("a #let x = 1 {5}", 3 .. 6, "if", 0 .. 11);
|
|
test("a {let x = 1 {5}} b", 3 .. 6, "if", 2 .. 16);
|
|
test("#let x = 1 {5}", 4 .. 4, " if", 0 .. 13);
|
|
test("{let x = 1 {5}}", 4 .. 4, " if", 0 .. 18);
|
|
test("a // b c #f()", 3 .. 4, "", 0 .. 12);
|
|
test("{\nf()\n//g(a)\n}", 6 .. 8, "", 0 .. 12);
|
|
test("a{\nf()\n//g(a)\n}b", 7 .. 9, "", 1 .. 13);
|
|
test("a #while x {\n g(x) \n} b", 11 .. 11, "//", 0 .. 26);
|
|
test("{(1, 2)}", 1 .. 1, "while ", 0 .. 14);
|
|
test("a b c", 1 .. 1, "{[}", 0 .. 8);
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_incremental_wrongly_or_unclosed_things() {
|
|
test(r#"{"hi"}"#, 4 .. 5, "c", 0 .. 6);
|
|
test(r"this \u{abcd}", 8 .. 9, "", 0 .. 12);
|
|
test(r"this \u{abcd} that", 12 .. 13, "", 0 .. 17);
|
|
test(r"{{let x = z}; a = 1} b", 6 .. 6, "//", 0 .. 24);
|
|
test("a b c", 1 .. 1, " /* letters */", 0 .. 19);
|
|
test("a b c", 1 .. 1, " /* letters", 0 .. 16);
|
|
test("{if i==1 {a} else [b]; b()}", 12 .. 12, " /* letters */", 0 .. 41);
|
|
test("{if i==1 {a} else [b]; b()}", 12 .. 12, " /* letters", 0 .. 38);
|
|
test("~~~~", 2 .. 2, "[]", 0 .. 5);
|
|
test("a[]b", 2 .. 2, "{", 1 .. 4);
|
|
test("[hello]", 2 .. 3, "]", 0 .. 7);
|
|
test("{a}", 1 .. 2, "b", 0 .. 3);
|
|
test("{ a; b; c }", 5 .. 6, "[}]", 0 .. 13);
|
|
test("#a()\n~", 3..4, "{}", 0..7);
|
|
test("[]\n~", 1..2, "#if i==0 {true}", 0..18);
|
|
}
|
|
}
|