remove mismatched errors when recovered

Author: chenyukang

compiler/rustc_parse/src/parser/item.rs

@@ -2699,9 +2699,17 @@ impl<'a> Parser<'a> {
         } else if self.check(exp!(OpenBrace)) || self.token.is_metavar_block() {
             let prev_in_fn_body = self.in_fn_body;
             self.in_fn_body = true;
-            let res = self
-                .parse_block_common(self.token.span, BlockCheckMode::Default, None)
-                .map(|(attrs, body)| (attrs, Some(body)));
+            let res = self.parse_block_common(self.token.span, BlockCheckMode::Default, None).map(
+                |(attrs, mut body)| {
+                    if let Some(guar) = self.fn_body_missing_semi_guar.take() {
+                        body.stmts.push(self.mk_stmt(
+                            body.span,
+                            StmtKind::Expr(self.mk_expr(body.span, ExprKind::Err(guar))),
+                        ));
+                    }
+                    (attrs, Some(body))
+                },
+            );
             self.in_fn_body = prev_in_fn_body;
             res?
         } else if self.token == token::Eq {
@@ -3478,6 +3486,7 @@ impl<'a> Parser<'a> {
             return None;
         }
         if let Some((span, guar)) = self.missing_semi_from_binop("const", rhs) {
+            self.fn_body_missing_semi_guar = Some(guar);
             Some(self.mk_expr(span, ExprKind::Err(guar)))
         } else {
             None

compiler/rustc_parse/src/parser/mod.rs

@@ -236,6 +236,8 @@ 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.
+    pub fn_body_missing_semi_guar: Option<ErrorGuaranteed> = None,
 }
 
 // This type is used a lot, e.g. it's cloned when matching many declarative macro rules with

compiler/rustc_parse/src/parser/stmt.rs

@@ -930,10 +930,10 @@ impl<'a> Parser<'a> {
             LocalKind::Decl => return None,
         };
         if let Some((span, guar)) = self.missing_semi_from_binop("`let` binding", expr) {
+            self.fn_body_missing_semi_guar = Some(guar);
             *expr = self.mk_expr(span, ExprKind::Err(guar));
             return Some(guar);
         }
-
         None
     }
 

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

@@ -15,7 +15,7 @@ const fn val() -> u8 {
 const C: u8 = u8::const_default()
 &1 //~ ERROR expected `;`, found keyword `const`
 
-const fn foo() -> &'static u8 { //~ ERROR mismatched types
+const fn foo() -> &'static u8 {
     const C: u8 = u8::const_default() //~ ERROR expected `;`
     &C
 }
@@ -30,7 +30,7 @@ const fn baz() -> u8 { //~ ERROR mismatched types
      + val() //~ ERROR expected `;`, found `}`
 }
 
-fn buzz() {
+fn buzz() -> &'static u8 {
     let r = 1 //~ ERROR expected `;`
     &r
 }

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

@@ -71,14 +71,6 @@ 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:18: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:23:19
    |
@@ -95,6 +87,6 @@ LL | const fn baz() -> u8 {
    |          |
    |          implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to 8 previous errors
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0308`.