1 files changed, 11 insertions, 61 deletions

diff --git a/crates/ra_syntax/src/parsing.rs b/crates/ra_syntax/src/parsing.rs
index 138d1394a..cf573801c 100644
--- a/crates/ra_syntax/src/parsing.rs
+++ b/crates/ra_syntax/src/parsing.rs
@@ -1,78 +1,28 @@
-#[macro_use]
-mod token_set;
-mod builder;
+//! Lexing, bridging to ra_parser (which does the actual parsing) and
+//! incremental reparsing.
+
 mod lexer;
-mod event;
 mod input;
-mod parser;
-mod grammar;
+mod builder;
 mod reparsing;
 
 use crate::{
-    SyntaxKind, SmolStr, SyntaxError,
+    SyntaxError,
+    syntax_node::GreenNode,
     parsing::{
-        builder::GreenBuilder,
+        builder::TreeBuilder,
         input::ParserInput,
-        event::EventProcessor,
-        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);
-    parse_with(GreenBuilder::default(), text, &tokens, grammar::root)
-}
-
-fn parse_with<S: TreeSink>(
-    tree_sink: S,
-    text: &str,
-    tokens: &[Token],
-    f: fn(&mut Parser),
-) -> S::Tree {
-    let mut events = {
-        let input = ParserInput::new(text, &tokens);
-        let mut p = Parser::new(&input);
-        f(&mut p);
-        p.finish()
-    };
-    EventProcessor::new(tree_sink, text, tokens, &mut events).process().finish()
-}
-
-/// `TreeSink` abstracts details of a particular syntax tree implementation.
-trait TreeSink {
-    type Tree;
-
-    /// Adds new leaf to the current branch.
-    fn leaf(&mut self, kind: SyntaxKind, text: SmolStr);
-
-    /// Start new branch and make it current.
-    fn start_branch(&mut self, kind: SyntaxKind);
-
-    /// Finish current branch and restore previous
-    /// branch as current.
-    fn finish_branch(&mut self);
-
-    fn error(&mut self, error: ParseError);
-
-    /// Complete tree building. Make sure that
-    /// `start_branch` and `finish_branch` calls
-    /// are paired!
-    fn finish(self) -> Self::Tree;
-}
-
-/// `TokenSource` abstracts the source of the tokens parser operates one.
-///
-/// Hopefully this will allow us to treat text and token trees in the same way!
-trait TokenSource {
-    fn token_kind(&self, pos: usize) -> SyntaxKind;
-    fn is_token_joint_to_next(&self, pos: usize) -> bool;
-    fn is_keyword(&self, pos: usize, kw: &str) -> bool;
+    let token_source = ParserInput::new(text, &tokens);
+    let mut tree_sink = TreeBuilder::new(text, &tokens);
+    ra_parser::parse(&token_source, &mut tree_sink);
+    tree_sink.finish()
 }