Imporve error message: missing ; in macro_rules

Author: mu001999

compiler/rustc_expand/src/mbe/diagnostics.rs

@@ -55,7 +55,7 @@ pub(super) fn failed_to_match_macro<'cx>(
 
     let span = token.span.substitute_dummy(sp);
 
-    let mut err = cx.dcx().struct_span_err(span, parse_failure_msg(&token));
+    let mut err = cx.dcx().struct_span_err(span, parse_failure_msg(&token, &None));
     err.span_label(span, label);
     if !def_span.is_dummy() && !cx.source_map().is_imported(def_span) {
         err.span_label(cx.source_map().guess_head_span(def_span), "when calling this macro");
@@ -134,7 +134,12 @@ impl BestFailure {
 impl<'a, 'cx, 'matcher> Tracker<'matcher> for CollectTrackerAndEmitter<'a, 'cx, 'matcher> {
     type Failure = (Token, usize, &'static str);
 
-    fn build_failure(tok: Token, position: usize, msg: &'static str) -> Self::Failure {
+    fn build_failure(
+        tok: Token,
+        _: Option<Token>,
+        position: usize,
+        msg: &'static str,
+    ) -> Self::Failure {
         (tok, position, msg)
     }
 
@@ -203,10 +208,15 @@ impl<'a, 'cx> CollectTrackerAndEmitter<'a, 'cx, '_> {
 pub struct FailureForwarder;
 
 impl<'matcher> Tracker<'matcher> for FailureForwarder {
-    type Failure = (Token, usize, &'static str);
-
-    fn build_failure(tok: Token, position: usize, msg: &'static str) -> Self::Failure {
-        (tok, position, msg)
+    type Failure = (Token, Option<Token>, usize, &'static str);
+
+    fn build_failure(
+        tok: Token,
+        expect_token: Option<Token>,
+        position: usize,
+        msg: &'static str,
+    ) -> Self::Failure {
+        (tok, expect_token, position, msg)
     }
 
     fn description() -> &'static str {
@@ -320,9 +330,19 @@ pub(super) fn annotate_doc_comment(dcx: &DiagCtxt, err: &mut Diag<'_>, sm: &Sour
 
 /// Generates an appropriate parsing failure message. For EOF, this is "unexpected end...". For
 /// other tokens, this is "unexpected token...".
-pub(super) fn parse_failure_msg(tok: &Token) -> Cow<'static, str> {
-    match tok.kind {
-        token::Eof => Cow::from("unexpected end of macro invocation"),
-        _ => Cow::from(format!("no rules expected the token `{}`", pprust::token_to_string(tok))),
+pub(super) fn parse_failure_msg(tok: &Token, expect_tok: &Option<Token>) -> Cow<'static, str> {
+    if let Some(expect_tok) = expect_tok {
+        Cow::from(format!(
+            "expected `{}`, found `{}`",
+            pprust::token_to_string(expect_tok),
+            pprust::token_to_string(tok),
+        ))
+    } else {
+        match tok.kind {
+            token::Eof => Cow::from("unexpected end of macro invocation"),
+            _ => {
+                Cow::from(format!("no rules expected the token `{}`", pprust::token_to_string(tok)))
+            }
+        }
     }
 }

compiler/rustc_expand/src/mbe/macro_parser.rs

@@ -454,10 +454,11 @@ impl TtParser {
         token: &Token,
         approx_position: usize,
         track: &mut T,
-    ) -> Option<NamedParseResult<T::Failure>> {
+    ) -> (Option<NamedParseResult<T::Failure>>, Option<Token>) {
         // Matcher positions that would be valid if the macro invocation was over now. Only
         // modified if `token == Eof`.
         let mut eof_mps = EofMatcherPositions::None;
+        let mut expected_token = None;
 
         while let Some(mut mp) = self.cur_mps.pop() {
             let matcher_loc = &matcher[mp.idx];
@@ -541,6 +542,8 @@ impl TtParser {
                         // The separator matches the current token. Advance past it.
                         mp.idx += 1;
                         self.next_mps.push(mp);
+                    } else {
+                        expected_token = Some(separator.clone());
                     }
                 }
                 &MatcherLoc::SequenceKleeneOpAfterSep { idx_first } => {
@@ -560,7 +563,7 @@ impl TtParser {
                     } else {
                         // E.g. `$e` instead of `$e:expr`, reported as a hard error if actually used.
                         // Both this check and the one in `nameize` are necessary, surprisingly.
-                        return Some(Error(span, "missing fragment specifier".to_string()));
+                        return (Some(Error(span, "missing fragment specifier".to_string())), None);
                     }
                 }
                 MatcherLoc::Eof => {
@@ -581,27 +584,35 @@ impl TtParser {
         // If we reached the end of input, check that there is EXACTLY ONE possible matcher.
         // Otherwise, either the parse is ambiguous (which is an error) or there is a syntax error.
         if *token == token::Eof {
-            Some(match eof_mps {
-                EofMatcherPositions::One(mut eof_mp) => {
-                    // Need to take ownership of the matches from within the `Rc`.
-                    Rc::make_mut(&mut eof_mp.matches);
-                    let matches = Rc::try_unwrap(eof_mp.matches).unwrap().into_iter();
-                    self.nameize(matcher, matches)
-                }
-                EofMatcherPositions::Multiple => {
-                    Error(token.span, "ambiguity: multiple successful parses".to_string())
-                }
-                EofMatcherPositions::None => Failure(T::build_failure(
-                    Token::new(
-                        token::Eof,
-                        if token.span.is_dummy() { token.span } else { token.span.shrink_to_hi() },
-                    ),
-                    approx_position,
-                    "missing tokens in macro arguments",
-                )),
-            })
+            (
+                Some(match eof_mps {
+                    EofMatcherPositions::One(mut eof_mp) => {
+                        // Need to take ownership of the matches from within the `Rc`.
+                        Rc::make_mut(&mut eof_mp.matches);
+                        let matches = Rc::try_unwrap(eof_mp.matches).unwrap().into_iter();
+                        self.nameize(matcher, matches)
+                    }
+                    EofMatcherPositions::Multiple => {
+                        Error(token.span, "ambiguity: multiple successful parses".to_string())
+                    }
+                    EofMatcherPositions::None => Failure(T::build_failure(
+                        Token::new(
+                            token::Eof,
+                            if token.span.is_dummy() {
+                                token.span
+                            } else {
+                                token.span.shrink_to_hi()
+                            },
+                        ),
+                        None,
+                        approx_position,
+                        "missing tokens in macro arguments",
+                    )),
+                }),
+                None,
+            )
         } else {
-            None
+            (None, expected_token)
         }
     }
 
@@ -626,12 +637,13 @@ impl TtParser {
 
             // Process `cur_mps` until either we have finished the input or we need to get some
             // parsing from the black-box parser done.
-            let res = self.parse_tt_inner(
+            let (res, expected_token) = self.parse_tt_inner(
                 matcher,
                 &parser.token,
                 parser.approx_token_stream_pos(),
                 track,
             );
+
             if let Some(res) = res {
                 return res;
             }
@@ -646,6 +658,7 @@ impl TtParser {
                     // parser: syntax error.
                     return Failure(T::build_failure(
                         parser.token.clone(),
+                        expected_token,
                         parser.approx_token_stream_pos(),
                         "no rules expected this token in macro call",
                     ));

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -152,7 +152,12 @@ pub(super) trait Tracker<'matcher> {
     /// Arm failed to match. If the token is `token::Eof`, it indicates an unexpected
     /// end of macro invocation. Otherwise, it indicates that no rules expected the given token.
     /// The usize is the approximate position of the token in the input token stream.
-    fn build_failure(tok: Token, position: usize, msg: &'static str) -> Self::Failure;
+    fn build_failure(
+        tok: Token,
+        expect_tok: Option<Token>,
+        position: usize,
+        msg: &'static str,
+    ) -> Self::Failure;
 
     /// This is called before trying to match next MatcherLoc on the current token.
     fn before_match_loc(&mut self, _parser: &TtParser, _matcher: &'matcher MatcherLoc) {}
@@ -176,7 +181,13 @@ pub(super) struct NoopTracker;
 impl<'matcher> Tracker<'matcher> for NoopTracker {
     type Failure = ();
 
-    fn build_failure(_tok: Token, _position: usize, _msg: &'static str) -> Self::Failure {}
+    fn build_failure(
+        _tok: Token,
+        _expect_tok: Option<Token>,
+        _position: usize,
+        _msg: &'static str,
+    ) -> Self::Failure {
+    }
 
     fn description() -> &'static str {
         "none"
@@ -452,11 +463,11 @@ pub fn compile_declarative_macro(
                     &argument_gram,
                     &mut diagnostics::FailureForwarder,
                 );
-                let Failure((token, _, msg)) = parse_result else {
+                let Failure((token, expect_tok, _, msg)) = parse_result else {
                     unreachable!("matcher returned something other than Failure after retry");
                 };
 
-                let s = parse_failure_msg(&token);
+                let s = parse_failure_msg(&token, &expect_tok);
                 let sp = token.span.substitute_dummy(def.span);
                 let mut err = sess.dcx().struct_span_err(sp, s);
                 err.span_label(sp, msg);

tests/ui/macros/missing-semi.rs

@@ -0,0 +1,11 @@
+#[allow(unused_macros)]
+macro_rules! foo {
+    () => {
+
+    }
+    () => { //~ERROR expected `;`, found `(`
+
+    }
+}
+
+fn main() {}

tests/ui/macros/missing-semi.stderr

@@ -0,0 +1,8 @@
+error: expected `;`, found `(`
+  --> $DIR/missing-semi.rs:6:5
+   |
+LL |     () => {
+   |     ^ no rules expected this token in macro call
+
+error: aborting due to 1 previous error
+