attrs,
id,
ident,
+ is_placeholder: _,
is_shorthand: _,
pat,
span,
}
pub fn noop_flat_map_arm<T: MutVisitor>(mut arm: Arm, vis: &mut T) -> SmallVec<[Arm; 1]> {
- let Arm { attrs, pat, guard, body, span, id } = &mut arm;
+ let Arm { attrs, pat, guard, body, span, id, is_placeholder: _ } = &mut arm;
visit_attrs(attrs, vis);
vis.visit_id(id);
vis.visit_pat(pat);
}
pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
- let Ty { id, node, span } = ty.deref_mut();
+ let Ty { id, kind, span } = ty.deref_mut();
vis.visit_id(id);
- match node {
+ match kind {
TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err |
TyKind::Never | TyKind::CVarArgs => {}
TyKind::Slice(ty) => vis.visit_ty(ty),
pub fn noop_flat_map_variant<T: MutVisitor>(mut variant: Variant, vis: &mut T)
-> SmallVec<[Variant; 1]>
{
- let Variant { ident, attrs, id, data, disr_expr, span } = &mut variant;
+ let Variant { ident, attrs, id, data, disr_expr, span, is_placeholder: _ } = &mut variant;
vis.visit_ident(ident);
visit_attrs(attrs, vis);
vis.visit_id(id);
}
pub fn noop_flat_map_param<T: MutVisitor>(mut param: Param, vis: &mut T) -> SmallVec<[Param; 1]> {
- let Param { attrs, id, pat, span, ty } = &mut param;
+ let Param { attrs, id, pat, span, ty, is_placeholder: _ } = &mut param;
vis.visit_id(id);
visit_thin_attrs(attrs, vis);
vis.visit_pat(pat);
vis: &mut T
) -> SmallVec<[GenericParam; 1]>
{
- let GenericParam { id, ident, attrs, bounds, kind } = &mut param;
+ let GenericParam { id, ident, attrs, bounds, kind, is_placeholder: _ } = &mut param;
vis.visit_id(id);
vis.visit_ident(ident);
visit_thin_attrs(attrs, vis);
pub fn noop_flat_map_struct_field<T: MutVisitor>(mut sf: StructField, visitor: &mut T)
-> SmallVec<[StructField; 1]>
{
- let StructField { span, ident, vis, id, ty, attrs } = &mut sf;
+ let StructField { span, ident, vis, id, ty, attrs, is_placeholder: _ } = &mut sf;
visitor.visit_span(span);
visit_opt(ident, |ident| visitor.visit_ident(ident));
visitor.visit_vis(vis);
}
pub fn noop_flat_map_field<T: MutVisitor>(mut f: Field, vis: &mut T) -> SmallVec<[Field; 1]> {
- let Field { ident, expr, span, is_shorthand: _, attrs, id } = &mut f;
+ let Field { ident, expr, span, is_shorthand: _, attrs, id, is_placeholder: _ } = &mut f;
vis.visit_ident(ident);
vis.visit_expr(expr);
vis.visit_id(id);
pub fn noop_flat_map_trait_item<T: MutVisitor>(mut item: TraitItem, vis: &mut T)
-> SmallVec<[TraitItem; 1]>
{
- let TraitItem { id, ident, attrs, generics, node, span, tokens: _ } = &mut item;
+ let TraitItem { id, ident, attrs, generics, kind, span, tokens: _ } = &mut item;
vis.visit_id(id);
vis.visit_ident(ident);
visit_attrs(attrs, vis);
vis.visit_generics(generics);
- match node {
+ match kind {
TraitItemKind::Const(ty, default) => {
vis.visit_ty(ty);
visit_opt(default, |default| vis.visit_expr(default));
pub fn noop_flat_map_impl_item<T: MutVisitor>(mut item: ImplItem, visitor: &mut T)
-> SmallVec<[ImplItem; 1]>
{
- let ImplItem { id, ident, vis, defaultness: _, attrs, generics, node, span, tokens: _ } =
+ let ImplItem { id, ident, vis, defaultness: _, attrs, generics, kind, span, tokens: _ } =
&mut item;
visitor.visit_id(id);
visitor.visit_ident(ident);
visitor.visit_vis(vis);
visit_attrs(attrs, visitor);
visitor.visit_generics(generics);
- match node {
+ match kind {
ImplItemKind::Const(ty, expr) => {
visitor.visit_ty(ty);
visitor.visit_expr(expr);
id: DUMMY_NODE_ID,
vis: respan(span.shrink_to_lo(), VisibilityKind::Public),
span,
- node: ItemKind::Mod(module),
+ kind: ItemKind::Mod(module),
tokens: None,
});
let items = vis.flat_map_item(item);
let module = Mod { inner: span, items: vec![], inline: true };
Crate { module, attrs: vec![], span }
} else if len == 1 {
- let Item { attrs, span, node, .. } = items.into_iter().next().unwrap().into_inner();
- match node {
+ let Item { attrs, span, kind, .. } = items.into_iter().next().unwrap().into_inner();
+ match kind {
ItemKind::Mod(module) => Crate { module, attrs, span },
_ => panic!("visitor converted a module to not a module"),
}
// Mutates one item into possibly many items.
pub fn noop_flat_map_item<T: MutVisitor>(mut item: P<Item>, visitor: &mut T)
-> SmallVec<[P<Item>; 1]> {
- let Item { ident, attrs, id, node, vis, span, tokens: _ } = item.deref_mut();
+ let Item { ident, attrs, id, kind, vis, span, tokens: _ } = item.deref_mut();
visitor.visit_ident(ident);
visit_attrs(attrs, visitor);
visitor.visit_id(id);
- visitor.visit_item_kind(node);
+ visitor.visit_item_kind(kind);
visitor.visit_vis(vis);
visitor.visit_span(span);
pub fn noop_flat_map_foreign_item<T: MutVisitor>(mut item: ForeignItem, visitor: &mut T)
-> SmallVec<[ForeignItem; 1]>
{
- let ForeignItem { ident, attrs, node, id, span, vis } = &mut item;
+ let ForeignItem { ident, attrs, kind, id, span, vis } = &mut item;
visitor.visit_ident(ident);
visit_attrs(attrs, visitor);
- match node {
+ match kind {
ForeignItemKind::Fn(fdec, generics) => {
visitor.visit_fn_decl(fdec);
visitor.visit_generics(generics);
}
pub fn noop_visit_pat<T: MutVisitor>(pat: &mut P<Pat>, vis: &mut T) {
- let Pat { id, node, span } = pat.deref_mut();
+ let Pat { id, kind, span } = pat.deref_mut();
vis.visit_id(id);
- match node {
+ match kind {
PatKind::Wild | PatKind::Rest => {}
PatKind::Ident(_binding_mode, ident, sub) => {
vis.visit_ident(ident);
vis.visit_expr(value);
}
-pub fn noop_visit_expr<T: MutVisitor>(Expr { node, id, span, attrs }: &mut Expr, vis: &mut T) {
- match node {
+pub fn noop_visit_expr<T: MutVisitor>(Expr { kind, id, span, attrs }: &mut Expr, vis: &mut T) {
+ match kind {
ExprKind::Box(expr) => vis.visit_expr(expr),
ExprKind::Array(exprs) => visit_exprs(exprs, vis),
ExprKind::Repeat(expr, count) => {
Some({ vis.visit_expr(&mut e); e })
}
-pub fn noop_flat_map_stmt<T: MutVisitor>(Stmt { node, mut span, mut id }: Stmt, vis: &mut T)
+pub fn noop_flat_map_stmt<T: MutVisitor>(Stmt { kind, mut span, mut id }: Stmt, vis: &mut T)
-> SmallVec<[Stmt; 1]>
{
vis.visit_id(&mut id);
vis.visit_span(&mut span);
- noop_flat_map_stmt_kind(node, vis).into_iter().map(|node| {
- Stmt { id, node, span }
+ noop_flat_map_stmt_kind(kind, vis).into_iter().map(|kind| {
+ Stmt { id, kind, span }
}).collect()
}
-pub fn noop_flat_map_stmt_kind<T: MutVisitor>(node: StmtKind, vis: &mut T)
+pub fn noop_flat_map_stmt_kind<T: MutVisitor>(kind: StmtKind, vis: &mut T)
-> SmallVec<[StmtKind; 1]> {
- match node {
+ match kind {
StmtKind::Local(mut local) =>
smallvec![StmtKind::Local({ vis.visit_local(&mut local); local })],
StmtKind::Item(item) => vis.flat_map_item(item).into_iter().map(StmtKind::Item).collect(),