Add ParsedDescription to the attribute parsers

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -19,6 +19,7 @@ use crate::context::{AcceptContext, ShouldEmit, Stage};
 use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser};
 use crate::session_diagnostics::{
     AttributeParseError, AttributeParseErrorReason, CfgAttrBadDelim, MetaBadDelimSugg,
+    ParsedDescription,
 };
 use crate::{
     AttributeParser, CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics,
@@ -352,7 +353,8 @@ pub fn parse_cfg_attr(
                 span,
                 attr_span: cfg_attr.span,
                 template: CFG_ATTR_TEMPLATE,
-                attribute: AttrPath::from_ast(&cfg_attr.get_normal_item().path),
+                path: AttrPath::from_ast(&cfg_attr.get_normal_item().path),
+                description: ParsedDescription::Attribute,
                 reason,
                 suggestions: CFG_ATTR_TEMPLATE.suggestions(Some(cfg_attr.style), sym::cfg_attr),
             });
@@ -395,6 +397,7 @@ fn parse_cfg_attr_internal<'a>(
                 .into_boxed_slice(),
             span: attribute.span,
         },
+        ParsedDescription::Attribute,
         pred_span,
         CRATE_NODE_ID,
         features,

compiler/rustc_attr_parsing/src/context.rs

@@ -70,7 +70,9 @@ use crate::attributes::traits::{
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
 use crate::parser::{ArgParser, PathParser};
-use crate::session_diagnostics::{AttributeParseError, AttributeParseErrorReason, UnknownMetaItem};
+use crate::session_diagnostics::{
+    AttributeParseError, AttributeParseErrorReason, ParsedDescription, UnknownMetaItem,
+};
 use crate::target_checking::AllowedTargets;
 
 type GroupType<S> = LazyLock<GroupTypeInner<S>>;
@@ -351,6 +353,10 @@ pub struct AcceptContext<'f, 'sess, S: Stage> {
     /// Whether it is an inner or outer attribute
     pub(crate) attr_style: AttrStyle,
 
+    /// A description of the thing we are parsing using this attribute parser
+    /// We are not only using these parsers for attributes, but also for macros such as the `cfg!()` macro.
+    pub(crate) parsed_description: ParsedDescription,
+
     /// The expected structure of the attribute.
     ///
     /// Used in reporting errors to give a hint to users what the attribute *should* look like.
@@ -429,7 +435,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedStringLiteral {
                 byte_string: actual_literal.and_then(|i| {
                     i.kind.is_bytestr().then(|| self.sess().source_map().start_point(i.span))
@@ -444,7 +451,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedIntegerLiteral,
             suggestions: self.suggestions(),
         })
@@ -455,7 +463,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedList,
             suggestions: self.suggestions(),
         })
@@ -466,7 +475,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span: args_span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedNoArgs,
             suggestions: self.suggestions(),
         })
@@ -478,7 +488,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedIdentifier,
             suggestions: self.suggestions(),
         })
@@ -491,7 +502,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedNameValue(name),
             suggestions: self.suggestions(),
         })
@@ -503,7 +515,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::DuplicateKey(key),
             suggestions: self.suggestions(),
         })
@@ -516,7 +529,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::UnexpectedLiteral,
             suggestions: self.suggestions(),
         })
@@ -527,7 +541,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedSingleArgument,
             suggestions: self.suggestions(),
         })
@@ -538,7 +553,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedAtLeastOneArgument,
             suggestions: self.suggestions(),
         })
@@ -554,7 +570,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedSpecificArgument {
                 possibilities,
                 strings: false,
@@ -575,7 +592,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedSpecificArgument {
                 possibilities,
                 strings: false,
@@ -595,7 +613,8 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             span,
             attr_span: self.attr_span,
             template: self.template.clone(),
-            attribute: self.attr_path.clone(),
+            path: self.attr_path.clone(),
+            description: self.parsed_description,
             reason: AttributeParseErrorReason::ExpectedSpecificArgument {
                 possibilities,
                 strings: true,

compiler/rustc_attr_parsing/src/interface.rs

@@ -12,6 +12,7 @@ use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 
 use crate::context::{AcceptContext, FinalizeContext, SharedContext, Stage};
 use crate::parser::{ArgParser, MetaItemParser, PathParser};
+use crate::session_diagnostics::ParsedDescription;
 use crate::{Early, Late, OmitDoc, ShouldEmit};
 
 /// Context created once, for example as part of the ast lowering
@@ -145,6 +146,7 @@ impl<'sess> AttributeParser<'sess, Early> {
             normal_attr.item.span(),
             attr.style,
             path.get_attribute_path(),
+            ParsedDescription::Attribute,
             target_span,
             target_node_id,
             features,
@@ -163,6 +165,7 @@ impl<'sess> AttributeParser<'sess, Early> {
         inner_span: Span,
         attr_style: AttrStyle,
         attr_path: AttrPath,
+        parsed_description: ParsedDescription,
         target_span: Span,
         target_node_id: NodeId,
         features: Option<&'sess Features>,
@@ -190,6 +193,7 @@ impl<'sess> AttributeParser<'sess, Early> {
             attr_span,
             inner_span,
             attr_style,
+            parsed_description,
             template,
             attr_path,
         };
@@ -310,6 +314,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                 attr_span: lower_span(attr.span),
                                 inner_span: lower_span(attr.get_normal_item().span()),
                                 attr_style: attr.style,
+                                parsed_description: ParsedDescription::Attribute,
                                 template: &accept.template,
                                 attr_path: path.get_attribute_path(),
                             };

compiler/rustc_attr_parsing/src/lib.rs

@@ -113,5 +113,6 @@ pub use attributes::util::{is_builtin_attr, is_doc_alias_attrs_contain_symbol, p
 pub use context::{Early, Late, OmitDoc, ShouldEmit};
 pub use interface::AttributeParser;
 pub use lints::emit_attribute_lint;
+pub use session_diagnostics::ParsedDescription;
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -610,20 +610,33 @@ pub(crate) enum AttributeParseErrorReason<'a> {
     ExpectedIdentifier,
 }
 
+/// A description of a thing that can be parsed using an attribute parser.
+#[derive(Copy, Clone)]
+pub enum ParsedDescription {
+    Attribute,
+    Macro,
+}
+
 pub(crate) struct AttributeParseError<'a> {
     pub(crate) span: Span,
     pub(crate) attr_span: Span,
     pub(crate) template: AttributeTemplate,
-    pub(crate) attribute: AttrPath,
+    pub(crate) path: AttrPath,
+    pub(crate) description: ParsedDescription,
     pub(crate) reason: AttributeParseErrorReason<'a>,
     pub(crate) suggestions: Vec<String>,
 }
 
 impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
-        let name = self.attribute.to_string();
+        let name = self.path.to_string();
+
+        let description = match self.description {
+            ParsedDescription::Attribute => "attribute",
+            ParsedDescription::Macro => "macro",
+        };
 
-        let mut diag = Diag::new(dcx, level, format!("malformed `{name}` attribute input"));
+        let mut diag = Diag::new(dcx, level, format!("malformed `{name}` {description} input"));
         diag.span(self.attr_span);
         diag.code(E0539);
         match self.reason {
@@ -724,12 +737,12 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
                         diag.span_label(
                             self.span,
                             format!(
-                                "this attribute is only valid with {quote}{x}{quote} as an argument"
+                                "this {description} is only valid with {quote}{x}{quote} as an argument"
                             ),
                         );
                     }
                     [first, second] => {
-                        diag.span_label(self.span, format!("this attribute is only valid with either {quote}{first}{quote} or {quote}{second}{quote} as an argument"));
+                        diag.span_label(self.span, format!("this {description} is only valid with either {quote}{first}{quote} or {quote}{second}{quote} as an argument"));
                     }
                     [first @ .., second_to_last, last] => {
                         let mut res = String::new();
@@ -740,7 +753,7 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
                             "{quote}{second_to_last}{quote} or {quote}{last}{quote}"
                         ));
 
-                        diag.span_label(self.span, format!("this attribute is only valid with one of the following arguments: {res}"));
+                        diag.span_label(self.span, format!("this {description} is only valid with one of the following arguments: {res}"));
                     }
                 }
             }
@@ -756,9 +769,9 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
         diag.span_suggestions(
             self.attr_span,
             if self.suggestions.len() == 1 {
-                "must be of the form"
+                "must be of the form".to_string()
             } else {
-                "try changing it to one of the following valid forms of the attribute"
+                format!("try changing it to one of the following valid forms of the {description}")
             },
             self.suggestions,
             Applicability::HasPlaceholders,

compiler/rustc_builtin_macros/src/cfg.rs

@@ -6,7 +6,9 @@ use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{AttrStyle, CRATE_NODE_ID, token};
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::parser::MetaItemOrLitParser;
-use rustc_attr_parsing::{AttributeParser, CFG_TEMPLATE, ShouldEmit, parse_cfg_entry};
+use rustc_attr_parsing::{
+    AttributeParser, CFG_TEMPLATE, ParsedDescription, ShouldEmit, parse_cfg_entry,
+};
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
 use rustc_hir::AttrPath;
 use rustc_hir::attrs::CfgEntry;
@@ -53,6 +55,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
         span,
         AttrStyle::Inner,
         AttrPath { segments: vec![Ident::from_str("cfg")].into_boxed_slice(), span },
+        ParsedDescription::Macro,
         span,
         CRATE_NODE_ID,
         Some(cx.ecfg.features),

tests/ui/macros/cfg.rs

@@ -1,6 +1,6 @@
 fn main() {
     cfg!(); //~ ERROR macro requires a cfg-pattern
-    cfg!(123); //~ ERROR malformed `cfg` attribute input
-    cfg!(foo = 123); //~ ERROR malformed `cfg` attribute input
+    cfg!(123); //~ ERROR malformed `cfg` macro input
+    cfg!(foo = 123); //~ ERROR malformed `cfg` macro input
     cfg!(foo, bar); //~ ERROR expected 1 cfg-pattern
 }

tests/ui/macros/cfg.stderr

@@ -4,7 +4,7 @@ error: macro requires a cfg-pattern as an argument
 LL |     cfg!();
    |     ^^^^^^ cfg-pattern required
 
-error[E0539]: malformed `cfg` attribute input
+error[E0539]: malformed `cfg` macro input
   --> $DIR/cfg.rs:3:5
    |
 LL |     cfg!(123);
@@ -15,7 +15,7 @@ LL |     cfg!(123);
    |
    = note: for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute>
 
-error[E0539]: malformed `cfg` attribute input
+error[E0539]: malformed `cfg` macro input
   --> $DIR/cfg.rs:4:5
    |
 LL |     cfg!(foo = 123);

tests/ui/span/E0805.stderr

@@ -1,4 +1,4 @@
-error[E0805]: malformed `cfg` attribute input
+error[E0805]: malformed `cfg` macro input
   --> $DIR/E0805.rs:2:8
    |
 LL |     if cfg!(not()) { }