Move hir::Item::ident into hir::ItemKind.
`hir::Item` has an `ident` field.
- It's always non-empty for these item kinds: `ExternCrate`, `Static`,
`Const`, `Fn`, `Macro`, `Mod`, `TyAlias`, `Enum`, `Struct`, `Union`,
Trait`, TraitAalis`.
- It's always empty for these item kinds: `ForeignMod`, `GlobalAsm`,
`Impl`.
- For `Use`, it is non-empty for `UseKind::Single` and empty for
`UseKind::{Glob,ListStem}`.
All of this is quite non-obvious; the only documentation is a single
comment saying "The name might be a dummy name in case of anonymous
items". 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.
- A similar transformation makes sense for `ast::Item`, but this is
already a big change. That can be done later.
- Lots of assertions are added to item lowering to ensure that
identifiers are empty/non-empty as expected. These will be removable
when `ast::Item` is done later.
- `ItemKind::Use` doesn't get an `Ident`, but `UseKind::Single` does.
- `lower_use_tree` is significantly simpler. No more confusing `&mut
Ident` to deal with.
- `ItemKind::ident` is a new method, it returns an `Option<Ident>`. It's
used with `unwrap` in a few places; sometimes it's hard to tell
exactly which item kinds might occur. None of these unwraps fail on
the test suite. It's conceivable that some might fail on alternative
input. We can deal with those if/when they happen.
- In `trait_path` the `find_map`/`if let` is replaced with a loop, and
things end up much clearer that way.
- `named_span` no longer checks for an empty name; instead the call site
now checks for a missing identifier if necessary.
- `maybe_inline_local` doesn't need the `glob` argument, it can be
computed in-function from the `renamed` argument.
- `arbitrary_source_item_ordering::check_mod` had a big `if` statement
that was just getting the ident from the item kinds that had one. It
could be mostly replaced by a single call to the new `ItemKind::ident`
method.
- `ItemKind` grows from 56 to 64 bytes, but `Item` stays the same size,
and that's what matters, because `ItemKind` only occurs within `Item`.
This commit is contained in:
Nicholas Nethercote
parent
6698c26b3a
commit
f2ddbcd24b
82 changed files with 666 additions and 555 deletions
|
|
@ -3755,7 +3755,10 @@ pub enum UseKind {
|
|||
/// One import, e.g., `use foo::bar` or `use foo::bar as baz`.
|
||||
/// Also produced for each element of a list `use`, e.g.
|
||||
/// `use foo::{a, b}` lowers to `use foo::a; use foo::b;`.
|
||||
Single,
|
||||
///
|
||||
/// The identifier is the name defined by the import. E.g. for `use
|
||||
/// foo::bar` it is `bar`, for `use foo::bar as baz` it is `baz`.
|
||||
Single(Ident),
|
||||
|
||||
/// Glob import, e.g., `use foo::*`.
|
||||
Glob,
|
||||
|
|
@ -3897,8 +3900,6 @@ impl ItemId {
|
|||
|
||||
/// An item
|
||||
///
|
||||
/// The name might be a dummy name in case of anonymous items
|
||||
///
|
||||
/// For more details, see the [rust lang reference].
|
||||
/// Note that the reference does not document nightly-only features.
|
||||
/// There may be also slight differences in the names and representation of AST nodes between
|
||||
|
|
@ -3907,7 +3908,6 @@ impl ItemId {
|
|||
/// [rust lang reference]: https://doc.rust-lang.org/reference/items.html
|
||||
#[derive(Debug, Clone, Copy, HashStable_Generic)]
|
||||
pub struct Item<'hir> {
|
||||
pub ident: Ident,
|
||||
pub owner_id: OwnerId,
|
||||
pub kind: ItemKind<'hir>,
|
||||
pub span: Span,
|
||||
|
|
@ -3937,46 +3937,56 @@ impl<'hir> Item<'hir> {
|
|||
}
|
||||
|
||||
expect_methods_self_kind! {
|
||||
expect_extern_crate, Option<Symbol>, ItemKind::ExternCrate(s), *s;
|
||||
expect_extern_crate, (Option<Symbol>, Ident),
|
||||
ItemKind::ExternCrate(s, ident), (*s, *ident);
|
||||
|
||||
expect_use, (&'hir UsePath<'hir>, UseKind), ItemKind::Use(p, uk), (p, *uk);
|
||||
|
||||
expect_static, (&'hir Ty<'hir>, Mutability, BodyId),
|
||||
ItemKind::Static(ty, mutbl, body), (ty, *mutbl, *body);
|
||||
expect_static, (Ident, &'hir Ty<'hir>, Mutability, BodyId),
|
||||
ItemKind::Static(ident, ty, mutbl, body), (*ident, ty, *mutbl, *body);
|
||||
|
||||
expect_const, (&'hir Ty<'hir>, &'hir Generics<'hir>, BodyId),
|
||||
ItemKind::Const(ty, generics, body), (ty, generics, *body);
|
||||
expect_const, (Ident, &'hir Ty<'hir>, &'hir Generics<'hir>, BodyId),
|
||||
ItemKind::Const(ident, ty, generics, body), (*ident, ty, generics, *body);
|
||||
|
||||
expect_fn, (&FnSig<'hir>, &'hir Generics<'hir>, BodyId),
|
||||
ItemKind::Fn { sig, generics, body, .. }, (sig, generics, *body);
|
||||
expect_fn, (Ident, &FnSig<'hir>, &'hir Generics<'hir>, BodyId),
|
||||
ItemKind::Fn { ident, sig, generics, body, .. }, (*ident, sig, generics, *body);
|
||||
|
||||
expect_macro, (&ast::MacroDef, MacroKind), ItemKind::Macro(def, mk), (def, *mk);
|
||||
expect_macro, (Ident, &ast::MacroDef, MacroKind),
|
||||
ItemKind::Macro(ident, def, mk), (*ident, def, *mk);
|
||||
|
||||
expect_mod, &'hir Mod<'hir>, ItemKind::Mod(m), m;
|
||||
expect_mod, (Ident, &'hir Mod<'hir>), ItemKind::Mod(ident, m), (*ident, m);
|
||||
|
||||
expect_foreign_mod, (ExternAbi, &'hir [ForeignItemRef]),
|
||||
ItemKind::ForeignMod { abi, items }, (*abi, items);
|
||||
|
||||
expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm { asm, .. }, asm;
|
||||
|
||||
expect_ty_alias, (&'hir Ty<'hir>, &'hir Generics<'hir>),
|
||||
ItemKind::TyAlias(ty, generics), (ty, generics);
|
||||
expect_ty_alias, (Ident, &'hir Ty<'hir>, &'hir Generics<'hir>),
|
||||
ItemKind::TyAlias(ident, ty, generics), (*ident, ty, generics);
|
||||
|
||||
expect_enum, (&EnumDef<'hir>, &'hir Generics<'hir>), ItemKind::Enum(def, generics), (def, generics);
|
||||
expect_enum, (Ident, &EnumDef<'hir>, &'hir Generics<'hir>),
|
||||
ItemKind::Enum(ident, def, generics), (*ident, def, generics);
|
||||
|
||||
expect_struct, (&VariantData<'hir>, &'hir Generics<'hir>),
|
||||
ItemKind::Struct(data, generics), (data, generics);
|
||||
expect_struct, (Ident, &VariantData<'hir>, &'hir Generics<'hir>),
|
||||
ItemKind::Struct(ident, data, generics), (*ident, data, generics);
|
||||
|
||||
expect_union, (&VariantData<'hir>, &'hir Generics<'hir>),
|
||||
ItemKind::Union(data, generics), (data, generics);
|
||||
expect_union, (Ident, &VariantData<'hir>, &'hir Generics<'hir>),
|
||||
ItemKind::Union(ident, data, generics), (*ident, data, generics);
|
||||
|
||||
expect_trait,
|
||||
(IsAuto, Safety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
|
||||
ItemKind::Trait(is_auto, safety, generics, bounds, items),
|
||||
(*is_auto, *safety, generics, bounds, items);
|
||||
(
|
||||
IsAuto,
|
||||
Safety,
|
||||
Ident,
|
||||
&'hir Generics<'hir>,
|
||||
GenericBounds<'hir>,
|
||||
&'hir [TraitItemRef]
|
||||
),
|
||||
ItemKind::Trait(is_auto, safety, ident, generics, bounds, items),
|
||||
(*is_auto, *safety, *ident, generics, bounds, items);
|
||||
|
||||
expect_trait_alias, (&'hir Generics<'hir>, GenericBounds<'hir>),
|
||||
ItemKind::TraitAlias(generics, bounds), (generics, bounds);
|
||||
expect_trait_alias, (Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
|
||||
ItemKind::TraitAlias(ident, generics, bounds), (*ident, generics, bounds);
|
||||
|
||||
expect_impl, &'hir Impl<'hir>, ItemKind::Impl(imp), imp;
|
||||
}
|
||||
|
|
@ -4094,7 +4104,7 @@ pub enum ItemKind<'hir> {
|
|||
/// An `extern crate` item, with 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),
|
||||
|
||||
/// `use foo::bar::*;` or `use foo::bar::baz as quux;`
|
||||
///
|
||||
|
|
@ -4104,11 +4114,12 @@ pub enum ItemKind<'hir> {
|
|||
Use(&'hir UsePath<'hir>, UseKind),
|
||||
|
||||
/// A `static` item.
|
||||
Static(&'hir Ty<'hir>, Mutability, BodyId),
|
||||
Static(Ident, &'hir Ty<'hir>, Mutability, BodyId),
|
||||
/// A `const` item.
|
||||
Const(&'hir Ty<'hir>, &'hir Generics<'hir>, BodyId),
|
||||
Const(Ident, &'hir Ty<'hir>, &'hir Generics<'hir>, BodyId),
|
||||
/// A function declaration.
|
||||
Fn {
|
||||
ident: Ident,
|
||||
sig: FnSig<'hir>,
|
||||
generics: &'hir Generics<'hir>,
|
||||
body: BodyId,
|
||||
|
|
@ -4118,9 +4129,9 @@ pub enum ItemKind<'hir> {
|
|||
has_body: bool,
|
||||
},
|
||||
/// A MBE macro definition (`macro_rules!` or `macro`).
|
||||
Macro(&'hir ast::MacroDef, MacroKind),
|
||||
Macro(Ident, &'hir ast::MacroDef, MacroKind),
|
||||
/// A module.
|
||||
Mod(&'hir Mod<'hir>),
|
||||
Mod(Ident, &'hir Mod<'hir>),
|
||||
/// An external module, e.g. `extern { .. }`.
|
||||
ForeignMod { abi: ExternAbi, items: &'hir [ForeignItemRef] },
|
||||
/// Module-level inline assembly (from `global_asm!`).
|
||||
|
|
@ -4134,17 +4145,17 @@ pub enum ItemKind<'hir> {
|
|||
fake_body: BodyId,
|
||||
},
|
||||
/// A type alias, e.g., `type Foo = Bar<u8>`.
|
||||
TyAlias(&'hir Ty<'hir>, &'hir Generics<'hir>),
|
||||
/// An enum definition, e.g., `enum Foo<A, B> {C<A>, D<B>}`.
|
||||
Enum(EnumDef<'hir>, &'hir Generics<'hir>),
|
||||
TyAlias(Ident, &'hir Ty<'hir>, &'hir Generics<'hir>),
|
||||
/// An enum definition, e.g., `enum Foo<A, B> { C<A>, D<B> }`.
|
||||
Enum(Ident, EnumDef<'hir>, &'hir Generics<'hir>),
|
||||
/// A struct definition, e.g., `struct Foo<A> {x: A}`.
|
||||
Struct(VariantData<'hir>, &'hir Generics<'hir>),
|
||||
Struct(Ident, VariantData<'hir>, &'hir Generics<'hir>),
|
||||
/// A union definition, e.g., `union Foo<A, B> {x: A, y: B}`.
|
||||
Union(VariantData<'hir>, &'hir Generics<'hir>),
|
||||
Union(Ident, VariantData<'hir>, &'hir Generics<'hir>),
|
||||
/// A trait definition.
|
||||
Trait(IsAuto, Safety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
|
||||
Trait(IsAuto, Safety, Ident, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
|
||||
/// A trait alias.
|
||||
TraitAlias(&'hir Generics<'hir>, GenericBounds<'hir>),
|
||||
TraitAlias(Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
|
||||
|
||||
/// An implementation, e.g., `impl<A> Trait for Foo { .. }`.
|
||||
Impl(&'hir Impl<'hir>),
|
||||
|
|
@ -4173,16 +4184,39 @@ pub struct Impl<'hir> {
|
|||
}
|
||||
|
||||
impl ItemKind<'_> {
|
||||
pub fn ident(&self) -> Option<Ident> {
|
||||
match *self {
|
||||
ItemKind::ExternCrate(_, ident)
|
||||
| ItemKind::Use(_, UseKind::Single(ident))
|
||||
| ItemKind::Static(ident, ..)
|
||||
| ItemKind::Const(ident, ..)
|
||||
| ItemKind::Fn { ident, .. }
|
||||
| ItemKind::Macro(ident, ..)
|
||||
| ItemKind::Mod(ident, ..)
|
||||
| ItemKind::TyAlias(ident, ..)
|
||||
| ItemKind::Enum(ident, ..)
|
||||
| ItemKind::Struct(ident, ..)
|
||||
| ItemKind::Union(ident, ..)
|
||||
| ItemKind::Trait(_, _, ident, ..)
|
||||
| ItemKind::TraitAlias(ident, ..) => Some(ident),
|
||||
|
||||
ItemKind::Use(_, UseKind::Glob | UseKind::ListStem)
|
||||
| ItemKind::ForeignMod { .. }
|
||||
| ItemKind::GlobalAsm { .. }
|
||||
| ItemKind::Impl(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn generics(&self) -> Option<&Generics<'_>> {
|
||||
Some(match self {
|
||||
ItemKind::Fn { generics, .. }
|
||||
| ItemKind::TyAlias(_, generics)
|
||||
| ItemKind::Const(_, generics, _)
|
||||
| ItemKind::Enum(_, generics)
|
||||
| ItemKind::Struct(_, generics)
|
||||
| ItemKind::Union(_, generics)
|
||||
| ItemKind::Trait(_, _, generics, _, _)
|
||||
| ItemKind::TraitAlias(generics, _)
|
||||
| ItemKind::TyAlias(_, _, generics)
|
||||
| ItemKind::Const(_, _, generics, _)
|
||||
| ItemKind::Enum(_, _, generics)
|
||||
| ItemKind::Struct(_, _, generics)
|
||||
| ItemKind::Union(_, _, generics)
|
||||
| ItemKind::Trait(_, _, _, generics, _, _)
|
||||
| ItemKind::TraitAlias(_, generics, _)
|
||||
| ItemKind::Impl(Impl { generics, .. }) => generics,
|
||||
_ => return None,
|
||||
})
|
||||
|
|
@ -4374,8 +4408,8 @@ impl<'hir> OwnerNode<'hir> {
|
|||
match self {
|
||||
OwnerNode::Item(Item {
|
||||
kind:
|
||||
ItemKind::Static(_, _, body)
|
||||
| ItemKind::Const(_, _, body)
|
||||
ItemKind::Static(_, _, _, body)
|
||||
| ItemKind::Const(_, _, _, body)
|
||||
| ItemKind::Fn { body, .. },
|
||||
..
|
||||
})
|
||||
|
|
@ -4518,12 +4552,12 @@ impl<'hir> Node<'hir> {
|
|||
/// ```
|
||||
pub fn ident(&self) -> Option<Ident> {
|
||||
match self {
|
||||
Node::Item(item) => item.kind.ident(),
|
||||
Node::TraitItem(TraitItem { ident, .. })
|
||||
| Node::ImplItem(ImplItem { ident, .. })
|
||||
| Node::ForeignItem(ForeignItem { ident, .. })
|
||||
| Node::Field(FieldDef { ident, .. })
|
||||
| Node::Variant(Variant { ident, .. })
|
||||
| Node::Item(Item { ident, .. })
|
||||
| Node::PathSegment(PathSegment { ident, .. }) => Some(*ident),
|
||||
Node::Lifetime(lt) => Some(lt.ident),
|
||||
Node::GenericParam(p) => Some(p.name.ident()),
|
||||
|
|
@ -4599,9 +4633,9 @@ impl<'hir> Node<'hir> {
|
|||
pub fn ty(self) -> Option<&'hir Ty<'hir>> {
|
||||
match self {
|
||||
Node::Item(it) => match it.kind {
|
||||
ItemKind::TyAlias(ty, _)
|
||||
| ItemKind::Static(ty, _, _)
|
||||
| ItemKind::Const(ty, _, _) => Some(ty),
|
||||
ItemKind::TyAlias(_, ty, _)
|
||||
| ItemKind::Static(_, ty, _, _)
|
||||
| ItemKind::Const(_, ty, _, _) => Some(ty),
|
||||
ItemKind::Impl(impl_item) => Some(&impl_item.self_ty),
|
||||
_ => None,
|
||||
},
|
||||
|
|
@ -4621,7 +4655,7 @@ impl<'hir> Node<'hir> {
|
|||
|
||||
pub fn alias_ty(self) -> Option<&'hir Ty<'hir>> {
|
||||
match self {
|
||||
Node::Item(Item { kind: ItemKind::TyAlias(ty, ..), .. }) => Some(ty),
|
||||
Node::Item(Item { kind: ItemKind::TyAlias(_, ty, _), .. }) => Some(ty),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -4632,7 +4666,9 @@ impl<'hir> Node<'hir> {
|
|||
Node::Item(Item {
|
||||
owner_id,
|
||||
kind:
|
||||
ItemKind::Const(_, _, body) | ItemKind::Static(.., body) | ItemKind::Fn { body, .. },
|
||||
ItemKind::Const(_, _, _, body)
|
||||
| ItemKind::Static(.., body)
|
||||
| ItemKind::Fn { body, .. },
|
||||
..
|
||||
})
|
||||
| Node::TraitItem(TraitItem {
|
||||
|
|
@ -4693,8 +4729,8 @@ impl<'hir> Node<'hir> {
|
|||
pub fn fn_kind(self) -> Option<FnKind<'hir>> {
|
||||
match self {
|
||||
Node::Item(i) => match i.kind {
|
||||
ItemKind::Fn { sig, generics, .. } => {
|
||||
Some(FnKind::ItemFn(i.ident, generics, sig.header))
|
||||
ItemKind::Fn { ident, sig, generics, .. } => {
|
||||
Some(FnKind::ItemFn(ident, generics, sig.header))
|
||||
}
|
||||
_ => None,
|
||||
},
|
||||
|
|
@ -4767,7 +4803,7 @@ mod size_asserts {
|
|||
static_assert_size!(ImplItem<'_>, 88);
|
||||
static_assert_size!(ImplItemKind<'_>, 40);
|
||||
static_assert_size!(Item<'_>, 88);
|
||||
static_assert_size!(ItemKind<'_>, 56);
|
||||
static_assert_size!(ItemKind<'_>, 64);
|
||||
static_assert_size!(LetStmt<'_>, 64);
|
||||
static_assert_size!(Param<'_>, 32);
|
||||
static_assert_size!(Pat<'_>, 72);
|
||||
|
|
|
|||
|
|
@ -533,34 +533,44 @@ pub fn walk_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Param<'v>) ->
|
|||
|
||||
pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::Result {
|
||||
try_visit!(visitor.visit_id(item.hir_id()));
|
||||
try_visit!(visitor.visit_ident(item.ident));
|
||||
match item.kind {
|
||||
ItemKind::ExternCrate(orig_name) => {
|
||||
ItemKind::ExternCrate(orig_name, ident) => {
|
||||
visit_opt!(visitor, visit_name, orig_name);
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
}
|
||||
ItemKind::Use(ref path, _) => {
|
||||
ItemKind::Use(ref path, kind) => {
|
||||
try_visit!(visitor.visit_use(path, item.hir_id()));
|
||||
match kind {
|
||||
UseKind::Single(ident) => try_visit!(visitor.visit_ident(ident)),
|
||||
UseKind::Glob | UseKind::ListStem => {}
|
||||
}
|
||||
}
|
||||
ItemKind::Static(ref typ, _, body) => {
|
||||
ItemKind::Static(ident, ref typ, _, body) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_ty_unambig(typ));
|
||||
try_visit!(visitor.visit_nested_body(body));
|
||||
}
|
||||
ItemKind::Const(ref typ, ref generics, body) => {
|
||||
ItemKind::Const(ident, ref typ, ref generics, body) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_ty_unambig(typ));
|
||||
try_visit!(visitor.visit_generics(generics));
|
||||
try_visit!(visitor.visit_nested_body(body));
|
||||
}
|
||||
ItemKind::Fn { sig, generics, body: body_id, .. } => {
|
||||
ItemKind::Fn { ident, sig, generics, body: body_id, .. } => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_fn(
|
||||
FnKind::ItemFn(item.ident, generics, sig.header),
|
||||
FnKind::ItemFn(ident, generics, sig.header),
|
||||
sig.decl,
|
||||
body_id,
|
||||
item.span,
|
||||
item.owner_id.def_id,
|
||||
));
|
||||
}
|
||||
ItemKind::Macro(..) => {}
|
||||
ItemKind::Mod(ref module) => {
|
||||
ItemKind::Macro(ident, _def, _kind) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
}
|
||||
ItemKind::Mod(ident, ref module) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_mod(module, item.span, item.hir_id()));
|
||||
}
|
||||
ItemKind::ForeignMod { abi: _, items } => {
|
||||
|
|
@ -573,11 +583,13 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
|
|||
// typeck results set correctly.
|
||||
try_visit!(visitor.visit_nested_body(fake_body));
|
||||
}
|
||||
ItemKind::TyAlias(ref ty, ref generics) => {
|
||||
ItemKind::TyAlias(ident, ref ty, ref generics) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_ty_unambig(ty));
|
||||
try_visit!(visitor.visit_generics(generics));
|
||||
}
|
||||
ItemKind::Enum(ref enum_definition, ref generics) => {
|
||||
ItemKind::Enum(ident, ref enum_definition, ref generics) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_generics(generics));
|
||||
try_visit!(visitor.visit_enum_def(enum_definition));
|
||||
}
|
||||
|
|
@ -597,17 +609,20 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
|
|||
try_visit!(visitor.visit_ty_unambig(self_ty));
|
||||
walk_list!(visitor, visit_impl_item_ref, *items);
|
||||
}
|
||||
ItemKind::Struct(ref struct_definition, ref generics)
|
||||
| ItemKind::Union(ref struct_definition, ref generics) => {
|
||||
ItemKind::Struct(ident, ref struct_definition, ref generics)
|
||||
| ItemKind::Union(ident, ref struct_definition, ref generics) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_generics(generics));
|
||||
try_visit!(visitor.visit_variant_data(struct_definition));
|
||||
}
|
||||
ItemKind::Trait(.., ref generics, bounds, trait_item_refs) => {
|
||||
ItemKind::Trait(_is_auto, _safety, ident, ref generics, bounds, trait_item_refs) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_generics(generics));
|
||||
walk_list!(visitor, visit_param_bound, bounds);
|
||||
walk_list!(visitor, visit_trait_item_ref, trait_item_refs);
|
||||
}
|
||||
ItemKind::TraitAlias(ref generics, bounds) => {
|
||||
ItemKind::TraitAlias(ident, ref generics, bounds) => {
|
||||
try_visit!(visitor.visit_ident(ident));
|
||||
try_visit!(visitor.visit_generics(generics));
|
||||
walk_list!(visitor, visit_param_bound, bounds);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue