Fix incorrect suggestion for never patterns with bodies or guard

When encountering an unreachable match arm, (correctly) suggest removing the entire arm:

```
error: a never pattern is always unreachable
  --> $DIR/ICE-130779-never-arm-no-oatherwise-block.rs:10:20
   |
LL |         Some(!) if true => {}
   |                            ^^ this will never be executed
   |
help: remove the unreachable match arm
   |
LL -         Some(!) if true => {}
LL +         Some(!),
   |
```

Noticed in rust-lang#137343 (comment).

Author: estebank

compiler/rustc_ast_lowering/messages.ftl

@@ -133,11 +133,11 @@ ast_lowering_misplaced_relax_trait_bound =
 ast_lowering_never_pattern_with_body =
     a never pattern is always unreachable
     .label = this will never be executed
-    .suggestion = remove this expression
+    .suggestion = remove the match arm expression
 
 ast_lowering_never_pattern_with_guard =
     a guard on a never pattern will never be run
-    .suggestion = remove this guard
+    .suggestion = remove the match arm guard
 
 ast_lowering_no_precise_captures_on_apit = `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
 

compiler/rustc_ast_lowering/src/errors.rs

@@ -335,7 +335,7 @@ pub(crate) struct MisplacedRelaxTraitBound {
 pub(crate) struct MatchArmWithNoBody {
     #[primary_span]
     pub span: Span,
-    #[suggestion(code = " => todo!(),", applicability = "has-placeholders")]
+    #[suggestion(code = " => todo!(),", applicability = "has-placeholders", style = "verbose")]
     pub suggestion: Span,
 }
 
@@ -344,16 +344,18 @@ pub(crate) struct MatchArmWithNoBody {
 pub(crate) struct NeverPatternWithBody {
     #[primary_span]
     #[label]
-    #[suggestion(code = "", applicability = "maybe-incorrect")]
     pub span: Span,
+    #[suggestion(code = ",", applicability = "maybe-incorrect", style = "verbose")]
+    pub removal_span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_never_pattern_with_guard)]
 pub(crate) struct NeverPatternWithGuard {
     #[primary_span]
-    #[suggestion(code = "", applicability = "maybe-incorrect")]
     pub span: Span,
+    #[suggestion(code = ",", applicability = "maybe-incorrect", style = "verbose")]
+    pub removal_span: Span,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_ast_lowering/src/expr.rs

@@ -685,9 +685,33 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self.dcx().emit_err(MatchArmWithNoBody { span, suggestion });
                 }
             } else if let Some(body) = &arm.body {
-                self.dcx().emit_err(NeverPatternWithBody { span: body.span });
+                self.dcx().emit_err(NeverPatternWithBody {
+                    span: body.span,
+                    removal_span: if pat.span.eq_ctxt(arm.span) {
+                        // - ! => {}
+                        // + !,
+                        // FIXME: account for `(!|!)`, as pat.span ends *within* the parentheses.
+                        pat.span.shrink_to_hi().with_hi(arm.span.hi())
+                    } else {
+                        // Subtly incorrect, but close enough if macros are involved.
+                        // - ! => {}
+                        // + ! => ,
+                        body.span
+                    },
+                });
             } else if let Some(g) = &arm.guard {
-                self.dcx().emit_err(NeverPatternWithGuard { span: g.span });
+                self.dcx().emit_err(NeverPatternWithGuard {
+                    span: g.span,
+                    removal_span: if pat.span.eq_ctxt(arm.span) {
+                        // - ! if cond,
+                        // + !,
+                        pat.span.shrink_to_hi().with_hi(arm.span.hi())
+                    } else {
+                        // We have something like `never!() if cond =>`
+                        //                      We just remove ^^^^ which isn't entirely correct.
+                        g.span
+                    },
+                });
             }
 
             // We add a fake `loop {}` arm body so that it typecks to `!`. The mir lowering of never

compiler/rustc_parse/src/parser/expr.rs

@@ -3175,13 +3175,13 @@ impl<'a> Parser<'a> {
                     arm_body = Some(expr);
                     // Eat a comma if it exists, though.
                     let _ = this.eat(exp!(Comma));
-                    comma = Some(this.prev_token.span);
                     Ok(Recovered::No)
                 } else if let Some((span, guar)) =
                     this.parse_arm_body_missing_braces(&expr, arrow_span)
                 {
                     let body = this.mk_expr_err(span, guar);
                     arm_body = Some(body);
+                    let _ = this.eat(exp!(Comma));
                     Ok(Recovered::Yes(guar))
                 } else {
                     let expr_span = expr.span;
@@ -3222,6 +3222,9 @@ impl<'a> Parser<'a> {
                     })
                 }
             };
+            if let TokenKind::Comma = this.prev_token.kind {
+                comma = Some(this.prev_token.span);
+            }
 
             let hi_span =
                 comma.unwrap_or(arm_body.as_ref().map_or(span_before_body, |body| body.span));

tests/ui/attributes/collapse-debuginfo-invalid.stderr

@@ -76,7 +76,7 @@ LL |         #[collapse_debuginfo(yes)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL |         _ => (),
-   |         ------- not a macro definition
+   |         -------- not a macro definition
 
 error: `collapse_debuginfo` attribute should be applied to macro definitions
   --> $DIR/collapse-debuginfo-invalid.rs:40:1

tests/ui/closures/2229_closure_analysis/match/issue-88331.stderr

@@ -13,7 +13,7 @@ LL | pub struct Opcode(pub u8);
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         Opcode::OP1 => unimplemented!(),
-LL ~         Opcode(0_u8) | Opcode(2_u8..=u8::MAX) => todo!(),
+LL +         Opcode(0_u8) | Opcode(2_u8..=u8::MAX) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Opcode2(Opcode(0_u8))` and `Opcode2(Opcode(2_u8..=u8::MAX))` not covered
@@ -31,7 +31,7 @@ LL | pub struct Opcode2(Opcode);
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         Opcode2::OP2=> unimplemented!(),
-LL ~         Opcode2(Opcode(0_u8)) | Opcode2(Opcode(2_u8..=u8::MAX)) => todo!(),
+LL +         Opcode2(Opcode(0_u8)) | Opcode2(Opcode(2_u8..=u8::MAX)) => todo!()
    |
 
 error: aborting due to 2 previous errors

tests/ui/coverage-attr/allowed-positions.stderr

@@ -82,7 +82,7 @@ error[E0788]: coverage attribute not allowed here
 LL |         #[coverage(off)]
    |         ^^^^^^^^^^^^^^^^
 LL |         () => (),
-   |         -------- not a function, impl block, or module
+   |         --------- not a function, impl block, or module
    |
    = help: coverage attribute can be applied to a function (with body), impl block, or module
 

tests/ui/feature-gates/feature-gate-never_patterns.stderr

@@ -108,7 +108,13 @@ error: a guard on a never pattern will never be run
   --> $DIR/feature-gate-never_patterns.rs:54:19
    |
 LL |         Err(!) if false,
-   |                   ^^^^^ help: remove this guard
+   |                   ^^^^^
+   |
+help: remove the match arm guard
+   |
+LL -         Err(!) if false,
+LL +         Err(!),
+   |
 
 error: aborting due to 13 previous errors
 

tests/ui/force-inlining/invalid.stderr

@@ -316,7 +316,7 @@ LL |         #[rustc_force_inline]
    |         ^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL |         1 => (),
-   |         ------- not a function definition
+   |         -------- not a function definition
 
 error: attribute should be applied to a function
   --> $DIR/invalid.rs:98:5

tests/ui/pattern/usefulness/issue-15129.stderr

@@ -8,7 +8,7 @@ LL |     match (T::T1(()), V::V2(true)) {
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
    |
 LL ~         (T::T2(()), V::V2(b)) => (),
-LL ~         (T::T1(()), V::V2(_)) | (T::T2(()), V::V1(_)) => todo!(),
+LL +         (T::T1(()), V::V2(_)) | (T::T2(()), V::V1(_)) => todo!()
    |
 
 error: aborting due to 1 previous error