Fallback removal span when involving macros

```
error: a never pattern is always unreachable
  --> $DIR/pattern-behind-macro.rs:13:21
   |
LL |         never!() => {}
   |                     ^^ this will never be executed
   |
help: remove the match arm expression
   |
LL -         never!() => {}
LL +         never!(),
   |
```

Look up the macro backtrace call sites to see if we find where the macro was used as a pattern, to properly suggest removing match arm guard and body.

Author: estebank

compiler/rustc_ast_lowering/src/expr.rs

@@ -676,6 +676,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
         {
             self.lower_expr(body)
         } else {
+            let removal_span = |mut removal_span: Span| {
+                for data in pat.span.macro_backtrace() {
+                    // Seek upwards in the macro call sites to see if we find the place where
+                    // `pat!()` was called so that we can get the right span to remove.
+                    if arm.span.eq_ctxt(data.call_site) {
+                        // - pat!() => {}
+                        // + pat!(),
+                        removal_span = data.call_site.shrink_to_hi().with_hi(arm.span.hi())
+                    }
+                }
+                if arm.span.eq_ctxt(pat.span) {
+                    // - ! => {}
+                    // + !,
+                    removal_span = pat.span.shrink_to_hi().with_hi(arm.span.hi())
+                }
+                removal_span
+            };
             // Either `body.is_none()` or `is_never_pattern` here.
             if !is_never_pattern {
                 if self.tcx.features().never_patterns() {
@@ -686,29 +703,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
             } else if let Some(body) = &arm.body {
                 self.dcx().emit_err(NeverPatternWithBody {
                     span: body.span,
-                    removal_span: if pat.span.eq_ctxt(arm.span) {
-                        // - ! => {}
-                        // + !,
-                        pat.span.shrink_to_hi().with_hi(arm.span.hi())
-                    } else {
-                        // Subtly incorrect, but close enough if macros are involved.
-                        // - ! => {}
-                        // + ! => ,
-                        body.span
-                    },
+                    removal_span: removal_span(body.span),
                 });
             } else if let Some(g) = &arm.guard {
                 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
-                    },
+                    removal_span: removal_span(g.span),
                 });
             }
 

tests/ui/rfcs/rfc-0000-never_patterns/parse.stderr

@@ -76,7 +76,7 @@ LL |         never!() if true,
 help: remove the match arm guard
    |
 LL -         never!() if true,
-LL +         never!() if ,,
+LL +         never!(),
    |
 
 error: aborting due to 8 previous errors

tests/ui/rfcs/rfc-0000-never_patterns/pattern-behind-macro.rs

@@ -0,0 +1,16 @@
+#![feature(never_patterns, never_type)]
+#![allow(incomplete_features)]
+
+enum Void {}
+fn main() {}
+
+macro_rules! never {
+    () => { ! }
+}
+
+fn no_arms_or_guards(x: Void) {
+    match x {
+        never!() => {}
+        //~^ ERROR a never pattern is always unreachable
+    }
+}

tests/ui/rfcs/rfc-0000-never_patterns/pattern-behind-macro.stderr

@@ -0,0 +1,14 @@
+error: a never pattern is always unreachable
+  --> $DIR/pattern-behind-macro.rs:13:21
+   |
+LL |         never!() => {}
+   |                     ^^ this will never be executed
+   |
+help: remove the match arm expression
+   |
+LL -         never!() => {}
+LL +         never!(),
+   |
+
+error: aborting due to 1 previous error
+