1use core::ops::ControlFlow;
2
3use rustc_ast as ast;
4use rustc_ast::mut_visit::MutVisitor;
5use rustc_ast::ptr::P;
6use rustc_ast::visit::{AssocCtxt, Visitor};
7use rustc_ast::{Attribute, HasAttrs, HasTokens, NodeId, mut_visit, visit};
8use rustc_errors::PResult;
9use rustc_expand::base::{Annotatable, ExtCtxt};
10use rustc_expand::config::StripUnconfigured;
11use rustc_expand::configure;
12use rustc_feature::Features;
13use rustc_parse::parser::{ForceCollect, Parser};
14use rustc_session::Session;
15use rustc_span::{Span, sym};
16use smallvec::SmallVec;
17use tracing::instrument;
18
19use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
20
21pub(crate) fn expand(
22 ecx: &mut ExtCtxt<'_>,
23 _span: Span,
24 meta_item: &ast::MetaItem,
25 annotatable: Annotatable,
26) -> Vec<Annotatable> {
27 check_builtin_macro_attribute(ecx, meta_item, sym::cfg_eval);
28 warn_on_duplicate_attribute(ecx, &annotatable, sym::cfg_eval);
29 vec![cfg_eval(ecx.sess, ecx.ecfg.features, annotatable, ecx.current_expansion.lint_node_id)]
30}
31
32pub(crate) fn cfg_eval(
33 sess: &Session,
34 features: &Features,
35 annotatable: Annotatable,
36 lint_node_id: NodeId,
37) -> Annotatable {
38 let features = Some(features);
39 CfgEval(StripUnconfigured { sess, features, config_tokens: true, lint_node_id })
40 .configure_annotatable(annotatable)
41}
42
43struct CfgEval<'a>(StripUnconfigured<'a>);
44
45fn has_cfg_or_cfg_attr(annotatable: &Annotatable) -> bool {
46 struct CfgFinder;
47
48 impl<'ast> visit::Visitor<'ast> for CfgFinder {
49 type Result = ControlFlow<()>;
50 fn visit_attribute(&mut self, attr: &'ast Attribute) -> ControlFlow<()> {
51 if attr
52 .ident()
53 .is_some_and(|ident| ident.name == sym::cfg || ident.name == sym::cfg_attr)
54 {
55 ControlFlow::Break(())
56 } else {
57 ControlFlow::Continue(())
58 }
59 }
60 }
61
62 let res = match annotatable {
63 Annotatable::Item(item) => CfgFinder.visit_item(item),
64 Annotatable::AssocItem(item, ctxt) => CfgFinder.visit_assoc_item(item, *ctxt),
65 Annotatable::ForeignItem(item) => CfgFinder.visit_foreign_item(item),
66 Annotatable::Stmt(stmt) => CfgFinder.visit_stmt(stmt),
67 Annotatable::Expr(expr) => CfgFinder.visit_expr(expr),
68 _ => unreachable!(),
69 };
70 res.is_break()
71}
72
73impl CfgEval<'_> {
74 fn configure<T: HasAttrs + HasTokens>(&mut self, node: T) -> Option<T> {
75 self.0.configure(node)
76 }
77
78 fn configure_annotatable(mut self, annotatable: Annotatable) -> Annotatable {
79 if !has_cfg_or_cfg_attr(&annotatable) {
82 return annotatable;
83 }
84
85 let orig_tokens = annotatable.to_tokens().flattened();
109
110 let mut parser = Parser::new(&self.0.sess.psess, orig_tokens, None);
117 parser.capture_cfg = true;
118 let res: PResult<'_, Annotatable> = try {
119 match annotatable {
120 Annotatable::Item(_) => {
121 let item = parser.parse_item(ForceCollect::Yes)?.unwrap();
122 Annotatable::Item(self.flat_map_item(item).pop().unwrap())
123 }
124 Annotatable::AssocItem(_, AssocCtxt::Trait) => {
125 let item = parser.parse_trait_item(ForceCollect::Yes)?.unwrap().unwrap();
126 Annotatable::AssocItem(
127 self.flat_map_assoc_item(item, AssocCtxt::Trait).pop().unwrap(),
128 AssocCtxt::Trait,
129 )
130 }
131 Annotatable::AssocItem(_, AssocCtxt::Impl) => {
132 let item = parser.parse_impl_item(ForceCollect::Yes)?.unwrap().unwrap();
133 Annotatable::AssocItem(
134 self.flat_map_assoc_item(item, AssocCtxt::Impl).pop().unwrap(),
135 AssocCtxt::Impl,
136 )
137 }
138 Annotatable::ForeignItem(_) => {
139 let item = parser.parse_foreign_item(ForceCollect::Yes)?.unwrap().unwrap();
140 Annotatable::ForeignItem(self.flat_map_foreign_item(item).pop().unwrap())
141 }
142 Annotatable::Stmt(_) => {
143 let stmt = parser
144 .parse_stmt_without_recovery(false, ForceCollect::Yes, false)?
145 .unwrap();
146 Annotatable::Stmt(P(self.flat_map_stmt(stmt).pop().unwrap()))
147 }
148 Annotatable::Expr(_) => {
149 let mut expr = parser.parse_expr_force_collect()?;
150 self.visit_expr(&mut expr);
151 Annotatable::Expr(expr)
152 }
153 _ => unreachable!(),
154 }
155 };
156
157 match res {
158 Ok(ann) => ann,
159 Err(err) => {
160 err.emit();
161 annotatable
162 }
163 }
164 }
165}
166
167impl MutVisitor for CfgEval<'_> {
168 #[instrument(level = "trace", skip(self))]
169 fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
170 self.0.configure_expr(expr, false);
171 mut_visit::walk_expr(self, expr);
172 }
173
174 #[instrument(level = "trace", skip(self))]
175 fn visit_method_receiver_expr(&mut self, expr: &mut P<ast::Expr>) {
176 self.0.configure_expr(expr, true);
177 mut_visit::walk_expr(self, expr);
178 }
179
180 fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
181 let mut expr = configure!(self, expr);
182 mut_visit::walk_expr(self, &mut expr);
183 Some(expr)
184 }
185
186 fn flat_map_generic_param(
187 &mut self,
188 param: ast::GenericParam,
189 ) -> SmallVec<[ast::GenericParam; 1]> {
190 let param = configure!(self, param);
191 mut_visit::walk_flat_map_generic_param(self, param)
192 }
193
194 fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> {
195 let stmt = configure!(self, stmt);
196 mut_visit::walk_flat_map_stmt(self, stmt)
197 }
198
199 fn flat_map_item(&mut self, item: P<ast::Item>) -> SmallVec<[P<ast::Item>; 1]> {
200 let item = configure!(self, item);
201 mut_visit::walk_flat_map_item(self, item)
202 }
203
204 fn flat_map_assoc_item(
205 &mut self,
206 item: P<ast::AssocItem>,
207 ctxt: AssocCtxt,
208 ) -> SmallVec<[P<ast::AssocItem>; 1]> {
209 let item = configure!(self, item);
210 mut_visit::walk_flat_map_assoc_item(self, item, ctxt)
211 }
212
213 fn flat_map_foreign_item(
214 &mut self,
215 foreign_item: P<ast::ForeignItem>,
216 ) -> SmallVec<[P<ast::ForeignItem>; 1]> {
217 let foreign_item = configure!(self, foreign_item);
218 mut_visit::walk_flat_map_foreign_item(self, foreign_item)
219 }
220
221 fn flat_map_arm(&mut self, arm: ast::Arm) -> SmallVec<[ast::Arm; 1]> {
222 let arm = configure!(self, arm);
223 mut_visit::walk_flat_map_arm(self, arm)
224 }
225
226 fn flat_map_expr_field(&mut self, field: ast::ExprField) -> SmallVec<[ast::ExprField; 1]> {
227 let field = configure!(self, field);
228 mut_visit::walk_flat_map_expr_field(self, field)
229 }
230
231 fn flat_map_pat_field(&mut self, fp: ast::PatField) -> SmallVec<[ast::PatField; 1]> {
232 let fp = configure!(self, fp);
233 mut_visit::walk_flat_map_pat_field(self, fp)
234 }
235
236 fn flat_map_param(&mut self, p: ast::Param) -> SmallVec<[ast::Param; 1]> {
237 let p = configure!(self, p);
238 mut_visit::walk_flat_map_param(self, p)
239 }
240
241 fn flat_map_field_def(&mut self, sf: ast::FieldDef) -> SmallVec<[ast::FieldDef; 1]> {
242 let sf = configure!(self, sf);
243 mut_visit::walk_flat_map_field_def(self, sf)
244 }
245
246 fn flat_map_variant(&mut self, variant: ast::Variant) -> SmallVec<[ast::Variant; 1]> {
247 let variant = configure!(self, variant);
248 mut_visit::walk_flat_map_variant(self, variant)
249 }
250}