1 //! Functions dealing with attributes and meta items.
4 use crate::ast::{AttrId, AttrItem, AttrKind, AttrStyle, Attribute};
5 use crate::ast::{Lit, LitKind};
6 use crate::ast::{MacArgs, MacDelimiter, MetaItem, MetaItemKind, NestedMetaItem};
7 use crate::ast::{Path, PathSegment};
8 use crate::token::{self, CommentKind, Token};
9 use crate::tokenstream::{DelimSpan, LazyTokenStream, TokenStream, TokenTree, TreeAndSpacing};
11 use rustc_index::bit_set::GrowableBitSet;
12 use rustc_span::source_map::BytePos;
13 use rustc_span::symbol::{sym, Ident, Symbol};
18 pub struct MarkedAttrs(GrowableBitSet<AttrId>);
21 // We have no idea how many attributes there will be, so just
22 // initiate the vectors with 0 bits. We'll grow them as necessary.
23 pub fn new() -> Self {
24 MarkedAttrs(GrowableBitSet::new_empty())
27 pub fn mark(&mut self, attr: &Attribute) {
28 self.0.insert(attr.id);
31 pub fn is_marked(&self, attr: &Attribute) -> bool {
32 self.0.contains(attr.id)
37 /// Returns the `MetaItem` if `self` is a `NestedMetaItem::MetaItem`.
38 pub fn meta_item(&self) -> Option<&MetaItem> {
40 NestedMetaItem::MetaItem(ref item) => Some(item),
45 /// Returns the `Lit` if `self` is a `NestedMetaItem::Literal`s.
46 pub fn literal(&self) -> Option<&Lit> {
48 NestedMetaItem::Literal(ref lit) => Some(lit),
53 /// Returns `true` if this list item is a MetaItem with a name of `name`.
54 pub fn has_name(&self, name: Symbol) -> bool {
55 self.meta_item().map_or(false, |meta_item| meta_item.has_name(name))
58 /// For a single-segment meta item, returns its name; otherwise, returns `None`.
59 pub fn ident(&self) -> Option<Ident> {
60 self.meta_item().and_then(|meta_item| meta_item.ident())
62 pub fn name_or_empty(&self) -> Symbol {
63 self.ident().unwrap_or_else(Ident::invalid).name
66 /// Gets the string value if `self` is a `MetaItem` and the `MetaItem` is a
67 /// `MetaItemKind::NameValue` variant containing a string, otherwise `None`.
68 pub fn value_str(&self) -> Option<Symbol> {
69 self.meta_item().and_then(|meta_item| meta_item.value_str())
72 /// Returns a name and single literal value tuple of the `MetaItem`.
73 pub fn name_value_literal(&self) -> Option<(Symbol, &Lit)> {
74 self.meta_item().and_then(|meta_item| {
75 meta_item.meta_item_list().and_then(|meta_item_list| {
76 if meta_item_list.len() == 1 {
77 if let Some(ident) = meta_item.ident() {
78 if let Some(lit) = meta_item_list[0].literal() {
79 return Some((ident.name, lit));
88 /// Gets a list of inner meta items from a list `MetaItem` type.
89 pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> {
90 self.meta_item().and_then(|meta_item| meta_item.meta_item_list())
93 /// Returns `true` if the variant is `MetaItem`.
94 pub fn is_meta_item(&self) -> bool {
95 self.meta_item().is_some()
98 /// Returns `true` if `self` is a `MetaItem` and the meta item is a word.
99 pub fn is_word(&self) -> bool {
100 self.meta_item().map_or(false, |meta_item| meta_item.is_word())
103 /// See [`MetaItem::name_value_literal_span`].
104 pub fn name_value_literal_span(&self) -> Option<Span> {
105 self.meta_item()?.name_value_literal_span()
111 pub fn has_name(&self, name: Symbol) -> bool {
113 AttrKind::Normal(ref item, _) => item.path == name,
114 AttrKind::DocComment(..) => false,
118 /// For a single-segment attribute, returns its name; otherwise, returns `None`.
119 pub fn ident(&self) -> Option<Ident> {
121 AttrKind::Normal(ref item, _) => {
122 if item.path.segments.len() == 1 {
123 Some(item.path.segments[0].ident)
128 AttrKind::DocComment(..) => None,
131 pub fn name_or_empty(&self) -> Symbol {
132 self.ident().unwrap_or_else(Ident::invalid).name
135 pub fn value_str(&self) -> Option<Symbol> {
137 AttrKind::Normal(ref item, _) => item.meta(self.span).and_then(|meta| meta.value_str()),
138 AttrKind::DocComment(..) => None,
142 pub fn meta_item_list(&self) -> Option<Vec<NestedMetaItem>> {
144 AttrKind::Normal(ref item, _) => match item.meta(self.span) {
145 Some(MetaItem { kind: MetaItemKind::List(list), .. }) => Some(list),
148 AttrKind::DocComment(..) => None,
152 pub fn is_word(&self) -> bool {
153 if let AttrKind::Normal(item, _) = &self.kind {
154 matches!(item.args, MacArgs::Empty)
162 /// For a single-segment meta item, returns its name; otherwise, returns `None`.
163 pub fn ident(&self) -> Option<Ident> {
164 if self.path.segments.len() == 1 { Some(self.path.segments[0].ident) } else { None }
166 pub fn name_or_empty(&self) -> Symbol {
167 self.ident().unwrap_or_else(Ident::invalid).name
171 // #[attribute(name = "value")]
173 pub fn name_value_literal(&self) -> Option<&Lit> {
175 MetaItemKind::NameValue(v) => Some(v),
180 pub fn value_str(&self) -> Option<Symbol> {
182 MetaItemKind::NameValue(ref v) => match v.kind {
183 LitKind::Str(ref s, _) => Some(*s),
190 pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> {
192 MetaItemKind::List(ref l) => Some(&l[..]),
197 pub fn is_word(&self) -> bool {
198 matches!(self.kind, MetaItemKind::Word)
201 pub fn has_name(&self, name: Symbol) -> bool {
205 /// This is used in case you want the value span instead of the whole attribute. Example:
208 /// #[doc(alias = "foo")]
211 /// In here, it'll return a span for `"foo"`.
212 pub fn name_value_literal_span(&self) -> Option<Span> {
213 Some(self.name_value_literal()?.span)
218 pub fn span(&self) -> Span {
219 self.args.span().map_or(self.path.span, |args_span| self.path.span.to(args_span))
222 pub fn meta(&self, span: Span) -> Option<MetaItem> {
224 path: self.path.clone(),
225 kind: MetaItemKind::from_mac_args(&self.args)?,
232 pub fn is_doc_comment(&self) -> bool {
234 AttrKind::Normal(..) => false,
235 AttrKind::DocComment(..) => true,
239 pub fn doc_str(&self) -> Option<Symbol> {
241 AttrKind::DocComment(.., data) => Some(data),
242 AttrKind::Normal(ref item, _) if item.path == sym::doc => {
243 item.meta(self.span).and_then(|meta| meta.value_str())
249 pub fn get_normal_item(&self) -> &AttrItem {
251 AttrKind::Normal(ref item, _) => item,
252 AttrKind::DocComment(..) => panic!("unexpected doc comment"),
256 pub fn unwrap_normal_item(self) -> AttrItem {
258 AttrKind::Normal(item, _) => item,
259 AttrKind::DocComment(..) => panic!("unexpected doc comment"),
263 /// Extracts the MetaItem from inside this Attribute.
264 pub fn meta(&self) -> Option<MetaItem> {
266 AttrKind::Normal(ref item, _) => item.meta(self.span),
267 AttrKind::DocComment(..) => None,
271 pub fn tokens(&self) -> TokenStream {
273 AttrKind::Normal(_, ref tokens) => tokens
275 .unwrap_or_else(|| panic!("attribute is missing tokens: {:?}", self))
276 .create_token_stream(),
277 AttrKind::DocComment(comment_kind, data) => TokenStream::from(TokenTree::Token(
278 Token::new(token::DocComment(comment_kind, self.style, data), self.span),
286 pub fn mk_name_value_item_str(ident: Ident, str: Symbol, str_span: Span) -> MetaItem {
287 let lit_kind = LitKind::Str(str, ast::StrStyle::Cooked);
288 mk_name_value_item(ident, lit_kind, str_span)
291 pub fn mk_name_value_item(ident: Ident, lit_kind: LitKind, lit_span: Span) -> MetaItem {
292 let lit = Lit::from_lit_kind(lit_kind, lit_span);
293 let span = ident.span.to(lit_span);
294 MetaItem { path: Path::from_ident(ident), span, kind: MetaItemKind::NameValue(lit) }
297 pub fn mk_list_item(ident: Ident, items: Vec<NestedMetaItem>) -> MetaItem {
298 MetaItem { path: Path::from_ident(ident), span: ident.span, kind: MetaItemKind::List(items) }
301 pub fn mk_word_item(ident: Ident) -> MetaItem {
302 MetaItem { path: Path::from_ident(ident), span: ident.span, kind: MetaItemKind::Word }
305 pub fn mk_nested_word_item(ident: Ident) -> NestedMetaItem {
306 NestedMetaItem::MetaItem(mk_word_item(ident))
309 crate fn mk_attr_id() -> AttrId {
310 use std::sync::atomic::AtomicU32;
311 use std::sync::atomic::Ordering;
313 static NEXT_ATTR_ID: AtomicU32 = AtomicU32::new(0);
315 let id = NEXT_ATTR_ID.fetch_add(1, Ordering::SeqCst);
316 assert!(id != u32::MAX);
320 pub fn mk_attr(style: AttrStyle, path: Path, args: MacArgs, span: Span) -> Attribute {
321 mk_attr_from_item(AttrItem { path, args, tokens: None }, None, style, span)
324 pub fn mk_attr_from_item(
326 tokens: Option<LazyTokenStream>,
330 Attribute { kind: AttrKind::Normal(item, tokens), id: mk_attr_id(), style, span }
333 /// Returns an inner attribute with the given value and span.
334 pub fn mk_attr_inner(item: MetaItem) -> Attribute {
335 mk_attr(AttrStyle::Inner, item.path, item.kind.mac_args(item.span), item.span)
338 /// Returns an outer attribute with the given value and span.
339 pub fn mk_attr_outer(item: MetaItem) -> Attribute {
340 mk_attr(AttrStyle::Outer, item.path, item.kind.mac_args(item.span), item.span)
343 pub fn mk_doc_comment(
344 comment_kind: CommentKind,
349 Attribute { kind: AttrKind::DocComment(comment_kind, data), id: mk_attr_id(), style, span }
352 pub fn list_contains_name(items: &[NestedMetaItem], name: Symbol) -> bool {
353 items.iter().any(|item| item.has_name(name))
357 fn token_trees_and_spacings(&self) -> Vec<TreeAndSpacing> {
358 let mut idents = vec![];
359 let mut last_pos = BytePos(0_u32);
360 for (i, segment) in self.path.segments.iter().enumerate() {
361 let is_first = i == 0;
364 Span::new(last_pos, segment.ident.span.lo(), segment.ident.span.ctxt());
365 idents.push(TokenTree::token(token::ModSep, mod_sep_span).into());
367 idents.push(TokenTree::Token(Token::from_ast_ident(segment.ident)).into());
368 last_pos = segment.ident.span.hi();
370 idents.extend(self.kind.token_trees_and_spacings(self.span));
374 fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItem>
376 I: Iterator<Item = TokenTree>,
378 // FIXME: Share code with `parse_path`.
379 let path = match tokens.next().map(TokenTree::uninterpolate) {
380 Some(TokenTree::Token(Token {
381 kind: kind @ (token::Ident(..) | token::ModSep),
384 let mut segments = if let token::Ident(name, _) = kind {
385 if let Some(TokenTree::Token(Token { kind: token::ModSep, .. })) = tokens.peek()
388 vec![PathSegment::from_ident(Ident::new(name, span))]
390 break 'arm Path::from_ident(Ident::new(name, span));
393 vec![PathSegment::path_root(span)]
396 if let Some(TokenTree::Token(Token { kind: token::Ident(name, _), span })) =
397 tokens.next().map(TokenTree::uninterpolate)
399 segments.push(PathSegment::from_ident(Ident::new(name, span)));
403 if let Some(TokenTree::Token(Token { kind: token::ModSep, .. })) = tokens.peek()
410 let span = span.with_hi(segments.last().unwrap().ident.span.hi());
411 Path { span, segments, tokens: None }
413 Some(TokenTree::Token(Token { kind: token::Interpolated(nt), .. })) => match *nt {
414 token::Nonterminal::NtMeta(ref item) => return item.meta(item.path.span),
415 token::Nonterminal::NtPath(ref path) => path.clone(),
420 let list_closing_paren_pos = tokens.peek().map(|tt| tt.span().hi());
421 let kind = MetaItemKind::from_tokens(tokens)?;
422 let hi = match kind {
423 MetaItemKind::NameValue(ref lit) => lit.span.hi(),
424 MetaItemKind::List(..) => list_closing_paren_pos.unwrap_or(path.span.hi()),
427 let span = path.span.with_hi(hi);
428 Some(MetaItem { path, kind, span })
433 pub fn mac_args(&self, span: Span) -> MacArgs {
435 MetaItemKind::Word => MacArgs::Empty,
436 MetaItemKind::NameValue(lit) => MacArgs::Eq(span, lit.to_token()),
437 MetaItemKind::List(list) => {
438 let mut tts = Vec::new();
439 for (i, item) in list.iter().enumerate() {
441 tts.push(TokenTree::token(token::Comma, span).into());
443 tts.extend(item.token_trees_and_spacings())
446 DelimSpan::from_single(span),
447 MacDelimiter::Parenthesis,
448 TokenStream::new(tts),
454 fn token_trees_and_spacings(&self, span: Span) -> Vec<TreeAndSpacing> {
456 MetaItemKind::Word => vec![],
457 MetaItemKind::NameValue(ref lit) => {
459 TokenTree::token(token::Eq, span).into(),
460 TokenTree::Token(lit.to_token()).into(),
463 MetaItemKind::List(ref list) => {
464 let mut tokens = Vec::new();
465 for (i, item) in list.iter().enumerate() {
467 tokens.push(TokenTree::token(token::Comma, span).into());
469 tokens.extend(item.token_trees_and_spacings())
472 TokenTree::Delimited(
473 DelimSpan::from_single(span),
475 TokenStream::new(tokens),
483 fn list_from_tokens(tokens: TokenStream) -> Option<MetaItemKind> {
484 let mut tokens = tokens.into_trees().peekable();
485 let mut result = Vec::new();
486 while tokens.peek().is_some() {
487 let item = NestedMetaItem::from_tokens(&mut tokens)?;
489 match tokens.next() {
490 None | Some(TokenTree::Token(Token { kind: token::Comma, .. })) => {}
494 Some(MetaItemKind::List(result))
497 fn name_value_from_tokens(
498 tokens: &mut impl Iterator<Item = TokenTree>,
499 ) -> Option<MetaItemKind> {
500 match tokens.next() {
501 Some(TokenTree::Delimited(_, token::NoDelim, inner_tokens)) => {
502 MetaItemKind::name_value_from_tokens(&mut inner_tokens.trees())
504 Some(TokenTree::Token(token)) => {
505 Lit::from_token(&token).ok().map(MetaItemKind::NameValue)
511 fn from_mac_args(args: &MacArgs) -> Option<MetaItemKind> {
513 MacArgs::Delimited(_, MacDelimiter::Parenthesis, tokens) => {
514 MetaItemKind::list_from_tokens(tokens.clone())
516 MacArgs::Delimited(..) => None,
517 MacArgs::Eq(_, token) => Lit::from_token(token).ok().map(MetaItemKind::NameValue),
518 MacArgs::Empty => Some(MetaItemKind::Word),
523 tokens: &mut iter::Peekable<impl Iterator<Item = TokenTree>>,
524 ) -> Option<MetaItemKind> {
525 match tokens.peek() {
526 Some(TokenTree::Delimited(_, token::Paren, inner_tokens)) => {
527 let inner_tokens = inner_tokens.clone();
529 MetaItemKind::list_from_tokens(inner_tokens)
531 Some(TokenTree::Delimited(..)) => None,
532 Some(TokenTree::Token(Token { kind: token::Eq, .. })) => {
534 MetaItemKind::name_value_from_tokens(tokens)
536 _ => Some(MetaItemKind::Word),
541 impl NestedMetaItem {
542 pub fn span(&self) -> Span {
544 NestedMetaItem::MetaItem(ref item) => item.span,
545 NestedMetaItem::Literal(ref lit) => lit.span,
549 fn token_trees_and_spacings(&self) -> Vec<TreeAndSpacing> {
551 NestedMetaItem::MetaItem(ref item) => item.token_trees_and_spacings(),
552 NestedMetaItem::Literal(ref lit) => vec![TokenTree::Token(lit.to_token()).into()],
556 fn from_tokens<I>(tokens: &mut iter::Peekable<I>) -> Option<NestedMetaItem>
558 I: Iterator<Item = TokenTree>,
560 match tokens.peek() {
561 Some(TokenTree::Token(token)) => {
562 if let Ok(lit) = Lit::from_token(token) {
564 return Some(NestedMetaItem::Literal(lit));
567 Some(TokenTree::Delimited(_, token::NoDelim, inner_tokens)) => {
568 let inner_tokens = inner_tokens.clone();
570 return NestedMetaItem::from_tokens(&mut inner_tokens.into_trees().peekable());
574 MetaItem::from_tokens(tokens).map(NestedMetaItem::MetaItem)