Macro call with braces does not require semicolon to be statement

This commit by itself is supposed to have no effect on behavior. All of
the call sites are updated to preserve their previous behavior.

The behavior changes are in the commits that follow.

Author: dtolnay

compiler/rustc_ast/src/util/classify.rs

@@ -1,6 +1,7 @@
 //! Routines the parser and pretty-printer use to classify AST nodes.
 
 use crate::ast;
+use crate::token::Delimiter;
 
 /// Does this expression require a semicolon to be treated as a statement?
 ///
@@ -42,19 +43,23 @@ use crate::ast;
 ///      _ => m! {} - 1,  // binary subtraction operator
 /// }
 /// ```
-#[allow(non_snake_case)]
-pub fn expr_requires_semi_to_be_stmt_FIXME(e: &ast::Expr) -> bool {
-    !matches!(
-        e.kind,
-        ast::ExprKind::If(..)
-            | ast::ExprKind::Match(..)
-            | ast::ExprKind::Block(..)
-            | ast::ExprKind::While(..)
-            | ast::ExprKind::Loop(..)
-            | ast::ExprKind::ForLoop { .. }
-            | ast::ExprKind::TryBlock(..)
-            | ast::ExprKind::ConstBlock(..)
-    )
+pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
+    use ast::ExprKind::*;
+
+    match &e.kind {
+        If(..)
+        | Match(..)
+        | Block(..)
+        | While(..)
+        | Loop(..)
+        | ForLoop { .. }
+        | TryBlock(..)
+        | ConstBlock(..) => false,
+
+        MacCall(mac_call) => mac_call.args.delim != Delimiter::Brace,
+
+        _ => true,
+    }
 }
 
 /// If an expression ends with `}`, returns the innermost expression ending in the `}`

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1101,7 +1101,10 @@ impl<'a> State<'a> {
                     false,
                     FixupContext { stmt: true, ..FixupContext::default() },
                 );
-                if classify::expr_requires_semi_to_be_stmt_FIXME(expr) {
+                if match expr.kind {
+                    ast::ExprKind::MacCall(_) => true,
+                    _ => classify::expr_requires_semi_to_be_stmt(expr),
+                } {
                     self.word(";");
                 }
             }

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -471,7 +471,10 @@ impl<'a> State<'a> {
         // Same applies to a small set of other expression kinds which eagerly
         // terminate a statement which opens with them.
         let needs_par = fixup.leftmost_subexpression_in_stmt
-            && !classify::expr_requires_semi_to_be_stmt_FIXME(expr);
+            && match expr.kind {
+                ast::ExprKind::MacCall(_) => false,
+                _ => !classify::expr_requires_semi_to_be_stmt(expr),
+            };
         if needs_par {
             self.popen();
             fixup = FixupContext::default();

compiler/rustc_lint/src/unused.rs

@@ -674,7 +674,10 @@ trait UnusedDelimLint {
                     ExprKind::Index(base, _subscript, _) => base,
                     _ => break,
                 };
-                if !classify::expr_requires_semi_to_be_stmt_FIXME(innermost) {
+                if match innermost.kind {
+                    ExprKind::MacCall(_) => false,
+                    _ => !classify::expr_requires_semi_to_be_stmt(innermost),
+                } {
                     return true;
                 }
             }

compiler/rustc_parse/src/parser/expr.rs

@@ -470,7 +470,10 @@ impl<'a> Parser<'a> {
     /// Checks if this expression is a successfully parsed statement.
     fn expr_is_complete(&self, e: &Expr) -> bool {
         self.restrictions.contains(Restrictions::STMT_EXPR)
-            && !classify::expr_requires_semi_to_be_stmt_FIXME(e)
+            && match e.kind {
+                ExprKind::MacCall(_) => false,
+                _ => !classify::expr_requires_semi_to_be_stmt(e),
+            }
     }
 
     /// Parses `x..y`, `x..=y`, and `x..`/`x..=`.
@@ -2567,7 +2570,10 @@ impl<'a> Parser<'a> {
                 // If it's not a free-standing expression, and is followed by a block,
                 // then it's very likely the condition to an `else if`.
                     if self.check(&TokenKind::OpenDelim(Delimiter::Brace))
-                        && classify::expr_requires_semi_to_be_stmt_FIXME(&cond) =>
+                        && match cond.kind {
+                            ExprKind::MacCall(_) => true,
+                            _ => classify::expr_requires_semi_to_be_stmt(&cond),
+                        } =>
                 {
                     self.dcx().emit_err(errors::ExpectedElseBlock {
                         first_tok_span,
@@ -2989,8 +2995,10 @@ impl<'a> Parser<'a> {
                         err
                     })?;
 
-                let require_comma = classify::expr_requires_semi_to_be_stmt_FIXME(&expr)
-                    && this.token != token::CloseDelim(Delimiter::Brace);
+                let require_comma = match expr.kind {
+                    ExprKind::MacCall(_) => true,
+                    _ => classify::expr_requires_semi_to_be_stmt(&expr),
+                } && this.token != token::CloseDelim(Delimiter::Brace);
 
                 if !require_comma {
                     arm_body = Some(expr);

compiler/rustc_parse/src/parser/stmt.rs

@@ -637,8 +637,10 @@ impl<'a> Parser<'a> {
         match &mut stmt.kind {
             // Expression without semicolon.
             StmtKind::Expr(expr)
-                if classify::expr_requires_semi_to_be_stmt_FIXME(expr)
-                    && !expr.attrs.is_empty()
+                if match expr.kind {
+                    ExprKind::MacCall(_) => true,
+                    _ => classify::expr_requires_semi_to_be_stmt(expr),
+                } && !expr.attrs.is_empty()
                     && ![token::Eof, token::Semi, token::CloseDelim(Delimiter::Brace)]
                         .contains(&self.token.kind) =>
             {
@@ -652,7 +654,10 @@ impl<'a> Parser<'a> {
             // Expression without semicolon.
             StmtKind::Expr(expr)
                 if self.token != token::Eof
-                    && classify::expr_requires_semi_to_be_stmt_FIXME(expr) =>
+                    && match expr.kind {
+                        ExprKind::MacCall(_) => true,
+                        _ => classify::expr_requires_semi_to_be_stmt(expr),
+                    } =>
             {
                 // Just check for errors and recover; do not eat semicolon yet.
                 // `expect_one_of` returns PResult<'a, bool /* recovered */>