Move ast::Item::ident into ast::ItemKind.

`ast::Item` has an `ident` field.
- It's always non-empty for these item kinds: `ExternCrate`, `Static`,
`Const`, `Fn`, `Mod`, `TyAlias`, `Enum`, `Struct`, `Union`,
`Trait`, `TraitAlias`, `MacroDef`, `Delegation`.
- It's always empty for these item kinds: `Use`, `ForeignMod`,
`GlobalAsm`, `Impl`, `MacCall`, `DelegationMac`.
There is a similar story for `AssocItemKind` and `ForeignItemKind`.
Some sites that handle items check for an empty ident, some don't. This
is a very C-like way of doing things, but this is Rust, we have sum
types, we can do this properly and never forget to check for the
exceptional case and never YOLO possibly empty identifiers (or possibly
dummy spans) around and hope that things will work out.
The commit is large but it's mostly obvious plumbing work. Some notable
things.
- `ast::Item` got 8 bytes bigger. This could be avoided by boxing the
fields within some of the `ast::ItemKind` variants (specifically:
`Struct`, `Union`, `Enum`). I might do that in a follow-up; this
commit is big enough already.
- For the visitors: `FnKind` no longer needs an `ident` field because
the `Fn` within how has one.
- In the parser, the `ItemInfo` typedef is no longer needed. It was used
in various places to return an `Ident` alongside an `ItemKind`, but
now the `Ident` (if present) is within the `ItemKind`.
- In a few places I renamed identifier variables called `name` (or
`foo_name`) as `ident` (or `foo_ident`), to better match the type, and
because `name` is normally used for `Symbol`s. It's confusing to see
something like `foo_name.name`.

Author: nnethercote

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);