Try to recover from over-parsing in const item with missing semicolon

compiler/rustc_parse/src/errors.rs

@@ -1284,7 +1284,6 @@ pub(crate) struct HelpIdentifierStartsWithNumber {
 pub(crate) struct ExpectedSemi {
     pub span: Span,
     pub token: Token,
-
     pub unexpected_token_label: Option<Span>,
     pub sugg: ExpectedSemiSugg,
 }

compiler/rustc_parse/src/parser/item.rs

@@ -6,6 +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::util::classify;
 use rustc_ast::{
     attr, {self as ast},
 };
@@ -1571,6 +1572,9 @@ 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))));
+        }
         self.expect_semi()?;
 
         Ok((ident, generics, ty, rhs))
@@ -3407,6 +3411,45 @@ impl<'a> Parser<'a> {
             Ok(Some(_))
         )
     }
+
+    /// Try to recover from over-parsing in const item when a semicolon is missing.
+    ///
+    /// This detects cases where we parsed too much because a semicolon was missing
+    /// and the next line started an expression that the parser treated as a continuation
+    /// (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>> {
+        if self.token == TokenKind::Semi {
+            return None;
+        }
+        let Some(ConstItemRhs::Body(rhs)) = rhs else {
+            return None;
+        };
+        if !self.may_recover() || rhs.span.from_expansion() {
+            return None;
+        }
+        let sm = self.psess.source_map();
+        // Check if this is a binary expression that spans multiple lines
+        // and the RHS looks like it could be an independent expression.
+        if let ExprKind::Binary(op, lhs, rhs_inner) = &rhs.kind
+            && sm.is_multiline(lhs.span.shrink_to_hi().until(rhs_inner.span.shrink_to_lo()))
+            && matches!(op.node, BinOpKind::Mul | BinOpKind::BitAnd)
+            && classify::expr_requires_semi_to_be_stmt(rhs_inner)
+        {
+            let lhs_end_span = lhs.span.shrink_to_hi();
+            let guar = self.dcx().emit_err(errors::ExpectedSemi {
+                span: lhs_end_span,
+                token: self.token,
+                unexpected_token_label: Some(self.token.span),
+                sugg: errors::ExpectedSemiSugg::AddSemi(lhs_end_span),
+            });
+
+            Some(self.mk_expr(lhs.span, ExprKind::Err(guar)))
+        } else {
+            None
+        }
+    }
 }
 
 enum IsMacroRulesItem {

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

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

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

@@ -0,0 +1,52 @@
+error: expected `;`, found `}`
+  --> $DIR/const-recover-semi-issue-151149.rs:16:38
+   |
+LL |     const C: u8 = u8::const_default()
+   |                                      ^ help: add `;` here
+LL |     &C
+LL | }
+   | - unexpected token
+
+error: expected `;`, found `}`
+  --> $DIR/const-recover-semi-issue-151149.rs:22:9
+   |
+LL |      + 2
+   |         ^ help: add `;` here
+LL | }
+   | - unexpected token
+
+error: expected `;`, found `}`
+  --> $DIR/const-recover-semi-issue-151149.rs:27:13
+   |
+LL |      + val()
+   |             ^ help: add `;` here
+LL | }
+   | - unexpected token
+
+error[E0308]: mismatched types
+  --> $DIR/const-recover-semi-issue-151149.rs:15:19
+   |
+LL | const fn foo() -> &'static 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:20: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:25:19
+   |
+LL | const fn baz() -> u8 {
+   |          ---      ^^ expected `u8`, found `()`
+   |          |
+   |          implicitly returns `()` as its body has no tail or `return` expression
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0308`.