1 files changed, 27 insertions, 16 deletions

diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs
index f2d218ab9..19d8adcfb 100644
--- a/crates/ra_syntax/src/parsing/reparsing.rs
+++ b/crates/ra_syntax/src/parsing/reparsing.rs
@@ -1,18 +1,25 @@
+//! Implementation of incremental re-parsing.
+//!
+//! We use two simple strategies for this:
+//!   - if the edit modifies only a single token (like changing an identifier's
+//!     letter), we replace only this token.
+//!   - otherwise, we search for the nearest `{}` block which contains the edit
+//!     and try to parse only this block.
+
+use ra_text_edit::AtomTextEdit;
+use ra_parser::Reparser;
+
 use crate::{
-    SyntaxKind::*, TextRange, TextUnit,
+    SyntaxKind::*, TextRange, TextUnit, SyntaxError,
     algo,
     syntax_node::{GreenNode, SyntaxNode},
-    syntax_error::SyntaxError,
     parsing::{
-        grammar, parse_with,
-        builder::GreenBuilder,
-        parser::Parser,
+        input::ParserInput,
+        builder::TreeBuilder,
         lexer::{tokenize, Token},
     }
 };
 
-use ra_text_edit::AtomTextEdit;
-
 pub(crate) fn incremental_reparse(
     node: &SyntaxNode,
     edit: &AtomTextEdit,
@@ -61,7 +68,10 @@ fn reparse_block<'node>(
     if !is_balanced(&tokens) {
         return None;
     }
-    let (green, new_errors) = parse_with(GreenBuilder::default(), &text, &tokens, reparser);
+    let token_source = ParserInput::new(&text, &tokens);
+    let mut tree_sink = TreeBuilder::new(&text, &tokens);
+    reparser.parse(&token_source, &mut tree_sink);
+    let (green, new_errors) = tree_sink.finish();
     Some((node, green, new_errors))
 }
 
@@ -77,12 +87,13 @@ fn is_contextual_kw(text: &str) -> bool {
     }
 }
 
-fn find_reparsable_node(
-    node: &SyntaxNode,
-    range: TextRange,
-) -> Option<(&SyntaxNode, fn(&mut Parser))> {
+fn find_reparsable_node(node: &SyntaxNode, range: TextRange) -> Option<(&SyntaxNode, Reparser)> {
     let node = algo::find_covering_node(node, range);
-    node.ancestors().find_map(|node| grammar::reparser(node).map(|r| (node, r)))
+    node.ancestors().find_map(|node| {
+        let first_child = node.first_child().map(|it| it.kind());
+        let parent = node.parent().map(|it| it.kind());
+        Reparser::for_node(node.kind(), first_child, parent).map(|r| (node, r))
+    })
 }
 
 fn is_balanced(tokens: &[Token]) -> bool {
@@ -132,7 +143,7 @@ fn merge_errors(
 mod tests {
     use test_utils::{extract_range, assert_eq_text};
 
-    use crate::{SourceFile, AstNode, utils::dump_tree};
+    use crate::{SourceFile, AstNode};
     use super::*;
 
     fn do_check<F>(before: &str, replace_with: &str, reparser: F)
@@ -158,8 +169,8 @@ mod tests {
         };
 
         assert_eq_text!(
-            &dump_tree(fully_reparsed.syntax()),
-            &dump_tree(incrementally_reparsed.syntax()),
+            &fully_reparsed.syntax().debug_dump(),
+            &incrementally_reparsed.syntax().debug_dump(),
         )
     }