Recover from let outside function

Author: obeis

compiler/rustc_parse/locales/en-US.ftl

@@ -442,6 +442,10 @@ parse_visibility_not_followed_by_item = visibility `{$vis}` is not followed by a
 parse_visibility_followed_by_let = visibility does not apply to `let` statement
     .suggestion = remove pub
 
+parse_invalid_let_outside_function = `let` is invalid outside of a function
+    .suggestion_static = consider using `static` instead of `let`
+    .suggestion_const = consider using `const` instead of `let`
+
 parse_default_not_followed_by_item = `default` is not followed by an item
     .label = the `default` qualifier
     .note = only `fn`, `const`, `type`, or `impl` items may be prefixed by `default`

compiler/rustc_parse/src/errors.rs

@@ -1411,6 +1411,25 @@ pub(crate) struct VisibilityFollowedByLet {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_invalid_let_outside_function)]
+pub(crate) struct InvalidLetOutsideFunction {
+    #[primary_span]
+    #[suggestion(
+        parse_suggestion_static,
+        style = "verbose",
+        code = "static",
+        applicability = "machine-applicable"
+    )]
+    #[suggestion(
+        parse_suggestion_const,
+        style = "verbose",
+        code = "const",
+        applicability = "machine-applicable"
+    )]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_default_not_followed_by_item)]
 #[note]

compiler/rustc_parse/src/parser/item.rs

@@ -68,16 +68,17 @@ impl<'a> Parser<'a> {
         }
 
         if !self.eat(term) {
-            let token_str = super::token_descr(&self.token);
             if !self.maybe_consume_incorrect_semicolon(&items) {
-                let msg = &format!("expected item, found {token_str}");
-                let mut err = self.struct_span_err(self.token.span, msg);
-                let label = if self.is_kw_followed_by_ident(kw::Let) {
-                    "consider using `const` or `static` instead of `let` for global variables"
-                } else {
-                    "expected item"
-                };
-                err.span_label(self.token.span, label);
+                if self.is_kw_followed_by_ident(kw::Let) {
+                    let err = self
+                        .sess
+                        .create_err(errors::InvalidLetOutsideFunction { span: self.token.span });
+                    return Err(err);
+                }
+                let token_str = super::token_descr(&self.token);
+                let mut err = self
+                    .struct_span_err(self.token.span, &format!("expected item, found {token_str}"));
+                err.span_label(self.token.span, "expected item");
                 return Err(err);
             }
         }