Rollup merge of #148712 - JonathanBrouwer:cfg_select, r=jdonszelmann

Zalathar · web-flow · commit e26b42333ddc · 2025-11-11T21:11:48.000+11:00
Port `cfg_select!` to the new attribute parsing system

Best reviewed commit by commit, since it involves some moving around of code

r? `````@jdonszelmann`````
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs b/compiler/rustc_attr_parsing/src/attributes/cfg_select.rs
@@ -0,0 +1,89 @@
+use rustc_ast::token::Token;
+use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{AttrStyle, NodeId, token};
+use rustc_feature::{AttributeTemplate, Features};
+use rustc_hir::AttrPath;
+use rustc_hir::attrs::CfgEntry;
+use rustc_parse::exp;
+use rustc_parse::parser::Parser;
+use rustc_session::Session;
+use rustc_span::{ErrorGuaranteed, Ident, Span};
+
+use crate::parser::MetaItemOrLitParser;
+use crate::{AttributeParser, ParsedDescription, ShouldEmit, parse_cfg_entry};
+
+pub enum CfgSelectPredicate {
+    Cfg(CfgEntry),
+    Wildcard(Token),
+}
+
+#[derive(Default)]
+pub struct CfgSelectBranches {
+    /// All the conditional branches.
+    pub reachable: Vec<(CfgEntry, TokenStream, Span)>,
+    /// The first wildcard `_ => { ... }` branch.
+    pub wildcard: Option<(Token, TokenStream, Span)>,
+    /// All branches after the first wildcard, including further wildcards.
+    /// These branches are kept for formatting.
+    pub unreachable: Vec<(CfgSelectPredicate, TokenStream, Span)>,
+}
+
+pub fn parse_cfg_select(
+    p: &mut Parser<'_>,
+    sess: &Session,
+    features: Option<&Features>,
+    lint_node_id: NodeId,
+) -> Result<CfgSelectBranches, ErrorGuaranteed> {
+    let mut branches = CfgSelectBranches::default();
+
+    while p.token != token::Eof {
+        if p.eat_keyword(exp!(Underscore)) {
+            let underscore = p.prev_token;
+            p.expect(exp!(FatArrow)).map_err(|e| e.emit())?;
+
+            let tts = p.parse_delimited_token_tree().map_err(|e| e.emit())?;
+            let span = underscore.span.to(p.token.span);
+
+            match branches.wildcard {
+                None => branches.wildcard = Some((underscore, tts, span)),
+                Some(_) => {
+                    branches.unreachable.push((CfgSelectPredicate::Wildcard(underscore), tts, span))
+                }
+            }
+        } else {
+            let meta = MetaItemOrLitParser::parse_single(p, ShouldEmit::ErrorsAndLints)
+                .map_err(|diag| diag.emit())?;
+            let cfg_span = meta.span();
+            let cfg = AttributeParser::parse_single_args(
+                sess,
+                cfg_span,
+                cfg_span,
+                AttrStyle::Inner,
+                AttrPath {
+                    segments: vec![Ident::from_str("cfg_select")].into_boxed_slice(),
+                    span: cfg_span,
+                },
+                ParsedDescription::Macro,
+                cfg_span,
+                lint_node_id,
+                features,
+                ShouldEmit::ErrorsAndLints,
+                &meta,
+                parse_cfg_entry,
+                &AttributeTemplate::default(),
+            )?;
+
+            p.expect(exp!(FatArrow)).map_err(|e| e.emit())?;
+
+            let tts = p.parse_delimited_token_tree().map_err(|e| e.emit())?;
+            let span = cfg_span.to(p.token.span);
+
+            match branches.wildcard {
+                None => branches.reachable.push((cfg, tts, span)),
+                Some(_) => branches.unreachable.push((CfgSelectPredicate::Cfg(cfg), tts, span)),
+            }
+        }
+    }
+
+    Ok(branches)
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -33,6 +33,7 @@ pub(crate) mod allow_unstable;
 pub(crate) mod body;
 pub(crate) mod cfg;
 pub(crate) mod cfg_old;
+pub(crate) mod cfg_select;
 pub(crate) mod codegen_attrs;
 pub(crate) mod confusables;
 pub(crate) mod crate_level;
diff --git a/compiler/rustc_attr_parsing/src/lib.rs b/compiler/rustc_attr_parsing/src/lib.rs
@@ -106,6 +106,7 @@ pub use attributes::cfg::{
     CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg, parse_cfg_attr, parse_cfg_entry,
 };
 pub use attributes::cfg_old::*;
+pub use attributes::cfg_select::*;
 pub use attributes::util::{is_builtin_attr, is_doc_alias_attrs_contain_symbol, parse_version};
 pub use context::{Early, Late, OmitDoc, ShouldEmit};
 pub use interface::AttributeParser;
diff --git a/compiler/rustc_builtin_macros/src/cfg_select.rs b/compiler/rustc_builtin_macros/src/cfg_select.rs
@@ -1,19 +1,21 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_attr_parsing as attr;
+use rustc_attr_parsing::{
+    CfgSelectBranches, CfgSelectPredicate, EvalConfigResult, ShouldEmit, parse_cfg_select,
+};
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
-use rustc_parse::parser::cfg_select::{CfgSelectBranches, CfgSelectPredicate, parse_cfg_select};
 use rustc_span::{Ident, Span, sym};
 
 use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
 
 /// Selects the first arm whose predicate evaluates to true.
 fn select_arm(ecx: &ExtCtxt<'_>, branches: CfgSelectBranches) -> Option<(TokenStream, Span)> {
     for (cfg, tt, arm_span) in branches.reachable {
-        if attr::cfg_matches(
-            &cfg,
+        if let EvalConfigResult::True = attr::eval_config_entry(
             &ecx.sess,
+            &cfg,
             ecx.current_expansion.lint_node_id,
-            Some(ecx.ecfg.features),
+            ShouldEmit::ErrorsAndLints,
         ) {
             return Some((tt, arm_span));
         }
@@ -27,37 +29,41 @@ pub(super) fn expand_cfg_select<'cx>(
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {
-    ExpandResult::Ready(match parse_cfg_select(&mut ecx.new_parser_from_tts(tts)) {
-        Ok(branches) => {
-            if let Some((underscore, _, _)) = branches.wildcard {
-                // Warn for every unreachable predicate. We store the fully parsed branch for rustfmt.
-                for (predicate, _, _) in &branches.unreachable {
-                    let span = match predicate {
-                        CfgSelectPredicate::Wildcard(underscore) => underscore.span,
-                        CfgSelectPredicate::Cfg(cfg) => cfg.span(),
-                    };
-                    let err = CfgSelectUnreachable { span, wildcard_span: underscore.span };
-                    ecx.dcx().emit_warn(err);
+    ExpandResult::Ready(
+        match parse_cfg_select(
+            &mut ecx.new_parser_from_tts(tts),
+            ecx.sess,
+            Some(ecx.ecfg.features),
+            ecx.current_expansion.lint_node_id,
+        ) {
+            Ok(branches) => {
+                if let Some((underscore, _, _)) = branches.wildcard {
+                    // Warn for every unreachable predicate. We store the fully parsed branch for rustfmt.
+                    for (predicate, _, _) in &branches.unreachable {
+                        let span = match predicate {
+                            CfgSelectPredicate::Wildcard(underscore) => underscore.span,
+                            CfgSelectPredicate::Cfg(cfg) => cfg.span(),
+                        };
+                        let err = CfgSelectUnreachable { span, wildcard_span: underscore.span };
+                        ecx.dcx().emit_warn(err);
+                    }
                 }
-            }
 
-            if let Some((tts, arm_span)) = select_arm(ecx, branches) {
-                return ExpandResult::from_tts(
-                    ecx,
-                    tts,
-                    sp,
-                    arm_span,
-                    Ident::with_dummy_span(sym::cfg_select),
-                );
-            } else {
-                // Emit a compiler error when none of the predicates matched.
-                let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });
-                DummyResult::any(sp, guar)
+                if let Some((tts, arm_span)) = select_arm(ecx, branches) {
+                    return ExpandResult::from_tts(
+                        ecx,
+                        tts,
+                        sp,
+                        arm_span,
+                        Ident::with_dummy_span(sym::cfg_select),
+                    );
+                } else {
+                    // Emit a compiler error when none of the predicates matched.
+                    let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });
+                    DummyResult::any(sp, guar)
+                }
             }
-        }
-        Err(err) => {
-            let guar = err.emit();
-            DummyResult::any(sp, guar)
-        }
-    })
+            Err(guar) => DummyResult::any(sp, guar),
+        },
+    )
 }
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -194,6 +194,18 @@ pub enum CfgEntry {
     Version(Option<RustcVersion>, Span),
 }
 
+impl CfgEntry {
+    pub fn span(&self) -> Span {
+        let (CfgEntry::All(_, span)
+        | CfgEntry::Any(_, span)
+        | CfgEntry::Not(_, span)
+        | CfgEntry::Bool(_, span)
+        | CfgEntry::NameValue { span, .. }
+        | CfgEntry::Version(_, span)) = self;
+        *span
+    }
+}
+
 /// Possible values for the `#[linkage]` attribute, allowing to specify the
 /// linkage type for a `MonoItem`.
 ///
diff --git a/compiler/rustc_parse/src/parser/cfg_select.rs b/compiler/rustc_parse/src/parser/cfg_select.rs
@@ -1,83 +1,34 @@
-use rustc_ast::token::Token;
+use rustc_ast::token;
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_ast::util::classify;
-use rustc_ast::{MetaItemInner, token};
 use rustc_errors::PResult;
-use rustc_span::Span;
 
 use crate::exp;
 use crate::parser::{AttrWrapper, ForceCollect, Parser, Restrictions, Trailing, UsePreAttrPos};
 
-pub enum CfgSelectPredicate {
-    Cfg(MetaItemInner),
-    Wildcard(Token),
-}
-
-#[derive(Default)]
-pub struct CfgSelectBranches {
-    /// All the conditional branches.
-    pub reachable: Vec<(MetaItemInner, TokenStream, Span)>,
-    /// The first wildcard `_ => { ... }` branch.
-    pub wildcard: Option<(Token, TokenStream, Span)>,
-    /// All branches after the first wildcard, including further wildcards.
-    /// These branches are kept for formatting.
-    pub unreachable: Vec<(CfgSelectPredicate, TokenStream, Span)>,
-}
-
-/// Parses a `TokenTree` consisting either of `{ /* ... */ }` (and strip the braces) or an
-/// expression followed by a comma (and strip the comma).
-fn parse_token_tree<'a>(p: &mut Parser<'a>) -> PResult<'a, TokenStream> {
-    if p.token == token::OpenBrace {
-        // Strip the outer '{' and '}'.
-        match p.parse_token_tree() {
-            TokenTree::Token(..) => unreachable!("because of the expect above"),
-            TokenTree::Delimited(.., tts) => return Ok(tts),
-        }
-    }
-    let expr = p.collect_tokens(None, AttrWrapper::empty(), ForceCollect::Yes, |p, _| {
-        p.parse_expr_res(Restrictions::STMT_EXPR, AttrWrapper::empty())
-            .map(|(expr, _)| (expr, Trailing::No, UsePreAttrPos::No))
-    })?;
-    if !classify::expr_is_complete(&expr) && p.token != token::CloseBrace && p.token != token::Eof {
-        p.expect(exp!(Comma))?;
-    } else {
-        let _ = p.eat(exp!(Comma));
-    }
-    Ok(TokenStream::from_ast(&expr))
-}
-
-pub fn parse_cfg_select<'a>(p: &mut Parser<'a>) -> PResult<'a, CfgSelectBranches> {
-    let mut branches = CfgSelectBranches::default();
-
-    while p.token != token::Eof {
-        if p.eat_keyword(exp!(Underscore)) {
-            let underscore = p.prev_token;
-            p.expect(exp!(FatArrow))?;
-
-            let tts = parse_token_tree(p)?;
-            let span = underscore.span.to(p.token.span);
-
-            match branches.wildcard {
-                None => branches.wildcard = Some((underscore, tts, span)),
-                Some(_) => {
-                    branches.unreachable.push((CfgSelectPredicate::Wildcard(underscore), tts, span))
-                }
+impl<'a> Parser<'a> {
+    /// Parses a `TokenTree` consisting either of `{ /* ... */ }` (and strip the braces) or an
+    /// expression followed by a comma (and strip the comma).
+    pub fn parse_delimited_token_tree(&mut self) -> PResult<'a, TokenStream> {
+        if self.token == token::OpenBrace {
+            // Strip the outer '{' and '}'.
+            match self.parse_token_tree() {
+                TokenTree::Token(..) => unreachable!("because of the expect above"),
+                TokenTree::Delimited(.., tts) => return Ok(tts),
             }
+        }
+        let expr = self.collect_tokens(None, AttrWrapper::empty(), ForceCollect::Yes, |p, _| {
+            p.parse_expr_res(Restrictions::STMT_EXPR, AttrWrapper::empty())
+                .map(|(expr, _)| (expr, Trailing::No, UsePreAttrPos::No))
+        })?;
+        if !classify::expr_is_complete(&expr)
+            && self.token != token::CloseBrace
+            && self.token != token::Eof
+        {
+            self.expect(exp!(Comma))?;
         } else {
-            let meta_item = p.parse_meta_item_inner()?;
-            p.expect(exp!(FatArrow))?;
-
-            let tts = parse_token_tree(p)?;
-            let span = meta_item.span().to(p.token.span);
-
-            match branches.wildcard {
-                None => branches.reachable.push((meta_item, tts, span)),
-                Some(_) => {
-                    branches.unreachable.push((CfgSelectPredicate::Cfg(meta_item), tts, span))
-                }
-            }
+            let _ = self.eat(exp!(Comma));
         }
+        Ok(TokenStream::from_ast(&expr))
     }
-
-    Ok(branches)
 }
diff --git a/tests/ui/macros/cfg_select.rs b/tests/ui/macros/cfg_select.rs
@@ -60,3 +60,38 @@ cfg_select! {
 
 cfg_select! {}
 //~^ ERROR none of the predicates in this `cfg_select` evaluated to true
+
+cfg_select! {
+    => {}
+    //~^ ERROR expected a literal (`1u8`, `1.0f32`, `"string"`, etc.) here, found `=>`
+}
+
+cfg_select! {
+    () => {}
+    //~^ ERROR expected a literal (`1u8`, `1.0f32`, `"string"`, etc.) here, found `(`
+}
+
+cfg_select! {
+    "str" => {}
+    //~^ ERROR malformed `cfg_select` macro input [E0539]
+}
+
+cfg_select! {
+    a::b => {}
+    //~^ ERROR malformed `cfg_select` macro input [E0539]
+}
+
+cfg_select! {
+    a() => {}
+    //~^ ERROR invalid predicate `a` [E0537]
+}
+
+cfg_select! {
+    a + 1 => {}
+    //~^ ERROR expected one of `(`, `::`, `=>`, or `=`, found `+`
+}
+
+cfg_select! {
+    cfg!() => {}
+    //~^ ERROR expected one of `(`, `::`, `=>`, or `=`, found `!`
+}
diff --git a/tests/ui/macros/cfg_select.stderr b/tests/ui/macros/cfg_select.stderr
