crates/mbe/src/syntax_bridge.rs

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