crates/mbe/src/syntax_bridge.rs

   1 //! Conversions between [`SyntaxNode`] and [`tt::TokenTree`].
   2
   3 use rustc_hash::{FxHashMap, FxHashSet};
   4 use syntax::{
   5     ast::{self, make::tokens::doc_comment},
   6     AstToken, Parse, PreorderWithTokens, SmolStr, SyntaxElement, SyntaxKind,
   7     SyntaxKind::*,
   8     SyntaxNode, SyntaxToken, SyntaxTreeBuilder, TextRange, TextSize, WalkEvent, T,
   9 };
  10 use tt::buffer::{Cursor, TokenBuffer};
  11
  12 use crate::{to_parser_input::to_parser_input, tt_iter::TtIter, ExpandError, TokenMap};
  13
  14 /// Convert the syntax node to a `TokenTree` (what macro
  15 /// will consume).
  16 pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> (tt::Subtree, TokenMap) {
  17     syntax_node_to_token_tree_censored(node, &Default::default())
  18 }
  19
  20 /// Convert the syntax node to a `TokenTree` (what macro will consume)
  21 /// with the censored range excluded.
  22 pub fn syntax_node_to_token_tree_censored(
  23     node: &SyntaxNode,
  24     censor: &FxHashSet<SyntaxNode>,
  25 ) -> (tt::Subtree, TokenMap) {
  26     let global_offset = node.text_range().start();
  27     let mut c = Convertor::new(node, global_offset, censor);
  28     let subtree = convert_tokens(&mut c);
  29     c.id_alloc.map.shrink_to_fit();
  30     (subtree, c.id_alloc.map)
  31 }
  32
  33 // The following items are what `rustc` macro can be parsed into :
  34 // link: https://github.com/rust-lang/rust/blob/9ebf47851a357faa4cd97f4b1dc7835f6376e639/src/libsyntax/ext/expand.rs#L141
  35 // * Expr(P<ast::Expr>)                     -> token_tree_to_expr
  36 // * Pat(P<ast::Pat>)                       -> token_tree_to_pat
  37 // * Ty(P<ast::Ty>)                         -> token_tree_to_ty
  38 // * Stmts(SmallVec<[ast::Stmt; 1]>)        -> token_tree_to_stmts
  39 // * Items(SmallVec<[P<ast::Item>; 1]>)     -> token_tree_to_items
  40 //
  41 // * TraitItems(SmallVec<[ast::TraitItem; 1]>)
  42 // * AssocItems(SmallVec<[ast::AssocItem; 1]>)
  43 // * ForeignItems(SmallVec<[ast::ForeignItem; 1]>
  44
  45 pub fn token_tree_to_syntax_node(
  46     tt: &tt::Subtree,
  47     entry_point: parser::TopEntryPoint,
  48 ) -> Result<(Parse<SyntaxNode>, TokenMap), ExpandError> {
  49     let buffer = match tt {
  50         tt::Subtree { delimiter: None, token_trees } => {
  51             TokenBuffer::from_tokens(token_trees.as_slice())
  52         }
  53         _ => TokenBuffer::from_subtree(tt),
  54     };
  55     let parser_input = to_parser_input(&buffer);
  56     let parser_output = entry_point.parse(&parser_input);
  57     let mut tree_sink = TtTreeSink::new(buffer.begin());
  58     for event in parser_output.iter() {
  59         match event {
  60             parser::Step::Token { kind, n_input_tokens: n_raw_tokens } => {
  61                 tree_sink.token(kind, n_raw_tokens)
  62             }
  63             parser::Step::Enter { kind } => tree_sink.start_node(kind),
  64             parser::Step::Exit => tree_sink.finish_node(),
  65             parser::Step::Error { msg } => tree_sink.error(msg.to_string()),
  66         }
  67     }
  68     if tree_sink.roots.len() != 1 {
  69         return Err(ExpandError::ConversionError);
  70     }
  71     //FIXME: would be cool to report errors
  72     let (parse, range_map) = tree_sink.finish();
  73     Ok((parse, range_map))
  74 }
  75
  76 /// Convert a string to a `TokenTree`
  77 pub fn parse_to_token_tree(text: &str) -> Option<(tt::Subtree, TokenMap)> {
  78     let lexed = parser::LexedStr::new(text);
  79     if lexed.errors().next().is_some() {
  80         return None;
  81     }
  82
  83     let mut conv = RawConvertor {
  84         lexed,
  85         pos: 0,
  86         id_alloc: TokenIdAlloc {
  87             map: Default::default(),
  88             global_offset: TextSize::default(),
  89             next_id: 0,
  90         },
  91     };
  92
  93     let subtree = convert_tokens(&mut conv);
  94     Some((subtree, conv.id_alloc.map))
  95 }
  96
  97 /// Split token tree with separate expr: $($e:expr)SEP*
  98 pub fn parse_exprs_with_sep(tt: &tt::Subtree, sep: char) -> Vec<tt::Subtree> {
  99     if tt.token_trees.is_empty() {
 100         return Vec::new();
 101     }
 102
 103     let mut iter = TtIter::new(tt);
 104     let mut res = Vec::new();
 105
 106     while iter.peek_n(0).is_some() {
 107         let expanded = iter.expect_fragment(parser::PrefixEntryPoint::Expr);
 108
 109         res.push(match expanded.value {
 110             None => break,
 111             Some(tt @ tt::TokenTree::Leaf(_)) => {
 112                 tt::Subtree { delimiter: None, token_trees: vec![tt] }
 113             }
 114             Some(tt::TokenTree::Subtree(tt)) => tt,
 115         });
 116
 117         let mut fork = iter.clone();
 118         if fork.expect_char(sep).is_err() {
 119             break;
 120         }
 121         iter = fork;
 122     }
 123
 124     if iter.peek_n(0).is_some() {
 125         res.push(tt::Subtree { delimiter: None, token_trees: iter.into_iter().cloned().collect() });
 126     }
 127
 128     res
 129 }
 130
 131 fn convert_tokens<C: TokenConvertor>(conv: &mut C) -> tt::Subtree {
 132     struct StackEntry {
 133         subtree: tt::Subtree,
 134         idx: usize,
 135         open_range: TextRange,
 136     }
 137
 138     let entry = StackEntry {
 139         subtree: tt::Subtree { delimiter: None, ..Default::default() },
 140         // never used (delimiter is `None`)
 141         idx: !0,
 142         open_range: TextRange::empty(TextSize::of('.')),
 143     };
 144     let mut stack = vec![entry];
 145
 146     loop {
 147         let entry = stack.last_mut().unwrap();
 148         let result = &mut entry.subtree.token_trees;
 149         let (token, range) = match conv.bump() {
 150             Some(it) => it,
 151             None => break,
 152         };
 153
 154         let k: SyntaxKind = token.kind(&conv);
 155         if k == COMMENT {
 156             if let Some(tokens) = conv.convert_doc_comment(&token) {
 157                 // FIXME: There has to be a better way to do this
 158                 // Add the comments token id to the converted doc string
 159                 let id = conv.id_alloc().alloc(range);
 160                 result.extend(tokens.into_iter().map(|mut tt| {
 161                     if let tt::TokenTree::Subtree(sub) = &mut tt {
 162                         if let tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) = &mut sub.token_trees[2]
 163                         {
 164                             lit.id = id
 165                         }
 166                     }
 167                     tt
 168                 }));
 169             }
 170             continue;
 171         }
 172
 173         result.push(if k.is_punct() && k != UNDERSCORE {
 174             assert_eq!(range.len(), TextSize::of('.'));
 175
 176             if let Some(delim) = entry.subtree.delimiter {
 177                 let expected = match delim.kind {
 178                     tt::DelimiterKind::Parenthesis => T![')'],
 179                     tt::DelimiterKind::Brace => T!['}'],
 180                     tt::DelimiterKind::Bracket => T![']'],
 181                 };
 182
 183                 if k == expected {
 184                     let entry = stack.pop().unwrap();
 185                     conv.id_alloc().close_delim(entry.idx, Some(range));
 186                     stack.last_mut().unwrap().subtree.token_trees.push(entry.subtree.into());
 187                     continue;
 188                 }
 189             }
 190
 191             let delim = match k {
 192                 T!['('] => Some(tt::DelimiterKind::Parenthesis),
 193                 T!['{'] => Some(tt::DelimiterKind::Brace),
 194                 T!['['] => Some(tt::DelimiterKind::Bracket),
 195                 _ => None,
 196             };
 197
 198             if let Some(kind) = delim {
 199                 let mut subtree = tt::Subtree::default();
 200                 let (id, idx) = conv.id_alloc().open_delim(range);
 201                 subtree.delimiter = Some(tt::Delimiter { id, kind });
 202                 stack.push(StackEntry { subtree, idx, open_range: range });
 203                 continue;
 204             } else {
 205                 let spacing = match conv.peek() {
 206                     Some(next)
 207                         if next.kind(&conv).is_trivia()
 208                             || next.kind(&conv) == T!['[']
 209                             || next.kind(&conv) == T!['{']
 210                             || next.kind(&conv) == T!['('] =>
 211                     {
 212                         tt::Spacing::Alone
 213                     }
 214                     Some(next) if next.kind(&conv).is_punct() && next.kind(&conv) != UNDERSCORE => {
 215                         tt::Spacing::Joint
 216                     }
 217                     _ => tt::Spacing::Alone,
 218                 };
 219                 let char = match token.to_char(&conv) {
 220                     Some(c) => c,
 221                     None => {
 222                         panic!("Token from lexer must be single char: token = {:#?}", token);
 223                     }
 224                 };
 225                 tt::Leaf::from(tt::Punct { char, spacing, id: conv.id_alloc().alloc(range) }).into()
 226             }
 227         } else {
 228             macro_rules! make_leaf {
 229                 ($i:ident) => {
 230                     tt::$i { id: conv.id_alloc().alloc(range), text: token.to_text(conv) }.into()
 231                 };
 232             }
 233             let leaf: tt::Leaf = match k {
 234                 T![true] | T![false] => make_leaf!(Ident),
 235                 IDENT => make_leaf!(Ident),
 236                 UNDERSCORE => make_leaf!(Ident),
 237                 k if k.is_keyword() => make_leaf!(Ident),
 238                 k if k.is_literal() => make_leaf!(Literal),
 239                 LIFETIME_IDENT => {
 240                     let char_unit = TextSize::of('\'');
 241                     let r = TextRange::at(range.start(), char_unit);
 242                     let apostrophe = tt::Leaf::from(tt::Punct {
 243                         char: '\'',
 244                         spacing: tt::Spacing::Joint,
 245                         id: conv.id_alloc().alloc(r),
 246                     });
 247                     result.push(apostrophe.into());
 248
 249                     let r = TextRange::at(range.start() + char_unit, range.len() - char_unit);
 250                     let ident = tt::Leaf::from(tt::Ident {
 251                         text: SmolStr::new(&token.to_text(conv)[1..]),
 252                         id: conv.id_alloc().alloc(r),
 253                     });
 254                     result.push(ident.into());
 255                     continue;
 256                 }
 257                 _ => continue,
 258             };
 259
 260             leaf.into()
 261         });
 262     }
 263
 264     // If we get here, we've consumed all input tokens.
 265     // We might have more than one subtree in the stack, if the delimiters are improperly balanced.
 266     // Merge them so we're left with one.
 267     while stack.len() > 1 {
 268         let entry = stack.pop().unwrap();
 269         let parent = stack.last_mut().unwrap();
 270
 271         conv.id_alloc().close_delim(entry.idx, None);
 272         let leaf: tt::Leaf = tt::Punct {
 273             id: conv.id_alloc().alloc(entry.open_range),
 274             char: match entry.subtree.delimiter.unwrap().kind {
 275                 tt::DelimiterKind::Parenthesis => '(',
 276                 tt::DelimiterKind::Brace => '{',
 277                 tt::DelimiterKind::Bracket => '[',
 278             },
 279             spacing: tt::Spacing::Alone,
 280         }
 281         .into();
 282         parent.subtree.token_trees.push(leaf.into());
 283         parent.subtree.token_trees.extend(entry.subtree.token_trees);
 284     }
 285
 286     let subtree = stack.pop().unwrap().subtree;
 287     if subtree.token_trees.len() == 1 {
 288         if let tt::TokenTree::Subtree(first) = &subtree.token_trees[0] {
 289             return first.clone();
 290         }
 291     }
 292     subtree
 293 }
 294
 295 /// Returns the textual content of a doc comment block as a quoted string
 296 /// That is, strips leading `///` (or `/**`, etc)
 297 /// and strips the ending `*/`
 298 /// And then quote the string, which is needed to convert to `tt::Literal`
 299 fn doc_comment_text(comment: &ast::Comment) -> SmolStr {
 300     let prefix_len = comment.prefix().len();
 301     let mut text = &comment.text()[prefix_len..];
 302
 303     // Remove ending "*/"
 304     if comment.kind().shape == ast::CommentShape::Block {
 305         text = &text[0..text.len() - 2];
 306     }
 307
 308     // Quote the string
 309     // Note that `tt::Literal` expect an escaped string
 310     let text = format!("\"{}\"", text.escape_debug());
 311     text.into()
 312 }
 313
 314 fn convert_doc_comment(token: &syntax::SyntaxToken) -> Option<Vec<tt::TokenTree>> {
 315     cov_mark::hit!(test_meta_doc_comments);
 316     let comment = ast::Comment::cast(token.clone())?;
 317     let doc = comment.kind().doc?;
 318
 319     // Make `doc="\" Comments\""
 320     let meta_tkns = vec![mk_ident("doc"), mk_punct('='), mk_doc_literal(&comment)];
 321
 322     // Make `#![]`
 323     let mut token_trees = vec![mk_punct('#')];
 324     if let ast::CommentPlacement::Inner = doc {
 325         token_trees.push(mk_punct('!'));
 326     }
 327     token_trees.push(tt::TokenTree::from(tt::Subtree {
 328         delimiter: Some(tt::Delimiter {
 329             kind: tt::DelimiterKind::Bracket,
 330             id: tt::TokenId::unspecified(),
 331         }),
 332         token_trees: meta_tkns,
 333     }));
 334
 335     return Some(token_trees);
 336
 337     // Helper functions
 338     fn mk_ident(s: &str) -> tt::TokenTree {
 339         tt::TokenTree::from(tt::Leaf::from(tt::Ident {
 340             text: s.into(),
 341             id: tt::TokenId::unspecified(),
 342         }))
 343     }
 344
 345     fn mk_punct(c: char) -> tt::TokenTree {
 346         tt::TokenTree::from(tt::Leaf::from(tt::Punct {
 347             char: c,
 348             spacing: tt::Spacing::Alone,
 349             id: tt::TokenId::unspecified(),
 350         }))
 351     }
 352
 353     fn mk_doc_literal(comment: &ast::Comment) -> tt::TokenTree {
 354         let lit = tt::Literal { text: doc_comment_text(comment), id: tt::TokenId::unspecified() };
 355
 356         tt::TokenTree::from(tt::Leaf::from(lit))
 357     }
 358 }
 359
 360 struct TokenIdAlloc {
 361     map: TokenMap,
 362     global_offset: TextSize,
 363     next_id: u32,
 364 }
 365
 366 impl TokenIdAlloc {
 367     fn alloc(&mut self, absolute_range: TextRange) -> tt::TokenId {
 368         let relative_range = absolute_range - self.global_offset;
 369         let token_id = tt::TokenId(self.next_id);
 370         self.next_id += 1;
 371         self.map.insert(token_id, relative_range);
 372         token_id
 373     }
 374
 375     fn open_delim(&mut self, open_abs_range: TextRange) -> (tt::TokenId, usize) {
 376         let token_id = tt::TokenId(self.next_id);
 377         self.next_id += 1;
 378         let idx = self.map.insert_delim(
 379             token_id,
 380             open_abs_range - self.global_offset,
 381             open_abs_range - self.global_offset,
 382         );
 383         (token_id, idx)
 384     }
 385
 386     fn close_delim(&mut self, idx: usize, close_abs_range: Option<TextRange>) {
 387         match close_abs_range {
 388             None => {
 389                 self.map.remove_delim(idx);
 390             }
 391             Some(close) => {
 392                 self.map.update_close_delim(idx, close - self.global_offset);
 393             }
 394         }
 395     }
 396 }
 397
 398 /// A Raw Token (straightly from lexer) convertor
 399 struct RawConvertor<'a> {
 400     lexed: parser::LexedStr<'a>,
 401     pos: usize,
 402     id_alloc: TokenIdAlloc,
 403 }
 404
 405 trait SrcToken<Ctx>: std::fmt::Debug {
 406     fn kind(&self, ctx: &Ctx) -> SyntaxKind;
 407
 408     fn to_char(&self, ctx: &Ctx) -> Option<char>;
 409
 410     fn to_text(&self, ctx: &Ctx) -> SmolStr;
 411 }
 412
 413 trait TokenConvertor: Sized {
 414     type Token: SrcToken<Self>;
 415
 416     fn convert_doc_comment(&self, token: &Self::Token) -> Option<Vec<tt::TokenTree>>;
 417
 418     fn bump(&mut self) -> Option<(Self::Token, TextRange)>;
 419
 420     fn peek(&self) -> Option<Self::Token>;
 421
 422     fn id_alloc(&mut self) -> &mut TokenIdAlloc;
 423 }
 424
 425 impl<'a> SrcToken<RawConvertor<'a>> for usize {
 426     fn kind(&self, ctx: &RawConvertor<'a>) -> SyntaxKind {
 427         ctx.lexed.kind(*self)
 428     }
 429
 430     fn to_char(&self, ctx: &RawConvertor<'a>) -> Option<char> {
 431         ctx.lexed.text(*self).chars().next()
 432     }
 433
 434     fn to_text(&self, ctx: &RawConvertor<'_>) -> SmolStr {
 435         ctx.lexed.text(*self).into()
 436     }
 437 }
 438
 439 impl<'a> TokenConvertor for RawConvertor<'a> {
 440     type Token = usize;
 441
 442     fn convert_doc_comment(&self, token: &usize) -> Option<Vec<tt::TokenTree>> {
 443         let text = self.lexed.text(*token);
 444         convert_doc_comment(&doc_comment(text))
 445     }
 446
 447     fn bump(&mut self) -> Option<(Self::Token, TextRange)> {
 448         if self.pos == self.lexed.len() {
 449             return None;
 450         }
 451         let token = self.pos;
 452         self.pos += 1;
 453         let range = self.lexed.text_range(token);
 454         let range = TextRange::new(range.start.try_into().unwrap(), range.end.try_into().unwrap());
 455
 456         Some((token, range))
 457     }
 458
 459     fn peek(&self) -> Option<Self::Token> {
 460         if self.pos == self.lexed.len() {
 461             return None;
 462         }
 463         Some(self.pos)
 464     }
 465
 466     fn id_alloc(&mut self) -> &mut TokenIdAlloc {
 467         &mut self.id_alloc
 468     }
 469 }
 470
 471 struct Convertor<'c> {
 472     id_alloc: TokenIdAlloc,
 473     current: Option<SyntaxToken>,
 474     preorder: PreorderWithTokens,
 475     censor: &'c FxHashSet<SyntaxNode>,
 476     range: TextRange,
 477     punct_offset: Option<(SyntaxToken, TextSize)>,
 478 }
 479
 480 impl<'c> Convertor<'c> {
 481     fn new(
 482         node: &SyntaxNode,
 483         global_offset: TextSize,
 484         censor: &'c FxHashSet<SyntaxNode>,
 485     ) -> Convertor<'c> {
 486         let range = node.text_range();
 487         let mut preorder = node.preorder_with_tokens();
 488         let first = Self::next_token(&mut preorder, censor);
 489         Convertor {
 490             id_alloc: { TokenIdAlloc { map: TokenMap::default(), global_offset, next_id: 0 } },
 491             current: first,
 492             preorder,
 493             range,
 494             censor,
 495             punct_offset: None,
 496         }
 497     }
 498
 499     fn next_token(
 500         preorder: &mut PreorderWithTokens,
 501         censor: &FxHashSet<SyntaxNode>,
 502     ) -> Option<SyntaxToken> {
 503         while let Some(ev) = preorder.next() {
 504             let ele = match ev {
 505                 WalkEvent::Enter(ele) => ele,
 506                 _ => continue,
 507             };
 508             match ele {
 509                 SyntaxElement::Token(t) => return Some(t),
 510                 SyntaxElement::Node(node) if censor.contains(&node) => preorder.skip_subtree(),
 511                 SyntaxElement::Node(_) => (),
 512             }
 513         }
 514         None
 515     }
 516 }
 517
 518 #[derive(Debug)]
 519 enum SynToken {
 520     Ordinary(SyntaxToken),
 521     Punch(SyntaxToken, TextSize),
 522 }
 523
 524 impl SynToken {
 525     fn token(&self) -> &SyntaxToken {
 526         match self {
 527             SynToken::Ordinary(it) => it,
 528             SynToken::Punch(it, _) => it,
 529         }
 530     }
 531 }
 532
 533 impl<'a> SrcToken<Convertor<'a>> for SynToken {
 534     fn kind(&self, _ctx: &Convertor<'a>) -> SyntaxKind {
 535         self.token().kind()
 536     }
 537     fn to_char(&self, _ctx: &Convertor<'a>) -> Option<char> {
 538         match self {
 539             SynToken::Ordinary(_) => None,
 540             SynToken::Punch(it, i) => it.text().chars().nth((*i).into()),
 541         }
 542     }
 543     fn to_text(&self, _ctx: &Convertor<'a>) -> SmolStr {
 544         self.token().text().into()
 545     }
 546 }
 547
 548 impl TokenConvertor for Convertor<'_> {
 549     type Token = SynToken;
 550     fn convert_doc_comment(&self, token: &Self::Token) -> Option<Vec<tt::TokenTree>> {
 551         convert_doc_comment(token.token())
 552     }
 553
 554     fn bump(&mut self) -> Option<(Self::Token, TextRange)> {
 555         if let Some((punct, offset)) = self.punct_offset.clone() {
 556             if usize::from(offset) + 1 < punct.text().len() {
 557                 let offset = offset + TextSize::of('.');
 558                 let range = punct.text_range();
 559                 self.punct_offset = Some((punct.clone(), offset));
 560                 let range = TextRange::at(range.start() + offset, TextSize::of('.'));
 561                 return Some((SynToken::Punch(punct, offset), range));
 562             }
 563         }
 564
 565         let curr = self.current.clone()?;
 566         if !&self.range.contains_range(curr.text_range()) {
 567             return None;
 568         }
 569         self.current = Self::next_token(&mut self.preorder, self.censor);
 570         let token = if curr.kind().is_punct() {
 571             let range = curr.text_range();
 572             let range = TextRange::at(range.start(), TextSize::of('.'));
 573             self.punct_offset = Some((curr.clone(), 0.into()));
 574             (SynToken::Punch(curr, 0.into()), range)
 575         } else {
 576             self.punct_offset = None;
 577             let range = curr.text_range();
 578             (SynToken::Ordinary(curr), range)
 579         };
 580
 581         Some(token)
 582     }
 583
 584     fn peek(&self) -> Option<Self::Token> {
 585         if let Some((punct, mut offset)) = self.punct_offset.clone() {
 586             offset += TextSize::of('.');
 587             if usize::from(offset) < punct.text().len() {
 588                 return Some(SynToken::Punch(punct, offset));
 589             }
 590         }
 591
 592         let curr = self.current.clone()?;
 593         if !self.range.contains_range(curr.text_range()) {
 594             return None;
 595         }
 596
 597         let token = if curr.kind().is_punct() {
 598             SynToken::Punch(curr, 0.into())
 599         } else {
 600             SynToken::Ordinary(curr)
 601         };
 602         Some(token)
 603     }
 604
 605     fn id_alloc(&mut self) -> &mut TokenIdAlloc {
 606         &mut self.id_alloc
 607     }
 608 }
 609
 610 struct TtTreeSink<'a> {
 611     buf: String,
 612     cursor: Cursor<'a>,
 613     open_delims: FxHashMap<tt::TokenId, TextSize>,
 614     text_pos: TextSize,
 615     inner: SyntaxTreeBuilder,
 616     token_map: TokenMap,
 617
 618     // Number of roots
 619     // Use for detect ill-form tree which is not single root
 620     roots: smallvec::SmallVec<[usize; 1]>,
 621 }
 622
 623 impl<'a> TtTreeSink<'a> {
 624     fn new(cursor: Cursor<'a>) -> Self {
 625         TtTreeSink {
 626             buf: String::new(),
 627             cursor,
 628             open_delims: FxHashMap::default(),
 629             text_pos: 0.into(),
 630             inner: SyntaxTreeBuilder::default(),
 631             roots: smallvec::SmallVec::new(),
 632             token_map: TokenMap::default(),
 633         }
 634     }
 635
 636     fn finish(mut self) -> (Parse<SyntaxNode>, TokenMap) {
 637         self.token_map.shrink_to_fit();
 638         (self.inner.finish(), self.token_map)
 639     }
 640 }
 641
 642 fn delim_to_str(d: tt::DelimiterKind, closing: bool) -> &'static str {
 643     let texts = match d {
 644         tt::DelimiterKind::Parenthesis => "()",
 645         tt::DelimiterKind::Brace => "{}",
 646         tt::DelimiterKind::Bracket => "[]",
 647     };
 648
 649     let idx = closing as usize;
 650     &texts[idx..texts.len() - (1 - idx)]
 651 }
 652
 653 impl<'a> TtTreeSink<'a> {
 654     fn token(&mut self, kind: SyntaxKind, mut n_tokens: u8) {
 655         if kind == LIFETIME_IDENT {
 656             n_tokens = 2;
 657         }
 658
 659         let mut last = self.cursor;
 660         for _ in 0..n_tokens {
 661             let tmp_str: SmolStr;
 662             if self.cursor.eof() {
 663                 break;
 664             }
 665             last = self.cursor;
 666             let text: &str = loop {
 667                 break match self.cursor.token_tree() {
 668                     Some(tt::buffer::TokenTreeRef::Leaf(leaf, _)) => {
 669                         // Mark the range if needed
 670                         let (text, id) = match leaf {
 671                             tt::Leaf::Ident(ident) => (&ident.text, ident.id),
 672                             tt::Leaf::Punct(punct) => {
 673                                 assert!(punct.char.is_ascii());
 674                                 let char = &(punct.char as u8);
 675                                 tmp_str = SmolStr::new_inline(
 676                                     std::str::from_utf8(std::slice::from_ref(char)).unwrap(),
 677                                 );
 678                                 (&tmp_str, punct.id)
 679                             }
 680                             tt::Leaf::Literal(lit) => (&lit.text, lit.id),
 681                         };
 682                         let range = TextRange::at(self.text_pos, TextSize::of(text.as_str()));
 683                         self.token_map.insert(id, range);
 684                         self.cursor = self.cursor.bump();
 685                         text
 686                     }
 687                     Some(tt::buffer::TokenTreeRef::Subtree(subtree, _)) => {
 688                         self.cursor = self.cursor.subtree().unwrap();
 689                         match subtree.delimiter {
 690                             Some(d) => {
 691                                 self.open_delims.insert(d.id, self.text_pos);
 692                                 delim_to_str(d.kind, false)
 693                             }
 694                             None => continue,
 695                         }
 696                     }
 697                     None => {
 698                         let parent = self.cursor.end().unwrap();
 699                         self.cursor = self.cursor.bump();
 700                         match parent.delimiter {
 701                             Some(d) => {
 702                                 if let Some(open_delim) = self.open_delims.get(&d.id) {
 703                                     let open_range = TextRange::at(*open_delim, TextSize::of('('));
 704                                     let close_range =
 705                                         TextRange::at(self.text_pos, TextSize::of('('));
 706                                     self.token_map.insert_delim(d.id, open_range, close_range);
 707                                 }
 708                                 delim_to_str(d.kind, true)
 709                             }
 710                             None => continue,
 711                         }
 712                     }
 713                 };
 714             };
 715             self.buf += text;
 716             self.text_pos += TextSize::of(text);
 717         }
 718
 719         self.inner.token(kind, self.buf.as_str());
 720         self.buf.clear();
 721         // Add whitespace between adjoint puncts
 722         let next = last.bump();
 723         if let (
 724             Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(curr), _)),
 725             Some(tt::buffer::TokenTreeRef::Leaf(tt::Leaf::Punct(_), _)),
 726         ) = (last.token_tree(), next.token_tree())
 727         {
 728             // Note: We always assume the semi-colon would be the last token in
 729             // other parts of RA such that we don't add whitespace here.
 730             if curr.spacing == tt::Spacing::Alone && curr.char != ';' {
 731                 self.inner.token(WHITESPACE, " ");
 732                 self.text_pos += TextSize::of(' ');
 733             }
 734         }
 735     }
 736
 737     fn start_node(&mut self, kind: SyntaxKind) {
 738         self.inner.start_node(kind);
 739
 740         match self.roots.last_mut() {
 741             None | Some(0) => self.roots.push(1),
 742             Some(ref mut n) => **n += 1,
 743         };
 744     }
 745
 746     fn finish_node(&mut self) {
 747         self.inner.finish_node();
 748         *self.roots.last_mut().unwrap() -= 1;
 749     }
 750
 751     fn error(&mut self, error: String) {
 752         self.inner.error(error, self.text_pos)
 753     }
 754 }