caisin/typst
1
0
Fork 0
mirror of https://github.com/typst/typst synced 2025-05-14 04:56:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

Turn reparsing methods into free functions

Browse Source
This commit is contained in:
Laurenz 2022-06-14 14:03:13 +02:00
parent c81e2a5f56
commit e03f32ca34
1 changed files with 250 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
src/parse/incremental.rs
View File

@ -20,8 +20,8 @@ pub fn reparse(
replacement_len: usize,
) -> Range<usize> {
if let SyntaxNode::Inner(inner) = root {
let reparser = Reparser { src, replaced, replacement_len };
if let Some(range) = reparser.reparse_step(Arc::make_mut(inner), 0, true, true) {
let change = Change { src, replaced, replacement_len };
if let Some(range) = try_reparse(&change, Arc::make_mut(inner), 0, true, true) {
return range;
}
}
@ -32,28 +32,14 @@ pub fn reparse(
0 .. src.len()
}
/// Allows partial refreshs of the syntax tree.
///
/// This struct holds a description of a change. Its methods can be used to try
/// and apply the change to a syntax tree.
struct Reparser<'a> {
/// The new source code, with the change applied.
src: &'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,
}
impl Reparser<'_> {
/// Try to reparse inside the given node.
fn reparse_step(
&self,
/// Try to reparse inside the given node.
fn try_reparse(
change: &Change,
node: &mut InnerNode,
mut offset: usize,
outermost: bool,
safe_to_replace: bool,
) -> Option<Range<usize>> {
) -> Option<Range<usize>> {
let is_markup = matches!(node.kind(), NodeKind::Markup { .. });
let original_count = node.children().len();
let original_offset = offset;
@ -76,20 +62,20 @@ impl Reparser<'_> {
match search {
SearchState::NoneFound => {
// The edit is contained within the span of the current element.
if child_span.contains(&self.replaced.start)
&& child_span.end >= self.replaced.end
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 == self.replaced.end {
search = if is_markup && child_span.end == change.replaced.end {
SearchState::RequireNonTrivia(pos)
} else {
SearchState::Contained(pos)
};
} else if child_span.contains(&self.replaced.start) {
} else if child_span.contains(&change.replaced.start) {
search = SearchState::Inside(pos);
} else if child_span.end == self.replaced.start
&& self.replaced.start == self.replaced.end
} else if child_span.end == change.replaced.start
&& change.replaced.start == change.replaced.end
&& child_outermost
{
search = SearchState::SpanFound(pos, pos);
@ -107,23 +93,20 @@ impl Reparser<'_> {
if !child.kind().is_space()
&& child.kind() != &NodeKind::Semicolon
&& child.kind() != &NodeKind::Text('/'.into())
&& (ahead.is_none() || self.replaced.start > child_span.end)
&& (ahead.is_none() || change.replaced.start > child_span.end)
&& !ahead.map_or(false, Ahead::is_compulsory)
{
ahead = Some(Ahead::new(
pos,
at_start,
child.kind().is_bounded(),
));
ahead =
Some(Ahead::new(pos, at_start, child.kind().is_bounded()));
}
at_start = child.kind().is_at_start(at_start);
}
}
SearchState::Inside(start) => {
if child_span.end == self.replaced.end {
if child_span.end == change.replaced.end {
search = SearchState::RequireNonTrivia(start);
} else if child_span.end > self.replaced.end {
} else if child_span.end > change.replaced.end {
search = SearchState::SpanFound(start, pos);
}
}
@ -160,7 +143,8 @@ impl Reparser<'_> {
let prev_descendants = child.descendants();
if let Some(range) = match child {
SyntaxNode::Inner(node) => self.reparse_step(
SyntaxNode::Inner(node) => try_reparse(
change,
Arc::make_mut(node),
pos.offset,
child_outermost,
@ -184,7 +168,8 @@ impl Reparser<'_> {
// 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) = self.replace(
if let Some(result) = replace(
change,
node,
func,
pos.idx .. pos.idx + 1,
@ -205,7 +190,7 @@ impl Reparser<'_> {
let (mut start, end) = search.done()?;
if let Some(ahead) = ahead {
if start.offset == self.replaced.start || ahead.is_compulsory() {
if start.offset == change.replaced.start || ahead.is_compulsory() {
start = ahead.pos;
at_start = ahead.at_start;
}
@ -216,60 +201,60 @@ impl Reparser<'_> {
let superseded_span =
start.offset .. end.offset + node.children().as_slice()[end.idx].len();
self.replace(
replace(
change,
node,
ReparseMode::MarkupElements { at_start, min_indent },
start.idx .. end.idx + 1,
superseded_span,
outermost,
)
}
}
fn replace(
&self,
/// Reparse the superseded nodes and replace them.
fn replace(
change: &Change,
node: &mut InnerNode,
mode: ReparseMode,
superseded_idx: Range<usize>,
superseded_span: Range<usize>,
outermost: bool,
) -> Option<Range<usize>> {
) -> Option<Range<usize>> {
let superseded_start = superseded_idx.start;
let differential: isize =
self.replacement_len as isize - self.replaced.len() as 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 self.src[.. newborn_span.start].char_indices().rev() {
for (i, c) in change.src[.. newborn_span.start].char_indices().rev() {
if is_newline(c) {
break;
}
prefix = &self.src[i .. newborn_span.start];
prefix = &change.src[i .. newborn_span.start];
}
let (newborns, terminated, amount) = match mode {
ReparseMode::Code => reparse_code_block(
&prefix,
&self.src[newborn_span.start ..],
&change.src[newborn_span.start ..],
newborn_span.len(),
),
ReparseMode::Content => reparse_content_block(
&prefix,
&self.src[newborn_span.start ..],
&change.src[newborn_span.start ..],
newborn_span.len(),
),
ReparseMode::MarkupElements { at_start, min_indent } => {
reparse_markup_elements(
ReparseMode::MarkupElements { at_start, min_indent } => reparse_markup_elements(
&prefix,
&self.src[newborn_span.start ..],
&change.src[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
@ -282,16 +267,16 @@ impl Reparser<'_> {
.ok()?;
Some(newborn_span)
}
}
/// 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,
/// A description of a change.
struct Change<'a> {
/// The new source code, with the change applied.
src: &'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
@ -332,6 +317,15 @@ impl SearchState {
}
}
/// 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 {