mbe: Report attr rules using a MultiSpan

This avoids emitting a single span that includes both the argument
matcher and body matcher.

Author: joshtriplett

Cargo.lock

@@ -3714,6 +3714,7 @@ dependencies = [
  "rustc_attr_data_structures",
  "rustc_attr_parsing",
  "rustc_data_structures",
+ "rustc_error_messages",
  "rustc_errors",
  "rustc_feature",
  "rustc_fluent_macro",

compiler/rustc_expand/Cargo.toml

@@ -15,6 +15,7 @@ rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }
 rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_data_structures = { path = "../rustc_data_structures" }
+rustc_error_messages = { path = "../rustc_error_messages" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -12,6 +12,7 @@ use rustc_ast::{self as ast, DUMMY_NODE_ID, NodeId};
 use rustc_ast_pretty::pprust;
 use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
+use rustc_error_messages::MultiSpan;
 use rustc_errors::{Applicability, Diag, ErrorGuaranteed};
 use rustc_feature::Features;
 use rustc_hir as hir;
@@ -129,7 +130,13 @@ pub(super) enum MacroRule {
     /// A function-style rule, for use with `m!()`
     Func { lhs: Vec<MatcherLoc>, lhs_span: Span, rhs: mbe::TokenTree },
     /// An attr rule, for use with `#[m]`
-    Attr { args: Vec<MatcherLoc>, body: Vec<MatcherLoc>, lhs_span: Span, rhs: mbe::TokenTree },
+    Attr {
+        args: Vec<MatcherLoc>,
+        args_span: Span,
+        body: Vec<MatcherLoc>,
+        body_span: Span,
+        rhs: mbe::TokenTree,
+    },
 }
 
 pub struct MacroRulesMacroExpander {
@@ -141,11 +148,15 @@ pub struct MacroRulesMacroExpander {
 }
 
 impl MacroRulesMacroExpander {
-    pub fn get_unused_rule(&self, rule_i: usize) -> Option<(&Ident, Span)> {
+    pub fn get_unused_rule(&self, rule_i: usize) -> Option<(&Ident, MultiSpan)> {
         // If the rhs contains an invocation like `compile_error!`, don't report it as unused.
-        let (MacroRule::Func { lhs_span, ref rhs, .. } | MacroRule::Attr { lhs_span, ref rhs, .. }) =
-            self.rules[rule_i];
-        if has_compile_error_macro(rhs) { None } else { Some((&self.name, lhs_span)) }
+        let (span, rhs) = match self.rules[rule_i] {
+            MacroRule::Func { lhs_span, ref rhs, .. } => (MultiSpan::from_span(lhs_span), rhs),
+            MacroRule::Attr { args_span, body_span, ref rhs, .. } => {
+                (MultiSpan::from_spans(vec![args_span, body_span]), rhs)
+            }
+        };
+        if has_compile_error_macro(rhs) { None } else { Some((&self.name, span)) }
     }
 }
 
@@ -594,12 +605,13 @@ pub fn compile_declarative_macro(
             return dummy_syn_ext(guar.unwrap());
         };
         if let Some(args) = args {
-            let lhs_span = args.span().to(lhs_span);
+            let args_span = args.span();
             let mbe::TokenTree::Delimited(.., delimited) = args else {
                 return dummy_syn_ext(guar.unwrap());
             };
             let args = mbe::macro_parser::compute_locs(&delimited.tts);
-            rules.push(MacroRule::Attr { args, body: lhs, lhs_span, rhs: rhs_tt });
+            let body_span = lhs_span;
+            rules.push(MacroRule::Attr { args, args_span, body: lhs, body_span, rhs: rhs_tt });
         } else {
             rules.push(MacroRule::Func { lhs, lhs_span, rhs: rhs_tt });
         }

tests/ui/macros/macro-rules-attr.stderr

@@ -2,7 +2,7 @@ warning: rule #3 of macro `local_attr` is never used
   --> $DIR/macro-rules-attr.rs:43:9
    |
 LL |     attr() {} => {
-   |         ^^^^^
+   |         ^^ ^^
    |
 note: the lint level is defined here
   --> $DIR/macro-rules-attr.rs:4:9