make cfg_select a builtin macro

Author: folkertdev

Cargo.lock

@@ -3481,6 +3481,7 @@ dependencies = [
 name = "rustc_builtin_macros"
 version = "0.0.0"
 dependencies = [
+ "either",
  "rustc_ast",
  "rustc_ast_pretty",
  "rustc_attr_data_structures",

compiler/rustc_builtin_macros/Cargo.toml

@@ -8,6 +8,7 @@ doctest = false
 
 [dependencies]
 # tidy-alphabetical-start
+either = "1.5.0"
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
 rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }

compiler/rustc_builtin_macros/messages.ftl

@@ -81,6 +81,12 @@ builtin_macros_cfg_accessible_literal_path = `cfg_accessible` path cannot be a l
 builtin_macros_cfg_accessible_multiple_paths = multiple `cfg_accessible` paths are specified
 builtin_macros_cfg_accessible_unspecified_path = `cfg_accessible` path is not specified
 
+builtin_macros_cfg_select_no_matches = none of the rules in this `cfg_select` evaluated to true
+
+builtin_macros_cfg_select_unreachable = unreachable rule
+    .label = always matches
+    .label2 = this rules is never reached
+
 builtin_macros_coerce_pointee_requires_maybe_sized = `derive(CoercePointee)` requires `{$name}` to be marked `?Sized`
 
 builtin_macros_coerce_pointee_requires_one_field = `CoercePointee` can only be derived on `struct`s with at least one field

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -0,0 +1,117 @@
+use either::Either;
+use rustc_ast::tokenstream::{TokenStream, TokenTree};
+use rustc_ast::{MetaItemInner, token};
+use rustc_attr_parsing as attr;
+use rustc_errors::PResult;
+use rustc_expand::base::{ExtCtxt, MacroExpanderResult, *};
+use rustc_parse::exp;
+use rustc_parse::parser::Parser;
+use rustc_span::{Span, kw};
+
+use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
+
+#[derive(Default)]
+struct SelectBranches {
+    reachable: Vec<(MetaItemInner, TokenStream)>,
+    wildcard: Option<(Span, TokenStream)>,
+    // Either the span of the `_`, or the rule of the arm.
+    unreachable: Vec<(Either<Span, MetaItemInner>, TokenStream)>,
+}
+
+impl SelectBranches {
+    /// Selects the first arm whose rule evaluates to true.
+    fn select_arm(self, cx: &ExtCtxt<'_>) -> Option<TokenStream> {
+        for (cfg, tt) in self.reachable {
+            if attr::cfg_matches(
+                &cfg,
+                &cx.sess,
+                cx.current_expansion.lint_node_id,
+                Some(cx.ecfg.features),
+            ) {
+                return Some(tt);
+            }
+        }
+
+        self.wildcard.map(|(_, tt)| tt)
+    }
+}
+
+/// Parses a `TokenTree` that must be of the form `{ /* ... */ }`, and returns a `TokenStream` where
+/// the the surrounding braces are stripped.
+fn parse_token_tree<'a>(p: &mut Parser<'a>) -> PResult<'a, TokenStream> {
+    // generate an error if the `=>` is not followed by `{`
+    if p.token != token::OpenBrace {
+        p.expect(exp!(OpenBrace))?;
+    }
+
+    // Strip the outer '{' and '}'
+    match p.parse_token_tree() {
+        TokenTree::Token(..) => unreachable!("because of the expect above"),
+        TokenTree::Delimited(.., tts) => Ok(tts),
+    }
+}
+
+fn parse_args<'a>(p: &mut Parser<'a>) -> PResult<'a, SelectBranches> {
+    let mut branches = SelectBranches::default();
+
+    while p.token != token::Eof {
+        if p.token.is_keyword(kw::Underscore) {
+            let span = p.token.span;
+            p.bump();
+            p.expect(exp!(FatArrow))?;
+
+            let tts = parse_token_tree(p)?;
+
+            match branches.wildcard {
+                None => branches.wildcard = Some((span, tts)),
+                Some(_) => branches.unreachable.push((Either::Left(span), tts)),
+            }
+        } else {
+            let meta_item = p.parse_meta_item_inner()?;
+            p.expect(exp!(FatArrow))?;
+
+            let tts = parse_token_tree(p)?;
+
+            match branches.wildcard {
+                None => branches.reachable.push((meta_item, tts)),
+                Some(_) => branches.unreachable.push((Either::Right(meta_item), tts)),
+            }
+        }
+    }
+
+    Ok(branches)
+}
+
+pub(super) fn expand_cfg_select<'cx>(
+    ecx: &'cx mut ExtCtxt<'_>,
+    sp: Span,
+    tts: TokenStream,
+) -> MacroExpanderResult<'cx> {
+    ExpandResult::Ready(match parse_args(&mut ecx.new_parser_from_tts(tts)) {
+        Ok(branches) => {
+            if let Some((wildcard_span, _)) = branches.wildcard {
+                // Warn for every unreachable rule.
+                for (rule, _) in &branches.unreachable {
+                    let span = match rule {
+                        Either::Left(wildcard_span) => *wildcard_span,
+                        Either::Right(rule) => rule.span(),
+                    };
+                    let err = CfgSelectUnreachable { span, wildcard_span };
+                    ecx.dcx().emit_warn(err);
+                }
+            }
+
+            if let Some(tts) = branches.select_arm(ecx) {
+                rustc_expand::expand_token_stream(ecx, sp, tts)
+            } else {
+                // Emit a compiler error when none of the rules matched.
+                let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });
+                DummyResult::any(sp, guar)
+            }
+        }
+        Err(err) => {
+            let guar = err.emit();
+            DummyResult::any(sp, guar)
+        }
+    })
+}

compiler/rustc_builtin_macros/src/errors.rs

@@ -954,3 +954,21 @@ pub(crate) struct AsmExpectedOther {
     pub(crate) span: Span,
     pub(crate) is_inline_asm: bool,
 }
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_cfg_select_no_matches)]
+pub(crate) struct CfgSelectNoMatches {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_cfg_select_unreachable)]
+pub(crate) struct CfgSelectUnreachable {
+    #[primary_span]
+    #[label(builtin_macros_label2)]
+    pub span: Span,
+
+    #[label]
+    pub wildcard_span: Span,
+}

compiler/rustc_builtin_macros/src/lib.rs

@@ -33,6 +33,7 @@ mod autodiff;
 mod cfg;
 mod cfg_accessible;
 mod cfg_eval;
+mod cfg_select;
 mod compile_error;
 mod concat;
 mod concat_bytes;
@@ -79,6 +80,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         asm: asm::expand_asm,
         assert: assert::expand_assert,
         cfg: cfg::expand_cfg,
+        cfg_select: cfg_select::expand_cfg_select,
         column: source_util::expand_column,
         compile_error: compile_error::expand_compile_error,
         concat: concat::expand_concat,

compiler/rustc_expand/src/lib.rs

@@ -22,7 +22,7 @@ mod placeholders;
 mod proc_macro_server;
 mod stats;
 
-pub use mbe::macro_rules::compile_declarative_macro;
+pub use mbe::macro_rules::{compile_declarative_macro, expand_token_stream};
 pub mod base;
 pub mod config;
 pub mod expand;

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -183,6 +183,45 @@ impl<'matcher> Tracker<'matcher> for NoopTracker {
     }
 }
 
+pub fn expand_token_stream<'cx>(
+    cx: &'cx mut ExtCtxt<'_>,
+    sp: Span,
+    tts: TokenStream,
+) -> Box<dyn MacResult + 'cx> {
+    let psess = &cx.sess.psess;
+    // Macros defined in the current crate have a real node id,
+    // whereas macros from an external crate have a dummy id.
+    let node_id = cx.current_expansion.lint_node_id;
+    let is_local = node_id != DUMMY_NODE_ID;
+
+    if cx.trace_macros() {
+        let msg = format!("to `{}`", pprust::tts_to_string(&tts));
+        trace_macros_note(&mut cx.expansions, sp, msg);
+    }
+
+    let p = Parser::new(psess, tts, None);
+
+    if is_local {
+        cx.resolver.record_macro_rule_usage(node_id, 0);
+    }
+
+    // Let the context choose how to interpret the result.
+    // Weird, but useful for X-macros.
+    Box::new(ParserAnyMacro {
+        parser: p,
+
+        // Pass along the original expansion site and the name of the macro
+        // so we can print a useful error message if the parse of the expanded
+        // macro leaves unparsed tokens.
+        site_span: sp,
+        macro_ident: Ident::with_dummy_span(sym::cfg_select),
+        lint_node_id: cx.current_expansion.lint_node_id,
+        is_trailing_mac: cx.current_expansion.is_trailing_mac,
+        arm_span: Span::default(),
+        is_local,
+    })
+}
+
 /// Expands the rules based macro defined by `lhses` and `rhses` for a given
 /// input `arg`.
 #[instrument(skip(cx, transparency, arg, lhses, rhses))]

compiler/rustc_span/src/symbol.rs

@@ -624,6 +624,7 @@ symbols! {
         cfg_relocation_model,
         cfg_sanitize,
         cfg_sanitizer_cfi,
+        cfg_select,
         cfg_target_abi,
         cfg_target_compact,
         cfg_target_feature,

library/core/src/macros/mod.rs

@@ -230,32 +230,17 @@ pub macro assert_matches {
 /// ```
 /// #![feature(cfg_select)]
 ///
-/// let _some_string = cfg_select! {{
+/// let _some_string = cfg_select! {
 ///     unix => { "With great power comes great electricity bills" }
 ///     _ => { "Behind every successful diet is an unwatched pizza" }
-/// }};
+/// };
 /// ```
 #[unstable(feature = "cfg_select", issue = "115585")]
 #[rustc_diagnostic_item = "cfg_select"]
 #[rustc_macro_transparency = "semitransparent"]
-pub macro cfg_select {
-    ({ $($tt:tt)* }) => {{
-        $crate::cfg_select! { $($tt)* }
-    }},
-    (_ => { $($output:tt)* }) => {
-        $($output)*
-    },
-    (
-        $cfg:meta => $output:tt
-        $($( $rest:tt )+)?
-    ) => {
-        #[cfg($cfg)]
-        $crate::cfg_select! { _ => $output }
-        $(
-            #[cfg(not($cfg))]
-            $crate::cfg_select! { $($rest)+ }
-        )?
-    },
+#[rustc_builtin_macro]
+pub macro cfg_select($($tt:tt)*) {
+    /* compiler built-in */
 }
 
 /// Asserts that a boolean expression is `true` at runtime.