Turn reparsing methods into free functions

src/parse/incremental.rs

@@ -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,23 +32,9 @@ 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,
+fn try_reparse(
+    change: &Change,
     node: &mut InnerNode,
     mut offset: usize,
     outermost: bool,
@@ -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,7 +201,8 @@ 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,
@@ -225,8 +211,9 @@ impl Reparser<'_> {
     )
 }
 
+/// Reparse the superseded nodes and replace them.
 fn replace(
-        &self,
+    change: &Change,
     node: &mut InnerNode,
     mode: ReparseMode,
     superseded_idx: Range<usize>,
@@ -236,40 +223,38 @@ impl Reparser<'_> {
     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
@@ -283,15 +268,15 @@ impl Reparser<'_> {
 
     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 {