Merge #1105

1105: [WIP] Implement ra_mbe meta variables support  r=matklad a=edwin0cheng

This PR implements the following meta variable support in `ra_mba` crate (issue  #720):

- [x] `path`
- [ ] `expr`
- [ ] `ty`
- [ ]  `pat`
- [ ] `stmt`
- [ ]  `block`
- [ ]  `meta`
- [ ] `item`

*Implementation Details*

In the macro expanding lhs phase, if we see a meta variable type, we try to create a `tt:TokenTree` from the remaining input. And then we use a special set of `ra_parser` to parse it to `SyntaxNode`. 


Co-authored-by: Edwin Cheng <edwin0cheng@gmail.com>

crates/ra_mbe/src/lib.rs

@@ -15,10 +15,13 @@ macro_rules! impl_froms {
     }
 }
 
-mod tt_cursor;
+// mod tt_cursor;
 mod mbe_parser;
 mod mbe_expander;
 mod syntax_bridge;
+mod tt_cursor;
+mod subtree_source;
+mod subtree_parser;
 
 use ra_syntax::SmolStr;
 
@@ -379,4 +382,54 @@ SOURCE_FILE@[0; 40)
         // [let] [s] [=] ["rust1"] [;]
         assert_eq!(to_literal(&stm_tokens[15 + 3]).text, "\"rust1\"");
     }
+
+    #[test]
+    fn test_two_idents() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+            ($ i:ident, $ j:ident) => {
+                fn foo() { let a = $ i; let b = $j; }
+            }
+        }
+"#,
+        );
+        assert_expansion(&rules, "foo! { foo, bar }", "fn foo () {let a = foo ; let b = bar ;}");
+    }
+
+    // The following tests are port from intellij-rust directly
+    // https://github.com/intellij-rust/intellij-rust/blob/c4e9feee4ad46e7953b1948c112533360b6087bb/src/test/kotlin/org/rust/lang/core/macros/RsMacroExpansionTest.kt
+
+    #[test]
+    fn test_path() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+            ($ i:path) => {
+                fn foo() { let a = $ i; }
+            }
+        }
+"#,
+        );
+        assert_expansion(&rules, "foo! { foo }", "fn foo () {let a = foo ;}");
+        assert_expansion(
+            &rules,
+            "foo! { bar::<u8>::baz::<u8> }",
+            "fn foo () {let a = bar ::< u8 > ::baz ::< u8 > ;}",
+        );
+    }
+
+    #[test]
+    fn test_two_paths() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+            ($ i:path, $ j:path) => {
+                fn foo() { let a = $ i; let b = $j; }
+            }
+        }
+"#,
+        );
+        assert_expansion(&rules, "foo! { foo, bar }", "fn foo () {let a = foo ; let b = bar ;}");
+    }
 }

crates/ra_mbe/src/mbe_expander.rs

@@ -139,6 +139,11 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                                 Binding::Simple(tt::Leaf::from(ident).into()),
                             );
                         }
+                        "path" => {
+                            let path =
+                                input.eat_path().ok_or(ExpandError::UnexpectedToken)?.clone();
+                            res.inner.insert(text.clone(), Binding::Simple(path.into()));
+                        }
                         _ => return Err(ExpandError::UnexpectedToken),
                     }
                 }

crates/ra_mbe/src/subtree_parser.rs

@@ -0,0 +1,61 @@
+use crate::subtree_source::SubtreeTokenSource;
+
+use ra_parser::{TokenSource, TreeSink};
+use ra_syntax::{SyntaxKind};
+
+struct OffsetTokenSink {
+    token_pos: usize,
+}
+
+impl TreeSink for OffsetTokenSink {
+    fn token(&mut self, _kind: SyntaxKind, n_tokens: u8) {
+        self.token_pos += n_tokens as usize;
+    }
+    fn start_node(&mut self, _kind: SyntaxKind) {}
+    fn finish_node(&mut self) {}
+    fn error(&mut self, _error: ra_parser::ParseError) {}
+}
+
+pub(crate) struct Parser<'a> {
+    subtree: &'a tt::Subtree,
+    cur_pos: &'a mut usize,
+}
+
+impl<'a> Parser<'a> {
+    pub fn new(cur_pos: &'a mut usize, subtree: &'a tt::Subtree) -> Parser<'a> {
+        Parser { cur_pos, subtree }
+    }
+
+    pub fn parse_path(self) -> Option<tt::TokenTree> {
+        self.parse(ra_parser::parse_path)
+    }
+
+    fn parse<F>(self, f: F) -> Option<tt::TokenTree>
+    where
+        F: FnOnce(&dyn TokenSource, &mut dyn TreeSink),
+    {
+        let mut src = SubtreeTokenSource::new(self.subtree);
+        src.start_from_nth(*self.cur_pos);
+        let mut sink = OffsetTokenSink { token_pos: 0 };
+
+        f(&src, &mut sink);
+
+        self.finish(sink.token_pos, &mut src)
+    }
+
+    fn finish(self, parsed_token: usize, src: &mut SubtreeTokenSource) -> Option<tt::TokenTree> {
+        let res = src.bump_n(parsed_token);
+        *self.cur_pos += res.len();
+
+        let res: Vec<_> = res.into_iter().cloned().collect();
+
+        match res.len() {
+            0 => None,
+            1 => Some(res[0].clone()),
+            _ => Some(tt::TokenTree::Subtree(tt::Subtree {
+                delimiter: tt::Delimiter::None,
+                token_trees: res,
+            })),
+        }
+    }
+}

crates/ra_mbe/src/subtree_source.rs

@@ -0,0 +1,521 @@
+use ra_parser::{TokenSource};
+use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*};
+use std::cell::{RefCell};
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+struct TtToken {
+    pub kind: SyntaxKind,
+    pub is_joint_to_next: bool,
+    pub text: SmolStr,
+    pub n_tokens: usize,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+enum WalkCursor {
+    DelimiterBegin(Option<TtToken>),
+    Token(usize, Option<TtToken>),
+    DelimiterEnd(Option<TtToken>),
+    Eof,
+}
+
+#[derive(Debug)]
+struct SubTreeWalker<'a> {
+    pos: usize,
+    stack: Vec<(&'a tt::Subtree, Option<usize>)>,
+    cursor: WalkCursor,
+    last_steps: Vec<usize>,
+    subtree: &'a tt::Subtree,
+}
+
+impl<'a> SubTreeWalker<'a> {
+    fn new(subtree: &tt::Subtree) -> SubTreeWalker {
+        let mut res = SubTreeWalker {
+            pos: 0,
+            stack: vec![],
+            cursor: WalkCursor::Eof,
+            last_steps: vec![],
+            subtree,
+        };
+
+        res.reset();
+        res
+    }
+
+    fn is_eof(&self) -> bool {
+        self.cursor == WalkCursor::Eof
+    }
+
+    fn reset(&mut self) {
+        self.pos = 0;
+        self.stack = vec![(self.subtree, None)];
+        self.cursor = WalkCursor::DelimiterBegin(convert_delim(self.subtree.delimiter, false));
+        self.last_steps = vec![];
+
+        while self.is_empty_delimiter() {
+            self.forward_unchecked();
+        }
+    }
+
+    // This funciton will fast forward the cursor,
+    // Such that backward will stop at `start_pos` point
+    fn start_from_nth(&mut self, start_pos: usize) {
+        self.reset();
+        self.pos = start_pos;
+        self.cursor = self.walk_token(start_pos, 0, false);
+
+        while self.is_empty_delimiter() {
+            self.forward_unchecked();
+        }
+    }
+
+    fn current(&self) -> Option<&TtToken> {
+        match &self.cursor {
+            WalkCursor::DelimiterBegin(t) => t.as_ref(),
+            WalkCursor::Token(_, t) => t.as_ref(),
+            WalkCursor::DelimiterEnd(t) => t.as_ref(),
+            WalkCursor::Eof => None,
+        }
+    }
+
+    fn is_empty_delimiter(&self) -> bool {
+        match &self.cursor {
+            WalkCursor::DelimiterBegin(None) => true,
+            WalkCursor::DelimiterEnd(None) => true,
+            _ => false,
+        }
+    }
+
+    /// Move cursor backward by 1 step with empty checking
+    fn backward(&mut self) {
+        if self.last_steps.is_empty() {
+            return;
+        }
+        self.pos -= 1;
+        loop {
+            self.backward_unchecked();
+            // Skip Empty delimiter
+            if self.last_steps.is_empty() || !self.is_empty_delimiter() {
+                break;
+            }
+        }
+
+        // Move forward if it is empty delimiter
+        if self.last_steps.is_empty() {
+            while self.is_empty_delimiter() {
+                self.forward_unchecked();
+            }
+        }
+    }
+
+    /// Move cursor backward by 1 step without empty check
+    ///
+    /// Depends on the current state of cursor:
+    ///
+    /// * Delimiter Begin => Pop the stack, goto last walking token  (`walk_token`)
+    /// * Token => Goto prev token  (`walk_token`)
+    /// * Delimiter End => Goto the last child token (`walk_token`)
+    /// * Eof => push the root subtree, and set it as Delimiter End
+    fn backward_unchecked(&mut self) {
+        if self.last_steps.is_empty() {
+            return;
+        }
+
+        let last_step = self.last_steps.pop().unwrap();
+        let do_walk_token = match self.cursor {
+            WalkCursor::DelimiterBegin(_) => None,
+            WalkCursor::Token(u, _) => Some(u),
+            WalkCursor::DelimiterEnd(_) => {
+                let (top, _) = self.stack.last().unwrap();
+                Some(top.token_trees.len())
+            }
+            WalkCursor::Eof => None,
+        };
+
+        self.cursor = match do_walk_token {
+            Some(u) => self.walk_token(u, last_step, true),
+            None => match self.cursor {
+                WalkCursor::Eof => {
+                    self.stack.push((self.subtree, None));
+                    WalkCursor::DelimiterEnd(convert_delim(
+                        self.stack.last().unwrap().0.delimiter,
+                        true,
+                    ))
+                }
+                _ => {
+                    let (_, last_top_cursor) = self.stack.pop().unwrap();
+                    assert!(!self.stack.is_empty());
+
+                    self.walk_token(last_top_cursor.unwrap(), last_step, true)
+                }
+            },
+        };
+    }
+
+    /// Move cursor forward by 1 step with empty checking
+    fn forward(&mut self) {
+        if self.is_eof() {
+            return;
+        }
+
+        self.pos += 1;
+        loop {
+            self.forward_unchecked();
+            if !self.is_empty_delimiter() {
+                break;
+            }
+        }
+    }
+
+    /// Move cursor forward by 1 step without empty checking
+    ///
+    /// Depends on the current state of cursor:
+    ///
+    /// * Delimiter Begin => Goto the first child token (`walk_token`)
+    /// * Token => Goto next token  (`walk_token`)
+    /// * Delimiter End => Pop the stack, goto last walking token  (`walk_token`)
+    ///   
+    fn forward_unchecked(&mut self) {
+        if self.is_eof() {
+            return;
+        }
+
+        let step = self.current().map(|x| x.n_tokens).unwrap_or(1);
+        self.last_steps.push(step);
+
+        let do_walk_token = match self.cursor {
+            WalkCursor::DelimiterBegin(_) => Some((0, 0)),
+            WalkCursor::Token(u, _) => Some((u, step)),
+            WalkCursor::DelimiterEnd(_) => None,
+            _ => unreachable!(),
+        };
+
+        self.cursor = match do_walk_token {
+            Some((u, step)) => self.walk_token(u, step, false),
+            None => {
+                let (_, last_top_idx) = self.stack.pop().unwrap();
+                match self.stack.last() {
+                    Some(_) => self.walk_token(last_top_idx.unwrap(), 1, false),
+                    None => WalkCursor::Eof,
+                }
+            }
+        };
+    }
+
+    /// Traversal child token
+    /// Depends on the new position, it returns:
+    ///
+    /// * new position < 0 => DelimiterBegin
+    /// * new position > token_tree.len() => DelimiterEnd
+    /// * if new position is a subtree, depends on traversal direction:
+    /// ** backward => DelimiterEnd
+    /// ** forward => DelimiterBegin
+    /// * if new psoition is a leaf, return walk_leaf()
+    fn walk_token(&mut self, pos: usize, offset: usize, backward: bool) -> WalkCursor {
+        let (top, _) = self.stack.last().unwrap();
+
+        if backward && pos < offset {
+            return WalkCursor::DelimiterBegin(convert_delim(
+                self.stack.last().unwrap().0.delimiter,
+                false,
+            ));
+        }
+
+        if !backward && pos + offset >= top.token_trees.len() {
+            return WalkCursor::DelimiterEnd(convert_delim(
+                self.stack.last().unwrap().0.delimiter,
+                true,
+            ));
+        }
+
+        let pos = if backward { pos - offset } else { pos + offset };
+
+        match &top.token_trees[pos] {
+            tt::TokenTree::Subtree(subtree) => {
+                self.stack.push((subtree, Some(pos)));
+                let delim = convert_delim(self.stack.last().unwrap().0.delimiter, backward);
+                if backward {
+                    WalkCursor::DelimiterEnd(delim)
+                } else {
+                    WalkCursor::DelimiterBegin(delim)
+                }
+            }
+            tt::TokenTree::Leaf(leaf) => WalkCursor::Token(pos, Some(self.walk_leaf(leaf, pos))),
+        }
+    }
+
+    fn walk_leaf(&mut self, leaf: &tt::Leaf, pos: usize) -> TtToken {
+        match leaf {
+            tt::Leaf::Literal(l) => convert_literal(l),
+            tt::Leaf::Ident(ident) => convert_ident(ident),
+            tt::Leaf::Punct(punct) => {
+                let (top, _) = self.stack.last().unwrap();
+                convert_punct(punct, top, pos)
+            }
+        }
+    }
+}
+
+pub(crate) trait Querier {
+    fn token(&self, uidx: usize) -> (SyntaxKind, SmolStr);
+}
+
+// A wrapper class for ref cell
+#[derive(Debug)]
+pub(crate) struct WalkerOwner<'a> {
+    walker: RefCell<SubTreeWalker<'a>>,
+    offset: usize,
+}
+
+impl<'a> WalkerOwner<'a> {
+    fn new(subtree: &'a tt::Subtree) -> Self {
+        WalkerOwner { walker: RefCell::new(SubTreeWalker::new(subtree)), offset: 0 }
+    }
+
+    fn get<'b>(&self, pos: usize) -> Option<TtToken> {
+        self.set_walker_pos(pos);
+        let walker = self.walker.borrow();
+        walker.current().cloned()
+    }
+
+    fn start_from_nth(&mut self, pos: usize) {
+        self.offset = pos;
+        self.walker.borrow_mut().start_from_nth(pos);
+    }
+
+    fn set_walker_pos(&self, mut pos: usize) {
+        pos += self.offset;
+        let mut walker = self.walker.borrow_mut();
+        while pos > walker.pos && !walker.is_eof() {
+            walker.forward();
+        }
+        while pos < walker.pos {
+            walker.backward();
+        }
+    }
+
+    fn collect_token_trees(&mut self, n: usize) -> Vec<&tt::TokenTree> {
+        self.start_from_nth(self.offset);
+
+        let mut res = vec![];
+        let mut walker = self.walker.borrow_mut();
+
+        while walker.pos - self.offset < n {
+            if let WalkCursor::Token(u, tt) = &walker.cursor {
+                if walker.stack.len() == 1 {
+                    // We only collect the topmost child
+                    res.push(&walker.stack[0].0.token_trees[*u]);
+                    if let Some(tt) = tt {
+                        for i in 0..tt.n_tokens - 1 {
+                            res.push(&walker.stack[0].0.token_trees[u + i]);
+                        }
+                    }
+                }
+            }
+
+            walker.forward();
+        }
+
+        res
+    }
+}
+
+impl<'a> Querier for WalkerOwner<'a> {
+    fn token(&self, uidx: usize) -> (SyntaxKind, SmolStr) {
+        let tkn = self.get(uidx).unwrap();
+        (tkn.kind, tkn.text)
+    }
+}
+
+pub(crate) struct SubtreeTokenSource<'a> {
+    walker: WalkerOwner<'a>,
+}
+
+impl<'a> SubtreeTokenSource<'a> {
+    pub fn new(subtree: &tt::Subtree) -> SubtreeTokenSource {
+        SubtreeTokenSource { walker: WalkerOwner::new(subtree) }
+    }
+
+    pub fn start_from_nth(&mut self, n: usize) {
+        self.walker.start_from_nth(n);
+    }
+
+    pub fn querier<'b>(&'a self) -> &'b WalkerOwner<'a>
+    where
+        'a: 'b,
+    {
+        &self.walker
+    }
+
+    pub(crate) fn bump_n(&mut self, parsed_tokens: usize) -> Vec<&tt::TokenTree> {
+        let res = self.walker.collect_token_trees(parsed_tokens);
+        res
+    }
+}
+
+impl<'a> TokenSource for SubtreeTokenSource<'a> {
+    fn token_kind(&self, pos: usize) -> SyntaxKind {
+        if let Some(tok) = self.walker.get(pos) {
+            tok.kind
+        } else {
+            SyntaxKind::EOF
+        }
+    }
+    fn is_token_joint_to_next(&self, pos: usize) -> bool {
+        self.walker.get(pos).unwrap().is_joint_to_next
+    }
+    fn is_keyword(&self, pos: usize, kw: &str) -> bool {
+        self.walker.get(pos).unwrap().text == *kw
+    }
+}
+
+struct TokenPeek<'a, I>
+where
+    I: Iterator<Item = &'a tt::TokenTree>,
+{
+    iter: itertools::MultiPeek<I>,
+}
+
+// helper function
+fn to_punct(tt: &tt::TokenTree) -> Option<&tt::Punct> {
+    if let tt::TokenTree::Leaf(tt::Leaf::Punct(pp)) = tt {
+        return Some(pp);
+    }
+    None
+}
+
+impl<'a, I> TokenPeek<'a, I>
+where
+    I: Iterator<Item = &'a tt::TokenTree>,
+{
+    pub fn new(iter: I) -> Self {
+        TokenPeek { iter: itertools::multipeek(iter) }
+    }
+
+    fn current_punct2(&mut self, p: &tt::Punct) -> Option<((char, char), bool)> {
+        if p.spacing != tt::Spacing::Joint {
+            return None;
+        }
+
+        self.iter.reset_peek();
+        let p1 = to_punct(self.iter.peek()?)?;
+        Some(((p.char, p1.char), p1.spacing == tt::Spacing::Joint))
+    }
+
+    fn current_punct3(&mut self, p: &tt::Punct) -> Option<((char, char, char), bool)> {
+        self.current_punct2(p).and_then(|((p0, p1), last_joint)| {
+            if !last_joint {
+                None
+            } else {
+                let p2 = to_punct(*self.iter.peek()?)?;
+                Some(((p0, p1, p2.char), p2.spacing == tt::Spacing::Joint))
+            }
+        })
+    }
+}
+
+fn convert_multi_char_punct<'b, I>(
+    p: &tt::Punct,
+    iter: &mut TokenPeek<'b, I>,
+) -> Option<(SyntaxKind, bool, &'static str, usize)>
+where
+    I: Iterator<Item = &'b tt::TokenTree>,
+{
+    if let Some((m, is_joint_to_next)) = iter.current_punct3(p) {
+        if let Some((kind, text)) = match m {
+            ('<', '<', '=') => Some((SHLEQ, "<<=")),
+            ('>', '>', '=') => Some((SHREQ, ">>=")),
+            ('.', '.', '.') => Some((DOTDOTDOT, "...")),
+            ('.', '.', '=') => Some((DOTDOTEQ, "..=")),
+            _ => None,
+        } {
+            return Some((kind, is_joint_to_next, text, 3));
+        }
+    }
+
+    if let Some((m, is_joint_to_next)) = iter.current_punct2(p) {
+        if let Some((kind, text)) = match m {
+            ('<', '<') => Some((SHL, "<<")),
+            ('>', '>') => Some((SHR, ">>")),
+
+            ('|', '|') => Some((PIPEPIPE, "||")),
+            ('&', '&') => Some((AMPAMP, "&&")),
+            ('%', '=') => Some((PERCENTEQ, "%=")),
+            ('*', '=') => Some((STAREQ, "*=")),
+            ('/', '=') => Some((SLASHEQ, "/=")),
+            ('^', '=') => Some((CARETEQ, "^=")),
+
+            ('&', '=') => Some((AMPEQ, "&=")),
+            ('|', '=') => Some((PIPEEQ, "|=")),
+            ('-', '=') => Some((MINUSEQ, "-=")),
+            ('+', '=') => Some((PLUSEQ, "+=")),
+            ('>', '=') => Some((GTEQ, ">=")),
+            ('<', '=') => Some((LTEQ, "<=")),
+
+            ('-', '>') => Some((THIN_ARROW, "->")),
+            ('!', '=') => Some((NEQ, "!=")),
+            ('=', '>') => Some((FAT_ARROW, "=>")),
+            ('=', '=') => Some((EQEQ, "==")),
+            ('.', '.') => Some((DOTDOT, "..")),
+            (':', ':') => Some((COLONCOLON, "::")),
+
+            _ => None,
+        } {
+            return Some((kind, is_joint_to_next, text, 2));
+        }
+    }
+
+    None
+}
+
+fn convert_delim(d: tt::Delimiter, closing: bool) -> Option<TtToken> {
+    let (kinds, texts) = match d {
+        tt::Delimiter::Parenthesis => ([L_PAREN, R_PAREN], "()"),
+        tt::Delimiter::Brace => ([L_CURLY, R_CURLY], "{}"),
+        tt::Delimiter::Bracket => ([L_BRACK, R_BRACK], "[]"),
+        tt::Delimiter::None => return None,
+    };
+
+    let idx = closing as usize;
+    let kind = kinds[idx];
+    let text = &texts[idx..texts.len() - (1 - idx)];
+    Some(TtToken { kind, is_joint_to_next: false, text: SmolStr::new(text), n_tokens: 1 })
+}
+
+fn convert_literal(l: &tt::Literal) -> TtToken {
+    TtToken {
+        kind: classify_literal(&l.text).unwrap().kind,
+        is_joint_to_next: false,
+        text: l.text.clone(),
+        n_tokens: 1,
+    }
+}
+
+fn convert_ident(ident: &tt::Ident) -> TtToken {
+    let kind = SyntaxKind::from_keyword(ident.text.as_str()).unwrap_or(IDENT);
+    TtToken { kind, is_joint_to_next: false, text: ident.text.clone(), n_tokens: 1 }
+}
+
+fn convert_punct(p: &tt::Punct, parent: &tt::Subtree, next: usize) -> TtToken {
+    let iter = parent.token_trees[next + 1..].iter();
+    let mut peek = TokenPeek::new(iter);
+
+    if let Some((kind, is_joint_to_next, text, size)) = convert_multi_char_punct(p, &mut peek) {
+        TtToken { kind, is_joint_to_next, text: text.into(), n_tokens: size }
+    } else {
+        let kind = match p.char {
+            // lexer may produce combpund tokens for these ones
+            '.' => DOT,
+            ':' => COLON,
+            '=' => EQ,
+            '!' => EXCL,
+            '-' => MINUS,
+            c => SyntaxKind::from_char(c).unwrap(),
+        };
+        let text = {
+            let mut buf = [0u8; 4];
+            let s: &str = p.char.encode_utf8(&mut buf);
+            SmolStr::new(s)
+        };
+        TtToken { kind, is_joint_to_next: p.spacing == tt::Spacing::Joint, text, n_tokens: 1 }
+    }
+}

crates/ra_mbe/src/syntax_bridge.rs

@@ -1,9 +1,11 @@
-use ra_parser::{TokenSource, TreeSink, ParseError};
+use ra_parser::{TreeSink, ParseError};
 use ra_syntax::{
     AstNode, SyntaxNode, TextRange, SyntaxKind, SmolStr, SyntaxTreeBuilder, TreeArc, SyntaxElement,
-    ast, SyntaxKind::*, TextUnit, classify_literal
+    ast, SyntaxKind::*, TextUnit
 };
 
+use crate::subtree_source::{SubtreeTokenSource, Querier};
+
 /// Maps `tt::TokenId` to the relative range of the original token.
 #[derive(Default)]
 pub struct TokenMap {
@@ -22,8 +24,8 @@ pub fn ast_to_token_tree(ast: &ast::TokenTree) -> Option<(tt::Subtree, TokenMap)
 
 /// Parses the token tree (result of macro expansion) as a sequence of items
 pub fn token_tree_to_ast_item_list(tt: &tt::Subtree) -> TreeArc<ast::SourceFile> {
-    let token_source = TtTokenSource::new(tt);
-    let mut tree_sink = TtTreeSink::new(&token_source.tokens);
+    let token_source = SubtreeTokenSource::new(tt);
+    let mut tree_sink = TtTreeSink::new(token_source.querier());
     ra_parser::parse(&token_source, &mut tree_sink);
     let syntax = tree_sink.inner.finish();
     ast::SourceFile::cast(&syntax).unwrap().to_owned()
@@ -103,229 +105,19 @@ fn convert_tt(
     Some(res)
 }
 
-#[derive(Debug)]
-struct TtTokenSource {
-    tokens: Vec<TtToken>,
-}
-
-#[derive(Debug)]
-struct TtToken {
-    kind: SyntaxKind,
-    is_joint_to_next: bool,
-    text: SmolStr,
-}
-
-// Some helper functions
-fn to_punct(tt: &tt::TokenTree) -> Option<&tt::Punct> {
-    if let tt::TokenTree::Leaf(tt::Leaf::Punct(pp)) = tt {
-        return Some(pp);
-    }
-    None
-}
-
-struct TokenPeek<'a, I>
-where
-    I: Iterator<Item = &'a tt::TokenTree>,
-{
-    iter: itertools::MultiPeek<I>,
-}
-
-impl<'a, I> TokenPeek<'a, I>
-where
-    I: Iterator<Item = &'a tt::TokenTree>,
-{
-    fn next(&mut self) -> Option<&tt::TokenTree> {
-        self.iter.next()
-    }
-
-    fn current_punct2(&mut self, p: &tt::Punct) -> Option<((char, char), bool)> {
-        if p.spacing != tt::Spacing::Joint {
-            return None;
-        }
-
-        self.iter.reset_peek();
-        let p1 = to_punct(self.iter.peek()?)?;
-        Some(((p.char, p1.char), p1.spacing == tt::Spacing::Joint))
-    }
-
-    fn current_punct3(&mut self, p: &tt::Punct) -> Option<((char, char, char), bool)> {
-        self.current_punct2(p).and_then(|((p0, p1), last_joint)| {
-            if !last_joint {
-                None
-            } else {
-                let p2 = to_punct(*self.iter.peek()?)?;
-                Some(((p0, p1, p2.char), p2.spacing == tt::Spacing::Joint))
-            }
-        })
-    }
-}
-
-impl TtTokenSource {
-    fn new(tt: &tt::Subtree) -> TtTokenSource {
-        let mut res = TtTokenSource { tokens: Vec::new() };
-        res.convert_subtree(tt);
-        res
-    }
-    fn convert_subtree(&mut self, sub: &tt::Subtree) {
-        self.push_delim(sub.delimiter, false);
-        let mut peek = TokenPeek { iter: itertools::multipeek(sub.token_trees.iter()) };
-        while let Some(tt) = peek.iter.next() {
-            self.convert_tt(tt, &mut peek);
-        }
-        self.push_delim(sub.delimiter, true)
-    }
-
-    fn convert_tt<'a, I>(&mut self, tt: &tt::TokenTree, iter: &mut TokenPeek<'a, I>)
-    where
-        I: Iterator<Item = &'a tt::TokenTree>,
-    {
-        match tt {
-            tt::TokenTree::Leaf(token) => self.convert_token(token, iter),
-            tt::TokenTree::Subtree(sub) => self.convert_subtree(sub),
-        }
-    }
-
-    fn convert_token<'a, I>(&mut self, token: &tt::Leaf, iter: &mut TokenPeek<'a, I>)
-    where
-        I: Iterator<Item = &'a tt::TokenTree>,
-    {
-        let tok = match token {
-            tt::Leaf::Literal(l) => TtToken {
-                kind: classify_literal(&l.text).unwrap().kind,
-                is_joint_to_next: false,
-                text: l.text.clone(),
-            },
-            tt::Leaf::Punct(p) => {
-                if let Some(tt) = Self::convert_multi_char_punct(p, iter) {
-                    tt
-                } else {
-                    let kind = match p.char {
-                        // lexer may produce combpund tokens for these ones
-                        '.' => DOT,
-                        ':' => COLON,
-                        '=' => EQ,
-                        '!' => EXCL,
-                        '-' => MINUS,
-                        c => SyntaxKind::from_char(c).unwrap(),
-                    };
-                    let text = {
-                        let mut buf = [0u8; 4];
-                        let s: &str = p.char.encode_utf8(&mut buf);
-                        SmolStr::new(s)
-                    };
-                    TtToken { kind, is_joint_to_next: p.spacing == tt::Spacing::Joint, text }
-                }
-            }
-            tt::Leaf::Ident(ident) => {
-                let kind = SyntaxKind::from_keyword(ident.text.as_str()).unwrap_or(IDENT);
-                TtToken { kind, is_joint_to_next: false, text: ident.text.clone() }
-            }
-        };
-        self.tokens.push(tok)
-    }
-
-    fn convert_multi_char_punct<'a, I>(
-        p: &tt::Punct,
-        iter: &mut TokenPeek<'a, I>,
-    ) -> Option<TtToken>
-    where
-        I: Iterator<Item = &'a tt::TokenTree>,
-    {
-        if let Some((m, is_joint_to_next)) = iter.current_punct3(p) {
-            if let Some((kind, text)) = match m {
-                ('<', '<', '=') => Some((SHLEQ, "<<=")),
-                ('>', '>', '=') => Some((SHREQ, ">>=")),
-                ('.', '.', '.') => Some((DOTDOTDOT, "...")),
-                ('.', '.', '=') => Some((DOTDOTEQ, "..=")),
-                _ => None,
-            } {
-                iter.next();
-                iter.next();
-                return Some(TtToken { kind, is_joint_to_next, text: text.into() });
-            }
-        }
-
-        if let Some((m, is_joint_to_next)) = iter.current_punct2(p) {
-            if let Some((kind, text)) = match m {
-                ('<', '<') => Some((SHL, "<<")),
-                ('>', '>') => Some((SHR, ">>")),
-
-                ('|', '|') => Some((PIPEPIPE, "||")),
-                ('&', '&') => Some((AMPAMP, "&&")),
-                ('%', '=') => Some((PERCENTEQ, "%=")),
-                ('*', '=') => Some((STAREQ, "*=")),
-                ('/', '=') => Some((SLASHEQ, "/=")),
-                ('^', '=') => Some((CARETEQ, "^=")),
-
-                ('&', '=') => Some((AMPEQ, "&=")),
-                ('|', '=') => Some((PIPEEQ, "|=")),
-                ('-', '=') => Some((MINUSEQ, "-=")),
-                ('+', '=') => Some((PLUSEQ, "+=")),
-                ('>', '=') => Some((GTEQ, ">=")),
-                ('<', '=') => Some((LTEQ, "<=")),
-
-                ('-', '>') => Some((THIN_ARROW, "->")),
-                ('!', '=') => Some((NEQ, "!=")),
-                ('=', '>') => Some((FAT_ARROW, "=>")),
-                ('=', '=') => Some((EQEQ, "==")),
-                ('.', '.') => Some((DOTDOT, "..")),
-                (':', ':') => Some((COLONCOLON, "::")),
-
-                _ => None,
-            } {
-                iter.next();
-                return Some(TtToken { kind, is_joint_to_next, text: text.into() });
-            }
-        }
-
-        None
-    }
-
-    fn push_delim(&mut self, d: tt::Delimiter, closing: bool) {
-        let (kinds, texts) = match d {
-            tt::Delimiter::Parenthesis => ([L_PAREN, R_PAREN], "()"),
-            tt::Delimiter::Brace => ([L_CURLY, R_CURLY], "{}"),
-            tt::Delimiter::Bracket => ([L_BRACK, R_BRACK], "[]"),
-            tt::Delimiter::None => return,
-        };
-        let idx = closing as usize;
-        let kind = kinds[idx];
-        let text = &texts[idx..texts.len() - (1 - idx)];
-        let tok = TtToken { kind, is_joint_to_next: false, text: SmolStr::new(text) };
-        self.tokens.push(tok)
-    }
-}
-
-impl TokenSource for TtTokenSource {
-    fn token_kind(&self, pos: usize) -> SyntaxKind {
-        if let Some(tok) = self.tokens.get(pos) {
-            tok.kind
-        } else {
-            SyntaxKind::EOF
-        }
-    }
-    fn is_token_joint_to_next(&self, pos: usize) -> bool {
-        self.tokens[pos].is_joint_to_next
-    }
-    fn is_keyword(&self, pos: usize, kw: &str) -> bool {
-        self.tokens[pos].text == *kw
-    }
-}
-
-#[derive(Default)]
-struct TtTreeSink<'a> {
+struct TtTreeSink<'a, Q: Querier> {
     buf: String,
-    tokens: &'a [TtToken],
+    src_querier: &'a Q,
     text_pos: TextUnit,
     token_pos: usize,
     inner: SyntaxTreeBuilder,
 }
 
-impl<'a> TtTreeSink<'a> {
-    fn new(tokens: &'a [TtToken]) -> TtTreeSink {
+impl<'a, Q: Querier> TtTreeSink<'a, Q> {
+    fn new(src_querier: &'a Q) -> Self {
         TtTreeSink {
             buf: String::new(),
-            tokens,
+            src_querier,
             text_pos: 0.into(),
             token_pos: 0,
             inner: SyntaxTreeBuilder::default(),
@@ -333,10 +125,10 @@ impl<'a> TtTreeSink<'a> {
     }
 }
 
-impl<'a> TreeSink for TtTreeSink<'a> {
+impl<'a, Q: Querier> TreeSink for TtTreeSink<'a, Q> {
     fn token(&mut self, kind: SyntaxKind, n_tokens: u8) {
         for _ in 0..n_tokens {
-            self.buf += self.tokens[self.token_pos].text.as_str();
+            self.buf += &self.src_querier.token(self.token_pos).1;
             self.token_pos += 1;
         }
         self.text_pos += TextUnit::of_str(&self.buf);
@@ -380,21 +172,23 @@ mod tests {
             "#,
         );
         let expansion = expand(&rules, "literals!(foo)");
-        let tt_src = TtTokenSource::new(&expansion);
+        let tt_src = SubtreeTokenSource::new(&expansion);
+
+        let query = tt_src.querier();
 
         // [{]
         // [let] [a] [=] ['c'] [;]
-        assert_eq!(tt_src.tokens[1 + 3].text, "'c'");
-        assert_eq!(tt_src.tokens[1 + 3].kind, CHAR);
+        assert_eq!(query.token(1 + 3).1, "'c'");
+        assert_eq!(query.token(1 + 3).0, CHAR);
         // [let] [c] [=] [1000] [;]
-        assert_eq!(tt_src.tokens[1 + 5 + 3].text, "1000");
-        assert_eq!(tt_src.tokens[1 + 5 + 3].kind, INT_NUMBER);
+        assert_eq!(query.token(1 + 5 + 3).1, "1000");
+        assert_eq!(query.token(1 + 5 + 3).0, INT_NUMBER);
         // [let] [f] [=] [12E+99_f64] [;]
-        assert_eq!(tt_src.tokens[1 + 10 + 3].text, "12E+99_f64");
-        assert_eq!(tt_src.tokens[1 + 10 + 3].kind, FLOAT_NUMBER);
+        assert_eq!(query.token(1 + 10 + 3).1, "12E+99_f64");
+        assert_eq!(query.token(1 + 10 + 3).0, FLOAT_NUMBER);
 
         // [let] [s] [=] ["rust1"] [;]
-        assert_eq!(tt_src.tokens[1 + 15 + 3].text, "\"rust1\"");
-        assert_eq!(tt_src.tokens[1 + 15 + 3].kind, STRING);
+        assert_eq!(query.token(1 + 15 + 3).1, "\"rust1\"");
+        assert_eq!(query.token(1 + 15 + 3).0, STRING);
     }
 }

crates/ra_mbe/src/tt_cursor.rs

@@ -1,4 +1,5 @@
 use crate::ParseError;
+use crate::subtree_parser::Parser;
 
 #[derive(Clone)]
 pub(crate) struct TtCursor<'a> {
@@ -78,6 +79,11 @@ impl<'a> TtCursor<'a> {
         })
     }
 
+    pub(crate) fn eat_path(&mut self) -> Option<tt::TokenTree> {
+        let parser = Parser::new(&mut self.pos, self.subtree);
+        parser.parse_path()
+    }
+
     pub(crate) fn expect_char(&mut self, char: char) -> Result<(), ParseError> {
         if self.at_char(char) {
             self.bump();

crates/ra_parser/src/grammar.rs

@@ -49,6 +49,10 @@ pub(crate) fn root(p: &mut Parser) {
     m.complete(p, SOURCE_FILE);
 }
 
+pub(crate) fn path(p: &mut Parser) {
+    paths::type_path(p);
+}
+
 pub(crate) fn reparser(
     node: SyntaxKind,
     first_child: Option<SyntaxKind>,

crates/ra_parser/src/lib.rs

@@ -61,6 +61,14 @@ pub fn parse(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
     event::process(tree_sink, events);
 }
 
+/// 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);
+}
+
 /// A parsing function for a specific braced-block.
 pub struct Reparser(fn(&mut parser::Parser));