Add suggestion

Author: estebank

src/libsyntax/ext/tt/macro_rules.rs

@@ -757,7 +757,7 @@ fn check_matcher_core(sess: &ParseSess,
                 // against SUFFIX
                 continue 'each_token;
             }
-            TokenTree::Sequence(sp, ref seq_rep) => {
+            TokenTree::Sequence(delim_sp, ref seq_rep) => {
                 suffix_first = build_suffix_first();
                 // The trick here: when we check the interior, we want
                 // to include the separator (if any) as a potential
@@ -772,16 +772,16 @@ fn check_matcher_core(sess: &ParseSess,
                 let mut new;
                 let my_suffix = if let Some(ref u) = seq_rep.separator {
                     new = suffix_first.clone();
-                    new.add_one_maybe(TokenTree::Token(sp.entire(), u.clone()));
+                    new.add_one_maybe(TokenTree::Token(delim_sp.entire(), u.clone()));
                     &new
                 } else {
                     if let (
                         Some(tok),
                         Some(TokenTree::MetaVarDecl(sp, name, frag_spec)),
                      ) = (seq_rep.tts.first(), seq_rep.tts.last()) {
                         match is_in_follow(tok, &frag_spec.as_str()) {
-                            Err(_) | Ok(true) => {}  // handled elsewhere
-                            Ok(false) => {
+                            IsInFollow::Invalid(..) | IsInFollow::Yes => {}  // handled elsewhere
+                            IsInFollow::No(possible) => {
                                 let tok_sp = tok.span();
                                 let next = if *sp == tok_sp {
                                     "itself".to_owned()
@@ -815,6 +815,49 @@ fn check_matcher_core(sess: &ParseSess,
                                         "this is the first fragment in the evaluated repetition",
                                     );
                                 }
+                                let sugg_span = sess.source_map().next_point(delim_sp.close);
+                                let msg = "allowed there are: ";
+                                let sugg_msg = "add a valid separator for the repetition to be \
+                                                unambiguous";
+                                match &possible[..] {
+                                    &[] => {}
+                                    &[t] => {
+                                        err.note(&format!(
+                                            "only {} is allowed after `{}` fragments",
+                                            t,
+                                            frag_spec,
+                                        ));
+                                        if t.starts_with('`') && t.ends_with('`') {
+                                            err.span_suggestion_with_applicability(
+                                                sugg_span,
+                                                &format!("{}, for example", sugg_msg),
+                                                (&t[1..t.len()-1]).to_owned(),
+                                                Applicability::MaybeIncorrect,
+                                            );
+                                        } else {
+                                            err.note(sugg_msg);
+                                        }
+                                    }
+                                    ts => {
+                                        err.note(&format!(
+                                            "{}{} or {}",
+                                            msg,
+                                            ts[..ts.len() - 1].iter().map(|s| *s)
+                                                .collect::<Vec<_>>().join(", "),
+                                            ts[ts.len() - 1],
+                                        ));
+                                        if ts[0].starts_with('`') && ts[0].ends_with('`') {
+                                            err.span_suggestion_with_applicability(
+                                                sugg_span,
+                                                &format!("{}, for example", sugg_msg),
+                                                (&ts[0][1..ts[0].len()-1]).to_owned(),
+                                                Applicability::MaybeIncorrect,
+                                            );
+                                        } else {
+                                            err.note(sugg_msg);
+                                        }
+                                    }
+                                }
                                 err.emit();
                             }
                         }
@@ -979,7 +1022,7 @@ fn is_in_follow(tok: &quoted::TokenTree, frag: &str) -> IsInFollow {
                 IsInFollow::Yes
             },
             "stmt" | "expr"  => {
-                let tokens = vec!["`=>`", "`,`", "`;`"];
+                let tokens = vec!["`;`", "`=>`", "`,`"];
                 match *tok {
                     TokenTree::Token(_, ref tok) => match *tok {
                         FatArrow | Comma | Semi => IsInFollow::Yes,
@@ -1001,7 +1044,7 @@ fn is_in_follow(tok: &quoted::TokenTree, frag: &str) -> IsInFollow {
             },
             "path" | "ty" => {
                 let tokens = vec![
-                    "`{`", "`[`", "`=>`", "`,`", "`>`","`=`", "`:`", "`;`", "`|`", "`as`",
+                    "`,`", "`{`", "`[`", "`=>`", "`>`","`=`", "`:`", "`;`", "`|`", "`as`",
                     "`where`",
                 ];
                 match *tok {

src/test/ui/issues/issue-42755.stderr

@@ -3,6 +3,12 @@ error: `$p:vis` is followed (through repetition) by itself, which is not allowed
    |
 LL |     ($($p:vis)*) => {}
    |        ^^^^^^ this fragment is followed by itself without a valid separator
+   |
+   = note: allowed there are: `,`, an ident or a type
+help: add a valid separator for the repetition to be unambiguous, for example
+   |
+LL |     ($($p:vis),*) => {}
+   |               ^
 
 error: repetition matches empty token tree
   --> $DIR/issue-42755.rs:13:7

src/test/ui/macros/incorrrect-repetition-2.stderr

@@ -3,6 +3,12 @@ error: `$a:expr` is followed (through repetition) by itself, which is not allowe
    |
 LL |     ($($a:expr)*) => {};
    |        ^^^^^^^ this fragment is followed by itself without a valid separator
+   |
+   = note: allowed there are: `;`, `=>` or `,`
+help: add a valid separator for the repetition to be unambiguous, for example
+   |
+LL |     ($($a:expr);*) => {};
+   |                ^
 
 error[E0601]: `main` function not found in crate `incorrrect_repetition_2`
    |

src/test/ui/macros/incorrrect-repetition.stderr

@@ -5,6 +5,12 @@ LL |     ($($i:ident $e:expr)*) => {}
    |        -------- ^^^^^^^ this fragment is followed by the first fragment in this repetition without a valid separator
    |        |
    |        this is the first fragment in the evaluated repetition
+   |
+   = note: allowed there are: `;`, `=>` or `,`
+help: add a valid separator for the repetition to be unambiguous, for example
+   |
+LL |     ($($i:ident $e:expr);*) => {}
+   |                         ^
 
 error: aborting due to previous error