Mac calls include their semicolons

Author: compiler-errors

compiler/rustc_ast/src/ast.rs

@@ -1185,7 +1185,7 @@ impl Stmt {
     pub fn has_trailing_semicolon(&self) -> bool {
         match &self.kind {
             StmtKind::Semi(_) => true,
-            StmtKind::MacCall(mac) => matches!(mac.style, MacStmtStyle::Semicolon),
+            StmtKind::MacCall(mac) => matches!(mac.style, MacStmtStyle::Semicolon(_)),
             _ => false,
         }
     }
@@ -1197,11 +1197,14 @@ impl Stmt {
     /// `LazyAttrTokenStream`. The parser is responsible for calling
     /// `ToAttrTokenStream::add_trailing_semi` when there is actually
     /// a semicolon in the tokenstream.
-    pub fn add_trailing_semicolon(mut self) -> Self {
+    pub fn add_trailing_semicolon(mut self, semi_span: Span) -> Self {
+        if let Some(mac_span) = self.span.find_ancestor_in_same_ctxt(semi_span) {
+            self.span = mac_span.to(semi_span);
+        }
         self.kind = match self.kind {
             StmtKind::Expr(expr) => StmtKind::Semi(expr),
             StmtKind::MacCall(mut mac) => {
-                mac.style = MacStmtStyle::Semicolon;
+                mac.style = MacStmtStyle::Semicolon(semi_span);
                 StmtKind::MacCall(mac)
             }
             kind => kind,
@@ -1231,11 +1234,17 @@ pub enum StmtKind {
     /// Expr with a trailing semi-colon.
     Semi(P<Expr>),
     /// Just a trailing semi-colon.
-    Empty,
+    Empty(EmptyFromMacro),
     /// Macro.
     MacCall(P<MacCallStmt>),
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub enum EmptyFromMacro {
+    Yes,
+    No,
+}
+
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct MacCallStmt {
     pub mac: P<MacCall>,
@@ -1248,7 +1257,7 @@ pub struct MacCallStmt {
 pub enum MacStmtStyle {
     /// The macro statement had a trailing semicolon (e.g., `foo! { ... };`
     /// `foo!(...);`, `foo![...];`).
-    Semicolon,
+    Semicolon(Span),
     /// The macro statement had braces (e.g., `foo! { ... }`).
     Braces,
     /// The macro statement had parentheses or brackets and no semicolon (e.g.,

compiler/rustc_ast/src/ast_traits.rs

@@ -134,7 +134,7 @@ impl HasTokens for StmtKind {
             StmtKind::Let(local) => local.tokens.as_ref(),
             StmtKind::Item(item) => item.tokens(),
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens(),
-            StmtKind::Empty => None,
+            StmtKind::Empty(_) => None,
             StmtKind::MacCall(mac) => mac.tokens.as_ref(),
         }
     }
@@ -143,7 +143,7 @@ impl HasTokens for StmtKind {
             StmtKind::Let(local) => Some(&mut local.tokens),
             StmtKind::Item(item) => item.tokens_mut(),
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens_mut(),
-            StmtKind::Empty => None,
+            StmtKind::Empty(_) => None,
             StmtKind::MacCall(mac) => Some(&mut mac.tokens),
         }
     }
@@ -277,7 +277,7 @@ impl HasAttrs for StmtKind {
             StmtKind::Let(local) => &local.attrs,
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.attrs(),
             StmtKind::Item(item) => item.attrs(),
-            StmtKind::Empty => &[],
+            StmtKind::Empty(_) => &[],
             StmtKind::MacCall(mac) => &mac.attrs,
         }
     }
@@ -287,7 +287,7 @@ impl HasAttrs for StmtKind {
             StmtKind::Let(local) => f(&mut local.attrs),
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.visit_attrs(f),
             StmtKind::Item(item) => item.visit_attrs(f),
-            StmtKind::Empty => {}
+            StmtKind::Empty(_) => {}
             StmtKind::MacCall(mac) => f(&mut mac.attrs),
         }
     }

compiler/rustc_ast/src/mut_visit.rs

@@ -372,7 +372,7 @@ fn walk_flat_map_stmt_kind<T: MutVisitor>(vis: &mut T, kind: StmtKind) -> SmallV
         StmtKind::Item(item) => vis.flat_map_item(item).into_iter().map(StmtKind::Item).collect(),
         StmtKind::Expr(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect(),
         StmtKind::Semi(expr) => vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect(),
-        StmtKind::Empty => smallvec![StmtKind::Empty],
+        StmtKind::Empty(from_macro) => smallvec![StmtKind::Empty(from_macro)],
         StmtKind::MacCall(mut mac) => {
             let MacCallStmt { mac: mac_, style: _, attrs, tokens: _ } = mac.deref_mut();
             for attr in attrs {

compiler/rustc_ast/src/visit.rs

@@ -428,6 +428,7 @@ macro_rules! common_visitor_and_walkers {
             DelegationMac,
             DelimArgs,
             DelimSpan,
+            EmptyFromMacro,
             EnumDef,
             Extern,
             ForLoopKind,
@@ -1166,7 +1167,7 @@ pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) -> V:
         StmtKind::Let(local) => try_visit!(visitor.visit_local(local)),
         StmtKind::Item(item) => try_visit!(visitor.visit_item(item)),
         StmtKind::Expr(expr) | StmtKind::Semi(expr) => try_visit!(visitor.visit_expr(expr)),
-        StmtKind::Empty => {}
+        StmtKind::Empty(_) => {}
         StmtKind::MacCall(mac) => {
             let MacCallStmt { mac, attrs, style: _, tokens: _ } = &**mac;
             walk_list!(visitor, visit_attribute, attrs);

compiler/rustc_ast_lowering/src/block.rs

@@ -75,7 +75,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     let span = self.lower_span(s.span);
                     stmts.push(hir::Stmt { hir_id, kind, span });
                 }
-                StmtKind::Empty => {}
+                StmtKind::Empty(_) => {}
                 StmtKind::MacCall(..) => panic!("shouldn't exist here"),
             }
             ast_stmts = tail;

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1446,15 +1446,15 @@ impl<'a> State<'a> {
                 self.print_expr_outer_attr_style(expr, false, FixupContext::new_stmt());
                 self.word(";");
             }
-            ast::StmtKind::Empty => {
+            ast::StmtKind::Empty(_) => {
                 self.space_if_not_bol();
                 self.word(";");
             }
             ast::StmtKind::MacCall(mac) => {
                 self.space_if_not_bol();
                 self.print_outer_attributes(&mac.attrs);
                 self.print_mac(&mac.mac);
-                if mac.style == ast::MacStmtStyle::Semicolon {
+                if matches!(mac.style, ast::MacStmtStyle::Semicolon(_)) {
                     self.word(";");
                 }
             }

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -393,7 +393,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
                 )],
                 self.span,
             ))
-            .add_trailing_semicolon();
+            .add_trailing_semicolon(self.span.shrink_to_hi());
         let local_bind_path = self.cx.expr_path(Path::from_ident(local_bind));
         let rslt = if self.is_consumed {
             let ret = self.cx.stmt_expr(local_bind_path);

compiler/rustc_expand/src/base.rs

@@ -124,7 +124,7 @@ impl Annotatable {
             Annotatable::AssocItem(node, _) => TokenStream::from_ast(node),
             Annotatable::ForeignItem(node) => TokenStream::from_ast(node),
             Annotatable::Stmt(node) => {
-                assert!(!matches!(node.kind, ast::StmtKind::Empty));
+                assert!(!matches!(node.kind, ast::StmtKind::Empty(_)));
                 TokenStream::from_ast(node)
             }
             Annotatable::Expr(node) => TokenStream::from_ast(node),

compiler/rustc_expand/src/expand.rs

@@ -1204,7 +1204,7 @@ macro_rules! assign_id {
 }
 
 enum AddSemicolon {
-    Yes,
+    Yes(Span),
     No,
 }
 
@@ -1687,7 +1687,7 @@ impl InvocationCollectorNode for ast::Stmt {
             StmtKind::Item(item) => matches!(item.kind, ItemKind::MacCall(..)),
             StmtKind::Semi(expr) => matches!(expr.kind, ExprKind::MacCall(..)),
             StmtKind::Expr(..) => unreachable!(),
-            StmtKind::Let(..) | StmtKind::Empty => false,
+            StmtKind::Let(..) | StmtKind::Empty(_) => false,
         }
     }
     fn take_mac_call(self) -> (P<ast::MacCall>, ast::AttrVec, AddSemicolon) {
@@ -1696,23 +1696,32 @@ impl InvocationCollectorNode for ast::Stmt {
         let (add_semicolon, mac, attrs) = match self.kind {
             StmtKind::MacCall(mac) => {
                 let ast::MacCallStmt { mac, style, attrs, .. } = *mac;
-                (style == MacStmtStyle::Semicolon, mac, attrs)
+                let add_semicolon = match style {
+                    MacStmtStyle::Semicolon(span) => AddSemicolon::Yes(span),
+                    MacStmtStyle::Braces | MacStmtStyle::NoBraces => AddSemicolon::No,
+                };
+                (add_semicolon, mac, attrs)
             }
             StmtKind::Item(item) => match *item {
                 ast::Item { kind: ItemKind::MacCall(mac), attrs, .. } => {
-                    (mac.args.need_semicolon(), mac, attrs)
+                    (AddSemicolon::No, mac, attrs)
                 }
                 _ => unreachable!(),
             },
             StmtKind::Semi(expr) => match *expr {
-                ast::Expr { kind: ExprKind::MacCall(mac), attrs, .. } => {
-                    (mac.args.need_semicolon(), mac, attrs)
+                ast::Expr { kind: ExprKind::MacCall(mac), attrs, span: expr_span, .. } => {
+                    let add_semicolon = if mac.args.need_semicolon() {
+                        AddSemicolon::Yes(expr_span.shrink_to_hi().to(self.span))
+                    } else {
+                        AddSemicolon::No
+                    };
+                    (add_semicolon, mac, attrs)
                 }
                 _ => unreachable!(),
             },
             _ => unreachable!(),
         };
-        (mac, attrs, if add_semicolon { AddSemicolon::Yes } else { AddSemicolon::No })
+        (mac, attrs, add_semicolon)
     }
     fn delegation(&self) -> Option<(&ast::DelegationMac, &ast::Item<Self::ItemKind>)> {
         match &self.kind {
@@ -1735,9 +1744,9 @@ impl InvocationCollectorNode for ast::Stmt {
     fn post_flat_map_node_collect_bang(stmts: &mut Self::OutputTy, add_semicolon: AddSemicolon) {
         // If this is a macro invocation with a semicolon, then apply that
         // semicolon to the final statement produced by expansion.
-        if matches!(add_semicolon, AddSemicolon::Yes) {
+        if let AddSemicolon::Yes(semi_span) = add_semicolon {
             if let Some(stmt) = stmts.pop() {
-                stmts.push(stmt.add_trailing_semicolon());
+                stmts.push(stmt.add_trailing_semicolon(semi_span));
             }
         }
     }

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -431,7 +431,7 @@ fn transcribe_metavar<'tx>(
             mk_delimited(block.span, MetaVarKind::Block, TokenStream::from_ast(block))
         }
         MatchedSingle(ParseNtResult::Stmt(stmt)) => {
-            let stream = if let StmtKind::Empty = stmt.kind {
+            let stream = if let StmtKind::Empty(_) = stmt.kind {
                 // FIXME: Properly collect tokens for empty statements.
                 TokenStream::token_alone(token::Semi, stmt.span)
             } else {