Port #[cfg_attr] to the new attribute parsing infrastructure

JonathanBrouwer · JonathanBrouwer · commit e9bdfb0a9af1 · 2025-10-10T10:44:18.000+02:00
Signed-off-by: Jonathan Brouwer &lt;jonathantbrouwer@gmail.com&gt;
diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
@@ -4,6 +4,8 @@ attr_parsing_as_needed_compatibility =
 attr_parsing_bundle_needs_static =
     linking modifier `bundle` is only compatible with `static` linking kind
 
+attr_parsing_cfg_attr_bad_delim = wrong `cfg_attr` delimiters
+
 attr_parsing_cfg_predicate_identifier =
     `cfg` predicate key must be an identifier
 
@@ -150,6 +152,9 @@ attr_parsing_link_requires_name =
     `#[link]` attribute requires a `name = "string"` argument
     .label = missing `name` argument
 
+attr_parsing_malformed_cfg_attr = malformed `cfg_attr` attribute input
+    .suggestion = missing condition and attribute
+    .note = for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
 attr_parsing_meta_bad_delim = wrong meta list delimiters
 attr_parsing_meta_bad_delim_suggestion = the delimiters should be `(` and `)`
 
@@ -264,13 +269,3 @@ attr_parsing_unused_multiple =
 
 attr_parsing_whole_archive_needs_static =
     linking modifier `whole-archive` is only compatible with `static` linking kind
-
-attr_parsing_limit_invalid =
-    `limit` must be a non-negative integer
-    .label = {$error_str}
-
-attr_parsing_cfg_attr_bad_delim = wrong `cfg_attr` delimiters
-
-attr_parsing_malformed_cfg_attr = malformed `cfg_attr` attribute input
-    .suggestion = missing condition and attribute
-    .note = for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -1,10 +1,10 @@
 use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
-use rustc_ast::{AttrItem, Attribute, LitKind, MetaItemInner, NodeId, ast, token};
+use rustc_ast::{AttrItem, Attribute, CRATE_NODE_ID, LitKind, NodeId, ast, token};
 use rustc_errors::PResult;
 use rustc_feature::{AttributeTemplate, Features, template};
-use rustc_hir::RustcVersion;
 use rustc_hir::attrs::CfgEntry;
+use rustc_hir::{AttrPath, RustcVersion};
 use rustc_parse::parser::{ForceCollect, Parser};
 use rustc_parse::{exp, parse_in};
 use rustc_session::Session;
@@ -19,14 +19,20 @@ use crate::context::{AcceptContext, ShouldEmit, Stage};
 use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser};
 use crate::session_diagnostics::{CfgAttrBadDelim, MalformedCfgAttr, MetaBadDelimSugg};
 use crate::{
-    CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics, try_gate_cfg,
+    AttributeParser, CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics,
+    try_gate_cfg,
 };
 
 pub const CFG_TEMPLATE: AttributeTemplate = template!(
     List: &["predicate"],
     "https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg-attribute"
 );
 
+const CFG_ATTR_TEMPLATE: AttributeTemplate = template!(
+    List: &["predicate, attr1, attr2, ..."],
+    "https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute"
+);
+
 pub fn parse_cfg<'c, S: Stage>(
     cx: &'c mut AcceptContext<'_, '_, S>,
     args: &'c ArgParser<'_>,
@@ -309,8 +315,9 @@ impl EvalConfigResult {
 
 pub fn parse_cfg_attr(
     cfg_attr: &Attribute,
-    psess: &ParseSess,
-) -> Option<(MetaItemInner, Vec<(AttrItem, Span)>)> {
+    sess: &Session,
+    features: Option<&Features>,
+) -> Option<(CfgEntry, Vec<(AttrItem, Span)>)> {
     const CFG_ATTR_GRAMMAR_HELP: &str = "#[cfg_attr(condition, attribute, other_attribute, ...)]";
     const CFG_ATTR_NOTE_REF: &str = "for more information, visit \
         <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>";
@@ -319,9 +326,9 @@ pub fn parse_cfg_attr(
         ast::AttrArgs::Delimited(ast::DelimArgs { dspan, delim, ref tokens })
             if !tokens.is_empty() =>
         {
-            check_cfg_attr_bad_delim(psess, dspan, delim);
-            match parse_in(psess, tokens.clone(), "`cfg_attr` input", |p| {
-                parse_cfg_attr_internal(p)
+            check_cfg_attr_bad_delim(&sess.psess, dspan, delim);
+            match parse_in(&sess.psess, tokens.clone(), "`cfg_attr` input", |p| {
+                parse_cfg_attr_internal(p, sess, features, cfg_attr)
             }) {
                 Ok(r) => return Some(r),
                 Err(e) => {
@@ -332,8 +339,7 @@ pub fn parse_cfg_attr(
             }
         }
         _ => {
-            psess
-                .dcx()
+            sess.dcx()
                 .emit_err(MalformedCfgAttr { span: cfg_attr.span, sugg: CFG_ATTR_GRAMMAR_HELP });
         }
     }
@@ -353,8 +359,42 @@ fn check_cfg_attr_bad_delim(psess: &ParseSess, span: DelimSpan, delim: Delimiter
 /// Parses `cfg_attr(pred, attr_item_list)` where `attr_item_list` is comma-delimited.
 fn parse_cfg_attr_internal<'a>(
     parser: &mut Parser<'a>,
-) -> PResult<'a, (ast::MetaItemInner, Vec<(ast::AttrItem, Span)>)> {
-    let cfg_predicate = parser.parse_meta_item_inner()?;
+    sess: &'a Session,
+    features: Option<&Features>,
+    attribute: &Attribute,
+) -> PResult<'a, (CfgEntry, Vec<(ast::AttrItem, Span)>)> {
+    // Parse cfg predicate
+    let pred_start = parser.token.span;
+    let meta = MetaItemOrLitParser::parse_single(parser, ShouldEmit::ErrorsAndLints)?;
+    let pred_span = pred_start.with_hi(parser.token.span.hi());
+
+    let cfg_predicate = AttributeParser::parse_single_sub(
+        sess,
+        attribute.span,
+        attribute.style,
+        AttrPath {
+            segments: attribute
+                .ident_path()
+                .expect("cfg_attr is not a doc comment")
+                .into_boxed_slice(),
+            span: attribute.span,
+        },
+        pred_span,
+        CRATE_NODE_ID,
+        features,
+        ShouldEmit::ErrorsAndLints,
+        &meta,
+        parse_cfg_entry,
+        &CFG_ATTR_TEMPLATE,
+    )
+    .ok_or_else(|| {
+        let mut diag = sess.dcx().struct_err(
+            "cfg_entry parsing failing with `ShouldEmit::ErrorsAndLints` should emit a error.",
+        );
+        diag.downgrade_to_delayed_bug();
+        diag
+    })?;
+
     parser.expect(exp!(Comma))?;
 
     // Presumably, the majority of the time there will only be one attr.
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use rustc_ast as ast;
-use rustc_ast::NodeId;
+use rustc_ast::{AttrStyle, NodeId};
 use rustc_errors::DiagCtxtHandle;
 use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::attrs::AttributeKind;
@@ -121,13 +121,6 @@ impl<'sess> AttributeParser<'sess, Early> {
         parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser<'_>) -> Option<T>,
         template: &AttributeTemplate,
     ) -> Option<T> {
-        let mut parser = Self {
-            features,
-            tools: Vec::new(),
-            parse_only: None,
-            sess,
-            stage: Early { emit_errors },
-        };
         let ast::AttrKind::Normal(normal_attr) = &attr.kind else {
             panic!("parse_single called on a doc attr")
         };
@@ -136,6 +129,41 @@ impl<'sess> AttributeParser<'sess, Early> {
         let meta_parser = MetaItemParser::from_attr(normal_attr, &parts, &sess.psess, emit_errors)?;
         let path = meta_parser.path();
         let args = meta_parser.args();
+        Self::parse_single_sub(
+            sess,
+            attr.span,
+            attr.style,
+            path.get_attribute_path(),
+            target_span,
+            target_node_id,
+            features,
+            emit_errors,
+            args,
+            parse_fn,
+            template,
+        )
+    }
+
+    pub fn parse_single_sub<T, I>(
+        sess: &'sess Session,
+        attr_span: Span,
+        attr_style: AttrStyle,
+        attr_path: AttrPath,
+        target_span: Span,
+        target_node_id: NodeId,
+        features: Option<&'sess Features>,
+        emit_errors: ShouldEmit,
+        args: &I,
+        parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &I) -> Option<T>,
+        template: &AttributeTemplate,
+    ) -> Option<T> {
+        let mut parser = Self {
+            features,
+            tools: Vec::new(),
+            parse_only: None,
+            sess,
+            stage: Early { emit_errors },
+        };
         let mut cx: AcceptContext<'_, 'sess, Early> = AcceptContext {
             shared: SharedContext {
                 cx: &mut parser,
@@ -145,10 +173,10 @@ impl<'sess> AttributeParser<'sess, Early> {
                     crate::lints::emit_attribute_lint(&lint, sess);
                 },
             },
-            attr_span: attr.span,
-            attr_style: attr.style,
+            attr_span,
+            attr_style,
             template,
-            attr_path: path.get_attribute_path(),
+            attr_path,
         };
         parse_fn(&mut cx, args)
     }
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
@@ -8,7 +8,7 @@ use std::fmt::{Debug, Display};
 
 use rustc_ast::token::{self, Delimiter, MetaVarKind};
 use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::{AttrArgs, DelimArgs, Expr, ExprKind, LitKind, MetaItemLit, NormalAttr, Path};
+use rustc_ast::{AttrArgs, Expr, ExprKind, LitKind, MetaItemLit, NormalAttr, Path};
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Diag, PResult};
 use rustc_hir::{self as hir, AttrPath};
@@ -124,7 +124,11 @@ impl<'a> ArgParser<'a> {
                     return None;
                 }
 
-                Self::List(MetaItemListParser::new(args, psess, should_emit)?)
+                Self::List(
+                    MetaItemListParser::new(&args.tokens, args.dspan.entire(), psess, should_emit)
+                        .map_err(|e| should_emit.emit_err(e))
+                        .ok()?,
+                )
             }
             AttrArgs::Eq { eq_span, expr } => Self::NameValue(NameValueParser {
                 eq_span: *eq_span,
@@ -186,7 +190,15 @@ pub enum MetaItemOrLitParser<'a> {
     Err(Span, ErrorGuaranteed),
 }
 
-impl<'a> MetaItemOrLitParser<'a> {
+impl<'sess> MetaItemOrLitParser<'sess> {
+    pub fn parse_single(
+        parser: &mut Parser<'sess>,
+        should_emit: ShouldEmit,
+    ) -> PResult<'sess, MetaItemOrLitParser<'static>> {
+        let mut this = MetaItemListParserContext { parser, should_emit };
+        this.parse_meta_item_inner()
+    }
+
     pub fn span(&self) -> Span {
         match self {
             MetaItemOrLitParser::MetaItemParser(generic_meta_item_parser) => {
@@ -204,7 +216,7 @@ impl<'a> MetaItemOrLitParser<'a> {
         }
     }
 
-    pub fn meta_item(&self) -> Option<&MetaItemParser<'a>> {
+    pub fn meta_item(&self) -> Option<&MetaItemParser<'sess>> {
         match self {
             MetaItemOrLitParser::MetaItemParser(parser) => Some(parser),
             _ => None,
@@ -542,23 +554,13 @@ pub struct MetaItemListParser<'a> {
 }
 
 impl<'a> MetaItemListParser<'a> {
-    fn new<'sess>(
-        delim: &'a DelimArgs,
+    pub(crate) fn new<'sess>(
+        tokens: &'a TokenStream,
+        span: Span,
         psess: &'sess ParseSess,
         should_emit: ShouldEmit,
-    ) -> Option<Self> {
-        match MetaItemListParserContext::parse(
-            delim.tokens.clone(),
-            psess,
-            delim.dspan.entire(),
-            should_emit,
-        ) {
-            Ok(s) => Some(s),
-            Err(e) => {
-                should_emit.emit_err(e);
-                None
-            }
-        }
+    ) -> Result<Self, Diag<'sess>> {
+        MetaItemListParserContext::parse(tokens.clone(), psess, span, should_emit)
     }
 
     /// Lets you pick and choose as what you want to parse each element in the list
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
@@ -303,7 +303,7 @@ impl<'a> StripUnconfigured<'a> {
         let trace_attr = attr_into_trace(cfg_attr.clone(), sym::cfg_attr_trace);
 
         let Some((cfg_predicate, expanded_attrs)) =
-            rustc_attr_parsing::parse_cfg_attr(cfg_attr, &self.sess.psess)
+            rustc_attr_parsing::parse_cfg_attr(cfg_attr, &self.sess, self.features)
         else {
             return vec![trace_attr];
         };
@@ -318,7 +318,15 @@ impl<'a> StripUnconfigured<'a> {
             );
         }
 
-        if !attr::cfg_matches(&cfg_predicate, &self.sess, self.lint_node_id, self.features) {
+        if !attr::eval_config_entry(
+            self.sess,
+            &cfg_predicate,
+            ast::CRATE_NODE_ID,
+            self.features,
+            ShouldEmit::ErrorsAndLints,
+        )
+        .as_bool()
+        {
             return vec![trace_attr];
         }
 
