7 files changed, 31 insertions, 52 deletions

diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 7ce26b7c4..7e70dad3f 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -21,6 +21,7 @@ text_unit = { version = "0.1.6", features = ["serde"] }
 smol_str = { version = "0.1.9", features = ["serde"] }
 
 ra_text_edit = { path = "../ra_text_edit" }
+ra_parser = { path = "../ra_parser" }
 
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index b12282b39..c788bddec 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -16,7 +16,6 @@
 #![allow(missing_docs)]
 //#![warn(unreachable_pub)] // rust-lang/rust#47816
 
-mod syntax_kinds;
 mod syntax_node;
 mod syntax_text;
 mod syntax_error;
@@ -31,9 +30,9 @@ pub mod ast;
 pub mod utils;
 
 pub use rowan::{SmolStr, TextRange, TextUnit};
+pub use ra_parser::SyntaxKind;
 pub use crate::{
     ast::AstNode,
-    syntax_kinds::SyntaxKind,
     syntax_error::{SyntaxError, SyntaxErrorKind, Location},
     syntax_text::SyntaxText,
     syntax_node::{Direction,  SyntaxNode, WalkEvent, TreeArc},
diff --git a/crates/ra_syntax/src/parsing.rs b/crates/ra_syntax/src/parsing.rs
index 7e1b32035..0a11600e1 100644
--- a/crates/ra_syntax/src/parsing.rs
+++ b/crates/ra_syntax/src/parsing.rs
@@ -1,50 +1,28 @@
-#[macro_use]
-mod token_set;
 mod builder;
 mod lexer;
-mod event;
 mod input;
-mod parser;
-mod grammar;
 mod reparsing;
 
+use ra_parser::{parse, ParseError};
+
 use crate::{
     SyntaxKind, SyntaxError,
     parsing::{
         builder::TreeBuilder,
         input::ParserInput,
-        event::process,
-        parser::Parser,
     },
     syntax_node::GreenNode,
 };
 
 pub use self::lexer::{tokenize, Token};
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParseError(pub String);
-
 pub(crate) use self::reparsing::incremental_reparse;
 
 pub(crate) fn parse_text(text: &str) -> (GreenNode, Vec<SyntaxError>) {
     let tokens = tokenize(&text);
-    let tree_sink = TreeBuilder::new(text, &tokens);
-    parse_with(tree_sink, text, &tokens, grammar::root)
-}
-
-fn parse_with<S: TreeSink>(
-    mut tree_sink: S,
-    text: &str,
-    tokens: &[Token],
-    f: fn(&mut Parser),
-) -> S::Tree {
-    let events = {
-        let input = ParserInput::new(text, &tokens);
-        let mut p = Parser::new(&input);
-        f(&mut p);
-        p.finish()
-    };
-    process(&mut tree_sink, events);
+    let token_source = ParserInput::new(text, &tokens);
+    let mut tree_sink = TreeBuilder::new(text, &tokens);
+    parse(&token_source, &mut tree_sink);
     tree_sink.finish()
 }
 
diff --git a/crates/ra_syntax/src/parsing/builder.rs b/crates/ra_syntax/src/parsing/builder.rs
index 1041c6a7b..0775b0900 100644
--- a/crates/ra_syntax/src/parsing/builder.rs
+++ b/crates/ra_syntax/src/parsing/builder.rs
@@ -1,7 +1,9 @@
+use ra_parser::{TreeSink, ParseError};
+
 use crate::{
     SmolStr, SyntaxError, SyntaxErrorKind, TextUnit, TextRange,
     SyntaxKind::{self, *},
-    parsing::{TreeSink, ParseError, Token},
+    parsing::Token,
     syntax_node::{GreenNode, RaTypes},
 };
 
@@ -17,8 +19,6 @@ pub(crate) struct TreeBuilder<'a> {
 }
 
 impl<'a> TreeSink for TreeBuilder<'a> {
-    type Tree = (GreenNode, Vec<SyntaxError>);
-
     fn leaf(&mut self, kind: SyntaxKind, n_tokens: u8) {
         self.eat_trivias();
         let n_tokens = n_tokens as usize;
@@ -65,10 +65,6 @@ impl<'a> TreeSink for TreeBuilder<'a> {
         let error = SyntaxError::new(SyntaxErrorKind::ParseError(error), self.text_pos);
         self.errors.push(error)
     }
-
-    fn finish(self) -> (GreenNode, Vec<SyntaxError>) {
-        (self.inner.finish(), self.errors)
-    }
 }
 
 impl<'a> TreeBuilder<'a> {
@@ -82,6 +78,11 @@ impl<'a> TreeBuilder<'a> {
             inner: GreenNodeBuilder::new(),
         }
     }
+
+    pub(super) fn finish(self) -> (GreenNode, Vec<SyntaxError>) {
+        (self.inner.finish(), self.errors)
+    }
+
     fn eat_trivias(&mut self) {
         while let Some(&token) = self.tokens.get(self.token_pos) {
             if !token.kind.is_trivia() {
diff --git a/crates/ra_syntax/src/parsing/input.rs b/crates/ra_syntax/src/parsing/input.rs
index 96c03bb11..58be795bc 100644
--- a/crates/ra_syntax/src/parsing/input.rs
+++ b/crates/ra_syntax/src/parsing/input.rs
@@ -1,9 +1,8 @@
+use ra_parser::TokenSource;
+
 use crate::{
     SyntaxKind, SyntaxKind::EOF, TextRange, TextUnit,
-    parsing::{
-        TokenSource,
-        lexer::Token,
-    },
+    parsing::lexer::Token,
 };
 
 impl<'t> TokenSource for ParserInput<'t> {
diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs
index 2c860b3df..ffcb512ad 100644
--- a/crates/ra_syntax/src/parsing/reparsing.rs
+++ b/crates/ra_syntax/src/parsing/reparsing.rs
@@ -1,18 +1,18 @@
+use ra_text_edit::AtomTextEdit;
+use ra_parser::Reparser;
+
 use crate::{
     SyntaxKind::*, TextRange, TextUnit,
     algo,
     syntax_node::{GreenNode, SyntaxNode},
     syntax_error::SyntaxError,
     parsing::{
-        grammar, parse_with,
+        input::ParserInput,
         builder::TreeBuilder,
-        parser::Parser,
         lexer::{tokenize, Token},
     }
 };
 
-use ra_text_edit::AtomTextEdit;
-
 pub(crate) fn incremental_reparse(
     node: &SyntaxNode,
     edit: &AtomTextEdit,
@@ -61,8 +61,10 @@ fn reparse_block<'node>(
     if !is_balanced(&tokens) {
         return None;
     }
-    let tree_sink = TreeBuilder::new(&text, &tokens);
-    let (green, new_errors) = parse_with(tree_sink, &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))
 }
 
@@ -78,15 +80,12 @@ 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| {
         let first_child = node.first_child().map(|it| it.kind());
         let parent = node.parent().map(|it| it.kind());
-        grammar::reparser(node.kind(), first_child, parent).map(|r| (node, r))
+        Reparser::for_node(node.kind(), first_child, parent).map(|r| (node, r))
     })
 }
 
diff --git a/crates/ra_syntax/src/syntax_error.rs b/crates/ra_syntax/src/syntax_error.rs
index 1a00fcc27..bdd431742 100644
--- a/crates/ra_syntax/src/syntax_error.rs
+++ b/crates/ra_syntax/src/syntax_error.rs
@@ -1,6 +1,8 @@
 use std::fmt;
 
-use crate::{TextRange, TextUnit, parsing::ParseError};
+use ra_parser::ParseError;
+
+use crate::{TextRange, TextUnit};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SyntaxError {