Add suggestions for possible missing fn, struct, or enum keywords

Author: trevyn

compiler/rustc_parse/messages.ftl

@@ -528,14 +528,17 @@ parse_missing_comma_after_match_arm = expected `,` following `match` arm
 parse_missing_const_type = missing type for `{$kind}` item
     .suggestion = provide a type for the item
 
+parse_missing_enum_for_enum_definition = missing `enum` for enum definition
+    .suggestion = add `enum` here to parse `{$ident}` as an enum
+
 parse_missing_expression_in_for_loop = missing expression to iterate on in `for` loop
     .suggestion = try adding an expression to the `for` loop
 
 parse_missing_fn_for_function_definition = missing `fn` for function definition
-    .suggestion = add `fn` here to parse `{$ident}` as a public function
+    .suggestion = add `fn` here to parse `{$ident}` as a function
 
 parse_missing_fn_for_method_definition = missing `fn` for method definition
-    .suggestion = add `fn` here to parse `{$ident}` as a public method
+    .suggestion = add `fn` here to parse `{$ident}` as a method
 
 parse_missing_fn_params = missing parameters for function definition
     .suggestion = add a parameter list
@@ -555,7 +558,7 @@ parse_missing_semicolon_before_array = expected `;`, found `[`
     .suggestion = consider adding `;` here
 
 parse_missing_struct_for_struct_definition = missing `struct` for struct definition
-    .suggestion = add `struct` here to parse `{$ident}` as a public struct
+    .suggestion = add `struct` here to parse `{$ident}` as a struct
 
 parse_missing_trait_in_trait_impl = missing trait in a trait impl
     .suggestion_add_trait = add a trait here

compiler/rustc_parse/src/errors.rs

@@ -1612,24 +1612,31 @@ pub(crate) struct DefaultNotFollowedByItem {
 
 #[derive(Diagnostic)]
 pub(crate) enum MissingKeywordForItemDefinition {
+    #[diag(parse_missing_enum_for_enum_definition)]
+    Enum {
+        #[primary_span]
+        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "enum ")]
+        span: Span,
+        ident: Ident,
+    },
     #[diag(parse_missing_struct_for_struct_definition)]
     Struct {
         #[primary_span]
-        #[suggestion(style = "short", applicability = "maybe-incorrect", code = " struct ")]
+        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "struct ")]
         span: Span,
         ident: Ident,
     },
     #[diag(parse_missing_fn_for_function_definition)]
     Function {
         #[primary_span]
-        #[suggestion(style = "short", applicability = "maybe-incorrect", code = " fn ")]
+        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "fn ")]
         span: Span,
         ident: Ident,
     },
     #[diag(parse_missing_fn_for_method_definition)]
     Method {
         #[primary_span]
-        #[suggestion(style = "short", applicability = "maybe-incorrect", code = " fn ")]
+        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "fn ")]
         span: Span,
         ident: Ident,
     },
@@ -1644,7 +1651,12 @@ pub(crate) enum MissingKeywordForItemDefinition {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum AmbiguousMissingKwForItemSub {
-    #[suggestion(parse_suggestion, applicability = "maybe-incorrect", code = "{snippet}!")]
+    #[suggestion(
+        parse_suggestion,
+        style = "verbose",
+        applicability = "maybe-incorrect",
+        code = "{snippet}!"
+    )]
     SuggestMacro {
         #[primary_span]
         span: Span,

compiler/rustc_parse/src/parser/item.rs

@@ -239,6 +239,7 @@ impl<'a> Parser<'a> {
                 self.recover_const_impl(const_span, attrs, def_())?
             } else {
                 self.recover_const_mut(const_span);
+                self.recover_missing_kw_before_item()?;
                 let (ident, generics, ty, expr) = self.parse_const_item()?;
                 (
                     ident,
@@ -311,6 +312,9 @@ impl<'a> Parser<'a> {
                 Case::Insensitive,
             );
         } else if macros_allowed && self.check_path() {
+            if self.isnt_macro_invocation() {
+                self.recover_missing_kw_before_item()?;
+            }
             // MACRO INVOCATION ITEM
             (Ident::empty(), ItemKind::MacCall(P(self.parse_item_macro(vis)?)))
         } else {
@@ -374,25 +378,24 @@ impl<'a> Parser<'a> {
         self.check_ident() && self.look_ahead(1, |t| *t != token::Not && *t != token::PathSep)
     }
 
-    /// Recover on encountering a struct or method definition where the user
-    /// forgot to add the `struct` or `fn` keyword after writing `pub`: `pub S {}`.
+    /// Recover on encountering a struct, enum, or method definition where the user
+    /// forgot to add the `struct`, `enum`, or `fn` keyword
     fn recover_missing_kw_before_item(&mut self) -> PResult<'a, ()> {
-        // Space between `pub` keyword and the identifier
-        //
-        //     pub   S {}
-        //        ^^^ `sp` points here
-        let sp = self.prev_token.span.between(self.token.span);
-        let full_sp = self.prev_token.span.to(self.token.span);
+        let is_pub = self.prev_token.is_keyword(kw::Pub);
+        let is_const = self.prev_token.is_keyword(kw::Const);
+        let sp = self.token.span.shrink_to_lo();
         let ident_sp = self.token.span;
 
-        let ident = if self.look_ahead(1, |t| {
-            [
-                token::Lt,
-                token::OpenDelim(Delimiter::Brace),
-                token::OpenDelim(Delimiter::Parenthesis),
-            ]
-            .contains(&t.kind)
-        }) {
+        let ident = if (!is_const
+            || self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Parenthesis)))
+            && self.look_ahead(1, |t| {
+                [
+                    token::Lt,
+                    token::OpenDelim(Delimiter::Brace),
+                    token::OpenDelim(Delimiter::Parenthesis),
+                ]
+                .contains(&t.kind)
+            }) {
             self.parse_ident().unwrap()
         } else {
             return Ok(());
@@ -406,11 +409,17 @@ impl<'a> Parser<'a> {
         }
 
         let err = if self.check(&token::OpenDelim(Delimiter::Brace)) {
-            // possible public struct definition where `struct` was forgotten
-            Some(errors::MissingKeywordForItemDefinition::Struct { span: sp, ident })
+            // possible struct or enum definition where `struct` or `enum` was forgotten
+            if self.look_ahead(1, |t| *t == token::CloseDelim(Delimiter::Brace))
+                || self.look_ahead(2, |t| *t == token::Colon)
+                || self.look_ahead(3, |t| *t == token::Colon)
+            {
+                Some(errors::MissingKeywordForItemDefinition::Struct { span: sp, ident })
+            } else {
+                Some(errors::MissingKeywordForItemDefinition::Enum { span: sp, ident })
+            }
         } else if self.check(&token::OpenDelim(Delimiter::Parenthesis)) {
-            // possible public function or tuple struct definition where `fn`/`struct` was
-            // forgotten
+            // possible function or tuple struct definition where `fn` or `struct` was forgotten
             self.bump(); // `(`
             let is_method = self.recover_self_param();
 
@@ -426,7 +435,7 @@ impl<'a> Parser<'a> {
                     } else {
                         errors::MissingKeywordForItemDefinition::Function { span: sp, ident }
                     }
-                } else if self.check(&token::Semi) {
+                } else if is_pub && self.check(&token::Semi) {
                     errors::MissingKeywordForItemDefinition::Struct { span: sp, ident }
                 } else {
                     errors::MissingKeywordForItemDefinition::Ambiguous {
@@ -435,7 +444,7 @@ impl<'a> Parser<'a> {
                             None
                         } else if let Ok(snippet) = self.span_to_snippet(ident_sp) {
                             Some(errors::AmbiguousMissingKwForItemSub::SuggestMacro {
-                                span: full_sp,
+                                span: ident_sp,
                                 snippet,
                             })
                         } else {

tests/ui/did_you_mean/issue-40006.rs

@@ -5,15 +5,15 @@ impl dyn A {
 struct S;
 
 trait X {
-    X() {} //~ ERROR expected one of `!` or `::`, found `(`
+    X() {} //~ ERROR missing `fn` for function definition
     fn xxx() { ### }
     L = M;
     Z = { 2 + 3 };
     ::Y ();
 }
 
 trait A {
-    X() {} //~ ERROR expected one of `!` or `::`, found `(`
+    X() {} //~ ERROR missing `fn` for function definition
 }
 trait B {
     fn xxx() { ### } //~ ERROR expected

tests/ui/did_you_mean/issue-40006.stderr

@@ -11,26 +11,36 @@ LL | }
    | unexpected token
    | the item list ends here
 
-error: expected one of `!` or `::`, found `(`
-  --> $DIR/issue-40006.rs:8:6
+error: missing `fn` for function definition
+  --> $DIR/issue-40006.rs:8:5
    |
 LL | trait X {
    |         - while parsing this item list starting here
 LL |     X() {}
-   |      ^ expected one of `!` or `::`
+   |     ^
 ...
 LL | }
    | - the item list ends here
+   |
+help: add `fn` here to parse `X` as a function
+   |
+LL |     fn X() {}
+   |     ++
 
-error: expected one of `!` or `::`, found `(`
-  --> $DIR/issue-40006.rs:16:6
+error: missing `fn` for function definition
+  --> $DIR/issue-40006.rs:16:5
    |
 LL | trait A {
    |         - while parsing this item list starting here
 LL |     X() {}
-   |      ^ expected one of `!` or `::`
+   |     ^
 LL | }
    | - the item list ends here
+   |
+help: add `fn` here to parse `X` as a function
+   |
+LL |     fn X() {}
+   |     ++
 
 error: expected one of `!` or `[`, found `#`
   --> $DIR/issue-40006.rs:19:17
@@ -69,17 +79,17 @@ LL | }
    | - the item list ends here
 
 error: missing `fn` for method definition
-  --> $DIR/issue-40006.rs:32:8
+  --> $DIR/issue-40006.rs:32:9
    |
 LL | impl S {
    |        - while parsing this item list starting here
 LL |     pub hello_method(&self) {
-   |        ^
+   |         ^
 ...
 LL | }
    | - the item list ends here
    |
-help: add `fn` here to parse `hello_method` as a public method
+help: add `fn` here to parse `hello_method` as a method
    |
 LL |     pub fn hello_method(&self) {
    |         ++

tests/ui/mismatched_types/recovered-block.rs

@@ -10,6 +10,6 @@ pub fn foo() -> Foo {
 
     pub Foo { text }
 }
-//~^^ ERROR missing `struct` for struct definition
+//~^^ ERROR missing `enum` for enum definition
 
 fn main() {}

tests/ui/mismatched_types/recovered-block.stderr

@@ -1,13 +1,13 @@
-error: missing `struct` for struct definition
-  --> $DIR/recovered-block.rs:11:8
+error: missing `enum` for enum definition
+  --> $DIR/recovered-block.rs:11:9
    |
 LL |     pub Foo { text }
-   |        ^
+   |         ^
    |
-help: add `struct` here to parse `Foo` as a public struct
+help: add `enum` here to parse `Foo` as an enum
    |
-LL |     pub struct Foo { text }
-   |         ++++++
+LL |     pub enum Foo { text }
+   |         ++++
 
 error: aborting due to 1 previous error
 

tests/ui/parser/extern-no-fn.rs

@@ -1,5 +1,7 @@
 extern "C" {
-    f(); //~ ERROR expected one of `!` or `::`, found `(`
+    f();
+    //~^ ERROR missing `fn` or `struct` for function or struct definition
+    //~| HELP if you meant to call a macro, try
 }
 
 fn main() {

tests/ui/parser/extern-no-fn.stderr

@@ -1,12 +1,18 @@
-error: expected one of `!` or `::`, found `(`
-  --> $DIR/extern-no-fn.rs:2:6
+error: missing `fn` or `struct` for function or struct definition
+  --> $DIR/extern-no-fn.rs:2:5
    |
 LL | extern "C" {
    |            - while parsing this item list starting here
 LL |     f();
-   |      ^ expected one of `!` or `::`
+   |     ^
+...
 LL | }
    | - the item list ends here
+   |
+help: if you meant to call a macro, try
+   |
+LL |     f!();
+   |     ~~
 
 error: aborting due to 1 previous error
 

tests/ui/parser/missing-enum-issue-125446.rs

@@ -0,0 +1,6 @@
+Whoops {
+//~^ ERROR missing `enum` for enum definition
+//~| HELP add `enum` here to parse `Whoops` as an enum
+    OptionA,
+    OptionB,
+}