Address review comments: fix span and add run-rustfix

- Change error span to start from 'const' keyword instead of binop RHS
- Add decl_lo parameter to missing_semi_from_binop() for better spans
- Add run-rustfix directive to test file
- Simplify test to focus on const item recovery cases

Author: chenyukang

compiler/rustc_parse/src/parser/item.rs

@@ -6,9 +6,7 @@ use rustc_ast::ast::*;
 use rustc_ast::token::{self, Delimiter, InvisibleOrigin, MetaVarKind, TokenKind};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
 use rustc_ast::util::case::Case;
-use rustc_ast::{
-    attr, {self as ast},
-};
+use rustc_ast::{self as ast};
 use rustc_ast_pretty::pprust;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, PResult, StashKey, inline_fluent, struct_span_code_err};
@@ -286,7 +284,7 @@ impl<'a> Parser<'a> {
             // CONST ITEM
             self.recover_const_mut(const_span);
             self.recover_missing_kw_before_item()?;
-            let (ident, generics, ty, rhs_kind) = self.parse_const_item(false)?;
+            let (ident, generics, ty, rhs_kind) = self.parse_const_item(false, const_span)?;
             ItemKind::Const(Box::new(ConstItem {
                 defaultness: def_(),
                 ident,
@@ -307,7 +305,7 @@ impl<'a> Parser<'a> {
                 // TYPE CONST (mgca)
                 self.recover_const_mut(const_span);
                 self.recover_missing_kw_before_item()?;
-                let (ident, generics, ty, rhs_kind) = self.parse_const_item(true)?;
+                let (ident, generics, ty, rhs_kind) = self.parse_const_item(true, const_span)?;
                 // Make sure this is only allowed if the feature gate is enabled.
                 // #![feature(mgca_type_const_syntax)]
                 self.psess.gated_spans.gate(sym::mgca_type_const_syntax, lo.to(const_span));
@@ -1545,6 +1543,7 @@ impl<'a> Parser<'a> {
     fn parse_const_item(
         &mut self,
         const_arg: bool,
+        const_span: Span,
     ) -> PResult<'a, (Ident, Generics, Box<Ty>, ConstItemRhsKind)> {
         let ident = self.parse_ident_or_underscore()?;
 
@@ -1636,8 +1635,8 @@ impl<'a> Parser<'a> {
 
         generics.where_clause = where_clause;
 
-        if let Some(recovered_rhs) = self.try_recover_const_missing_semi(&rhs) {
-            return Ok((ident, generics, ty, Some(ConstItemRhs::Body(recovered_rhs))));
+        if let Some(rhs) = self.try_recover_const_missing_semi(&rhs, const_span) {
+            return Ok((ident, generics, ty, ConstItemRhsKind::Body { rhs: Some(rhs) }));
         }
         self.expect_semi()?;
 
@@ -3499,17 +3498,23 @@ impl<'a> Parser<'a> {
     /// (e.g., `foo() \n &bar` was parsed as `foo() & bar`).
     ///
     /// Returns a corrected expression if recovery is successful.
-    fn try_recover_const_missing_semi(&mut self, rhs: &Option<ConstItemRhs>) -> Option<Box<Expr>> {
+    fn try_recover_const_missing_semi(
+        &mut self,
+        rhs: &ConstItemRhsKind,
+        const_span: Span,
+    ) -> Option<Box<Expr>> {
         if self.token == TokenKind::Semi {
             return None;
         }
-        let Some(ConstItemRhs::Body(rhs)) = rhs else {
+        let ConstItemRhsKind::Body { rhs: Some(rhs) } = rhs else {
             return None;
         };
         if !self.in_fn_body || !self.may_recover() || rhs.span.from_expansion() {
             return None;
         }
-        if let Some((span, guar)) = self.missing_semi_from_binop("const", rhs) {
+        if let Some((span, guar)) =
+            self.missing_semi_from_binop("const", rhs, Some(const_span.shrink_to_lo()))
+        {
             self.fn_body_missing_semi_guar = Some(guar);
             Some(self.mk_expr(span, ExprKind::Err(guar)))
         } else {

compiler/rustc_parse/src/parser/mod.rs

@@ -34,9 +34,9 @@ use rustc_ast::tokenstream::{
 use rustc_ast::util::case::Case;
 use rustc_ast::util::classify;
 use rustc_ast::{
-    self as ast, AnonConst, AttrArgs, AttrId, BinOpKind, BlockCheckMode, ByRef, Const,
-    CoroutineKind, DUMMY_NODE_ID, DelimArgs, Expr, ExprKind, Extern, HasAttrs, HasTokens,
-    MgcaDisambiguation, Mutability, Recovered, Safety, StrLit, Visibility, VisibilityKind,
+    self as ast, AnonConst, AttrArgs, AttrId, BinOpKind, ByRef, Const, CoroutineKind,
+    DUMMY_NODE_ID, DelimArgs, Expr, ExprKind, Extern, HasAttrs, HasTokens, MgcaDisambiguation,
+    Mutability, Recovered, Safety, StrLit, Visibility, VisibilityKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::debug_assert_matches;
@@ -235,7 +235,7 @@ pub struct Parser<'a> {
     recovery: Recovery = Recovery::Allowed,
     /// Whether we're parsing a function body.
     in_fn_body: bool = false,
-    /// Whether we have detected a missing semicolon in the function body.
+    /// Whether we have detected a missing semicolon in function body.
     pub fn_body_missing_semi_guar: Option<ErrorGuaranteed> = None,
 }
 
@@ -1648,6 +1648,7 @@ impl<'a> Parser<'a> {
         &self,
         kind_desc: &str,
         expr: &Expr,
+        decl_lo: Option<Span>,
     ) -> Option<(Span, ErrorGuaranteed)> {
         if self.token == TokenKind::Semi {
             return None;
@@ -1668,7 +1669,9 @@ impl<'a> Parser<'a> {
                 .struct_span_err(lhs_end_span, format!("expected `;`, found {token_str}"));
             err.span_label(self.token.span, "unexpected token");
 
-            let continuation_span = lhs_end_span.until(rhs.span.shrink_to_hi());
+            // Use the declaration start if provided, otherwise fall back to lhs_end_span.
+            let continuation_start = decl_lo.unwrap_or(lhs_end_span);
+            let continuation_span = continuation_start.until(rhs.span.shrink_to_hi());
             err.span_label(
                 continuation_span,
                 format!(

compiler/rustc_parse/src/parser/stmt.rs

@@ -929,7 +929,9 @@ impl<'a> Parser<'a> {
             LocalKind::Init(expr) | LocalKind::InitElse(expr, _) => expr,
             LocalKind::Decl => return None,
         };
-        if let Some((span, guar)) = self.missing_semi_from_binop("`let` binding", expr) {
+        if let Some((span, guar)) =
+            self.missing_semi_from_binop("`let` binding", expr, Some(local.span.shrink_to_lo()))
+        {
             self.fn_body_missing_semi_guar = Some(guar);
             *expr = self.mk_expr(span, ExprKind::Err(guar));
             return Some(guar);

tests/ui/parser/const-recover-semi-issue-151149.fixed

@@ -0,0 +1,36 @@
+//@ run-rustfix
+#![feature(const_trait_impl)]
+#![allow(dead_code)]
+#![allow(unused)]
+
+const trait ConstDefault {
+    fn const_default() -> Self;
+}
+
+impl const ConstDefault for u8 {
+    fn const_default() -> Self { 0 }
+}
+
+const fn val() -> u8 {
+    42
+}
+
+const C: u8 = u8::const_default()
+&1; //~ ERROR expected `;`, found keyword `const`
+
+const fn foo() -> &'static u8 {
+    const C: u8 = u8::const_default(); //~ ERROR expected `;`
+    &C
+}
+
+const fn bar() {
+    const C: u8 = 1
+     + 2; //~ ERROR expected `;`, found `}`
+}
+
+const fn baz() {
+    const C: u8 = 1
+     + val(); //~ ERROR expected `;`, found `}`
+}
+
+fn main() {}

tests/ui/parser/const-recover-semi-issue-151149.rs

@@ -1,4 +1,7 @@
+//@ run-rustfix
 #![feature(const_trait_impl)]
+#![allow(dead_code)]
+#![allow(unused)]
 
 const trait ConstDefault {
     fn const_default() -> Self;
@@ -20,19 +23,14 @@ const fn foo() -> &'static u8 {
     &C
 }
 
-const fn bar() -> u8 { //~ ERROR mismatched types
+const fn bar() {
     const C: u8 = 1
      + 2 //~ ERROR expected `;`, found `}`
 }
 
-const fn baz() -> u8 { //~ ERROR mismatched types
+const fn baz() {
     const C: u8 = 1
      + val() //~ ERROR expected `;`, found `}`
 }
 
-fn buzz() -> &'static u8 {
-    let r = 1 //~ ERROR expected `;`
-    &r
-}
-
 fn main() {}

tests/ui/parser/const-recover-semi-issue-151149.stderr

@@ -1,5 +1,5 @@
 error: expected `;`, found keyword `const`
-  --> $DIR/const-recover-semi-issue-151149.rs:16:3
+  --> $DIR/const-recover-semi-issue-151149.rs:19:3
    |
 LL | &1
    |   ^ help: add `;` here
@@ -8,17 +8,17 @@ LL | const fn foo() -> &'static u8 {
    | ----- unexpected token
 
 error: expected `;`, found `}`
-  --> $DIR/const-recover-semi-issue-151149.rs:19:38
+  --> $DIR/const-recover-semi-issue-151149.rs:22:38
    |
 LL |       const C: u8 = u8::const_default()
-   |  ______________________________________^
+   |  _____-                                ^
 LL | |     &C
    | |______- to finish parsing this const, expected this to be followed by a `;`
 LL |   }
    |   - unexpected token
    |
 note: the const was parsed as having a bit-and binary expression
-  --> $DIR/const-recover-semi-issue-151149.rs:19:19
+  --> $DIR/const-recover-semi-issue-151149.rs:22:19
    |
 LL |     const C: u8 = u8::const_default()
    |                   ------------------- parsed as the left-hand expression
@@ -32,61 +32,20 @@ LL |     const C: u8 = u8::const_default();
    |                                      +
 
 error: expected `;`, found `}`
-  --> $DIR/const-recover-semi-issue-151149.rs:25:9
+  --> $DIR/const-recover-semi-issue-151149.rs:28:9
    |
 LL |      + 2
    |         ^ help: add `;` here
 LL | }
    | - unexpected token
 
 error: expected `;`, found `}`
-  --> $DIR/const-recover-semi-issue-151149.rs:30:13
+  --> $DIR/const-recover-semi-issue-151149.rs:33:13
    |
 LL |      + val()
    |             ^ help: add `;` here
 LL | }
    | - unexpected token
 
-error: expected `;`, found `}`
-  --> $DIR/const-recover-semi-issue-151149.rs:34:14
-   |
-LL |       let r = 1
-   |  ______________^
-LL | |     &r
-   | |______- to finish parsing this `let` binding, expected this to be followed by a `;`
-LL |   }
-   |   - unexpected token
-   |
-note: the `let` binding was parsed as having a bit-and binary expression
-  --> $DIR/const-recover-semi-issue-151149.rs:34:13
-   |
-LL |     let r = 1
-   |             - parsed as the left-hand expression
-LL |     &r
-   |     -- parsed as the right-hand expression
-   |     |
-   |     this was parsed as a bit-and
-help: you may have meant to write a `;` to terminate the `let` binding earlier
-   |
-LL |     let r = 1;
-   |              +
-
-error[E0308]: mismatched types
-  --> $DIR/const-recover-semi-issue-151149.rs:23:19
-   |
-LL | const fn bar() -> u8 {
-   |          ---      ^^ expected `u8`, found `()`
-   |          |
-   |          implicitly returns `()` as its body has no tail or `return` expression
-
-error[E0308]: mismatched types
-  --> $DIR/const-recover-semi-issue-151149.rs:28:19
-   |
-LL | const fn baz() -> u8 {
-   |          ---      ^^ expected `u8`, found `()`
-   |          |
-   |          implicitly returns `()` as its body has no tail or `return` expression
-
-error: aborting due to 7 previous errors
+error: aborting due to 4 previous errors
 
-For more information about this error, try `rustc --explain E0308`.