Fix bug and add expr , pat , ty matcher

5 files changed, 159 insertions, 30 deletions

diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index c5f510e6b..5a7a55141 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -53,6 +53,18 @@ pub(crate) fn path(p: &mut Parser) {
     paths::type_path(p);
 }
 
+pub(crate) fn expr(p: &mut Parser) {
+    expressions::expr(p);
+}
+
+pub(crate) fn type_(p: &mut Parser) {
+    types::type_(p)
+}
+
+pub(crate) fn pattern(p: &mut Parser) {
+    patterns::pattern(p)
+}
+
 pub(crate) fn reparser(
     node: SyntaxKind,
     first_child: Option<SyntaxKind>,
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 9b38b0a31..295577325 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -8,17 +8,20 @@ const EXPR_FIRST: TokenSet = LHS_FIRST;
 
 pub(super) fn expr(p: &mut Parser) -> BlockLike {
     let r = Restrictions { forbid_structs: false, prefer_stmt: false };
-    expr_bp(p, r, 1).1
+    let mut dollar_lvl = 0;
+    expr_bp(p, r, 1, &mut dollar_lvl).1
 }
 
 pub(super) fn expr_stmt(p: &mut Parser) -> (Option<CompletedMarker>, BlockLike) {
     let r = Restrictions { forbid_structs: false, prefer_stmt: true };
-    expr_bp(p, r, 1)
+    let mut dollar_lvl = 0;
+    expr_bp(p, r, 1, &mut dollar_lvl)
 }
 
 fn expr_no_struct(p: &mut Parser) {
     let r = Restrictions { forbid_structs: true, prefer_stmt: false };
-    expr_bp(p, r, 1);
+    let mut dollar_lvl = 0;
+    expr_bp(p, r, 1, &mut dollar_lvl);
 }
 
 // test block
@@ -206,8 +209,23 @@ fn current_op(p: &Parser) -> (u8, Op) {
 }
 
 // Parses expression with binding power of at least bp.
-fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>, BlockLike) {
-    let mut lhs = match lhs(p, r) {
+fn expr_bp(
+    p: &mut Parser,
+    r: Restrictions,
+    mut bp: u8,
+    dollar_lvl: &mut usize,
+) -> (Option<CompletedMarker>, BlockLike) {
+    // `newly_dollar_open` is a flag indicated that dollar is just closed after lhs, e.g.
+    // `$1$ + a`
+    // We use this flag to skip handling it.
+    let mut newly_dollar_open = false;
+
+    if p.at_l_dollar() {
+        *dollar_lvl += p.eat_l_dollars();
+        newly_dollar_open = true;
+    }
+
+    let mut lhs = match lhs(p, r, dollar_lvl) {
         Some((lhs, blocklike)) => {
             // test stmt_bin_expr_ambiguity
             // fn foo() {
@@ -223,6 +241,15 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
     };
 
     loop {
+        if *dollar_lvl > 0 && p.at_r_dollar() {
+            *dollar_lvl -= p.eat_r_dollars(*dollar_lvl);
+            if !newly_dollar_open {
+                // We "pump" bp for make it highest priority
+                bp = 255;
+            }
+            newly_dollar_open = false;
+        }
+
         let is_range = p.current() == DOTDOT || p.current() == DOTDOTEQ;
         let (op_bp, op) = current_op(p);
         if op_bp < bp {
@@ -235,7 +262,8 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
                 p.bump_compound(kind, n);
             }
         }
-        expr_bp(p, r, op_bp + 1);
+
+        expr_bp(p, r, op_bp + 1, dollar_lvl);
         lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
     }
     (Some(lhs), BlockLike::NotBlock)
@@ -244,7 +272,11 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
 const LHS_FIRST: TokenSet =
     atom::ATOM_EXPR_FIRST.union(token_set![AMP, STAR, EXCL, DOTDOT, DOTDOTEQ, MINUS]);
 
-fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
+fn lhs(
+    p: &mut Parser,
+    r: Restrictions,
+    dollar_lvl: &mut usize,
+) -> Option<(CompletedMarker, BlockLike)> {
     let m;
     let kind = match p.current() {
         // test ref_expr
@@ -275,7 +307,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
             m = p.start();
             p.bump();
             if p.at_ts(EXPR_FIRST) {
-                expr_bp(p, r, 2);
+                expr_bp(p, r, 2, dollar_lvl);
             }
             return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
         }
@@ -287,7 +319,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
             ));
         }
     };
-    expr_bp(p, r, 255);
+    expr_bp(p, r, 255, dollar_lvl);
     Some((m.complete(p, kind), BlockLike::NotBlock))
 }
 
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index 9a307559b..03fa9b71e 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -5,7 +5,7 @@ pub(super) const PATTERN_FIRST: TokenSet = expressions::LITERAL_FIRST
     .union(token_set![REF_KW, MUT_KW, L_PAREN, L_BRACK, AMP, UNDERSCORE, MINUS]);
 
 pub(super) fn pattern(p: &mut Parser) {
-    pattern_r(p, PAT_RECOVERY_SET)
+    pattern_r(p, PAT_RECOVERY_SET);
 }
 
 /// Parses a pattern list separated by pipes `|`
diff --git a/crates/ra_parser/src/lib.rs b/crates/ra_parser/src/lib.rs
index 3ceeeebd7..56755c394 100644
--- a/crates/ra_parser/src/lib.rs
+++ b/crates/ra_parser/src/lib.rs
@@ -53,20 +53,39 @@ pub trait TreeSink {
     fn error(&mut self, error: ParseError);
 }
 
-/// Parse given tokens into the given sink as a rust file.
-pub fn parse(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+fn parse_from_tokens<F>(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink, f: F)
+where
+    F: FnOnce(&mut parser::Parser),
+{
     let mut p = parser::Parser::new(token_source);
-    grammar::root(&mut p);
+    f(&mut p);
     let events = p.finish();
     event::process(tree_sink, events);
 }
 
+/// Parse given tokens into the given sink as a rust file.
+pub fn parse(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::root);
+}
+
 /// Parse given tokens into the given sink as a path
 pub fn parse_path(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
-    let mut p = parser::Parser::new(token_source);
-    grammar::path(&mut p);
-    let events = p.finish();
-    event::process(tree_sink, events);
+    parse_from_tokens(token_source, tree_sink, grammar::path);
+}
+
+/// Parse given tokens into the given sink as a expression
+pub fn parse_expr(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::expr);
+}
+
+/// Parse given tokens into the given sink as a ty
+pub fn parse_ty(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::type_);
+}
+
+/// Parse given tokens into the given sink as a pattern
+pub fn parse_pat(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::pattern);
 }
 
 /// A parsing function for a specific braced-block.
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index 3cb57ed9c..71f1f8b30 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -45,8 +45,9 @@ impl<'t> Parser<'t> {
     ///
     /// Useful for parsing things like `>>`.
     pub(crate) fn current2(&self) -> Option<(SyntaxKind, SyntaxKind)> {
-        let c1 = self.token_source.token_kind(self.token_pos);
-        let c2 = self.token_source.token_kind(self.token_pos + 1);
+        let c1 = self.nth(0);
+        let c2 = self.nth(1);
+
         if self.token_source.is_token_joint_to_next(self.token_pos) {
             Some((c1, c2))
         } else {
@@ -59,9 +60,9 @@ impl<'t> Parser<'t> {
     ///
     /// Useful for parsing things like `=>>`.
     pub(crate) fn current3(&self) -> Option<(SyntaxKind, SyntaxKind, SyntaxKind)> {
-        let c1 = self.token_source.token_kind(self.token_pos);
-        let c2 = self.token_source.token_kind(self.token_pos + 1);
-        let c3 = self.token_source.token_kind(self.token_pos + 2);
+        let c1 = self.nth(0);
+        let c2 = self.nth(1);
+        let c3 = self.nth(2);
         if self.token_source.is_token_joint_to_next(self.token_pos)
             && self.token_source.is_token_joint_to_next(self.token_pos + 1)
         {
@@ -77,7 +78,23 @@ impl<'t> Parser<'t> {
         let steps = self.steps.get();
         assert!(steps <= 10_000_000, "the parser seems stuck");
         self.steps.set(steps + 1);
-        self.token_source.token_kind(self.token_pos + n)
+
+        // It is beecause the Dollar will appear between nth
+        // Following code skips through it
+        let mut non_dollars_count = 0;
+        let mut i = 0;
+
+        loop {
+            let kind = self.token_source.token_kind(self.token_pos + i);
+            i += 1;
+
+            match kind {
+                EOF => return EOF,
+                SyntaxKind::L_DOLLAR | SyntaxKind::R_DOLLAR => {}
+                _ if non_dollars_count == n => return kind,
+                _ => non_dollars_count += 1,
+            }
+        }
     }
 
     /// Checks if the current token is `kind`.
@@ -99,8 +116,6 @@ impl<'t> Parser<'t> {
     /// consumed between the `start` and the corresponding `Marker::complete`
     /// belong to the same node.
     pub(crate) fn start(&mut self) -> Marker {
-        self.eat_dollars();
-
         let pos = self.events.len() as u32;
         self.push_event(Event::tombstone());
         Marker::new(pos)
@@ -185,7 +200,6 @@ impl<'t> Parser<'t> {
         self.eat_dollars();
         self.token_pos += usize::from(n_raw_tokens);
         self.push_event(Event::Token { kind, n_raw_tokens });
-        self.eat_dollars();
     }
 
     fn push_event(&mut self, event: Event) {
@@ -193,12 +207,64 @@ impl<'t> Parser<'t> {
     }
 
     fn eat_dollars(&mut self) {
-        while self.nth(0) == SyntaxKind::L_DOLLAR || self.nth(0) == SyntaxKind::R_DOLLAR {
-            let kind = self.nth(0);
-            self.token_pos += 1;
-            self.push_event(Event::Token { kind, n_raw_tokens: 1 });
+        loop {
+            match self.token_source.token_kind(self.token_pos) {
+                k @ SyntaxKind::L_DOLLAR | k @ SyntaxKind::R_DOLLAR => {
+                    self.token_pos += 1;
+                    self.push_event(Event::Token { kind: k, n_raw_tokens: 1 });
+                }
+                _ => {
+                    return;
+                }
+            }
+        }
+    }
+
+    pub(crate) fn eat_l_dollars(&mut self) -> usize {
+        let mut ate_count = 0;
+        loop {
+            match self.token_source.token_kind(self.token_pos) {
+                k @ SyntaxKind::L_DOLLAR => {
+                    self.token_pos += 1;
+                    self.push_event(Event::Token { kind: k, n_raw_tokens: 1 });
+                    ate_count += 1;
+                }
+                _ => {
+                    return ate_count;
+                }
+            }
         }
     }
+
+    pub(crate) fn eat_r_dollars(&mut self, max_count: usize) -> usize {
+        let mut ate_count = 0;
+        loop {
+            match self.token_source.token_kind(self.token_pos) {
+                k @ SyntaxKind::R_DOLLAR => {
+                    self.token_pos += 1;
+                    self.push_event(Event::Token { kind: k, n_raw_tokens: 1 });
+                    ate_count += 1;
+
+                    if max_count >= ate_count {
+                        return ate_count;
+                    }
+                }
+                _ => {
+                    return ate_count;
+                }
+            }
+        }
+    }
+
+    pub(crate) fn at_l_dollar(&self) -> bool {
+        let kind = self.token_source.token_kind(self.token_pos);
+        (kind == SyntaxKind::L_DOLLAR)
+    }
+
+    pub(crate) fn at_r_dollar(&self) -> bool {
+        let kind = self.token_source.token_kind(self.token_pos);
+        (kind == SyntaxKind::R_DOLLAR)
+    }
 }
 
 /// See `Parser::start`.