Alternative approach for tracking macro fragment span

Author: estebank

compiler/rustc_ast/src/ast_traits.rs

@@ -231,29 +231,29 @@ impl HasTokens for Attribute {
 impl HasTokens for Nonterminal {
     fn tokens(&self) -> Option<&LazyAttrTokenStream> {
         match self {
-            Nonterminal::NtItem(item, _) => item.tokens(),
-            Nonterminal::NtStmt(stmt, _) => stmt.tokens(),
-            Nonterminal::NtExpr(expr, _) | Nonterminal::NtLiteral(expr, _) => expr.tokens(),
-            Nonterminal::NtPat(pat, _) => pat.tokens(),
-            Nonterminal::NtTy(ty, _) => ty.tokens(),
-            Nonterminal::NtMeta(attr_item, _) => attr_item.tokens(),
-            Nonterminal::NtPath(path, _) => path.tokens(),
-            Nonterminal::NtVis(vis, _) => vis.tokens(),
-            Nonterminal::NtBlock(block, _) => block.tokens(),
+            Nonterminal::NtItem(item) => item.tokens(),
+            Nonterminal::NtStmt(stmt) => stmt.tokens(),
+            Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
+            Nonterminal::NtPat(pat) => pat.tokens(),
+            Nonterminal::NtTy(ty) => ty.tokens(),
+            Nonterminal::NtMeta(attr_item) => attr_item.tokens(),
+            Nonterminal::NtPath(path) => path.tokens(),
+            Nonterminal::NtVis(vis) => vis.tokens(),
+            Nonterminal::NtBlock(block) => block.tokens(),
             Nonterminal::NtIdent(..) | Nonterminal::NtLifetime(..) => None,
         }
     }
     fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> {
         match self {
-            Nonterminal::NtItem(item, _) => item.tokens_mut(),
-            Nonterminal::NtStmt(stmt, _) => stmt.tokens_mut(),
-            Nonterminal::NtExpr(expr, _) | Nonterminal::NtLiteral(expr, _) => expr.tokens_mut(),
-            Nonterminal::NtPat(pat, _) => pat.tokens_mut(),
-            Nonterminal::NtTy(ty, _) => ty.tokens_mut(),
-            Nonterminal::NtMeta(attr_item, _) => attr_item.tokens_mut(),
-            Nonterminal::NtPath(path, _) => path.tokens_mut(),
-            Nonterminal::NtVis(vis, _) => vis.tokens_mut(),
-            Nonterminal::NtBlock(block, _) => block.tokens_mut(),
+            Nonterminal::NtItem(item) => item.tokens_mut(),
+            Nonterminal::NtStmt(stmt) => stmt.tokens_mut(),
+            Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
+            Nonterminal::NtPat(pat) => pat.tokens_mut(),
+            Nonterminal::NtTy(ty) => ty.tokens_mut(),
+            Nonterminal::NtMeta(attr_item) => attr_item.tokens_mut(),
+            Nonterminal::NtPath(path) => path.tokens_mut(),
+            Nonterminal::NtVis(vis) => vis.tokens_mut(),
+            Nonterminal::NtBlock(block) => block.tokens_mut(),
             Nonterminal::NtIdent(..) | Nonterminal::NtLifetime(..) => None,
         }
     }

compiler/rustc_ast/src/attr/mod.rs

@@ -342,9 +342,9 @@ impl MetaItem {
                 let span = span.with_hi(segments.last().unwrap().ident.span.hi());
                 Path { span, segments, tokens: None }
             }
-            Some(TokenTree::Token(Token { kind: token::Interpolated(nt), .. }, _)) => match &**nt {
-                token::Nonterminal::NtMeta(item, _) => return item.meta(item.path.span),
-                token::Nonterminal::NtPath(path, _) => (**path).clone(),
+            Some(TokenTree::Token(Token { kind: token::Interpolated(nt), .. }, _)) => match &nt.0 {
+                token::Nonterminal::NtMeta(item) => return item.meta(item.path.span),
+                token::Nonterminal::NtPath(path) => (**path).clone(),
                 _ => return None,
             },
             _ => return None,

compiler/rustc_ast/src/mut_visit.rs

@@ -760,7 +760,10 @@ pub fn visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) {
             return; // Avoid visiting the span for the second time.
         }
         token::Interpolated(nt) => {
-            visit_nonterminal(Lrc::make_mut(nt), vis);
+            let nt = Lrc::make_mut(nt);
+            let (nt, sp) = (&mut nt.0, &mut nt.1);
+            vis.visit_span(sp);
+            visit_nonterminal(nt, vis);
         }
         _ => {}
     }
@@ -793,33 +796,33 @@ pub fn visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) {
 // multiple items there....
 pub fn visit_nonterminal<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) {
     match nt {
-        token::NtItem(item, _) => visit_clobber(item, |item| {
+        token::NtItem(item) => visit_clobber(item, |item| {
             // This is probably okay, because the only visitors likely to
             // peek inside interpolated nodes will be renamings/markings,
             // which map single items to single items.
             vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item")
         }),
-        token::NtBlock(block, _) => vis.visit_block(block),
-        token::NtStmt(stmt, _) => visit_clobber(stmt, |stmt| {
+        token::NtBlock(block) => vis.visit_block(block),
+        token::NtStmt(stmt) => visit_clobber(stmt, |stmt| {
             // See reasoning above.
             stmt.map(|stmt| {
                 vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
             })
         }),
-        token::NtPat(pat, _) => vis.visit_pat(pat),
-        token::NtExpr(expr, _) => vis.visit_expr(expr),
-        token::NtTy(ty, _) => vis.visit_ty(ty),
-        token::NtIdent(ident, _is_raw, _) => vis.visit_ident(ident),
-        token::NtLifetime(ident, _) => vis.visit_ident(ident),
-        token::NtLiteral(expr, _) => vis.visit_expr(expr),
-        token::NtMeta(item, _) => {
+        token::NtPat(pat) => vis.visit_pat(pat),
+        token::NtExpr(expr) => vis.visit_expr(expr),
+        token::NtTy(ty) => vis.visit_ty(ty),
+        token::NtIdent(ident, _is_raw) => vis.visit_ident(ident),
+        token::NtLifetime(ident) => vis.visit_ident(ident),
+        token::NtLiteral(expr) => vis.visit_expr(expr),
+        token::NtMeta(item) => {
             let AttrItem { path, args, tokens } = item.deref_mut();
             vis.visit_path(path);
             visit_attr_args(args, vis);
             visit_lazy_tts(tokens, vis);
         }
-        token::NtPath(path, _) => vis.visit_path(path),
-        token::NtVis(visib, _) => vis.visit_vis(visib),
+        token::NtPath(path) => vis.visit_path(path),
+        token::NtVis(visib) => vis.visit_vis(visib),
     }
 }
 

compiler/rustc_ast/src/token.rs

@@ -112,7 +112,7 @@ impl Lit {
             }
             Literal(token_lit) => Some(token_lit),
             Interpolated(ref nt)
-                if let NtExpr(expr, _) | NtLiteral(expr, _) = &**nt
+                if let NtExpr(expr) | NtLiteral(expr) = &nt.0
                 && let ast::ExprKind::Lit(token_lit) = expr.kind =>
             {
                 Some(token_lit)
@@ -289,7 +289,7 @@ pub enum TokenKind {
     /// - It prevents `Token` from implementing `Copy`.
     /// It adds complexity and likely slows things down. Please don't add new
     /// occurrences of this token kind!
-    Interpolated(Lrc<Nonterminal>),
+    Interpolated(Lrc<(Nonterminal, Span)>),
 
     /// A doc comment token.
     /// `Symbol` is the doc comment's data excluding its "quotes" (`///`, `/**`, etc)
@@ -395,7 +395,7 @@ impl Token {
     /// if they keep spans or perform edition checks.
     pub fn uninterpolated_span(&self) -> Span {
         match &self.kind {
-            Interpolated(nt) => nt.use_span(),
+            Interpolated(nt) => nt.0.use_span(),
             _ => self.span,
         }
     }
@@ -438,7 +438,7 @@ impl Token {
             ModSep                            | // global path
             Lifetime(..)                      | // labeled loop
             Pound                             => true, // expression attributes
-            Interpolated(ref nt) => matches!(**nt, NtLiteral(..) |
+            Interpolated(ref nt) => matches!(&nt.0, NtLiteral(..) |
                 NtExpr(..)    |
                 NtBlock(..)   |
                 NtPath(..)),
@@ -462,7 +462,7 @@ impl Token {
             | DotDot | DotDotDot | DotDotEq      // ranges
             | Lt | BinOp(Shl)                    // associated path
             | ModSep                    => true, // global path
-            Interpolated(ref nt) => matches!(**nt, NtLiteral(..) |
+            Interpolated(ref nt) => matches!(&nt.0, NtLiteral(..) |
                 NtPat(..)     |
                 NtBlock(..)   |
                 NtPath(..)),
@@ -485,7 +485,7 @@ impl Token {
             Lifetime(..)                | // lifetime bound in trait object
             Lt | BinOp(Shl)             | // associated path
             ModSep                      => true, // global path
-            Interpolated(ref nt) => matches!(**nt, NtTy(..) | NtPath(..)),
+            Interpolated(ref nt) => matches!(&nt.0, NtTy(..) | NtPath(..)),
             // For anonymous structs or unions, which only appear in specific positions
             // (type of struct fields or union fields), we don't consider them as regular types
             _ => false,
@@ -496,7 +496,7 @@ impl Token {
     pub fn can_begin_const_arg(&self) -> bool {
         match self.kind {
             OpenDelim(Delimiter::Brace) => true,
-            Interpolated(ref nt) => matches!(**nt, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
+            Interpolated(ref nt) => matches!(&nt.0, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
             _ => self.can_begin_literal_maybe_minus(),
         }
     }
@@ -550,9 +550,9 @@ impl Token {
         match self.uninterpolate().kind {
             Literal(..) | BinOp(Minus) => true,
             Ident(name, false) if name.is_bool_lit() => true,
-            Interpolated(ref nt) => match &**nt {
+            Interpolated(ref nt) => match &nt.0 {
                 NtLiteral(..) => true,
-                NtExpr(e, _) => match &e.kind {
+                NtExpr(e) => match &e.kind {
                     ast::ExprKind::Lit(_) => true,
                     ast::ExprKind::Unary(ast::UnOp::Neg, e) => {
                         matches!(&e.kind, ast::ExprKind::Lit(_))
@@ -571,11 +571,11 @@ impl Token {
     /// otherwise returns the original token.
     pub fn uninterpolate(&self) -> Cow<'_, Token> {
         match &self.kind {
-            Interpolated(nt) => match **nt {
-                NtIdent(ident, is_raw, _) => {
-                    Cow::Owned(Token::new(Ident(ident.name, is_raw), ident.span))
+            Interpolated(nt) => match &nt.0 {
+                NtIdent(ident, is_raw) => {
+                    Cow::Owned(Token::new(Ident(ident.name, *is_raw), ident.span))
                 }
-                NtLifetime(ident, _) => Cow::Owned(Token::new(Lifetime(ident.name), ident.span)),
+                NtLifetime(ident) => Cow::Owned(Token::new(Lifetime(ident.name), ident.span)),
                 _ => Cow::Borrowed(self),
             },
             _ => Cow::Borrowed(self),
@@ -588,8 +588,8 @@ impl Token {
         // We avoid using `Token::uninterpolate` here because it's slow.
         match &self.kind {
             &Ident(name, is_raw) => Some((Ident::new(name, self.span), is_raw)),
-            Interpolated(nt) => match **nt {
-                NtIdent(ident, is_raw, _) => Some((ident, is_raw)),
+            Interpolated(nt) => match &nt.0 {
+                NtIdent(ident, is_raw) => Some((*ident, *is_raw)),
                 _ => None,
             },
             _ => None,
@@ -602,8 +602,8 @@ impl Token {
         // We avoid using `Token::uninterpolate` here because it's slow.
         match &self.kind {
             &Lifetime(name) => Some(Ident::new(name, self.span)),
-            Interpolated(nt) => match **nt {
-                NtLifetime(ident, _) => Some(ident),
+            Interpolated(nt) => match &nt.0 {
+                NtLifetime(ident) => Some(*ident),
                 _ => None,
             },
             _ => None,
@@ -628,7 +628,7 @@ impl Token {
 
     /// Returns `true` if the token is an interpolated path.
     fn is_path(&self) -> bool {
-        if let Interpolated(nt) = &self.kind && let NtPath(..) = **nt {
+        if let Interpolated(nt) = &self.kind && let NtPath(..) = &nt.0 {
             return true;
         }
 
@@ -640,7 +640,7 @@ impl Token {
     /// (which happens while parsing the result of macro expansion)?
     pub fn is_whole_expr(&self) -> bool {
         if let Interpolated(nt) = &self.kind
-            && let NtExpr(..) | NtLiteral(..) | NtPath(..) | NtBlock(..) = **nt
+            && let NtExpr(..) | NtLiteral(..) | NtPath(..) | NtBlock(..) = &nt.0
         {
             return true;
         }
@@ -650,7 +650,7 @@ impl Token {
 
     /// Is the token an interpolated block (`$b:block`)?
     pub fn is_whole_block(&self) -> bool {
-        if let Interpolated(nt) = &self.kind && let NtBlock(..) = **nt {
+        if let Interpolated(nt) = &self.kind && let NtBlock(..) = &nt.0 {
             return true;
         }
 
@@ -803,19 +803,19 @@ impl PartialEq<TokenKind> for Token {
 #[derive(Clone, Encodable, Decodable)]
 /// For interpolation during macro expansion.
 pub enum Nonterminal {
-    NtItem(P<ast::Item>, Span),
-    NtBlock(P<ast::Block>, Span),
-    NtStmt(P<ast::Stmt>, Span),
-    NtPat(P<ast::Pat>, Span),
-    NtExpr(P<ast::Expr>, Span),
-    NtTy(P<ast::Ty>, Span),
-    NtIdent(Ident, /* is_raw */ bool, Span),
-    NtLifetime(Ident, Span),
-    NtLiteral(P<ast::Expr>, Span),
+    NtItem(P<ast::Item>),
+    NtBlock(P<ast::Block>),
+    NtStmt(P<ast::Stmt>),
+    NtPat(P<ast::Pat>),
+    NtExpr(P<ast::Expr>),
+    NtTy(P<ast::Ty>),
+    NtIdent(Ident, /* is_raw */ bool),
+    NtLifetime(Ident),
+    NtLiteral(P<ast::Expr>),
     /// Stuff inside brackets for attributes
-    NtMeta(P<ast::AttrItem>, Span),
-    NtPath(P<ast::Path>, Span),
-    NtVis(P<ast::Visibility>, Span),
+    NtMeta(P<ast::AttrItem>),
+    NtPath(P<ast::Path>),
+    NtVis(P<ast::Visibility>),
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable)]
@@ -899,33 +899,16 @@ impl fmt::Display for NonterminalKind {
 impl Nonterminal {
     pub fn use_span(&self) -> Span {
         match self {
-            NtItem(item, _) => item.span,
-            NtBlock(block, _) => block.span,
-            NtStmt(stmt, _) => stmt.span,
-            NtPat(pat, _) => pat.span,
-            NtExpr(expr, _) | NtLiteral(expr, _) => expr.span,
-            NtTy(ty, _) => ty.span,
-            NtIdent(ident, _, _) | NtLifetime(ident, _) => ident.span,
-            NtMeta(attr_item, _) => attr_item.span(),
-            NtPath(path, _) => path.span,
-            NtVis(vis, _) => vis.span,
-        }
-    }
-
-    pub fn def_span(&self) -> Span {
-        match self {
-            NtItem(_, span)
-            | NtBlock(_, span)
-            | NtStmt(_, span)
-            | NtPat(_, span)
-            | NtExpr(_, span)
-            | NtLiteral(_, span)
-            | NtTy(_, span)
-            | NtIdent(_, _, span)
-            | NtLifetime(_, span)
-            | NtMeta(_, span)
-            | NtPath(_, span)
-            | NtVis(_, span) => *span,
+            NtItem(item) => item.span,
+            NtBlock(block) => block.span,
+            NtStmt(stmt) => stmt.span,
+            NtPat(pat) => pat.span,
+            NtExpr(expr) | NtLiteral(expr) => expr.span,
+            NtTy(ty) => ty.span,
+            NtIdent(ident, _) | NtLifetime(ident) => ident.span,
+            NtMeta(attr_item) => attr_item.span(),
+            NtPath(path) => path.span,
+            NtVis(vis) => vis.span,
         }
     }
 
@@ -950,10 +933,10 @@ impl Nonterminal {
 impl PartialEq for Nonterminal {
     fn eq(&self, rhs: &Self) -> bool {
         match (self, rhs) {
-            (NtIdent(ident_lhs, is_raw_lhs, _), NtIdent(ident_rhs, is_raw_rhs, _)) => {
+            (NtIdent(ident_lhs, is_raw_lhs), NtIdent(ident_rhs, is_raw_rhs)) => {
                 ident_lhs == ident_rhs && is_raw_lhs == is_raw_rhs
             }
-            (NtLifetime(ident_lhs, _), NtLifetime(ident_rhs, _)) => ident_lhs == ident_rhs,
+            (NtLifetime(ident_lhs), NtLifetime(ident_rhs)) => ident_lhs == ident_rhs,
             // FIXME: Assume that all "complex" nonterminal are not equal, we can't compare them
             // correctly based on data from AST. This will prevent them from matching each other
             // in macros. The comparison will become possible only when each nonterminal has an
@@ -999,7 +982,7 @@ mod size_asserts {
     // tidy-alphabetical-start
     static_assert_size!(Lit, 12);
     static_assert_size!(LitKind, 2);
-    static_assert_size!(Nonterminal, 24);
+    static_assert_size!(Nonterminal, 16);
     static_assert_size!(Token, 24);
     static_assert_size!(TokenKind, 16);
     // tidy-alphabetical-end