Rename AttrItem as Meta.

I have long found the `Attribute`/`NormalAttr`/`AttrItem` naming
confusing. This commit renames `AttrItem` as `Meta` which helps a lot.
- Because `Meta` isn't the whole attribute, just the meta part, e.g. the
  `foo` within `#[foo]`.
- This also helps with remembering the distinction between
  `NormalAttr::tokens` and (the newly renamed) `Meta::tokens`.
- The name `Meta` also now matches `NtMeta`/`NonterminalKind::Meta`.
- The name `Meta` is similar to the existing `MetaItem` type. This is
  reasonble because they're very similar types!
- The variable name `meta` is much better than `item`, which can be
  easily confused with other language items.

Author: nnethercote

compiler/rustc_ast/src/ast.rs

@@ -2825,15 +2825,15 @@ pub enum AttrKind {
 
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct NormalAttr {
-    pub item: AttrItem,
+    pub meta: Meta,
     // Tokens for the full attribute, e.g. `#[foo]`, `#![bar]`.
     pub tokens: Option<LazyAttrTokenStream>,
 }
 
 impl NormalAttr {
     pub fn from_ident(ident: Ident) -> Self {
         Self {
-            item: AttrItem {
+            meta: Meta {
                 unsafety: Safety::Default,
                 path: Path::from_ident(ident),
                 args: AttrArgs::Empty,
@@ -2845,11 +2845,11 @@ impl NormalAttr {
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
-pub struct AttrItem {
+pub struct Meta {
     pub unsafety: Safety,
     pub path: Path,
     pub args: AttrArgs,
-    // Tokens for the meta item, e.g. just the `foo` within `#[foo]` or `#![foo]`.
+    // Tokens for the meta part, e.g. just the `foo` within `#[foo]` or `#![foo]`.
     pub tokens: Option<LazyAttrTokenStream>,
 }
 

compiler/rustc_ast/src/ast_traits.rs

@@ -7,7 +7,7 @@ use crate::token::Nonterminal;
 use crate::tokenstream::LazyAttrTokenStream;
 use crate::{Arm, Crate, ExprField, FieldDef, GenericParam, Param, PatField, Variant};
 use crate::{AssocItem, Expr, ForeignItem, Item, NodeId};
-use crate::{AttrItem, AttrKind, Block, Pat, Path, Ty, Visibility};
+use crate::{AttrKind, Block, Meta, Pat, Path, Ty, Visibility};
 use crate::{AttrVec, Attribute, Stmt, StmtKind};
 
 use rustc_span::Span;
@@ -116,7 +116,7 @@ impl<T: AstDeref<Target: HasSpan>> HasSpan for T {
     }
 }
 
-impl HasSpan for AttrItem {
+impl HasSpan for Meta {
     fn span(&self) -> Span {
         self.span()
     }
@@ -158,7 +158,7 @@ macro_rules! impl_has_tokens_none {
     };
 }
 
-impl_has_tokens!(AssocItem, AttrItem, Block, Expr, ForeignItem, Item, Pat, Path, Ty, Visibility);
+impl_has_tokens!(AssocItem, Block, Expr, ForeignItem, Item, Meta, Pat, Path, Ty, Visibility);
 impl_has_tokens_none!(Arm, ExprField, FieldDef, GenericParam, Param, PatField, Variant);
 
 impl<T: AstDeref<Target: HasTokens>> HasTokens for T {
@@ -236,7 +236,7 @@ impl HasTokens for Nonterminal {
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
             Nonterminal::NtPat(pat) => pat.tokens(),
             Nonterminal::NtTy(ty) => ty.tokens(),
-            Nonterminal::NtMeta(attr_item) => attr_item.tokens(),
+            Nonterminal::NtMeta(meta) => meta.tokens(),
             Nonterminal::NtPath(path) => path.tokens(),
             Nonterminal::NtVis(vis) => vis.tokens(),
             Nonterminal::NtBlock(block) => block.tokens(),
@@ -249,7 +249,7 @@ impl HasTokens for Nonterminal {
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
             Nonterminal::NtPat(pat) => pat.tokens_mut(),
             Nonterminal::NtTy(ty) => ty.tokens_mut(),
-            Nonterminal::NtMeta(attr_item) => attr_item.tokens_mut(),
+            Nonterminal::NtMeta(meta) => meta.tokens_mut(),
             Nonterminal::NtPath(path) => path.tokens_mut(),
             Nonterminal::NtVis(vis) => vis.tokens_mut(),
             Nonterminal::NtBlock(block) => block.tokens_mut(),
@@ -322,7 +322,7 @@ impl_has_attrs!(
     PatField,
     Variant,
 );
-impl_has_attrs_none!(Attribute, AttrItem, Block, Pat, Path, Ty, Visibility);
+impl_has_attrs_none!(Attribute, Block, Meta, Pat, Path, Ty, Visibility);
 
 impl<T: AstDeref<Target: HasAttrs>> HasAttrs for T {
     const SUPPORTS_CUSTOM_INNER_ATTRS: bool = T::Target::SUPPORTS_CUSTOM_INNER_ATTRS;

compiler/rustc_ast/src/attr/mod.rs

@@ -1,7 +1,7 @@
 //! Functions dealing with attributes and meta items.
 
 use crate::ast::{
-    AttrArgs, AttrArgsEq, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, Safety,
+    AttrArgs, AttrArgsEq, AttrId, AttrKind, AttrStyle, AttrVec, Attribute, Meta, Safety,
 };
 use crate::ast::{DelimArgs, Expr, ExprKind, LitKind, MetaItemLit};
 use crate::ast::{MetaItem, MetaItemKind, NestedMetaItem, NormalAttr};
@@ -53,16 +53,16 @@ impl AttrIdGenerator {
 }
 
 impl Attribute {
-    pub fn get_normal_item(&self) -> &AttrItem {
+    pub fn get_normal_meta(&self) -> &Meta {
         match &self.kind {
-            AttrKind::Normal(normal) => &normal.item,
+            AttrKind::Normal(normal) => &normal.meta,
             AttrKind::DocComment(..) => panic!("unexpected doc comment"),
         }
     }
 
-    pub fn unwrap_normal_item(self) -> AttrItem {
+    pub fn unwrap_normal_meta(self) -> Meta {
         match self.kind {
-            AttrKind::Normal(normal) => normal.into_inner().item,
+            AttrKind::Normal(normal) => normal.into_inner().meta,
             AttrKind::DocComment(..) => panic!("unexpected doc comment"),
         }
     }
@@ -81,7 +81,7 @@ impl Attribute {
     pub fn ident(&self) -> Option<Ident> {
         match &self.kind {
             AttrKind::Normal(normal) => {
-                if let [ident] = &*normal.item.path.segments {
+                if let [ident] = &*normal.meta.path.segments {
                     Some(ident.ident)
                 } else {
                     None
@@ -98,7 +98,7 @@ impl Attribute {
     pub fn path(&self) -> SmallVec<[Symbol; 1]> {
         match &self.kind {
             AttrKind::Normal(normal) => {
-                normal.item.path.segments.iter().map(|s| s.ident.name).collect()
+                normal.meta.path.segments.iter().map(|s| s.ident.name).collect()
             }
             AttrKind::DocComment(..) => smallvec![sym::doc],
         }
@@ -107,17 +107,17 @@ impl Attribute {
     #[inline]
     pub fn has_name(&self, name: Symbol) -> bool {
         match &self.kind {
-            AttrKind::Normal(normal) => normal.item.path == name,
+            AttrKind::Normal(normal) => normal.meta.path == name,
             AttrKind::DocComment(..) => false,
         }
     }
 
     pub fn path_matches(&self, name: &[Symbol]) -> bool {
         match &self.kind {
             AttrKind::Normal(normal) => {
-                normal.item.path.segments.len() == name.len()
+                normal.meta.path.segments.len() == name.len()
                     && normal
-                        .item
+                        .meta
                         .path
                         .segments
                         .iter()
@@ -130,22 +130,22 @@ impl Attribute {
 
     pub fn is_word(&self) -> bool {
         if let AttrKind::Normal(normal) = &self.kind {
-            matches!(normal.item.args, AttrArgs::Empty)
+            matches!(normal.meta.args, AttrArgs::Empty)
         } else {
             false
         }
     }
 
     pub fn meta_item_list(&self) -> Option<ThinVec<NestedMetaItem>> {
         match &self.kind {
-            AttrKind::Normal(normal) => normal.item.meta_item_list(),
+            AttrKind::Normal(normal) => normal.meta.meta_item_list(),
             AttrKind::DocComment(..) => None,
         }
     }
 
     pub fn value_str(&self) -> Option<Symbol> {
         match &self.kind {
-            AttrKind::Normal(normal) => normal.item.value_str(),
+            AttrKind::Normal(normal) => normal.meta.value_str(),
             AttrKind::DocComment(..) => None,
         }
     }
@@ -158,8 +158,8 @@ impl Attribute {
     pub fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
         match &self.kind {
             AttrKind::DocComment(kind, data) => Some((*data, *kind)),
-            AttrKind::Normal(normal) if normal.item.path == sym::doc => {
-                normal.item.value_str().map(|s| (s, CommentKind::Line))
+            AttrKind::Normal(normal) if normal.meta.path == sym::doc => {
+                normal.meta.value_str().map(|s| (s, CommentKind::Line))
             }
             _ => None,
         }
@@ -172,7 +172,7 @@ impl Attribute {
     pub fn doc_str(&self) -> Option<Symbol> {
         match &self.kind {
             AttrKind::DocComment(.., data) => Some(*data),
-            AttrKind::Normal(normal) if normal.item.path == sym::doc => normal.item.value_str(),
+            AttrKind::Normal(normal) if normal.meta.path == sym::doc => normal.meta.value_str(),
             _ => None,
         }
     }
@@ -190,14 +190,14 @@ impl Attribute {
     /// Extracts the MetaItem from inside this Attribute.
     pub fn meta(&self) -> Option<MetaItem> {
         match &self.kind {
-            AttrKind::Normal(normal) => normal.item.meta(self.span),
+            AttrKind::Normal(normal) => normal.meta.meta(self.span),
             AttrKind::DocComment(..) => None,
         }
     }
 
     pub fn meta_kind(&self) -> Option<MetaItemKind> {
         match &self.kind {
-            AttrKind::Normal(normal) => normal.item.meta_kind(),
+            AttrKind::Normal(normal) => normal.meta.meta_kind(),
             AttrKind::DocComment(..) => None,
         }
     }
@@ -220,7 +220,7 @@ impl Attribute {
     }
 }
 
-impl AttrItem {
+impl Meta {
     pub fn span(&self) -> Span {
         self.args.span().map_or(self.path.span, |args_span| self.path.span.to(args_span))
     }
@@ -579,18 +579,18 @@ pub fn mk_attr(
     args: AttrArgs,
     span: Span,
 ) -> Attribute {
-    mk_attr_from_item(g, AttrItem { unsafety, path, args, tokens: None }, None, style, span)
+    mk_attr_from_meta(g, Meta { unsafety, path, args, tokens: None }, None, style, span)
 }
 
-pub fn mk_attr_from_item(
+pub fn mk_attr_from_meta(
     g: &AttrIdGenerator,
-    item: AttrItem,
+    meta: Meta,
     tokens: Option<LazyAttrTokenStream>,
     style: AttrStyle,
     span: Span,
 ) -> Attribute {
     Attribute {
-        kind: AttrKind::Normal(P(NormalAttr { item, tokens })),
+        kind: AttrKind::Normal(P(NormalAttr { meta, tokens })),
         id: g.mk_attr_id(),
         style,
         span,

compiler/rustc_ast/src/mut_visit.rs

@@ -641,10 +641,8 @@ fn noop_visit_attribute<T: MutVisitor>(attr: &mut Attribute, vis: &mut T) {
     let Attribute { kind, id: _, style: _, span } = attr;
     match kind {
         AttrKind::Normal(normal) => {
-            let NormalAttr {
-                item: AttrItem { unsafety: _, path, args, tokens },
-                tokens: attr_tokens,
-            } = &mut **normal;
+            let NormalAttr { meta: Meta { unsafety: _, path, args, tokens }, tokens: attr_tokens } =
+                &mut **normal;
             vis.visit_path(path);
             visit_attr_args(args, vis);
             visit_lazy_tts(tokens, vis);
@@ -824,8 +822,8 @@ fn visit_nonterminal<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) {
         token::NtExpr(expr) => vis.visit_expr(expr),
         token::NtTy(ty) => vis.visit_ty(ty),
         token::NtLiteral(expr) => vis.visit_expr(expr),
-        token::NtMeta(item) => {
-            let AttrItem { unsafety: _, path, args, tokens } = item.deref_mut();
+        token::NtMeta(meta) => {
+            let Meta { unsafety: _, path, args, tokens } = meta.deref_mut();
             vis.visit_path(path);
             visit_attr_args(args, vis);
             visit_lazy_tts(tokens, vis);

compiler/rustc_ast/src/token.rs

@@ -905,7 +905,7 @@ pub enum Nonterminal {
     NtTy(P<ast::Ty>),
     NtLiteral(P<ast::Expr>),
     /// Stuff inside brackets for attributes
-    NtMeta(P<ast::AttrItem>),
+    NtMeta(P<ast::Meta>),
     NtPath(P<ast::Path>),
     NtVis(P<ast::Visibility>),
 }
@@ -1002,7 +1002,7 @@ impl Nonterminal {
             NtPat(pat) => pat.span,
             NtExpr(expr) | NtLiteral(expr) => expr.span,
             NtTy(ty) => ty.span,
-            NtMeta(attr_item) => attr_item.span(),
+            NtMeta(meta) => meta.span(),
             NtPath(path) => path.span,
             NtVis(vis) => vis.span,
         }

compiler/rustc_ast/src/tokenstream.rs

@@ -462,7 +462,7 @@ impl TokenStream {
             Nonterminal::NtStmt(stmt) => TokenStream::from_ast(stmt),
             Nonterminal::NtPat(pat) => TokenStream::from_ast(pat),
             Nonterminal::NtTy(ty) => TokenStream::from_ast(ty),
-            Nonterminal::NtMeta(attr) => TokenStream::from_ast(attr),
+            Nonterminal::NtMeta(meta) => TokenStream::from_ast(meta),
             Nonterminal::NtPath(path) => TokenStream::from_ast(path),
             Nonterminal::NtVis(vis) => TokenStream::from_ast(vis),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => TokenStream::from_ast(expr),

compiler/rustc_ast/src/visit.rs

@@ -1217,8 +1217,8 @@ pub fn walk_attribute<'a, V: Visitor<'a>>(visitor: &mut V, attr: &'a Attribute)
     let Attribute { kind, id: _, style: _, span: _ } = attr;
     match kind {
         AttrKind::Normal(normal) => {
-            let NormalAttr { item, tokens: _ } = &**normal;
-            let AttrItem { unsafety: _, path, args, tokens: _ } = item;
+            let NormalAttr { meta, tokens: _ } = &**normal;
+            let Meta { unsafety: _, path, args, tokens: _ } = meta;
             try_visit!(visitor.visit_path(path, DUMMY_NODE_ID));
             try_visit!(walk_attr_args(visitor, args));
         }

compiler/rustc_ast_lowering/src/lib.rs

@@ -912,10 +912,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // Tokens are also not needed after macro expansion and parsing.
         let kind = match attr.kind {
             AttrKind::Normal(ref normal) => AttrKind::Normal(P(NormalAttr {
-                item: AttrItem {
-                    unsafety: normal.item.unsafety,
-                    path: normal.item.path.clone(),
-                    args: self.lower_attr_args(&normal.item.args),
+                meta: Meta {
+                    unsafety: normal.meta.unsafety,
+                    path: normal.meta.path.clone(),
+                    args: self.lower_attr_args(&normal.meta.args),
                     tokens: None,
                 },
                 tokens: None,

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -613,7 +613,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
                     ast::AttrStyle::Inner => self.word("#!["),
                     ast::AttrStyle::Outer => self.word("#["),
                 }
-                self.print_attr_item(&normal.item, attr.span);
+                self.print_meta(&normal.meta, attr.span);
                 self.word("]");
             }
             ast::AttrKind::DocComment(comment_kind, data) => {
@@ -623,7 +623,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
         }
     }
 
-    fn print_attr_item(&mut self, item: &ast::AttrItem, span: Span) {
+    fn print_meta(&mut self, item: &ast::Meta, span: Span) {
         self.ibox(0);
         match &item.args {
             AttrArgs::Delimited(DelimArgs { dspan: _, delim, tokens }) => self.print_mac_common(
@@ -1011,8 +1011,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
         })
     }
 
-    fn attr_item_to_string(&self, ai: &ast::AttrItem) -> String {
-        Self::to_string(|s| s.print_attr_item(ai, ai.path.span))
+    fn meta_to_string(&self, meta: &ast::Meta) -> String {
+        Self::to_string(|s| s.print_meta(meta, meta.path.span))
     }
 
     fn tts_to_string(&self, tokens: &TokenStream) -> String {

compiler/rustc_builtin_macros/src/cmdline_attrs.rs

@@ -3,7 +3,7 @@
 use crate::errors;
 use rustc_ast::attr::mk_attr;
 use rustc_ast::token;
-use rustc_ast::{self as ast, AttrItem, AttrStyle};
+use rustc_ast::{self as ast, AttrStyle, Meta};
 use rustc_parse::{new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_session::parse::ParseSess;
 use rustc_span::FileName;
@@ -17,8 +17,8 @@ pub fn inject(krate: &mut ast::Crate, psess: &ParseSess, attrs: &[String]) {
         ));
 
         let start_span = parser.token.span;
-        let AttrItem { unsafety, path, args, tokens: _ } = match parser.parse_attr_item(false) {
-            Ok(ai) => ai,
+        let Meta { unsafety, path, args, tokens: _ } = match parser.parse_meta(false) {
+            Ok(meta) => meta,
             Err(err) => {
                 err.emit();
                 continue;