Auto merge of #138740 - nnethercote:ast-ItemKind-idents, r=fmease

Move `ast::Item::ident` into `ast::ItemKind`
The follow-up to #138384, which did the same thing for `hir::ItemKind`.
r? `@fmease`

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -3303,9 +3303,6 @@ pub struct Item<K = ItemKind> {
 pubid:NodeId,
 pubspan:Span,
 pubvis:Visibility,
-/// The name of the item.
-/// It might be a dummy name in case of anonymous items.
-pubident:Ident,
 
 pubkind:K,
 
@@ -3327,23 +3324,23 @@ impl Item {
 
 pubfnopt_generics(&self) -> Option<&Generics>{
 match&self.kind{
-ItemKind::ExternCrate(_)
+ItemKind::ExternCrate(..)
  | ItemKind::Use(_)
- | ItemKind::Mod(_, _)
+ | ItemKind::Mod(..)
  | ItemKind::ForeignMod(_)
  | ItemKind::GlobalAsm(_)
  | ItemKind::MacCall(_)
  | ItemKind::Delegation(_)
  | ItemKind::DelegationMac(_)
- | ItemKind::MacroDef(_) => None,
+ | ItemKind::MacroDef(..) => None,
 ItemKind::Static(_) => None,
 ItemKind::Const(i) => Some(&i.generics),
 ItemKind::Fn(i) => Some(&i.generics),
 ItemKind::TyAlias(i) => Some(&i.generics),
-ItemKind::TraitAlias(generics, _)
- | ItemKind::Enum(_, generics)
- | ItemKind::Struct(_, generics)
- | ItemKind::Union(_, generics) => Some(&generics),
+ItemKind::TraitAlias(_,generics, _)
+ | ItemKind::Enum(_,_,generics)
+ | ItemKind::Struct(_,_,generics)
+ | ItemKind::Union(_,_,generics) => Some(&generics),
 ItemKind::Trait(i) => Some(&i.generics),
 ItemKind::Impl(i) => Some(&i.generics),
 }
@@ -3420,6 +3417,7 @@ impl Default for FnHeader {
 pubstructTrait{
 pubsafety:Safety,
 pubis_auto:IsAuto,
+pubident:Ident,
 pubgenerics:Generics,
 pubbounds:GenericBounds,
 pubitems:ThinVec<P<AssocItem>>,
@@ -3465,6 +3463,7 @@ pub struct TyAliasWhereClauses {
 #[derive(Clone,Encodable,Decodable,Debug)]
 pubstructTyAlias{
 pubdefaultness:Defaultness,
+pubident:Ident,
 pubgenerics:Generics,
 pubwhere_clauses:TyAliasWhereClauses,
 pubbounds:GenericBounds,
@@ -3493,6 +3492,7 @@ pub struct FnContract {
 #[derive(Clone,Encodable,Decodable,Debug)]
 pubstructFn{
 pubdefaultness:Defaultness,
+pubident:Ident,
 pubgenerics:Generics,
 pubsig:FnSig,
 pubcontract:Option<P<FnContract>>,
@@ -3506,6 +3506,7 @@ pub struct Delegation {
 pubid:NodeId,
 pubqself:Option<P<QSelf>>,
 pubpath:Path,
+pubident:Ident,
 pubrename:Option<Ident>,
 pubbody:Option<P<Block>>,
 /// The item was expanded from a glob delegation item.
@@ -3523,6 +3524,7 @@ pub struct DelegationMac {
 
 #[derive(Clone,Encodable,Decodable,Debug)]
 pubstructStaticItem{
+pubident:Ident,
 pubty:P<Ty>,
 pubsafety:Safety,
 pubmutability:Mutability,
@@ -3533,6 +3535,7 @@ pub struct StaticItem {
 #[derive(Clone,Encodable,Decodable,Debug)]
 pubstructConstItem{
 pubdefaultness:Defaultness,
+pubident:Ident,
 pubgenerics:Generics,
 pubty:P<Ty>,
 pubexpr:Option<P<Expr>>,
@@ -3545,7 +3548,7 @@ pub enum ItemKind {
 /// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
 ///
 /// E.g., `extern crate foo` or `extern crate foo_bar as foo`.
-ExternCrate(Option<Symbol>),
+ExternCrate(Option<Symbol>,Ident),
 /// A use declaration item (`use`).
 ///
 /// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`.
@@ -3567,7 +3570,7 @@ pub enum ItemKind {
 /// E.g., `mod foo;` or `mod foo { .. }`.
 /// `unsafe` keyword on modules is accepted syntactically for macro DSLs, but not
 /// semantically by Rust.
-Mod(Safety,ModKind),
+Mod(Safety,Ident,ModKind),
 /// An external module (`extern`).
 ///
 /// E.g., `extern {}` or `extern "C" {}`.
@@ -3581,23 +3584,23 @@ pub enum ItemKind {
 /// An enum definition (`enum`).
 ///
 /// E.g., `enum Foo<A, B> { C<A>, D<B> }`.
-Enum(EnumDef,Generics),
+Enum(Ident,EnumDef,Generics),
 /// A struct definition (`struct`).
 ///
 /// E.g., `struct Foo<A> { x: A }`.
-Struct(VariantData,Generics),
+Struct(Ident,VariantData,Generics),
 /// A union definition (`union`).
 ///
 /// E.g., `union Foo<A, B> { x: A, y: B }`.
-Union(VariantData,Generics),
+Union(Ident,VariantData,Generics),
 /// A trait declaration (`trait`).
 ///
 /// E.g., `trait Foo { .. }`, `trait Foo<T> { .. }` or `auto trait Foo {}`.
 Trait(Box<Trait>),
 /// Trait alias.
 ///
 /// E.g., `trait Foo = Bar + Quux;`.
-TraitAlias(Generics,GenericBounds),
+TraitAlias(Ident,Generics,GenericBounds),
 /// An implementation.
 ///
 /// E.g., `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`.
@@ -3608,7 +3611,7 @@ pub enum ItemKind {
 MacCall(P<MacCall>),
 
 /// A macro definition.
-MacroDef(MacroDef),
+MacroDef(Ident,MacroDef),
 
 /// A single delegation item (`reuse`).
 ///
@@ -3620,6 +3623,31 @@ pub enum ItemKind {
 }
 
 implItemKind{
+pubfnident(&self) -> Option<Ident>{
+match*self{
+ItemKind::ExternCrate(_, ident)
+ | ItemKind::Static(box StaticItem{ ident, .. })
+ | ItemKind::Const(box ConstItem{ ident, .. })
+ | ItemKind::Fn(boxFn{ ident, .. })
+ | ItemKind::Mod(_, ident, _)
+ | ItemKind::TyAlias(box TyAlias{ ident, .. })
+ | ItemKind::Enum(ident, ..)
+ | ItemKind::Struct(ident, ..)
+ | ItemKind::Union(ident, ..)
+ | ItemKind::Trait(box Trait{ ident, .. })
+ | ItemKind::TraitAlias(ident, ..)
+ | ItemKind::MacroDef(ident, _)
+ | ItemKind::Delegation(box Delegation{ ident, .. }) => Some(ident),
+
+ItemKind::Use(_)
+ | ItemKind::ForeignMod(_)
+ | ItemKind::GlobalAsm(_)
+ | ItemKind::Impl(_)
+ | ItemKind::MacCall(_)
+ | ItemKind::DelegationMac(_) => None,
+}
+}
+
 /// "a" or "an"
 pubfnarticle(&self) -> &'staticstr{
 useItemKind::*;
@@ -3660,11 +3688,11 @@ impl ItemKind {
 Self::Fn(boxFn{ generics, .. })
  | Self::TyAlias(box TyAlias{ generics, .. })
  | Self::Const(box ConstItem{ generics, .. })
- | Self::Enum(_, generics)
- | Self::Struct(_, generics)
- | Self::Union(_, generics)
+ | Self::Enum(_,_,generics)
+ | Self::Struct(_,_,generics)
+ | Self::Union(_,_,generics)
  | Self::Trait(box Trait{ generics, .. })
- | Self::TraitAlias(generics, _)
+ | Self::TraitAlias(_,generics, _)
  | Self::Impl(box Impl{ generics, .. }) => Some(generics),
  _ => None,
 }
@@ -3700,6 +3728,17 @@ pub enum AssocItemKind {
 }
 
 implAssocItemKind{
+pubfnident(&self) -> Option<Ident>{
+match*self{
+AssocItemKind::Const(box ConstItem{ ident, .. })
+ | AssocItemKind::Fn(boxFn{ ident, .. })
+ | AssocItemKind::Type(box TyAlias{ ident, .. })
+ | AssocItemKind::Delegation(box Delegation{ ident, .. }) => Some(ident),
+
+AssocItemKind::MacCall(_) | AssocItemKind::DelegationMac(_) => None,
+}
+}
+
 pubfndefaultness(&self) -> Defaultness{
 match*self{
 Self::Const(box ConstItem{ defaultness, .. })
@@ -3746,14 +3785,26 @@ impl TryFrom<ItemKind> for AssocItemKind {
 pubenumForeignItemKind{
 /// A foreign static item (`static FOO: u8`).
 Static(Box<StaticItem>),
-/// An foreign function.
+/// A foreign function.
 Fn(Box<Fn>),
-/// An foreign type.
+/// A foreign type.
 TyAlias(Box<TyAlias>),
 /// A macro expanding to foreign items.
 MacCall(P<MacCall>),
 }
 
+implForeignItemKind{
+pubfnident(&self) -> Option<Ident>{
+match*self{
+ForeignItemKind::Static(box StaticItem{ ident, .. })
+ | ForeignItemKind::Fn(boxFn{ ident, .. })
+ | ForeignItemKind::TyAlias(box TyAlias{ ident, .. }) => Some(ident),
+
+ForeignItemKind::MacCall(_) => None,
+}
+}
+}
+
 implFrom<ForeignItemKind>forItemKind{
 fnfrom(foreign_item_kind:ForeignItemKind) -> ItemKind{
 match foreign_item_kind {
@@ -3790,21 +3841,21 @@ mod size_asserts {
 
 usesuper::*;
 // tidy-alphabetical-start
-static_assert_size!(AssocItem,88);
+static_assert_size!(AssocItem,80);
 static_assert_size!(AssocItemKind,16);
 static_assert_size!(Attribute,32);
 static_assert_size!(Block,32);
 static_assert_size!(Expr,72);
 static_assert_size!(ExprKind,40);
-static_assert_size!(Fn,176);
-static_assert_size!(ForeignItem,88);
+static_assert_size!(Fn,184);
+static_assert_size!(ForeignItem,80);
 static_assert_size!(ForeignItemKind,16);
 static_assert_size!(GenericArg,24);
 static_assert_size!(GenericBound,88);
 static_assert_size!(Generics,40);
 static_assert_size!(Impl,136);
-static_assert_size!(Item,136);
-static_assert_size!(ItemKind,64);
+static_assert_size!(Item,144);
+static_assert_size!(ItemKind,80);
 static_assert_size!(LitKind,24);
 static_assert_size!(Local,80);
 static_assert_size!(MetaItemLit,40);