Rename NestedMetaItem to MetaItemInner

Author: codemountains

compiler/rustc_ast/src/ast.rs

@@ -511,7 +511,7 @@ pub enum MetaItemKind {
     /// List meta item.
     ///
     /// E.g., `#[derive(..)]`, where the field represents the `..`.
-    List(ThinVec<NestedMetaItem>),
+    List(ThinVec<MetaItemInner>),
 
     /// Name value meta item.
     ///
@@ -523,7 +523,7 @@ pub enum MetaItemKind {
 ///
 /// E.g., each of `Clone`, `Copy` in `#[derive(Clone, Copy)]`.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
-pub enum NestedMetaItem {
+pub enum MetaItemInner {
     /// A full MetaItem, for recursive meta items.
     MetaItem(MetaItem),
 

compiler/rustc_ast/src/attr/mod.rs

@@ -11,7 +11,7 @@ use thin_vec::{ThinVec, thin_vec};
 
 use crate::ast::{
     AttrArgs, AttrArgsEq, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, DUMMY_NODE_ID,
-    DelimArgs, Expr, ExprKind, LitKind, MetaItem, MetaItemKind, MetaItemLit, NestedMetaItem,
+    DelimArgs, Expr, ExprKind, LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit,
     NormalAttr, Path, PathSegment, Safety,
 };
 use crate::ptr::P;
@@ -136,7 +136,7 @@ impl Attribute {
         }
     }
 
-    pub fn meta_item_list(&self) -> Option<ThinVec<NestedMetaItem>> {
+    pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.meta_item_list(),
             AttrKind::DocComment(..) => None,
@@ -223,7 +223,7 @@ impl AttrItem {
         self.args.span().map_or(self.path.span, |args_span| self.path.span.to(args_span))
     }
 
-    fn meta_item_list(&self) -> Option<ThinVec<NestedMetaItem>> {
+    fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
         match &self.args {
             AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => {
                 MetaItemKind::list_from_tokens(args.tokens.clone())
@@ -285,7 +285,7 @@ impl MetaItem {
         matches!(self.kind, MetaItemKind::Word)
     }
 
-    pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> {
+    pub fn meta_item_list(&self) -> Option<&[MetaItemInner]> {
         match &self.kind {
             MetaItemKind::List(l) => Some(&**l),
             _ => None,
@@ -393,11 +393,11 @@ impl MetaItem {
 }
 
 impl MetaItemKind {
-    fn list_from_tokens(tokens: TokenStream) -> Option<ThinVec<NestedMetaItem>> {
+    fn list_from_tokens(tokens: TokenStream) -> Option<ThinVec<MetaItemInner>> {
         let mut tokens = tokens.trees().peekable();
         let mut result = ThinVec::new();
         while tokens.peek().is_some() {
-            let item = NestedMetaItem::from_tokens(&mut tokens)?;
+            let item = MetaItemInner::from_tokens(&mut tokens)?;
             result.push(item);
             match tokens.next() {
                 None | Some(TokenTree::Token(Token { kind: token::Comma, .. }, _)) => {}
@@ -460,11 +460,11 @@ impl MetaItemKind {
     }
 }
 
-impl NestedMetaItem {
+impl MetaItemInner {
     pub fn span(&self) -> Span {
         match self {
-            NestedMetaItem::MetaItem(item) => item.span,
-            NestedMetaItem::Lit(lit) => lit.span,
+            MetaItemInner::MetaItem(item) => item.span,
+            MetaItemInner::Lit(lit) => lit.span,
         }
     }
 
@@ -488,7 +488,7 @@ impl NestedMetaItem {
     }
 
     /// Gets a list of inner meta items from a list `MetaItem` type.
-    pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> {
+    pub fn meta_item_list(&self) -> Option<&[MetaItemInner]> {
         self.meta_item().and_then(|meta_item| meta_item.meta_item_list())
     }
 
@@ -519,18 +519,18 @@ impl NestedMetaItem {
         self.meta_item().and_then(|meta_item| meta_item.value_str())
     }
 
-    /// Returns the `MetaItemLit` if `self` is a `NestedMetaItem::Literal`s.
+    /// Returns the `MetaItemLit` if `self` is a `MetaItemInner::Literal`s.
     pub fn lit(&self) -> Option<&MetaItemLit> {
         match self {
-            NestedMetaItem::Lit(lit) => Some(lit),
+            MetaItemInner::Lit(lit) => Some(lit),
             _ => None,
         }
     }
 
-    /// Returns the `MetaItem` if `self` is a `NestedMetaItem::MetaItem`.
+    /// Returns the `MetaItem` if `self` is a `MetaItemInner::MetaItem`.
     pub fn meta_item(&self) -> Option<&MetaItem> {
         match self {
-            NestedMetaItem::MetaItem(item) => Some(item),
+            MetaItemInner::MetaItem(item) => Some(item),
             _ => None,
         }
     }
@@ -540,22 +540,22 @@ impl NestedMetaItem {
         self.meta_item().is_some()
     }
 
-    fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<NestedMetaItem>
+    fn from_tokens<'a, I>(tokens: &mut iter::Peekable<I>) -> Option<MetaItemInner>
     where
         I: Iterator<Item = &'a TokenTree>,
     {
         match tokens.peek() {
             Some(TokenTree::Token(token, _)) if let Some(lit) = MetaItemLit::from_token(token) => {
                 tokens.next();
-                return Some(NestedMetaItem::Lit(lit));
+                return Some(MetaItemInner::Lit(lit));
             }
             Some(TokenTree::Delimited(.., Delimiter::Invisible, inner_tokens)) => {
                 tokens.next();
-                return NestedMetaItem::from_tokens(&mut inner_tokens.trees().peekable());
+                return MetaItemInner::from_tokens(&mut inner_tokens.trees().peekable());
             }
             _ => {}
         }
-        MetaItem::from_tokens(tokens).map(NestedMetaItem::MetaItem)
+        MetaItem::from_tokens(tokens).map(MetaItemInner::MetaItem)
     }
 }
 
@@ -666,6 +666,6 @@ pub fn contains_name(attrs: &[Attribute], name: Symbol) -> bool {
     find_by_name(attrs, name).is_some()
 }
 
-pub fn list_contains_name(items: &[NestedMetaItem], name: Symbol) -> bool {
+pub fn list_contains_name(items: &[MetaItemInner], name: Symbol) -> bool {
     items.iter().any(|item| item.has_name(name))
 }

compiler/rustc_ast/src/mut_visit.rs

@@ -83,7 +83,7 @@ pub trait MutVisitor: Sized {
         walk_crate(self, c)
     }
 
-    fn visit_meta_list_item(&mut self, list_item: &mut NestedMetaItem) {
+    fn visit_meta_list_item(&mut self, list_item: &mut MetaItemInner) {
         walk_meta_list_item(self, list_item);
     }
 
@@ -659,10 +659,10 @@ fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {
     visit_delim_args(vis, body);
 }
 
-fn walk_meta_list_item<T: MutVisitor>(vis: &mut T, li: &mut NestedMetaItem) {
+fn walk_meta_list_item<T: MutVisitor>(vis: &mut T, li: &mut MetaItemInner) {
     match li {
-        NestedMetaItem::MetaItem(mi) => vis.visit_meta_item(mi),
-        NestedMetaItem::Lit(_lit) => {}
+        MetaItemInner::MetaItem(mi) => vis.visit_meta_item(mi),
+        MetaItemInner::Lit(_lit) => {}
     }
 }
 

compiler/rustc_ast_pretty/src/pprust/mod.rs

@@ -67,7 +67,7 @@ pub fn vis_to_string(v: &ast::Visibility) -> String {
     State::new().vis_to_string(v)
 }
 
-pub fn meta_list_item_to_string(li: &ast::NestedMetaItem) -> String {
+pub fn meta_list_item_to_string(li: &ast::MetaItemInner) -> String {
     State::new().meta_list_item_to_string(li)
 }
 

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -2006,10 +2006,10 @@ impl<'a> State<'a> {
         self.print_attribute_inline(attr, false)
     }
 
-    fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) {
+    fn print_meta_list_item(&mut self, item: &ast::MetaItemInner) {
         match item {
-            ast::NestedMetaItem::MetaItem(mi) => self.print_meta_item(mi),
-            ast::NestedMetaItem::Lit(lit) => self.print_meta_item_lit(lit),
+            ast::MetaItemInner::MetaItem(mi) => self.print_meta_item(mi),
+            ast::MetaItemInner::Lit(lit) => self.print_meta_item_lit(lit),
         }
     }
 
@@ -2054,7 +2054,7 @@ impl<'a> State<'a> {
         Self::to_string(|s| s.print_path_segment(p, false))
     }
 
-    pub(crate) fn meta_list_item_to_string(&self, li: &ast::NestedMetaItem) -> String {
+    pub(crate) fn meta_list_item_to_string(&self, li: &ast::MetaItemInner) -> String {
         Self::to_string(|s| s.print_meta_list_item(li))
     }
 

compiler/rustc_attr/src/builtin.rs

@@ -4,7 +4,7 @@ use std::num::NonZero;
 
 use rustc_abi::Align;
 use rustc_ast::{
-    self as ast, Attribute, LitKind, MetaItem, MetaItemKind, MetaItemLit, NestedMetaItem, NodeId,
+    self as ast, Attribute, LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NodeId,
     attr,
 };
 use rustc_ast_pretty::pprust;
@@ -614,12 +614,12 @@ pub fn eval_condition(
         ast::MetaItemKind::List(mis) if cfg.name_or_empty() == sym::version => {
             try_gate_cfg(sym::version, cfg.span, sess, features);
             let (min_version, span) = match &mis[..] {
-                [NestedMetaItem::Lit(MetaItemLit { kind: LitKind::Str(sym, ..), span, .. })] => {
+                [MetaItemInner::Lit(MetaItemLit { kind: LitKind::Str(sym, ..), span, .. })] => {
                     (sym, span)
                 }
                 [
-                    NestedMetaItem::Lit(MetaItemLit { span, .. })
-                    | NestedMetaItem::MetaItem(MetaItem { span, .. }),
+                    MetaItemInner::Lit(MetaItemLit { span, .. })
+                    | MetaItemInner::MetaItem(MetaItem { span, .. }),
                 ] => {
                     dcx.emit_err(session_diagnostics::ExpectedVersionLiteral { span: *span });
                     return false;
@@ -840,7 +840,7 @@ pub fn find_deprecation(
 
                 for meta in list {
                     match meta {
-                        NestedMetaItem::MetaItem(mi) => match mi.name_or_empty() {
+                        MetaItemInner::MetaItem(mi) => match mi.name_or_empty() {
                             sym::since => {
                                 if !get(mi, &mut since) {
                                     continue 'outer;
@@ -879,7 +879,7 @@ pub fn find_deprecation(
                                 continue 'outer;
                             }
                         },
-                        NestedMetaItem::Lit(lit) => {
+                        MetaItemInner::Lit(lit) => {
                             sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
                                 span: lit.span,
                                 reason: UnsupportedLiteralReason::DeprecatedKvPair,
@@ -1244,7 +1244,7 @@ pub fn parse_confusables(attr: &Attribute) -> Option<Vec<Symbol>> {
     let mut candidates = Vec::new();
 
     for meta in metas {
-        let NestedMetaItem::Lit(meta_lit) = meta else {
+        let MetaItemInner::Lit(meta_lit) = meta else {
             return None;
         };
         candidates.push(meta_lit.symbol);

compiler/rustc_builtin_macros/src/derive.rs

@@ -1,5 +1,5 @@
 use rustc_ast as ast;
-use rustc_ast::{GenericParamKind, ItemKind, MetaItemKind, NestedMetaItem, StmtKind};
+use rustc_ast::{GenericParamKind, ItemKind, MetaItemInner, MetaItemKind, StmtKind};
 use rustc_expand::base::{
     Annotatable, DeriveResolution, ExpandResult, ExtCtxt, Indeterminate, MultiItemModifier,
 };
@@ -50,8 +50,8 @@ impl MultiItemModifier for Expander {
                     MetaItemKind::List(list) => {
                         list.iter()
                             .filter_map(|nested_meta| match nested_meta {
-                                NestedMetaItem::MetaItem(meta) => Some(meta),
-                                NestedMetaItem::Lit(lit) => {
+                                MetaItemInner::MetaItem(meta) => Some(meta),
+                                MetaItemInner::Lit(lit) => {
                                     // Reject `#[derive("Debug")]`.
                                     report_unexpected_meta_item_lit(sess, lit);
                                     None

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -1,4 +1,4 @@
-use rustc_ast::{MetaItemKind, NestedMetaItem, ast, attr};
+use rustc_ast::{MetaItemInner, MetaItemKind, ast, attr};
 use rustc_attr::{InlineAttr, InstructionSetAttr, OptimizeAttr, list_contains_name};
 use rustc_errors::codes::*;
 use rustc_errors::{DiagMessage, SubdiagMessage, struct_span_code_err};
@@ -357,7 +357,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
             sym::instruction_set => {
                 codegen_fn_attrs.instruction_set =
                     attr.meta_item_list().and_then(|l| match &l[..] {
-                        [NestedMetaItem::MetaItem(set)] => {
+                        [MetaItemInner::MetaItem(set)] => {
                             let segments =
                                 set.path.segments.iter().map(|x| x.ident.name).collect::<Vec<_>>();
                             match segments.as_slice() {

compiler/rustc_expand/src/base.rs

@@ -29,7 +29,7 @@ use rustc_span::{DUMMY_SP, FileName, Span};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 
-use crate::base::ast::NestedMetaItem;
+use crate::base::ast::MetaItemInner;
 use crate::errors;
 use crate::expand::{self, AstFragment, Invocation};
 use crate::module::DirOwnership;
@@ -783,7 +783,7 @@ impl SyntaxExtension {
 
     fn collapse_debuginfo_by_name(attr: &Attribute) -> Result<CollapseMacroDebuginfo, Span> {
         let list = attr.meta_item_list();
-        let Some([NestedMetaItem::MetaItem(item)]) = list.as_deref() else {
+        let Some([MetaItemInner::MetaItem(item)]) = list.as_deref() else {
             return Err(attr.span);
         };
         if !item.is_word() {

compiler/rustc_expand/src/config.rs

@@ -37,7 +37,7 @@ pub struct StripUnconfigured<'a> {
 }
 
 pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -> Features {
-    fn feature_list(attr: &Attribute) -> ThinVec<ast::NestedMetaItem> {
+    fn feature_list(attr: &Attribute) -> ThinVec<ast::MetaItemInner> {
         if attr.has_name(sym::feature)
             && let Some(list) = attr.meta_item_list()
         {