Put some notes in a separate note block

Author: Sasha Pourcelot

compiler/rustc_parse/src/parser/expr.rs

@@ -1736,9 +1736,6 @@ impl<'a> Parser<'a> {
             self.sess.gated_spans.gate(sym::async_closure, span);
         }
 
-        // Disable recovery for closure body
-        self.last_closure_body = Some(decl_hi);
-
         if self.token.kind == TokenKind::Semi && self.token_cursor.frame.delim == DelimToken::Paren
         {
             // It is likely that the closure body is a block but where the
@@ -1747,11 +1744,18 @@ impl<'a> Parser<'a> {
             body = self.mk_expr_err(body.span);
         }
 
-        Ok(self.mk_expr(
+        let body_span = body.span;
+
+        let clo = self.mk_expr(
             lo.to(body.span),
             ExprKind::Closure(capture_clause, asyncness, movability, decl, body, lo.to(decl_hi)),
             attrs,
-        ))
+        );
+
+        // Disable recovery for closure body
+        self.last_closure_body = Some((clo.span, decl_hi, body_span));
+
+        Ok(clo)
     }
 
     /// Parses an optional `move` prefix to a closure-like construct.

compiler/rustc_parse/src/parser/mod.rs

@@ -35,6 +35,7 @@ use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, FatalError
 use rustc_session::parse::ParseSess;
 use rustc_span::source_map::{Span, DUMMY_SP};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
+use rustc_span::MultiSpan;
 use tracing::debug;
 
 use std::ops::Range;
@@ -145,7 +146,11 @@ pub struct Parser<'a> {
 
     /// This allows us to recover when the user forget to add braces around
     /// multiple statements in the closure body.
-    pub last_closure_body: Option<Span /* The closing `|` of the closure declarator. */>,
+    pub last_closure_body: Option<(
+        Span, /* The whole body. */
+        Span, /* The closing `|` of the closure declarator. */
+        Span, /* What we parsed as closure body. */
+    )>,
 }
 
 /// Indicates a range of tokens that should be replaced by
@@ -779,15 +784,19 @@ impl<'a> Parser<'a> {
                             let token_str = pprust::token_kind_to_string(t);
 
                             match self.last_closure_body.take() {
-                                Some(right_pipe_span) if self.token.kind == TokenKind::Semi => {
+                                Some((closure_span, right_pipe_span, expr_span))
+                                    if self.token.kind == TokenKind::Semi =>
+                                {
                                     // Finding a semicolon instead of a comma
                                     // after a closure body indicates that the
                                     // closure body may be a block but the user
                                     // forgot to put braces around its
                                     // statements.
 
                                     self.recover_missing_braces_around_closure_body(
+                                        closure_span,
                                         right_pipe_span,
+                                        expr_span,
                                         expect_err,
                                     )?;
 
@@ -868,16 +877,13 @@ impl<'a> Parser<'a> {
 
     fn recover_missing_braces_around_closure_body(
         &mut self,
+        closure_span: Span,
         right_pipe_span: Span,
+        expr_span: Span,
         mut expect_err: DiagnosticBuilder<'_>,
     ) -> PResult<'a, ()> {
         let initial_semicolon = self.token.span;
 
-        expect_err.span_help(
-            initial_semicolon,
-            "This `;` turns the expression into a statement, which must be placed in a block",
-        );
-
         while self.eat(&TokenKind::Semi) {
             let _ = self.parse_stmt(ForceCollect::Yes)?;
         }
@@ -889,6 +895,25 @@ impl<'a> Parser<'a> {
         let preceding_pipe_span = right_pipe_span;
         let following_token_span = self.token.span;
 
+        let mut first_note = MultiSpan::from(vec![initial_semicolon]);
+        first_note.push_span_label(
+            initial_semicolon,
+            "this `;` turns the preceding expression into a statement".to_string(),
+        );
+        first_note.push_span_label(
+            expr_span,
+            "this expression is a statement because of the trailing semicolon".to_string(),
+        );
+        expect_err.span_note(first_note, "statement found outside of a block");
+
+        let mut second_note = MultiSpan::from(vec![closure_span]);
+        second_note.push_span_label(closure_span, "this is the parsed closure...".to_string());
+        second_note.push_span_label(
+            following_token_span,
+            "...but likely you meant the closure to end here".to_string(),
+        );
+        expect_err.span_note(second_note, "the closure body may be incorrectly delimited");
+
         expect_err.set_span(vec![preceding_pipe_span, following_token_span]);
 
         let opening_suggestion_str = " {".to_string();

src/test/ui/expr/malformed_closure/missing_braces_around_block.stderr

@@ -7,11 +7,24 @@ LL |     (1..num).reduce(|a, b|
 LL |     ).unwrap();
    |     ^
    |
-help: This `;` turns the expression into a statement, which must be placed in a block
+note: statement found outside of a block
   --> $DIR/missing_braces_around_block.rs:16:26
    |
 LL |         println!("{}", a);
-   |                          ^
+   |         -----------------^ this `;` turns the preceding expression into a statement
+   |         |
+   |         this expression is a statement because of the trailing semicolon
+note: the closure body may be incorrectly delimited
+  --> $DIR/missing_braces_around_block.rs:14:21
+   |
+LL |       (1..num).reduce(|a, b|
+   |  _____________________^
+LL | |
+LL | |         println!("{}", a);
+   | |_________________________^ this is the parsed closure...
+LL |           a * b
+LL |       ).unwrap();
+   |       - ...but likely you meant the closure to end here
 help: try adding braces
    |
 LL ~     (1..num).reduce(|a, b| {