cfg_select!: emit parse errors in unused branches

Author: folkertdev

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -28,6 +28,32 @@ pub struct CfgSelectBranches {
     pub unreachable: Vec<(CfgSelectPredicate, TokenStream, Span)>,
 }
 
+impl CfgSelectBranches {
+    /// Removes the top-most branch for which `predicate` returns `true`,
+    /// or the wildcard if none of the reachable branches satisfied the predicate.
+    pub fn pop_first_match<F>(&mut self, predicate: F) -> Option<TokenStream>
+    where
+        F: Fn(&CfgEntry) -> bool,
+    {
+        for (index, (cfg, _, _)) in self.reachable.iter().enumerate() {
+            if predicate(cfg) {
+                return Some(self.reachable.remove(index).1);
+            }
+        }
+
+        self.wildcard.take().map(|(_, tts, _)| tts)
+    }
+
+    /// Consume this value and iterate over all the `TokenStream`s that it stores.
+    pub fn into_iter_tts(self) -> impl Iterator<Item = TokenStream> {
+        let it1 = self.reachable.into_iter().map(|(_, tts, _)| tts);
+        let it2 = self.wildcard.into_iter().map(|(_, tts, _)| tts);
+        let it3 = self.unreachable.into_iter().map(|(_, tts, _)| tts);
+
+        it1.chain(it2).chain(it3)
+    }
+}
+
 pub fn parse_cfg_select(
     p: &mut Parser<'_>,
     sess: &Session,

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -1,22 +1,81 @@
 use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{Expr, ast, token};
+use rustc_ast_pretty::pprust;
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
     CfgSelectBranches, CfgSelectPredicate, EvalConfigResult, parse_cfg_select,
 };
-use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
-use rustc_span::{Ident, Span, sym};
+use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacResult, MacroExpanderResult};
+use rustc_parse::parser::ForceCollect;
+use rustc_span::Span;
+use smallvec::SmallVec;
 
+use crate::errors;
 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 let EvalConfigResult::True = attr::eval_config_entry(&ecx.sess, &cfg) {
-            return Some((tt, arm_span));
+/// This intermediate structure is used to emit parse errors for the branches that are not chosen.
+/// The `MacResult` instance below parses all branches, emitting any errors it encounters, but only
+/// keeps the parse result for the selected branch.
+struct CfgSelectResult<'cx, 'sess> {
+    ecx: &'cx mut ExtCtxt<'sess>,
+    selected_tts: TokenStream,
+    other_branches: CfgSelectBranches,
+}
+
+impl<'cx, 'sess> MacResult for CfgSelectResult<'cx, 'sess> {
+    fn make_expr(self: Box<Self>) -> Option<Box<Expr>> {
+        for tts in self.other_branches.into_iter_tts() {
+            let mut p = self.ecx.new_parser_from_tts(tts);
+            if let Err(diag) = p.parse_expr() {
+                diag.emit();
+                return None;
+            }
+        }
+
+        let mut p = self.ecx.new_parser_from_tts(self.selected_tts);
+        p.parse_expr().ok()
+    }
+
+    fn make_items(self: Box<Self>) -> Option<SmallVec<[Box<ast::Item>; 1]>> {
+        for tts in self.other_branches.into_iter_tts() {
+            let _ = make_items(self.ecx, tts, false);
         }
+
+        make_items(self.ecx, self.selected_tts, true)
     }
+}
 
-    branches.wildcard.map(|(_, tt, span)| (tt, span))
+fn make_items<'cx>(
+    ecx: &'cx mut ExtCtxt<'_>,
+    tts: TokenStream,
+    keep: bool,
+) -> Option<SmallVec<[Box<ast::Item>; 1]>> {
+    let mut p = ecx.new_parser_from_tts(tts);
+    let mut ret = SmallVec::new();
+    loop {
+        match p.parse_item(ForceCollect::No) {
+            Err(err) => {
+                err.emit();
+                break;
+            }
+            Ok(Some(item)) => {
+                if keep {
+                    ret.push(item)
+                }
+            }
+            Ok(None) => {
+                if p.token != token::Eof {
+                    p.dcx().emit_err(errors::ExpectedItem {
+                        span: p.token.span,
+                        token: &pprust::token_to_string(&p.token),
+                    });
+                }
+
+                break;
+            }
+        }
+    }
+    Some(ret)
 }
 
 pub(super) fn expand_cfg_select<'cx>(
@@ -31,7 +90,7 @@ pub(super) fn expand_cfg_select<'cx>(
             Some(ecx.ecfg.features),
             ecx.current_expansion.lint_node_id,
         ) {
-            Ok(branches) => {
+            Ok(mut 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 {
@@ -44,14 +103,11 @@ pub(super) fn expand_cfg_select<'cx>(
                     }
                 }
 
-                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),
-                    );
+                if let Some(selected_tts) = branches.pop_first_match(|cfg| {
+                    matches!(attr::eval_config_entry(&ecx.sess, cfg), EvalConfigResult::True)
+                }) {
+                    let mac = CfgSelectResult { ecx, selected_tts, other_branches: branches };
+                    return ExpandResult::Ready(Box::new(mac));
                 } else {
                     // Emit a compiler error when none of the predicates matched.
                     let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });

tests/ui/macros/cfg_select_parse_error.rs

@@ -0,0 +1,16 @@
+#![feature(cfg_select)]
+#![crate_type = "lib"]
+
+// Check that parse errors in arms that are not selected are still reported.
+
+fn print() {
+    println!(cfg_select! {
+        false => { 1 ++ 2 }
+        _ => { "not unix" }
+    });
+}
+
+cfg_select! {
+    false => { fn foo() { 1 +++ 2 } }
+    _ => {}
+}