1use std::iter;
4
5use rustc_ast::ptr::P;
6use rustc_ast::token::{Delimiter, Token, TokenKind};
7use rustc_ast::tokenstream::{
8 AttrTokenStream, AttrTokenTree, LazyAttrTokenStream, Spacing, TokenTree,
9};
10use rustc_ast::{
11 self as ast, AttrKind, AttrStyle, Attribute, HasAttrs, HasTokens, MetaItem, MetaItemInner,
12 NodeId, NormalAttr,
13};
14use rustc_attr_parsing as attr;
15use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
16use rustc_feature::{
17 ACCEPTED_LANG_FEATURES, AttributeSafety, EnabledLangFeature, EnabledLibFeature, Features,
18 REMOVED_LANG_FEATURES, UNSTABLE_LANG_FEATURES,
19};
20use rustc_lint_defs::BuiltinLintDiag;
21use rustc_parse::validate_attr;
22use rustc_session::Session;
23use rustc_session::parse::feature_err;
24use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
25use thin_vec::ThinVec;
26use tracing::instrument;
27
28use crate::errors::{
29 CrateNameInCfgAttr, CrateTypeInCfgAttr, FeatureNotAllowed, FeatureRemoved,
30 FeatureRemovedReason, InvalidCfg, MalformedFeatureAttribute, MalformedFeatureAttributeHelp,
31 RemoveExprNotSupported,
32};
33
34pub struct StripUnconfigured<'a> {
36 pub sess: &'a Session,
37 pub features: Option<&'a Features>,
38 pub config_tokens: bool,
42 pub lint_node_id: NodeId,
43}
44
45pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -> Features {
46 fn feature_list(attr: &Attribute) -> ThinVec<ast::MetaItemInner> {
47 if attr.has_name(sym::feature)
48 && let Some(list) = attr.meta_item_list()
49 {
50 list
51 } else {
52 ThinVec::new()
53 }
54 }
55
56 let mut features = Features::default();
57
58 for attr in krate_attrs {
60 for mi in feature_list(attr) {
61 let name = match mi.ident() {
62 Some(ident) if mi.is_word() => ident.name,
63 Some(ident) => {
64 sess.dcx().emit_err(MalformedFeatureAttribute {
65 span: mi.span(),
66 help: MalformedFeatureAttributeHelp::Suggestion {
67 span: mi.span(),
68 suggestion: ident.name,
69 },
70 });
71 continue;
72 }
73 None => {
74 sess.dcx().emit_err(MalformedFeatureAttribute {
75 span: mi.span(),
76 help: MalformedFeatureAttributeHelp::Label { span: mi.span() },
77 });
78 continue;
79 }
80 };
81
82 if let Some(f) = REMOVED_LANG_FEATURES.iter().find(|f| name == f.feature.name) {
84 sess.dcx().emit_err(FeatureRemoved {
85 span: mi.span(),
86 reason: f.reason.map(|reason| FeatureRemovedReason { reason }),
87 });
88 continue;
89 }
90
91 if let Some(f) = ACCEPTED_LANG_FEATURES.iter().find(|f| name == f.name) {
93 features.set_enabled_lang_feature(EnabledLangFeature {
94 gate_name: name,
95 attr_sp: mi.span(),
96 stable_since: Some(Symbol::intern(f.since)),
97 });
98 continue;
99 }
100
101 if let Some(allowed) = sess.opts.unstable_opts.allow_features.as_ref() {
105 if allowed.iter().all(|f| name.as_str() != f) {
106 sess.dcx().emit_err(FeatureNotAllowed { span: mi.span(), name });
107 continue;
108 }
109 }
110
111 if UNSTABLE_LANG_FEATURES.iter().find(|f| name == f.name).is_some() {
113 if features.internal(name) && !STDLIB_STABLE_CRATES.contains(&crate_name) {
118 sess.using_internal_features.store(true, std::sync::atomic::Ordering::Relaxed);
119 }
120
121 features.set_enabled_lang_feature(EnabledLangFeature {
122 gate_name: name,
123 attr_sp: mi.span(),
124 stable_since: None,
125 });
126 continue;
127 }
128
129 features
132 .set_enabled_lib_feature(EnabledLibFeature { gate_name: name, attr_sp: mi.span() });
133
134 if features.internal(name) && !STDLIB_STABLE_CRATES.contains(&crate_name) {
137 sess.using_internal_features.store(true, std::sync::atomic::Ordering::Relaxed);
138 }
139 }
140 }
141
142 features
143}
144
145pub fn pre_configure_attrs(sess: &Session, attrs: &[Attribute]) -> ast::AttrVec {
146 let strip_unconfigured = StripUnconfigured {
147 sess,
148 features: None,
149 config_tokens: false,
150 lint_node_id: ast::CRATE_NODE_ID,
151 };
152 attrs
153 .iter()
154 .flat_map(|attr| strip_unconfigured.process_cfg_attr(attr))
155 .take_while(|attr| !is_cfg(attr) || strip_unconfigured.cfg_true(attr).0)
156 .collect()
157}
158
159pub(crate) fn attr_into_trace(mut attr: Attribute, trace_name: Symbol) -> Attribute {
160 match &mut attr.kind {
161 AttrKind::Normal(normal) => {
162 let NormalAttr { item, tokens } = &mut **normal;
163 item.path.segments[0].ident.name = trace_name;
164 *tokens = Some(LazyAttrTokenStream::new_direct(AttrTokenStream::default()));
166 }
167 AttrKind::DocComment(..) => unreachable!(),
168 }
169 attr
170}
171
172#[macro_export]
173macro_rules! configure {
174 ($this:ident, $node:ident) => {
175 match $this.configure($node) {
176 Some(node) => node,
177 None => return Default::default(),
178 }
179 };
180}
181
182impl<'a> StripUnconfigured<'a> {
183 pub fn configure<T: HasAttrs + HasTokens>(&self, mut node: T) -> Option<T> {
184 self.process_cfg_attrs(&mut node);
185 self.in_cfg(node.attrs()).then(|| {
186 self.try_configure_tokens(&mut node);
187 node
188 })
189 }
190
191 fn try_configure_tokens<T: HasTokens>(&self, node: &mut T) {
192 if self.config_tokens {
193 if let Some(Some(tokens)) = node.tokens_mut() {
194 let attr_stream = tokens.to_attr_token_stream();
195 *tokens = LazyAttrTokenStream::new_direct(self.configure_tokens(&attr_stream));
196 }
197 }
198 }
199
200 fn configure_tokens(&self, stream: &AttrTokenStream) -> AttrTokenStream {
205 fn can_skip(stream: &AttrTokenStream) -> bool {
206 stream.0.iter().all(|tree| match tree {
207 AttrTokenTree::AttrsTarget(_) => false,
208 AttrTokenTree::Token(..) => true,
209 AttrTokenTree::Delimited(.., inner) => can_skip(inner),
210 })
211 }
212
213 if can_skip(stream) {
214 return stream.clone();
215 }
216
217 let trees: Vec<_> = stream
218 .0
219 .iter()
220 .filter_map(|tree| match tree.clone() {
221 AttrTokenTree::AttrsTarget(mut target) => {
222 target.attrs.flat_map_in_place(|attr| self.process_cfg_attr(&attr));
224
225 if self.in_cfg(&target.attrs) {
226 target.tokens = LazyAttrTokenStream::new_direct(
227 self.configure_tokens(&target.tokens.to_attr_token_stream()),
228 );
229 Some(AttrTokenTree::AttrsTarget(target))
230 } else {
231 None
234 }
235 }
236 AttrTokenTree::Delimited(sp, spacing, delim, mut inner) => {
237 inner = self.configure_tokens(&inner);
238 Some(AttrTokenTree::Delimited(sp, spacing, delim, inner))
239 }
240 AttrTokenTree::Token(Token { kind, .. }, _) if kind.is_delim() => {
241 panic!("Should be `AttrTokenTree::Delimited`, not delim tokens: {:?}", tree);
242 }
243 AttrTokenTree::Token(token, spacing) => Some(AttrTokenTree::Token(token, spacing)),
244 })
245 .collect();
246 AttrTokenStream::new(trees)
247 }
248
249 fn process_cfg_attrs<T: HasAttrs>(&self, node: &mut T) {
256 node.visit_attrs(|attrs| {
257 attrs.flat_map_in_place(|attr| self.process_cfg_attr(&attr));
258 });
259 }
260
261 fn process_cfg_attr(&self, attr: &Attribute) -> Vec<Attribute> {
262 if attr.has_name(sym::cfg_attr) {
263 self.expand_cfg_attr(attr, true)
264 } else {
265 vec![attr.clone()]
266 }
267 }
268
269 pub(crate) fn expand_cfg_attr(&self, cfg_attr: &Attribute, recursive: bool) -> Vec<Attribute> {
277 validate_attr::check_attribute_safety(
278 &self.sess.psess,
279 Some(AttributeSafety::Normal),
280 &cfg_attr,
281 ast::CRATE_NODE_ID,
282 );
283
284 let trace_attr = attr_into_trace(cfg_attr.clone(), sym::cfg_attr_trace);
287
288 let Some((cfg_predicate, expanded_attrs)) =
289 rustc_parse::parse_cfg_attr(cfg_attr, &self.sess.psess)
290 else {
291 return vec![trace_attr];
292 };
293
294 if expanded_attrs.is_empty() {
296 self.sess.psess.buffer_lint(
297 rustc_lint_defs::builtin::UNUSED_ATTRIBUTES,
298 cfg_attr.span,
299 ast::CRATE_NODE_ID,
300 BuiltinLintDiag::CfgAttrNoAttributes,
301 );
302 }
303
304 if !attr::cfg_matches(&cfg_predicate, &self.sess, self.lint_node_id, self.features) {
305 return vec![trace_attr];
306 }
307
308 if recursive {
309 let expanded_attrs = expanded_attrs
313 .into_iter()
314 .flat_map(|item| self.process_cfg_attr(&self.expand_cfg_attr_item(cfg_attr, item)));
315 iter::once(trace_attr).chain(expanded_attrs).collect()
316 } else {
317 let expanded_attrs =
318 expanded_attrs.into_iter().map(|item| self.expand_cfg_attr_item(cfg_attr, item));
319 iter::once(trace_attr).chain(expanded_attrs).collect()
320 }
321 }
322
323 fn expand_cfg_attr_item(
324 &self,
325 cfg_attr: &Attribute,
326 (item, item_span): (ast::AttrItem, Span),
327 ) -> Attribute {
328 let mut orig_trees = cfg_attr.token_trees().into_iter();
332 let Some(TokenTree::Token(pound_token @ Token { kind: TokenKind::Pound, .. }, _)) =
333 orig_trees.next()
334 else {
335 panic!("Bad tokens for attribute {cfg_attr:?}");
336 };
337
338 let mut trees = if cfg_attr.style == AttrStyle::Inner {
340 let Some(TokenTree::Token(bang_token @ Token { kind: TokenKind::Bang, .. }, _)) =
341 orig_trees.next()
342 else {
343 panic!("Bad tokens for attribute {cfg_attr:?}");
344 };
345 vec![
346 AttrTokenTree::Token(pound_token, Spacing::Joint),
347 AttrTokenTree::Token(bang_token, Spacing::JointHidden),
348 ]
349 } else {
350 vec![AttrTokenTree::Token(pound_token, Spacing::JointHidden)]
351 };
352
353 let Some(TokenTree::Delimited(delim_span, delim_spacing, Delimiter::Bracket, _)) =
355 orig_trees.next()
356 else {
357 panic!("Bad tokens for attribute {cfg_attr:?}");
358 };
359 trees.push(AttrTokenTree::Delimited(
360 delim_span,
361 delim_spacing,
362 Delimiter::Bracket,
363 item.tokens
364 .as_ref()
365 .unwrap_or_else(|| panic!("Missing tokens for {item:?}"))
366 .to_attr_token_stream(),
367 ));
368
369 let tokens = Some(LazyAttrTokenStream::new_direct(AttrTokenStream::new(trees)));
370 let attr = ast::attr::mk_attr_from_item(
371 &self.sess.psess.attr_id_generator,
372 item,
373 tokens,
374 cfg_attr.style,
375 item_span,
376 );
377 if attr.has_name(sym::crate_type) {
378 self.sess.dcx().emit_err(CrateTypeInCfgAttr { span: attr.span });
379 }
380 if attr.has_name(sym::crate_name) {
381 self.sess.dcx().emit_err(CrateNameInCfgAttr { span: attr.span });
382 }
383 attr
384 }
385
386 fn in_cfg(&self, attrs: &[Attribute]) -> bool {
388 attrs.iter().all(|attr| !is_cfg(attr) || self.cfg_true(attr).0)
389 }
390
391 pub(crate) fn cfg_true(&self, attr: &Attribute) -> (bool, Option<MetaItem>) {
392 let meta_item = match validate_attr::parse_meta(&self.sess.psess, attr) {
393 Ok(meta_item) => meta_item,
394 Err(err) => {
395 err.emit();
396 return (true, None);
397 }
398 };
399
400 validate_attr::deny_builtin_meta_unsafety(&self.sess.psess, &meta_item);
401
402 (
403 parse_cfg(&meta_item, self.sess).is_none_or(|meta_item| {
404 attr::cfg_matches(meta_item, &self.sess, self.lint_node_id, self.features)
405 }),
406 Some(meta_item),
407 )
408 }
409
410 #[instrument(level = "trace", skip(self))]
412 pub(crate) fn maybe_emit_expr_attr_err(&self, attr: &Attribute) {
413 if self.features.is_some_and(|features| !features.stmt_expr_attributes())
414 && !attr.span.allows_unstable(sym::stmt_expr_attributes)
415 {
416 let mut err = feature_err(
417 &self.sess,
418 sym::stmt_expr_attributes,
419 attr.span,
420 crate::fluent_generated::expand_attributes_on_expressions_experimental,
421 );
422
423 if attr.is_doc_comment() {
424 err.help(if attr.style == AttrStyle::Outer {
425 crate::fluent_generated::expand_help_outer_doc
426 } else {
427 crate::fluent_generated::expand_help_inner_doc
428 });
429 }
430
431 err.emit();
432 }
433 }
434
435 #[instrument(level = "trace", skip(self))]
436 pub fn configure_expr(&self, expr: &mut P<ast::Expr>, method_receiver: bool) {
437 if !method_receiver {
438 for attr in expr.attrs.iter() {
439 self.maybe_emit_expr_attr_err(attr);
440 }
441 }
442
443 if let Some(attr) = expr.attrs().iter().find(|a| is_cfg(a)) {
451 self.sess.dcx().emit_err(RemoveExprNotSupported { span: attr.span });
452 }
453
454 self.process_cfg_attrs(expr);
455 self.try_configure_tokens(&mut *expr);
456 }
457}
458
459pub fn parse_cfg<'a>(meta_item: &'a MetaItem, sess: &Session) -> Option<&'a MetaItemInner> {
460 let span = meta_item.span;
461 match meta_item.meta_item_list() {
462 None => {
463 sess.dcx().emit_err(InvalidCfg::NotFollowedByParens { span });
464 None
465 }
466 Some([]) => {
467 sess.dcx().emit_err(InvalidCfg::NoPredicate { span });
468 None
469 }
470 Some([_, .., l]) => {
471 sess.dcx().emit_err(InvalidCfg::MultiplePredicates { span: l.span() });
472 None
473 }
474 Some([single]) => match single.meta_item_or_bool() {
475 Some(meta_item) => Some(meta_item),
476 None => {
477 sess.dcx().emit_err(InvalidCfg::PredicateLiteral { span: single.span() });
478 None
479 }
480 },
481 }
482}
483
484fn is_cfg(attr: &Attribute) -> bool {
485 attr.has_name(sym::cfg)
486}