Avoid conflicting imports in generated code
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 3faa53c..8580952 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -466,11 +466,10 @@
}
pub fn fold_attr_style<V: Folder + ?Sized>(_visitor: &mut V, _i: AttrStyle) -> AttrStyle {
- use ::AttrStyle::*;
match _i {
- Outer => { Outer }
- Inner(_binding_0, ) => {
- Inner (
+ AttrStyle::Outer => { AttrStyle::Outer }
+ AttrStyle::Inner(_binding_0, ) => {
+ AttrStyle::Inner (
Token ! [ ! ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
@@ -499,15 +498,14 @@
}
pub fn fold_bare_fn_arg_name<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnArgName) -> BareFnArgName {
- use ::BareFnArgName::*;
match _i {
- Named(_binding_0, ) => {
- Named (
+ BareFnArgName::Named(_binding_0, ) => {
+ BareFnArgName::Named (
_visitor.fold_ident(_binding_0),
)
}
- Wild(_binding_0, ) => {
- Wild (
+ BareFnArgName::Wild(_binding_0, ) => {
+ BareFnArgName::Wild (
Token ! [ _ ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
@@ -515,145 +513,144 @@
}
pub fn fold_bin_op<V: Folder + ?Sized>(_visitor: &mut V, _i: BinOp) -> BinOp {
- use ::BinOp::*;
match _i {
- Add(_binding_0, ) => {
- Add (
+ BinOp::Add(_binding_0, ) => {
+ BinOp::Add (
Token ! [ + ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Sub(_binding_0, ) => {
- Sub (
+ BinOp::Sub(_binding_0, ) => {
+ BinOp::Sub (
Token ! [ - ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Mul(_binding_0, ) => {
- Mul (
+ BinOp::Mul(_binding_0, ) => {
+ BinOp::Mul (
Token ! [ * ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Div(_binding_0, ) => {
- Div (
+ BinOp::Div(_binding_0, ) => {
+ BinOp::Div (
Token ! [ / ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Rem(_binding_0, ) => {
- Rem (
+ BinOp::Rem(_binding_0, ) => {
+ BinOp::Rem (
Token ! [ % ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- And(_binding_0, ) => {
- And (
+ BinOp::And(_binding_0, ) => {
+ BinOp::And (
Token ! [ && ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Or(_binding_0, ) => {
- Or (
+ BinOp::Or(_binding_0, ) => {
+ BinOp::Or (
Token ! [ || ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- BitXor(_binding_0, ) => {
- BitXor (
+ BinOp::BitXor(_binding_0, ) => {
+ BinOp::BitXor (
Token ! [ ^ ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- BitAnd(_binding_0, ) => {
- BitAnd (
+ BinOp::BitAnd(_binding_0, ) => {
+ BinOp::BitAnd (
Token ! [ & ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- BitOr(_binding_0, ) => {
- BitOr (
+ BinOp::BitOr(_binding_0, ) => {
+ BinOp::BitOr (
Token ! [ | ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Shl(_binding_0, ) => {
- Shl (
+ BinOp::Shl(_binding_0, ) => {
+ BinOp::Shl (
Token ! [ << ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Shr(_binding_0, ) => {
- Shr (
+ BinOp::Shr(_binding_0, ) => {
+ BinOp::Shr (
Token ! [ >> ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Eq(_binding_0, ) => {
- Eq (
+ BinOp::Eq(_binding_0, ) => {
+ BinOp::Eq (
Token ! [ == ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Lt(_binding_0, ) => {
- Lt (
+ BinOp::Lt(_binding_0, ) => {
+ BinOp::Lt (
Token ! [ < ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Le(_binding_0, ) => {
- Le (
+ BinOp::Le(_binding_0, ) => {
+ BinOp::Le (
Token ! [ <= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Ne(_binding_0, ) => {
- Ne (
+ BinOp::Ne(_binding_0, ) => {
+ BinOp::Ne (
Token ! [ != ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Ge(_binding_0, ) => {
- Ge (
+ BinOp::Ge(_binding_0, ) => {
+ BinOp::Ge (
Token ! [ >= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Gt(_binding_0, ) => {
- Gt (
+ BinOp::Gt(_binding_0, ) => {
+ BinOp::Gt (
Token ! [ > ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- AddEq(_binding_0, ) => {
- AddEq (
+ BinOp::AddEq(_binding_0, ) => {
+ BinOp::AddEq (
Token ! [ += ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- SubEq(_binding_0, ) => {
- SubEq (
+ BinOp::SubEq(_binding_0, ) => {
+ BinOp::SubEq (
Token ! [ -= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- MulEq(_binding_0, ) => {
- MulEq (
+ BinOp::MulEq(_binding_0, ) => {
+ BinOp::MulEq (
Token ! [ *= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- DivEq(_binding_0, ) => {
- DivEq (
+ BinOp::DivEq(_binding_0, ) => {
+ BinOp::DivEq (
Token ! [ /= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- RemEq(_binding_0, ) => {
- RemEq (
+ BinOp::RemEq(_binding_0, ) => {
+ BinOp::RemEq (
Token ! [ %= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- BitXorEq(_binding_0, ) => {
- BitXorEq (
+ BinOp::BitXorEq(_binding_0, ) => {
+ BinOp::BitXorEq (
Token ! [ ^= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- BitAndEq(_binding_0, ) => {
- BitAndEq (
+ BinOp::BitAndEq(_binding_0, ) => {
+ BinOp::BitAndEq (
Token ! [ &= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- BitOrEq(_binding_0, ) => {
- BitOrEq (
+ BinOp::BitOrEq(_binding_0, ) => {
+ BinOp::BitOrEq (
Token ! [ |= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- ShlEq(_binding_0, ) => {
- ShlEq (
+ BinOp::ShlEq(_binding_0, ) => {
+ BinOp::ShlEq (
Token ! [ <<= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- ShrEq(_binding_0, ) => {
- ShrEq (
+ BinOp::ShrEq(_binding_0, ) => {
+ BinOp::ShrEq (
Token ! [ >>= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
@@ -676,15 +673,14 @@
}
pub fn fold_body<V: Folder + ?Sized>(_visitor: &mut V, _i: Body) -> Body {
- use ::Body::*;
match _i {
- Enum(_binding_0, ) => {
- Enum (
+ Body::Enum(_binding_0, ) => {
+ Body::Enum (
_visitor.fold_body_enum(_binding_0),
)
}
- Struct(_binding_0, ) => {
- Struct (
+ Body::Struct(_binding_0, ) => {
+ Body::Struct (
_visitor.fold_body_struct(_binding_0),
)
}
@@ -739,205 +735,204 @@
}
pub fn fold_expr<V: Folder + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr {
- use ::Expr::*;
match _i {
- Box(_binding_0, ) => {
- Box (
+ Expr::Box(_binding_0, ) => {
+ Expr::Box (
full!(_visitor.fold_expr_box(_binding_0)),
)
}
- InPlace(_binding_0, ) => {
- InPlace (
+ Expr::InPlace(_binding_0, ) => {
+ Expr::InPlace (
full!(_visitor.fold_expr_in_place(_binding_0)),
)
}
- Array(_binding_0, ) => {
- Array (
+ Expr::Array(_binding_0, ) => {
+ Expr::Array (
full!(_visitor.fold_expr_array(_binding_0)),
)
}
- Call(_binding_0, ) => {
- Call (
+ Expr::Call(_binding_0, ) => {
+ Expr::Call (
_visitor.fold_expr_call(_binding_0),
)
}
- MethodCall(_binding_0, ) => {
- MethodCall (
+ Expr::MethodCall(_binding_0, ) => {
+ Expr::MethodCall (
full!(_visitor.fold_expr_method_call(_binding_0)),
)
}
- Tuple(_binding_0, ) => {
- Tuple (
+ Expr::Tuple(_binding_0, ) => {
+ Expr::Tuple (
full!(_visitor.fold_expr_tuple(_binding_0)),
)
}
- Binary(_binding_0, ) => {
- Binary (
+ Expr::Binary(_binding_0, ) => {
+ Expr::Binary (
_visitor.fold_expr_binary(_binding_0),
)
}
- Unary(_binding_0, ) => {
- Unary (
+ Expr::Unary(_binding_0, ) => {
+ Expr::Unary (
_visitor.fold_expr_unary(_binding_0),
)
}
- Lit(_binding_0, ) => {
- Lit (
+ Expr::Lit(_binding_0, ) => {
+ Expr::Lit (
_visitor.fold_expr_lit(_binding_0),
)
}
- Cast(_binding_0, ) => {
- Cast (
+ Expr::Cast(_binding_0, ) => {
+ Expr::Cast (
_visitor.fold_expr_cast(_binding_0),
)
}
- Type(_binding_0, ) => {
- Type (
+ Expr::Type(_binding_0, ) => {
+ Expr::Type (
full!(_visitor.fold_expr_type(_binding_0)),
)
}
- If(_binding_0, ) => {
- If (
+ Expr::If(_binding_0, ) => {
+ Expr::If (
full!(_visitor.fold_expr_if(_binding_0)),
)
}
- IfLet(_binding_0, ) => {
- IfLet (
+ Expr::IfLet(_binding_0, ) => {
+ Expr::IfLet (
full!(_visitor.fold_expr_if_let(_binding_0)),
)
}
- While(_binding_0, ) => {
- While (
+ Expr::While(_binding_0, ) => {
+ Expr::While (
full!(_visitor.fold_expr_while(_binding_0)),
)
}
- WhileLet(_binding_0, ) => {
- WhileLet (
+ Expr::WhileLet(_binding_0, ) => {
+ Expr::WhileLet (
full!(_visitor.fold_expr_while_let(_binding_0)),
)
}
- ForLoop(_binding_0, ) => {
- ForLoop (
+ Expr::ForLoop(_binding_0, ) => {
+ Expr::ForLoop (
full!(_visitor.fold_expr_for_loop(_binding_0)),
)
}
- Loop(_binding_0, ) => {
- Loop (
+ Expr::Loop(_binding_0, ) => {
+ Expr::Loop (
full!(_visitor.fold_expr_loop(_binding_0)),
)
}
- Match(_binding_0, ) => {
- Match (
+ Expr::Match(_binding_0, ) => {
+ Expr::Match (
full!(_visitor.fold_expr_match(_binding_0)),
)
}
- Closure(_binding_0, ) => {
- Closure (
+ Expr::Closure(_binding_0, ) => {
+ Expr::Closure (
full!(_visitor.fold_expr_closure(_binding_0)),
)
}
- Unsafe(_binding_0, ) => {
- Unsafe (
+ Expr::Unsafe(_binding_0, ) => {
+ Expr::Unsafe (
full!(_visitor.fold_expr_unsafe(_binding_0)),
)
}
- Block(_binding_0, ) => {
- Block (
+ Expr::Block(_binding_0, ) => {
+ Expr::Block (
full!(_visitor.fold_expr_block(_binding_0)),
)
}
- Assign(_binding_0, ) => {
- Assign (
+ Expr::Assign(_binding_0, ) => {
+ Expr::Assign (
full!(_visitor.fold_expr_assign(_binding_0)),
)
}
- AssignOp(_binding_0, ) => {
- AssignOp (
+ Expr::AssignOp(_binding_0, ) => {
+ Expr::AssignOp (
full!(_visitor.fold_expr_assign_op(_binding_0)),
)
}
- Field(_binding_0, ) => {
- Field (
+ Expr::Field(_binding_0, ) => {
+ Expr::Field (
full!(_visitor.fold_expr_field(_binding_0)),
)
}
- Index(_binding_0, ) => {
- Index (
+ Expr::Index(_binding_0, ) => {
+ Expr::Index (
_visitor.fold_expr_index(_binding_0),
)
}
- Range(_binding_0, ) => {
- Range (
+ Expr::Range(_binding_0, ) => {
+ Expr::Range (
full!(_visitor.fold_expr_range(_binding_0)),
)
}
- Path(_binding_0, ) => {
- Path (
+ Expr::Path(_binding_0, ) => {
+ Expr::Path (
_visitor.fold_expr_path(_binding_0),
)
}
- AddrOf(_binding_0, ) => {
- AddrOf (
+ Expr::AddrOf(_binding_0, ) => {
+ Expr::AddrOf (
full!(_visitor.fold_expr_addr_of(_binding_0)),
)
}
- Break(_binding_0, ) => {
- Break (
+ Expr::Break(_binding_0, ) => {
+ Expr::Break (
full!(_visitor.fold_expr_break(_binding_0)),
)
}
- Continue(_binding_0, ) => {
- Continue (
+ Expr::Continue(_binding_0, ) => {
+ Expr::Continue (
full!(_visitor.fold_expr_continue(_binding_0)),
)
}
- Return(_binding_0, ) => {
- Return (
+ Expr::Return(_binding_0, ) => {
+ Expr::Return (
full!(_visitor.fold_expr_return(_binding_0)),
)
}
- Macro(_binding_0, ) => {
- Macro (
+ Expr::Macro(_binding_0, ) => {
+ Expr::Macro (
full!(_visitor.fold_expr_macro(_binding_0)),
)
}
- Struct(_binding_0, ) => {
- Struct (
+ Expr::Struct(_binding_0, ) => {
+ Expr::Struct (
full!(_visitor.fold_expr_struct(_binding_0)),
)
}
- Repeat(_binding_0, ) => {
- Repeat (
+ Expr::Repeat(_binding_0, ) => {
+ Expr::Repeat (
full!(_visitor.fold_expr_repeat(_binding_0)),
)
}
- Paren(_binding_0, ) => {
- Paren (
+ Expr::Paren(_binding_0, ) => {
+ Expr::Paren (
full!(_visitor.fold_expr_paren(_binding_0)),
)
}
- Group(_binding_0, ) => {
- Group (
+ Expr::Group(_binding_0, ) => {
+ Expr::Group (
full!(_visitor.fold_expr_group(_binding_0)),
)
}
- Try(_binding_0, ) => {
- Try (
+ Expr::Try(_binding_0, ) => {
+ Expr::Try (
full!(_visitor.fold_expr_try(_binding_0)),
)
}
- Catch(_binding_0, ) => {
- Catch (
+ Expr::Catch(_binding_0, ) => {
+ Expr::Catch (
full!(_visitor.fold_expr_catch(_binding_0)),
)
}
- Yield(_binding_0, ) => {
- Yield (
+ Expr::Yield(_binding_0, ) => {
+ Expr::Yield (
full!(_visitor.fold_expr_yield(_binding_0)),
)
}
- Verbatim(_binding_0, ) => {
- Verbatim (
+ Expr::Verbatim(_binding_0, ) => {
+ Expr::Verbatim (
_visitor.fold_expr_verbatim(_binding_0),
)
}
@@ -1349,30 +1344,29 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_fn_arg<V: Folder + ?Sized>(_visitor: &mut V, _i: FnArg) -> FnArg {
- use ::FnArg::*;
match _i {
- SelfRef(_binding_0, ) => {
- SelfRef (
+ FnArg::SelfRef(_binding_0, ) => {
+ FnArg::SelfRef (
_visitor.fold_arg_self_ref(_binding_0),
)
}
- SelfValue(_binding_0, ) => {
- SelfValue (
+ FnArg::SelfValue(_binding_0, ) => {
+ FnArg::SelfValue (
_visitor.fold_arg_self(_binding_0),
)
}
- Captured(_binding_0, ) => {
- Captured (
+ FnArg::Captured(_binding_0, ) => {
+ FnArg::Captured (
_visitor.fold_arg_captured(_binding_0),
)
}
- Inferred(_binding_0, ) => {
- Inferred (
+ FnArg::Inferred(_binding_0, ) => {
+ FnArg::Inferred (
_visitor.fold_pat(_binding_0),
)
}
- Ignored(_binding_0, ) => {
- Ignored (
+ FnArg::Ignored(_binding_0, ) => {
+ FnArg::Ignored (
_visitor.fold_type(_binding_0),
)
}
@@ -1391,25 +1385,24 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_foreign_item<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItem) -> ForeignItem {
- use ::ForeignItem::*;
match _i {
- Fn(_binding_0, ) => {
- Fn (
+ ForeignItem::Fn(_binding_0, ) => {
+ ForeignItem::Fn (
_visitor.fold_foreign_item_fn(_binding_0),
)
}
- Static(_binding_0, ) => {
- Static (
+ ForeignItem::Static(_binding_0, ) => {
+ ForeignItem::Static (
_visitor.fold_foreign_item_static(_binding_0),
)
}
- Type(_binding_0, ) => {
- Type (
+ ForeignItem::Type(_binding_0, ) => {
+ ForeignItem::Type (
_visitor.fold_foreign_item_type(_binding_0),
)
}
- Verbatim(_binding_0, ) => {
- Verbatim (
+ ForeignItem::Verbatim(_binding_0, ) => {
+ ForeignItem::Verbatim (
_visitor.fold_foreign_item_verbatim(_binding_0),
)
}
@@ -1456,25 +1449,24 @@
}
pub fn fold_generic_argument<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericArgument) -> GenericArgument {
- use ::GenericArgument::*;
match _i {
- Lifetime(_binding_0, ) => {
- Lifetime (
+ GenericArgument::Lifetime(_binding_0, ) => {
+ GenericArgument::Lifetime (
_visitor.fold_lifetime(_binding_0),
)
}
- Type(_binding_0, ) => {
- Type (
+ GenericArgument::Type(_binding_0, ) => {
+ GenericArgument::Type (
_visitor.fold_type(_binding_0),
)
}
- Binding(_binding_0, ) => {
- Binding (
+ GenericArgument::Binding(_binding_0, ) => {
+ GenericArgument::Binding (
_visitor.fold_binding(_binding_0),
)
}
- Const(_binding_0, ) => {
- Const (
+ GenericArgument::Const(_binding_0, ) => {
+ GenericArgument::Const (
_visitor.fold_expr(_binding_0),
)
}
@@ -1482,15 +1474,14 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_generic_method_argument<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericMethodArgument) -> GenericMethodArgument {
- use ::GenericMethodArgument::*;
match _i {
- Type(_binding_0, ) => {
- Type (
+ GenericMethodArgument::Type(_binding_0, ) => {
+ GenericMethodArgument::Type (
_visitor.fold_type(_binding_0),
)
}
- Const(_binding_0, ) => {
- Const (
+ GenericMethodArgument::Const(_binding_0, ) => {
+ GenericMethodArgument::Const (
_visitor.fold_expr(_binding_0),
)
}
@@ -1498,20 +1489,19 @@
}
pub fn fold_generic_param<V: Folder + ?Sized>(_visitor: &mut V, _i: GenericParam) -> GenericParam {
- use ::GenericParam::*;
match _i {
- Lifetime(_binding_0, ) => {
- Lifetime (
+ GenericParam::Lifetime(_binding_0, ) => {
+ GenericParam::Lifetime (
_visitor.fold_lifetime_def(_binding_0),
)
}
- Type(_binding_0, ) => {
- Type (
+ GenericParam::Type(_binding_0, ) => {
+ GenericParam::Type (
_visitor.fold_type_param(_binding_0),
)
}
- Const(_binding_0, ) => {
- Const (
+ GenericParam::Const(_binding_0, ) => {
+ GenericParam::Const (
_visitor.fold_const_param(_binding_0),
)
}
@@ -1528,30 +1518,29 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_impl_item<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItem) -> ImplItem {
- use ::ImplItem::*;
match _i {
- Const(_binding_0, ) => {
- Const (
+ ImplItem::Const(_binding_0, ) => {
+ ImplItem::Const (
_visitor.fold_impl_item_const(_binding_0),
)
}
- Method(_binding_0, ) => {
- Method (
+ ImplItem::Method(_binding_0, ) => {
+ ImplItem::Method (
_visitor.fold_impl_item_method(_binding_0),
)
}
- Type(_binding_0, ) => {
- Type (
+ ImplItem::Type(_binding_0, ) => {
+ ImplItem::Type (
_visitor.fold_impl_item_type(_binding_0),
)
}
- Macro(_binding_0, ) => {
- Macro (
+ ImplItem::Macro(_binding_0, ) => {
+ ImplItem::Macro (
_visitor.fold_impl_item_macro(_binding_0),
)
}
- Verbatim(_binding_0, ) => {
- Verbatim (
+ ImplItem::Verbatim(_binding_0, ) => {
+ ImplItem::Verbatim (
_visitor.fold_impl_item_verbatim(_binding_0),
)
}
@@ -1619,85 +1608,84 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_item<V: Folder + ?Sized>(_visitor: &mut V, _i: Item) -> Item {
- use ::Item::*;
match _i {
- ExternCrate(_binding_0, ) => {
- ExternCrate (
+ Item::ExternCrate(_binding_0, ) => {
+ Item::ExternCrate (
_visitor.fold_item_extern_crate(_binding_0),
)
}
- Use(_binding_0, ) => {
- Use (
+ Item::Use(_binding_0, ) => {
+ Item::Use (
_visitor.fold_item_use(_binding_0),
)
}
- Static(_binding_0, ) => {
- Static (
+ Item::Static(_binding_0, ) => {
+ Item::Static (
_visitor.fold_item_static(_binding_0),
)
}
- Const(_binding_0, ) => {
- Const (
+ Item::Const(_binding_0, ) => {
+ Item::Const (
_visitor.fold_item_const(_binding_0),
)
}
- Fn(_binding_0, ) => {
- Fn (
+ Item::Fn(_binding_0, ) => {
+ Item::Fn (
_visitor.fold_item_fn(_binding_0),
)
}
- Mod(_binding_0, ) => {
- Mod (
+ Item::Mod(_binding_0, ) => {
+ Item::Mod (
_visitor.fold_item_mod(_binding_0),
)
}
- ForeignMod(_binding_0, ) => {
- ForeignMod (
+ Item::ForeignMod(_binding_0, ) => {
+ Item::ForeignMod (
_visitor.fold_item_foreign_mod(_binding_0),
)
}
- Type(_binding_0, ) => {
- Type (
+ Item::Type(_binding_0, ) => {
+ Item::Type (
_visitor.fold_item_type(_binding_0),
)
}
- Enum(_binding_0, ) => {
- Enum (
+ Item::Enum(_binding_0, ) => {
+ Item::Enum (
_visitor.fold_item_enum(_binding_0),
)
}
- Struct(_binding_0, ) => {
- Struct (
+ Item::Struct(_binding_0, ) => {
+ Item::Struct (
_visitor.fold_item_struct(_binding_0),
)
}
- Union(_binding_0, ) => {
- Union (
+ Item::Union(_binding_0, ) => {
+ Item::Union (
_visitor.fold_item_union(_binding_0),
)
}
- Trait(_binding_0, ) => {
- Trait (
+ Item::Trait(_binding_0, ) => {
+ Item::Trait (
_visitor.fold_item_trait(_binding_0),
)
}
- Impl(_binding_0, ) => {
- Impl (
+ Item::Impl(_binding_0, ) => {
+ Item::Impl (
_visitor.fold_item_impl(_binding_0),
)
}
- Macro(_binding_0, ) => {
- Macro (
+ Item::Macro(_binding_0, ) => {
+ Item::Macro (
_visitor.fold_item_macro(_binding_0),
)
}
- Macro2(_binding_0, ) => {
- Macro2 (
+ Item::Macro2(_binding_0, ) => {
+ Item::Macro2 (
_visitor.fold_item_macro2(_binding_0),
)
}
- Verbatim(_binding_0, ) => {
- Verbatim (
+ Item::Verbatim(_binding_0, ) => {
+ Item::Verbatim (
_visitor.fold_item_verbatim(_binding_0),
)
}
@@ -1956,20 +1944,19 @@
}
pub fn fold_macro_delimiter<V: Folder + ?Sized>(_visitor: &mut V, _i: MacroDelimiter) -> MacroDelimiter {
- use ::MacroDelimiter::*;
match _i {
- Paren(_binding_0, ) => {
- Paren (
+ MacroDelimiter::Paren(_binding_0, ) => {
+ MacroDelimiter::Paren (
Paren(tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Brace(_binding_0, ) => {
- Brace (
+ MacroDelimiter::Brace(_binding_0, ) => {
+ MacroDelimiter::Brace (
Brace(tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Bracket(_binding_0, ) => {
- Bracket (
+ MacroDelimiter::Bracket(_binding_0, ) => {
+ MacroDelimiter::Bracket (
Bracket(tokens_helper(_visitor, &(_binding_0).0)),
)
}
@@ -1977,15 +1964,14 @@
}
pub fn fold_member<V: Folder + ?Sized>(_visitor: &mut V, _i: Member) -> Member {
- use ::Member::*;
match _i {
- Named(_binding_0, ) => {
- Named (
+ Member::Named(_binding_0, ) => {
+ Member::Named (
_visitor.fold_ident(_binding_0),
)
}
- Unnamed(_binding_0, ) => {
- Unnamed (
+ Member::Unnamed(_binding_0, ) => {
+ Member::Unnamed (
_visitor.fold_index(_binding_0),
)
}
@@ -1993,20 +1979,19 @@
}
pub fn fold_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: MetaItem) -> MetaItem {
- use ::MetaItem::*;
match _i {
- Term(_binding_0, ) => {
- Term (
+ MetaItem::Term(_binding_0, ) => {
+ MetaItem::Term (
_visitor.fold_ident(_binding_0),
)
}
- List(_binding_0, ) => {
- List (
+ MetaItem::List(_binding_0, ) => {
+ MetaItem::List (
_visitor.fold_meta_item_list(_binding_0),
)
}
- NameValue(_binding_0, ) => {
- NameValue (
+ MetaItem::NameValue(_binding_0, ) => {
+ MetaItem::NameValue (
_visitor.fold_meta_name_value(_binding_0),
)
}
@@ -2049,15 +2034,14 @@
}
pub fn fold_nested_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: NestedMetaItem) -> NestedMetaItem {
- use ::NestedMetaItem::*;
match _i {
- MetaItem(_binding_0, ) => {
- MetaItem (
+ NestedMetaItem::MetaItem(_binding_0, ) => {
+ NestedMetaItem::MetaItem (
_visitor.fold_meta_item(_binding_0),
)
}
- Literal(_binding_0, ) => {
- Literal (
+ NestedMetaItem::Literal(_binding_0, ) => {
+ NestedMetaItem::Literal (
_visitor.fold_lit(_binding_0),
)
}
@@ -2073,70 +2057,69 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_pat<V: Folder + ?Sized>(_visitor: &mut V, _i: Pat) -> Pat {
- use ::Pat::*;
match _i {
- Wild(_binding_0, ) => {
- Wild (
+ Pat::Wild(_binding_0, ) => {
+ Pat::Wild (
_visitor.fold_pat_wild(_binding_0),
)
}
- Ident(_binding_0, ) => {
- Ident (
+ Pat::Ident(_binding_0, ) => {
+ Pat::Ident (
_visitor.fold_pat_ident(_binding_0),
)
}
- Struct(_binding_0, ) => {
- Struct (
+ Pat::Struct(_binding_0, ) => {
+ Pat::Struct (
_visitor.fold_pat_struct(_binding_0),
)
}
- TupleStruct(_binding_0, ) => {
- TupleStruct (
+ Pat::TupleStruct(_binding_0, ) => {
+ Pat::TupleStruct (
_visitor.fold_pat_tuple_struct(_binding_0),
)
}
- Path(_binding_0, ) => {
- Path (
+ Pat::Path(_binding_0, ) => {
+ Pat::Path (
_visitor.fold_pat_path(_binding_0),
)
}
- Tuple(_binding_0, ) => {
- Tuple (
+ Pat::Tuple(_binding_0, ) => {
+ Pat::Tuple (
_visitor.fold_pat_tuple(_binding_0),
)
}
- Box(_binding_0, ) => {
- Box (
+ Pat::Box(_binding_0, ) => {
+ Pat::Box (
_visitor.fold_pat_box(_binding_0),
)
}
- Ref(_binding_0, ) => {
- Ref (
+ Pat::Ref(_binding_0, ) => {
+ Pat::Ref (
_visitor.fold_pat_ref(_binding_0),
)
}
- Lit(_binding_0, ) => {
- Lit (
+ Pat::Lit(_binding_0, ) => {
+ Pat::Lit (
_visitor.fold_pat_lit(_binding_0),
)
}
- Range(_binding_0, ) => {
- Range (
+ Pat::Range(_binding_0, ) => {
+ Pat::Range (
_visitor.fold_pat_range(_binding_0),
)
}
- Slice(_binding_0, ) => {
- Slice (
+ Pat::Slice(_binding_0, ) => {
+ Pat::Slice (
_visitor.fold_pat_slice(_binding_0),
)
}
- Macro(_binding_0, ) => {
- Macro (
+ Pat::Macro(_binding_0, ) => {
+ Pat::Macro (
_visitor.fold_pat_macro(_binding_0),
)
}
- Verbatim(_binding_0, ) => {
- Verbatim (
+ Pat::Verbatim(_binding_0, ) => {
+ Pat::Verbatim (
_visitor.fold_pat_verbatim(_binding_0),
)
}
@@ -2254,16 +2237,15 @@
}
pub fn fold_path_arguments<V: Folder + ?Sized>(_visitor: &mut V, _i: PathArguments) -> PathArguments {
- use ::PathArguments::*;
match _i {
- None => { None }
- AngleBracketed(_binding_0, ) => {
- AngleBracketed (
+ PathArguments::None => { PathArguments::None }
+ PathArguments::AngleBracketed(_binding_0, ) => {
+ PathArguments::AngleBracketed (
_visitor.fold_angle_bracketed_generic_arguments(_binding_0),
)
}
- Parenthesized(_binding_0, ) => {
- Parenthesized (
+ PathArguments::Parenthesized(_binding_0, ) => {
+ PathArguments::Parenthesized (
_visitor.fold_parenthesized_generic_arguments(_binding_0),
)
}
@@ -2295,15 +2277,14 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_range_limits<V: Folder + ?Sized>(_visitor: &mut V, _i: RangeLimits) -> RangeLimits {
- use ::RangeLimits::*;
match _i {
- HalfOpen(_binding_0, ) => {
- HalfOpen (
+ RangeLimits::HalfOpen(_binding_0, ) => {
+ RangeLimits::HalfOpen (
Token ! [ .. ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Closed(_binding_0, ) => {
- Closed (
+ RangeLimits::Closed(_binding_0, ) => {
+ RangeLimits::Closed (
Token ! [ ..= ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
@@ -2311,11 +2292,10 @@
}
pub fn fold_return_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ReturnType) -> ReturnType {
- use ::ReturnType::*;
match _i {
- Default => { Default }
- Type(_binding_0, _binding_1, ) => {
- Type (
+ ReturnType::Default => { ReturnType::Default }
+ ReturnType::Type(_binding_0, _binding_1, ) => {
+ ReturnType::Type (
Token ! [ -> ](tokens_helper(_visitor, &(_binding_0).0)),
Box::new(_visitor.fold_type(* _binding_1)),
)
@@ -2328,25 +2308,24 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_stmt<V: Folder + ?Sized>(_visitor: &mut V, _i: Stmt) -> Stmt {
- use ::Stmt::*;
match _i {
- Local(_binding_0, ) => {
- Local (
+ Stmt::Local(_binding_0, ) => {
+ Stmt::Local (
Box::new(_visitor.fold_local(* _binding_0)),
)
}
- Item(_binding_0, ) => {
- Item (
+ Stmt::Item(_binding_0, ) => {
+ Stmt::Item (
Box::new(_visitor.fold_item(* _binding_0)),
)
}
- Expr(_binding_0, ) => {
- Expr (
+ Stmt::Expr(_binding_0, ) => {
+ Stmt::Expr (
Box::new(_visitor.fold_expr(* _binding_0)),
)
}
- Semi(_binding_0, _binding_1, ) => {
- Semi (
+ Stmt::Semi(_binding_0, _binding_1, ) => {
+ Stmt::Semi (
Box::new(_visitor.fold_expr(* _binding_0)),
Token ! [ ; ](tokens_helper(_visitor, &(_binding_1).0)),
)
@@ -2355,11 +2334,10 @@
}
pub fn fold_trait_bound_modifier<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitBoundModifier) -> TraitBoundModifier {
- use ::TraitBoundModifier::*;
match _i {
- None => { None }
- Maybe(_binding_0, ) => {
- Maybe (
+ TraitBoundModifier::None => { TraitBoundModifier::None }
+ TraitBoundModifier::Maybe(_binding_0, ) => {
+ TraitBoundModifier::Maybe (
Token ! [ ? ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
@@ -2367,30 +2345,29 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_trait_item<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItem) -> TraitItem {
- use ::TraitItem::*;
match _i {
- Const(_binding_0, ) => {
- Const (
+ TraitItem::Const(_binding_0, ) => {
+ TraitItem::Const (
_visitor.fold_trait_item_const(_binding_0),
)
}
- Method(_binding_0, ) => {
- Method (
+ TraitItem::Method(_binding_0, ) => {
+ TraitItem::Method (
_visitor.fold_trait_item_method(_binding_0),
)
}
- Type(_binding_0, ) => {
- Type (
+ TraitItem::Type(_binding_0, ) => {
+ TraitItem::Type (
_visitor.fold_trait_item_type(_binding_0),
)
}
- Macro(_binding_0, ) => {
- Macro (
+ TraitItem::Macro(_binding_0, ) => {
+ TraitItem::Macro (
_visitor.fold_trait_item_macro(_binding_0),
)
}
- Verbatim(_binding_0, ) => {
- Verbatim (
+ TraitItem::Verbatim(_binding_0, ) => {
+ TraitItem::Verbatim (
_visitor.fold_trait_item_verbatim(_binding_0),
)
}
@@ -2452,80 +2429,79 @@
}
pub fn fold_type<V: Folder + ?Sized>(_visitor: &mut V, _i: Type) -> Type {
- use ::Type::*;
match _i {
- Slice(_binding_0, ) => {
- Slice (
+ Type::Slice(_binding_0, ) => {
+ Type::Slice (
_visitor.fold_type_slice(_binding_0),
)
}
- Array(_binding_0, ) => {
- Array (
+ Type::Array(_binding_0, ) => {
+ Type::Array (
_visitor.fold_type_array(_binding_0),
)
}
- Ptr(_binding_0, ) => {
- Ptr (
+ Type::Ptr(_binding_0, ) => {
+ Type::Ptr (
_visitor.fold_type_ptr(_binding_0),
)
}
- Reference(_binding_0, ) => {
- Reference (
+ Type::Reference(_binding_0, ) => {
+ Type::Reference (
_visitor.fold_type_reference(_binding_0),
)
}
- BareFn(_binding_0, ) => {
- BareFn (
+ Type::BareFn(_binding_0, ) => {
+ Type::BareFn (
_visitor.fold_type_bare_fn(_binding_0),
)
}
- Never(_binding_0, ) => {
- Never (
+ Type::Never(_binding_0, ) => {
+ Type::Never (
_visitor.fold_type_never(_binding_0),
)
}
- Tuple(_binding_0, ) => {
- Tuple (
+ Type::Tuple(_binding_0, ) => {
+ Type::Tuple (
_visitor.fold_type_tuple(_binding_0),
)
}
- Path(_binding_0, ) => {
- Path (
+ Type::Path(_binding_0, ) => {
+ Type::Path (
_visitor.fold_type_path(_binding_0),
)
}
- TraitObject(_binding_0, ) => {
- TraitObject (
+ Type::TraitObject(_binding_0, ) => {
+ Type::TraitObject (
_visitor.fold_type_trait_object(_binding_0),
)
}
- ImplTrait(_binding_0, ) => {
- ImplTrait (
+ Type::ImplTrait(_binding_0, ) => {
+ Type::ImplTrait (
_visitor.fold_type_impl_trait(_binding_0),
)
}
- Paren(_binding_0, ) => {
- Paren (
+ Type::Paren(_binding_0, ) => {
+ Type::Paren (
_visitor.fold_type_paren(_binding_0),
)
}
- Group(_binding_0, ) => {
- Group (
+ Type::Group(_binding_0, ) => {
+ Type::Group (
_visitor.fold_type_group(_binding_0),
)
}
- Infer(_binding_0, ) => {
- Infer (
+ Type::Infer(_binding_0, ) => {
+ Type::Infer (
_visitor.fold_type_infer(_binding_0),
)
}
- Macro(_binding_0, ) => {
- Macro (
+ Type::Macro(_binding_0, ) => {
+ Type::Macro (
_visitor.fold_type_macro(_binding_0),
)
}
- Verbatim(_binding_0, ) => {
- Verbatim (
+ Type::Verbatim(_binding_0, ) => {
+ Type::Verbatim (
_visitor.fold_type_verbatim(_binding_0),
)
}
@@ -2598,16 +2574,15 @@
}
pub fn fold_type_param_bound<V: Folder + ?Sized>(_visitor: &mut V, _i: TypeParamBound) -> TypeParamBound {
- use ::TypeParamBound::*;
match _i {
- Trait(_binding_0, _binding_1, ) => {
- Trait (
+ TypeParamBound::Trait(_binding_0, _binding_1, ) => {
+ TypeParamBound::Trait (
_visitor.fold_poly_trait_ref(_binding_0),
_visitor.fold_trait_bound_modifier(_binding_1),
)
}
- Region(_binding_0, ) => {
- Region (
+ TypeParamBound::Region(_binding_0, ) => {
+ TypeParamBound::Region (
_visitor.fold_lifetime(_binding_0),
)
}
@@ -2674,20 +2649,19 @@
}
pub fn fold_un_op<V: Folder + ?Sized>(_visitor: &mut V, _i: UnOp) -> UnOp {
- use ::UnOp::*;
match _i {
- Deref(_binding_0, ) => {
- Deref (
+ UnOp::Deref(_binding_0, ) => {
+ UnOp::Deref (
Token ! [ * ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Not(_binding_0, ) => {
- Not (
+ UnOp::Not(_binding_0, ) => {
+ UnOp::Not (
Token ! [ ! ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
- Neg(_binding_0, ) => {
- Neg (
+ UnOp::Neg(_binding_0, ) => {
+ UnOp::Neg (
Token ! [ - ](tokens_helper(_visitor, &(_binding_0).0)),
)
}
@@ -2718,20 +2692,19 @@
}
# [ cfg ( feature = "full" ) ]
pub fn fold_use_tree<V: Folder + ?Sized>(_visitor: &mut V, _i: UseTree) -> UseTree {
- use ::UseTree::*;
match _i {
- Path(_binding_0, ) => {
- Path (
+ UseTree::Path(_binding_0, ) => {
+ UseTree::Path (
_visitor.fold_use_path(_binding_0),
)
}
- Glob(_binding_0, ) => {
- Glob (
+ UseTree::Glob(_binding_0, ) => {
+ UseTree::Glob (
_visitor.fold_use_glob(_binding_0),
)
}
- List(_binding_0, ) => {
- List (
+ UseTree::List(_binding_0, ) => {
+ UseTree::List (
_visitor.fold_use_list(_binding_0),
)
}
@@ -2751,21 +2724,20 @@
}
pub fn fold_variant_data<V: Folder + ?Sized>(_visitor: &mut V, _i: VariantData) -> VariantData {
- use ::VariantData::*;
match _i {
- Struct(_binding_0, _binding_1, ) => {
- Struct (
+ VariantData::Struct(_binding_0, _binding_1, ) => {
+ VariantData::Struct (
FoldHelper::lift(_binding_0, |it| { _visitor.fold_field(it) }),
Brace(tokens_helper(_visitor, &(_binding_1).0)),
)
}
- Tuple(_binding_0, _binding_1, ) => {
- Tuple (
+ VariantData::Tuple(_binding_0, _binding_1, ) => {
+ VariantData::Tuple (
FoldHelper::lift(_binding_0, |it| { _visitor.fold_field(it) }),
Paren(tokens_helper(_visitor, &(_binding_1).0)),
)
}
- Unit => { Unit }
+ VariantData::Unit => { VariantData::Unit }
}
}
@@ -2793,24 +2765,23 @@
}
pub fn fold_visibility<V: Folder + ?Sized>(_visitor: &mut V, _i: Visibility) -> Visibility {
- use ::Visibility::*;
match _i {
- Public(_binding_0, ) => {
- Public (
+ Visibility::Public(_binding_0, ) => {
+ Visibility::Public (
_visitor.fold_vis_public(_binding_0),
)
}
- Crate(_binding_0, ) => {
- Crate (
+ Visibility::Crate(_binding_0, ) => {
+ Visibility::Crate (
_visitor.fold_vis_crate(_binding_0),
)
}
- Restricted(_binding_0, ) => {
- Restricted (
+ Visibility::Restricted(_binding_0, ) => {
+ Visibility::Restricted (
_visitor.fold_vis_restricted(_binding_0),
)
}
- Inherited => { Inherited }
+ Visibility::Inherited => { Visibility::Inherited }
}
}
@@ -2839,20 +2810,19 @@
}
pub fn fold_where_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WherePredicate) -> WherePredicate {
- use ::WherePredicate::*;
match _i {
- BoundPredicate(_binding_0, ) => {
- BoundPredicate (
+ WherePredicate::BoundPredicate(_binding_0, ) => {
+ WherePredicate::BoundPredicate (
_visitor.fold_where_bound_predicate(_binding_0),
)
}
- RegionPredicate(_binding_0, ) => {
- RegionPredicate (
+ WherePredicate::RegionPredicate(_binding_0, ) => {
+ WherePredicate::RegionPredicate (
_visitor.fold_where_region_predicate(_binding_0),
)
}
- EqPredicate(_binding_0, ) => {
- EqPredicate (
+ WherePredicate::EqPredicate(_binding_0, ) => {
+ WherePredicate::EqPredicate (
_visitor.fold_where_eq_predicate(_binding_0),
)
}
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 6beacf0..56ac2c8 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -440,10 +440,9 @@
}
pub fn visit_attr_style<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast AttrStyle) {
- use ::AttrStyle::*;
match *_i {
- Outer => { }
- Inner(ref _binding_0, ) => {
+ AttrStyle::Outer => { }
+ AttrStyle::Inner(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
}
@@ -467,102 +466,100 @@
}
pub fn visit_bare_fn_arg_name<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BareFnArgName) {
- use ::BareFnArgName::*;
match *_i {
- Named(ref _binding_0, ) => {
+ BareFnArgName::Named(ref _binding_0, ) => {
_visitor.visit_ident(_binding_0);
}
- Wild(ref _binding_0, ) => {
+ BareFnArgName::Wild(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
}
}
pub fn visit_bin_op<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BinOp) {
- use ::BinOp::*;
match *_i {
- Add(ref _binding_0, ) => {
+ BinOp::Add(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Sub(ref _binding_0, ) => {
+ BinOp::Sub(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Mul(ref _binding_0, ) => {
+ BinOp::Mul(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Div(ref _binding_0, ) => {
+ BinOp::Div(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Rem(ref _binding_0, ) => {
+ BinOp::Rem(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- And(ref _binding_0, ) => {
+ BinOp::And(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Or(ref _binding_0, ) => {
+ BinOp::Or(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- BitXor(ref _binding_0, ) => {
+ BinOp::BitXor(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- BitAnd(ref _binding_0, ) => {
+ BinOp::BitAnd(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- BitOr(ref _binding_0, ) => {
+ BinOp::BitOr(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Shl(ref _binding_0, ) => {
+ BinOp::Shl(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Shr(ref _binding_0, ) => {
+ BinOp::Shr(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Eq(ref _binding_0, ) => {
+ BinOp::Eq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Lt(ref _binding_0, ) => {
+ BinOp::Lt(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Le(ref _binding_0, ) => {
+ BinOp::Le(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Ne(ref _binding_0, ) => {
+ BinOp::Ne(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Ge(ref _binding_0, ) => {
+ BinOp::Ge(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Gt(ref _binding_0, ) => {
+ BinOp::Gt(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- AddEq(ref _binding_0, ) => {
+ BinOp::AddEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- SubEq(ref _binding_0, ) => {
+ BinOp::SubEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- MulEq(ref _binding_0, ) => {
+ BinOp::MulEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- DivEq(ref _binding_0, ) => {
+ BinOp::DivEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- RemEq(ref _binding_0, ) => {
+ BinOp::RemEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- BitXorEq(ref _binding_0, ) => {
+ BinOp::BitXorEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- BitAndEq(ref _binding_0, ) => {
+ BinOp::BitAndEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- BitOrEq(ref _binding_0, ) => {
+ BinOp::BitOrEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- ShlEq(ref _binding_0, ) => {
+ BinOp::ShlEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- ShrEq(ref _binding_0, ) => {
+ BinOp::ShrEq(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
}
@@ -580,12 +577,11 @@
}
pub fn visit_body<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Body) {
- use ::Body::*;
match *_i {
- Enum(ref _binding_0, ) => {
+ Body::Enum(ref _binding_0, ) => {
_visitor.visit_body_enum(_binding_0);
}
- Struct(ref _binding_0, ) => {
+ Body::Struct(ref _binding_0, ) => {
_visitor.visit_body_struct(_binding_0);
}
}
@@ -629,126 +625,125 @@
}
pub fn visit_expr<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Expr) {
- use ::Expr::*;
match *_i {
- Box(ref _binding_0, ) => {
+ Expr::Box(ref _binding_0, ) => {
full!(_visitor.visit_expr_box(_binding_0));
}
- InPlace(ref _binding_0, ) => {
+ Expr::InPlace(ref _binding_0, ) => {
full!(_visitor.visit_expr_in_place(_binding_0));
}
- Array(ref _binding_0, ) => {
+ Expr::Array(ref _binding_0, ) => {
full!(_visitor.visit_expr_array(_binding_0));
}
- Call(ref _binding_0, ) => {
+ Expr::Call(ref _binding_0, ) => {
_visitor.visit_expr_call(_binding_0);
}
- MethodCall(ref _binding_0, ) => {
+ Expr::MethodCall(ref _binding_0, ) => {
full!(_visitor.visit_expr_method_call(_binding_0));
}
- Tuple(ref _binding_0, ) => {
+ Expr::Tuple(ref _binding_0, ) => {
full!(_visitor.visit_expr_tuple(_binding_0));
}
- Binary(ref _binding_0, ) => {
+ Expr::Binary(ref _binding_0, ) => {
_visitor.visit_expr_binary(_binding_0);
}
- Unary(ref _binding_0, ) => {
+ Expr::Unary(ref _binding_0, ) => {
_visitor.visit_expr_unary(_binding_0);
}
- Lit(ref _binding_0, ) => {
+ Expr::Lit(ref _binding_0, ) => {
_visitor.visit_expr_lit(_binding_0);
}
- Cast(ref _binding_0, ) => {
+ Expr::Cast(ref _binding_0, ) => {
_visitor.visit_expr_cast(_binding_0);
}
- Type(ref _binding_0, ) => {
+ Expr::Type(ref _binding_0, ) => {
full!(_visitor.visit_expr_type(_binding_0));
}
- If(ref _binding_0, ) => {
+ Expr::If(ref _binding_0, ) => {
full!(_visitor.visit_expr_if(_binding_0));
}
- IfLet(ref _binding_0, ) => {
+ Expr::IfLet(ref _binding_0, ) => {
full!(_visitor.visit_expr_if_let(_binding_0));
}
- While(ref _binding_0, ) => {
+ Expr::While(ref _binding_0, ) => {
full!(_visitor.visit_expr_while(_binding_0));
}
- WhileLet(ref _binding_0, ) => {
+ Expr::WhileLet(ref _binding_0, ) => {
full!(_visitor.visit_expr_while_let(_binding_0));
}
- ForLoop(ref _binding_0, ) => {
+ Expr::ForLoop(ref _binding_0, ) => {
full!(_visitor.visit_expr_for_loop(_binding_0));
}
- Loop(ref _binding_0, ) => {
+ Expr::Loop(ref _binding_0, ) => {
full!(_visitor.visit_expr_loop(_binding_0));
}
- Match(ref _binding_0, ) => {
+ Expr::Match(ref _binding_0, ) => {
full!(_visitor.visit_expr_match(_binding_0));
}
- Closure(ref _binding_0, ) => {
+ Expr::Closure(ref _binding_0, ) => {
full!(_visitor.visit_expr_closure(_binding_0));
}
- Unsafe(ref _binding_0, ) => {
+ Expr::Unsafe(ref _binding_0, ) => {
full!(_visitor.visit_expr_unsafe(_binding_0));
}
- Block(ref _binding_0, ) => {
+ Expr::Block(ref _binding_0, ) => {
full!(_visitor.visit_expr_block(_binding_0));
}
- Assign(ref _binding_0, ) => {
+ Expr::Assign(ref _binding_0, ) => {
full!(_visitor.visit_expr_assign(_binding_0));
}
- AssignOp(ref _binding_0, ) => {
+ Expr::AssignOp(ref _binding_0, ) => {
full!(_visitor.visit_expr_assign_op(_binding_0));
}
- Field(ref _binding_0, ) => {
+ Expr::Field(ref _binding_0, ) => {
full!(_visitor.visit_expr_field(_binding_0));
}
- Index(ref _binding_0, ) => {
+ Expr::Index(ref _binding_0, ) => {
_visitor.visit_expr_index(_binding_0);
}
- Range(ref _binding_0, ) => {
+ Expr::Range(ref _binding_0, ) => {
full!(_visitor.visit_expr_range(_binding_0));
}
- Path(ref _binding_0, ) => {
+ Expr::Path(ref _binding_0, ) => {
_visitor.visit_expr_path(_binding_0);
}
- AddrOf(ref _binding_0, ) => {
+ Expr::AddrOf(ref _binding_0, ) => {
full!(_visitor.visit_expr_addr_of(_binding_0));
}
- Break(ref _binding_0, ) => {
+ Expr::Break(ref _binding_0, ) => {
full!(_visitor.visit_expr_break(_binding_0));
}
- Continue(ref _binding_0, ) => {
+ Expr::Continue(ref _binding_0, ) => {
full!(_visitor.visit_expr_continue(_binding_0));
}
- Return(ref _binding_0, ) => {
+ Expr::Return(ref _binding_0, ) => {
full!(_visitor.visit_expr_return(_binding_0));
}
- Macro(ref _binding_0, ) => {
+ Expr::Macro(ref _binding_0, ) => {
full!(_visitor.visit_expr_macro(_binding_0));
}
- Struct(ref _binding_0, ) => {
+ Expr::Struct(ref _binding_0, ) => {
full!(_visitor.visit_expr_struct(_binding_0));
}
- Repeat(ref _binding_0, ) => {
+ Expr::Repeat(ref _binding_0, ) => {
full!(_visitor.visit_expr_repeat(_binding_0));
}
- Paren(ref _binding_0, ) => {
+ Expr::Paren(ref _binding_0, ) => {
full!(_visitor.visit_expr_paren(_binding_0));
}
- Group(ref _binding_0, ) => {
+ Expr::Group(ref _binding_0, ) => {
full!(_visitor.visit_expr_group(_binding_0));
}
- Try(ref _binding_0, ) => {
+ Expr::Try(ref _binding_0, ) => {
full!(_visitor.visit_expr_try(_binding_0));
}
- Catch(ref _binding_0, ) => {
+ Expr::Catch(ref _binding_0, ) => {
full!(_visitor.visit_expr_catch(_binding_0));
}
- Yield(ref _binding_0, ) => {
+ Expr::Yield(ref _binding_0, ) => {
full!(_visitor.visit_expr_yield(_binding_0));
}
- Verbatim(ref _binding_0, ) => {
+ Expr::Verbatim(ref _binding_0, ) => {
_visitor.visit_expr_verbatim(_binding_0);
}
}
@@ -1071,21 +1066,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_fn_arg<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FnArg) {
- use ::FnArg::*;
match *_i {
- SelfRef(ref _binding_0, ) => {
+ FnArg::SelfRef(ref _binding_0, ) => {
_visitor.visit_arg_self_ref(_binding_0);
}
- SelfValue(ref _binding_0, ) => {
+ FnArg::SelfValue(ref _binding_0, ) => {
_visitor.visit_arg_self(_binding_0);
}
- Captured(ref _binding_0, ) => {
+ FnArg::Captured(ref _binding_0, ) => {
_visitor.visit_arg_captured(_binding_0);
}
- Inferred(ref _binding_0, ) => {
+ FnArg::Inferred(ref _binding_0, ) => {
_visitor.visit_pat(_binding_0);
}
- Ignored(ref _binding_0, ) => {
+ FnArg::Ignored(ref _binding_0, ) => {
_visitor.visit_type(_binding_0);
}
}
@@ -1101,18 +1095,17 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_foreign_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ForeignItem) {
- use ::ForeignItem::*;
match *_i {
- Fn(ref _binding_0, ) => {
+ ForeignItem::Fn(ref _binding_0, ) => {
_visitor.visit_foreign_item_fn(_binding_0);
}
- Static(ref _binding_0, ) => {
+ ForeignItem::Static(ref _binding_0, ) => {
_visitor.visit_foreign_item_static(_binding_0);
}
- Type(ref _binding_0, ) => {
+ ForeignItem::Type(ref _binding_0, ) => {
_visitor.visit_foreign_item_type(_binding_0);
}
- Verbatim(ref _binding_0, ) => {
+ ForeignItem::Verbatim(ref _binding_0, ) => {
_visitor.visit_foreign_item_verbatim(_binding_0);
}
}
@@ -1150,45 +1143,42 @@
}
pub fn visit_generic_argument<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast GenericArgument) {
- use ::GenericArgument::*;
match *_i {
- Lifetime(ref _binding_0, ) => {
+ GenericArgument::Lifetime(ref _binding_0, ) => {
_visitor.visit_lifetime(_binding_0);
}
- Type(ref _binding_0, ) => {
+ GenericArgument::Type(ref _binding_0, ) => {
_visitor.visit_type(_binding_0);
}
- Binding(ref _binding_0, ) => {
+ GenericArgument::Binding(ref _binding_0, ) => {
_visitor.visit_binding(_binding_0);
}
- Const(ref _binding_0, ) => {
+ GenericArgument::Const(ref _binding_0, ) => {
_visitor.visit_expr(_binding_0);
}
}
}
# [ cfg ( feature = "full" ) ]
pub fn visit_generic_method_argument<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast GenericMethodArgument) {
- use ::GenericMethodArgument::*;
match *_i {
- Type(ref _binding_0, ) => {
+ GenericMethodArgument::Type(ref _binding_0, ) => {
_visitor.visit_type(_binding_0);
}
- Const(ref _binding_0, ) => {
+ GenericMethodArgument::Const(ref _binding_0, ) => {
_visitor.visit_expr(_binding_0);
}
}
}
pub fn visit_generic_param<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast GenericParam) {
- use ::GenericParam::*;
match *_i {
- Lifetime(ref _binding_0, ) => {
+ GenericParam::Lifetime(ref _binding_0, ) => {
_visitor.visit_lifetime_def(_binding_0);
}
- Type(ref _binding_0, ) => {
+ GenericParam::Type(ref _binding_0, ) => {
_visitor.visit_type_param(_binding_0);
}
- Const(ref _binding_0, ) => {
+ GenericParam::Const(ref _binding_0, ) => {
_visitor.visit_const_param(_binding_0);
}
}
@@ -1207,21 +1197,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_impl_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ImplItem) {
- use ::ImplItem::*;
match *_i {
- Const(ref _binding_0, ) => {
+ ImplItem::Const(ref _binding_0, ) => {
_visitor.visit_impl_item_const(_binding_0);
}
- Method(ref _binding_0, ) => {
+ ImplItem::Method(ref _binding_0, ) => {
_visitor.visit_impl_item_method(_binding_0);
}
- Type(ref _binding_0, ) => {
+ ImplItem::Type(ref _binding_0, ) => {
_visitor.visit_impl_item_type(_binding_0);
}
- Macro(ref _binding_0, ) => {
+ ImplItem::Macro(ref _binding_0, ) => {
_visitor.visit_impl_item_macro(_binding_0);
}
- Verbatim(ref _binding_0, ) => {
+ ImplItem::Verbatim(ref _binding_0, ) => {
_visitor.visit_impl_item_verbatim(_binding_0);
}
}
@@ -1276,54 +1265,53 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Item) {
- use ::Item::*;
match *_i {
- ExternCrate(ref _binding_0, ) => {
+ Item::ExternCrate(ref _binding_0, ) => {
_visitor.visit_item_extern_crate(_binding_0);
}
- Use(ref _binding_0, ) => {
+ Item::Use(ref _binding_0, ) => {
_visitor.visit_item_use(_binding_0);
}
- Static(ref _binding_0, ) => {
+ Item::Static(ref _binding_0, ) => {
_visitor.visit_item_static(_binding_0);
}
- Const(ref _binding_0, ) => {
+ Item::Const(ref _binding_0, ) => {
_visitor.visit_item_const(_binding_0);
}
- Fn(ref _binding_0, ) => {
+ Item::Fn(ref _binding_0, ) => {
_visitor.visit_item_fn(_binding_0);
}
- Mod(ref _binding_0, ) => {
+ Item::Mod(ref _binding_0, ) => {
_visitor.visit_item_mod(_binding_0);
}
- ForeignMod(ref _binding_0, ) => {
+ Item::ForeignMod(ref _binding_0, ) => {
_visitor.visit_item_foreign_mod(_binding_0);
}
- Type(ref _binding_0, ) => {
+ Item::Type(ref _binding_0, ) => {
_visitor.visit_item_type(_binding_0);
}
- Enum(ref _binding_0, ) => {
+ Item::Enum(ref _binding_0, ) => {
_visitor.visit_item_enum(_binding_0);
}
- Struct(ref _binding_0, ) => {
+ Item::Struct(ref _binding_0, ) => {
_visitor.visit_item_struct(_binding_0);
}
- Union(ref _binding_0, ) => {
+ Item::Union(ref _binding_0, ) => {
_visitor.visit_item_union(_binding_0);
}
- Trait(ref _binding_0, ) => {
+ Item::Trait(ref _binding_0, ) => {
_visitor.visit_item_trait(_binding_0);
}
- Impl(ref _binding_0, ) => {
+ Item::Impl(ref _binding_0, ) => {
_visitor.visit_item_impl(_binding_0);
}
- Macro(ref _binding_0, ) => {
+ Item::Macro(ref _binding_0, ) => {
_visitor.visit_item_macro(_binding_0);
}
- Macro2(ref _binding_0, ) => {
+ Item::Macro2(ref _binding_0, ) => {
_visitor.visit_item_macro2(_binding_0);
}
- Verbatim(ref _binding_0, ) => {
+ Item::Verbatim(ref _binding_0, ) => {
_visitor.visit_item_verbatim(_binding_0);
}
}
@@ -1544,42 +1532,39 @@
}
pub fn visit_macro_delimiter<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MacroDelimiter) {
- use ::MacroDelimiter::*;
match *_i {
- Paren(ref _binding_0, ) => {
+ MacroDelimiter::Paren(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Brace(ref _binding_0, ) => {
+ MacroDelimiter::Brace(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Bracket(ref _binding_0, ) => {
+ MacroDelimiter::Bracket(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
}
}
pub fn visit_member<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Member) {
- use ::Member::*;
match *_i {
- Named(ref _binding_0, ) => {
+ Member::Named(ref _binding_0, ) => {
_visitor.visit_ident(_binding_0);
}
- Unnamed(ref _binding_0, ) => {
+ Member::Unnamed(ref _binding_0, ) => {
_visitor.visit_index(_binding_0);
}
}
}
pub fn visit_meta_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaItem) {
- use ::MetaItem::*;
match *_i {
- Term(ref _binding_0, ) => {
+ MetaItem::Term(ref _binding_0, ) => {
_visitor.visit_ident(_binding_0);
}
- List(ref _binding_0, ) => {
+ MetaItem::List(ref _binding_0, ) => {
_visitor.visit_meta_item_list(_binding_0);
}
- NameValue(ref _binding_0, ) => {
+ MetaItem::NameValue(ref _binding_0, ) => {
_visitor.visit_meta_name_value(_binding_0);
}
}
@@ -1613,12 +1598,11 @@
}
pub fn visit_nested_meta_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast NestedMetaItem) {
- use ::NestedMetaItem::*;
match *_i {
- MetaItem(ref _binding_0, ) => {
+ NestedMetaItem::MetaItem(ref _binding_0, ) => {
_visitor.visit_meta_item(_binding_0);
}
- Literal(ref _binding_0, ) => {
+ NestedMetaItem::Literal(ref _binding_0, ) => {
_visitor.visit_lit(_binding_0);
}
}
@@ -1631,45 +1615,44 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Pat) {
- use ::Pat::*;
match *_i {
- Wild(ref _binding_0, ) => {
+ Pat::Wild(ref _binding_0, ) => {
_visitor.visit_pat_wild(_binding_0);
}
- Ident(ref _binding_0, ) => {
+ Pat::Ident(ref _binding_0, ) => {
_visitor.visit_pat_ident(_binding_0);
}
- Struct(ref _binding_0, ) => {
+ Pat::Struct(ref _binding_0, ) => {
_visitor.visit_pat_struct(_binding_0);
}
- TupleStruct(ref _binding_0, ) => {
+ Pat::TupleStruct(ref _binding_0, ) => {
_visitor.visit_pat_tuple_struct(_binding_0);
}
- Path(ref _binding_0, ) => {
+ Pat::Path(ref _binding_0, ) => {
_visitor.visit_pat_path(_binding_0);
}
- Tuple(ref _binding_0, ) => {
+ Pat::Tuple(ref _binding_0, ) => {
_visitor.visit_pat_tuple(_binding_0);
}
- Box(ref _binding_0, ) => {
+ Pat::Box(ref _binding_0, ) => {
_visitor.visit_pat_box(_binding_0);
}
- Ref(ref _binding_0, ) => {
+ Pat::Ref(ref _binding_0, ) => {
_visitor.visit_pat_ref(_binding_0);
}
- Lit(ref _binding_0, ) => {
+ Pat::Lit(ref _binding_0, ) => {
_visitor.visit_pat_lit(_binding_0);
}
- Range(ref _binding_0, ) => {
+ Pat::Range(ref _binding_0, ) => {
_visitor.visit_pat_range(_binding_0);
}
- Slice(ref _binding_0, ) => {
+ Pat::Slice(ref _binding_0, ) => {
_visitor.visit_pat_slice(_binding_0);
}
- Macro(ref _binding_0, ) => {
+ Pat::Macro(ref _binding_0, ) => {
_visitor.visit_pat_macro(_binding_0);
}
- Verbatim(ref _binding_0, ) => {
+ Pat::Verbatim(ref _binding_0, ) => {
_visitor.visit_pat_verbatim(_binding_0);
}
}
@@ -1758,13 +1741,12 @@
}
pub fn visit_path_arguments<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathArguments) {
- use ::PathArguments::*;
match *_i {
- None => { }
- AngleBracketed(ref _binding_0, ) => {
+ PathArguments::None => { }
+ PathArguments::AngleBracketed(ref _binding_0, ) => {
_visitor.visit_angle_bracketed_generic_arguments(_binding_0);
}
- Parenthesized(ref _binding_0, ) => {
+ PathArguments::Parenthesized(ref _binding_0, ) => {
_visitor.visit_parenthesized_generic_arguments(_binding_0);
}
}
@@ -1789,22 +1771,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_range_limits<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast RangeLimits) {
- use ::RangeLimits::*;
match *_i {
- HalfOpen(ref _binding_0, ) => {
+ RangeLimits::HalfOpen(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Closed(ref _binding_0, ) => {
+ RangeLimits::Closed(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
}
}
pub fn visit_return_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ReturnType) {
- use ::ReturnType::*;
match *_i {
- Default => { }
- Type(ref _binding_0, ref _binding_1, ) => {
+ ReturnType::Default => { }
+ ReturnType::Type(ref _binding_0, ref _binding_1, ) => {
tokens_helper(_visitor, &(_binding_0).0);
_visitor.visit_type(& * * _binding_1);
}
@@ -1815,18 +1795,17 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_stmt<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Stmt) {
- use ::Stmt::*;
match *_i {
- Local(ref _binding_0, ) => {
+ Stmt::Local(ref _binding_0, ) => {
_visitor.visit_local(& * * _binding_0);
}
- Item(ref _binding_0, ) => {
+ Stmt::Item(ref _binding_0, ) => {
_visitor.visit_item(& * * _binding_0);
}
- Expr(ref _binding_0, ) => {
+ Stmt::Expr(ref _binding_0, ) => {
_visitor.visit_expr(& * * _binding_0);
}
- Semi(ref _binding_0, ref _binding_1, ) => {
+ Stmt::Semi(ref _binding_0, ref _binding_1, ) => {
_visitor.visit_expr(& * * _binding_0);
tokens_helper(_visitor, &(_binding_1).0);
}
@@ -1834,31 +1813,29 @@
}
pub fn visit_trait_bound_modifier<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitBoundModifier) {
- use ::TraitBoundModifier::*;
match *_i {
- None => { }
- Maybe(ref _binding_0, ) => {
+ TraitBoundModifier::None => { }
+ TraitBoundModifier::Maybe(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
}
}
# [ cfg ( feature = "full" ) ]
pub fn visit_trait_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitItem) {
- use ::TraitItem::*;
match *_i {
- Const(ref _binding_0, ) => {
+ TraitItem::Const(ref _binding_0, ) => {
_visitor.visit_trait_item_const(_binding_0);
}
- Method(ref _binding_0, ) => {
+ TraitItem::Method(ref _binding_0, ) => {
_visitor.visit_trait_item_method(_binding_0);
}
- Type(ref _binding_0, ) => {
+ TraitItem::Type(ref _binding_0, ) => {
_visitor.visit_trait_item_type(_binding_0);
}
- Macro(ref _binding_0, ) => {
+ TraitItem::Macro(ref _binding_0, ) => {
_visitor.visit_trait_item_macro(_binding_0);
}
- Verbatim(ref _binding_0, ) => {
+ TraitItem::Verbatim(ref _binding_0, ) => {
_visitor.visit_trait_item_verbatim(_binding_0);
}
}
@@ -1909,51 +1886,50 @@
}
pub fn visit_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Type) {
- use ::Type::*;
match *_i {
- Slice(ref _binding_0, ) => {
+ Type::Slice(ref _binding_0, ) => {
_visitor.visit_type_slice(_binding_0);
}
- Array(ref _binding_0, ) => {
+ Type::Array(ref _binding_0, ) => {
_visitor.visit_type_array(_binding_0);
}
- Ptr(ref _binding_0, ) => {
+ Type::Ptr(ref _binding_0, ) => {
_visitor.visit_type_ptr(_binding_0);
}
- Reference(ref _binding_0, ) => {
+ Type::Reference(ref _binding_0, ) => {
_visitor.visit_type_reference(_binding_0);
}
- BareFn(ref _binding_0, ) => {
+ Type::BareFn(ref _binding_0, ) => {
_visitor.visit_type_bare_fn(_binding_0);
}
- Never(ref _binding_0, ) => {
+ Type::Never(ref _binding_0, ) => {
_visitor.visit_type_never(_binding_0);
}
- Tuple(ref _binding_0, ) => {
+ Type::Tuple(ref _binding_0, ) => {
_visitor.visit_type_tuple(_binding_0);
}
- Path(ref _binding_0, ) => {
+ Type::Path(ref _binding_0, ) => {
_visitor.visit_type_path(_binding_0);
}
- TraitObject(ref _binding_0, ) => {
+ Type::TraitObject(ref _binding_0, ) => {
_visitor.visit_type_trait_object(_binding_0);
}
- ImplTrait(ref _binding_0, ) => {
+ Type::ImplTrait(ref _binding_0, ) => {
_visitor.visit_type_impl_trait(_binding_0);
}
- Paren(ref _binding_0, ) => {
+ Type::Paren(ref _binding_0, ) => {
_visitor.visit_type_paren(_binding_0);
}
- Group(ref _binding_0, ) => {
+ Type::Group(ref _binding_0, ) => {
_visitor.visit_type_group(_binding_0);
}
- Infer(ref _binding_0, ) => {
+ Type::Infer(ref _binding_0, ) => {
_visitor.visit_type_infer(_binding_0);
}
- Macro(ref _binding_0, ) => {
+ Type::Macro(ref _binding_0, ) => {
_visitor.visit_type_macro(_binding_0);
}
- Verbatim(ref _binding_0, ) => {
+ Type::Verbatim(ref _binding_0, ) => {
_visitor.visit_type_verbatim(_binding_0);
}
}
@@ -2009,13 +1985,12 @@
}
pub fn visit_type_param_bound<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeParamBound) {
- use ::TypeParamBound::*;
match *_i {
- Trait(ref _binding_0, ref _binding_1, ) => {
+ TypeParamBound::Trait(ref _binding_0, ref _binding_1, ) => {
_visitor.visit_poly_trait_ref(_binding_0);
_visitor.visit_trait_bound_modifier(_binding_1);
}
- Region(ref _binding_0, ) => {
+ TypeParamBound::Region(ref _binding_0, ) => {
_visitor.visit_lifetime(_binding_0);
}
}
@@ -2065,15 +2040,14 @@
}
pub fn visit_un_op<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UnOp) {
- use ::UnOp::*;
match *_i {
- Deref(ref _binding_0, ) => {
+ UnOp::Deref(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Not(ref _binding_0, ) => {
+ UnOp::Not(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
- Neg(ref _binding_0, ) => {
+ UnOp::Neg(ref _binding_0, ) => {
tokens_helper(_visitor, &(_binding_0).0);
}
}
@@ -2097,15 +2071,14 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_use_tree<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseTree) {
- use ::UseTree::*;
match *_i {
- Path(ref _binding_0, ) => {
+ UseTree::Path(ref _binding_0, ) => {
_visitor.visit_use_path(_binding_0);
}
- Glob(ref _binding_0, ) => {
+ UseTree::Glob(ref _binding_0, ) => {
_visitor.visit_use_glob(_binding_0);
}
- List(ref _binding_0, ) => {
+ UseTree::List(ref _binding_0, ) => {
_visitor.visit_use_list(_binding_0);
}
}
@@ -2122,17 +2095,16 @@
}
pub fn visit_variant_data<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VariantData) {
- use ::VariantData::*;
match *_i {
- Struct(ref _binding_0, ref _binding_1, ) => {
+ VariantData::Struct(ref _binding_0, ref _binding_1, ) => {
for el in _binding_0 { let it = el.item(); _visitor.visit_field(it) };
tokens_helper(_visitor, &(_binding_1).0);
}
- Tuple(ref _binding_0, ref _binding_1, ) => {
+ VariantData::Tuple(ref _binding_0, ref _binding_1, ) => {
for el in _binding_0 { let it = el.item(); _visitor.visit_field(it) };
tokens_helper(_visitor, &(_binding_1).0);
}
- Unit => { }
+ VariantData::Unit => { }
}
}
@@ -2154,18 +2126,17 @@
}
pub fn visit_visibility<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Visibility) {
- use ::Visibility::*;
match *_i {
- Public(ref _binding_0, ) => {
+ Visibility::Public(ref _binding_0, ) => {
_visitor.visit_vis_public(_binding_0);
}
- Crate(ref _binding_0, ) => {
+ Visibility::Crate(ref _binding_0, ) => {
_visitor.visit_vis_crate(_binding_0);
}
- Restricted(ref _binding_0, ) => {
+ Visibility::Restricted(ref _binding_0, ) => {
_visitor.visit_vis_restricted(_binding_0);
}
- Inherited => { }
+ Visibility::Inherited => { }
}
}
@@ -2188,15 +2159,14 @@
}
pub fn visit_where_predicate<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast WherePredicate) {
- use ::WherePredicate::*;
match *_i {
- BoundPredicate(ref _binding_0, ) => {
+ WherePredicate::BoundPredicate(ref _binding_0, ) => {
_visitor.visit_where_bound_predicate(_binding_0);
}
- RegionPredicate(ref _binding_0, ) => {
+ WherePredicate::RegionPredicate(ref _binding_0, ) => {
_visitor.visit_where_region_predicate(_binding_0);
}
- EqPredicate(ref _binding_0, ) => {
+ WherePredicate::EqPredicate(ref _binding_0, ) => {
_visitor.visit_where_eq_predicate(_binding_0);
}
}
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 9c164dc..94fd73f 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -440,10 +440,9 @@
}
pub fn visit_attr_style_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AttrStyle) {
- use ::AttrStyle::*;
match *_i {
- Outer => { }
- Inner(ref mut _binding_0, ) => {
+ AttrStyle::Outer => { }
+ AttrStyle::Inner(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
}
@@ -467,102 +466,100 @@
}
pub fn visit_bare_fn_arg_name_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArgName) {
- use ::BareFnArgName::*;
match *_i {
- Named(ref mut _binding_0, ) => {
+ BareFnArgName::Named(ref mut _binding_0, ) => {
_visitor.visit_ident_mut(_binding_0);
}
- Wild(ref mut _binding_0, ) => {
+ BareFnArgName::Wild(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
}
}
pub fn visit_bin_op_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp) {
- use ::BinOp::*;
match *_i {
- Add(ref mut _binding_0, ) => {
+ BinOp::Add(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Sub(ref mut _binding_0, ) => {
+ BinOp::Sub(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Mul(ref mut _binding_0, ) => {
+ BinOp::Mul(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Div(ref mut _binding_0, ) => {
+ BinOp::Div(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Rem(ref mut _binding_0, ) => {
+ BinOp::Rem(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- And(ref mut _binding_0, ) => {
+ BinOp::And(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Or(ref mut _binding_0, ) => {
+ BinOp::Or(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- BitXor(ref mut _binding_0, ) => {
+ BinOp::BitXor(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- BitAnd(ref mut _binding_0, ) => {
+ BinOp::BitAnd(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- BitOr(ref mut _binding_0, ) => {
+ BinOp::BitOr(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Shl(ref mut _binding_0, ) => {
+ BinOp::Shl(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Shr(ref mut _binding_0, ) => {
+ BinOp::Shr(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Eq(ref mut _binding_0, ) => {
+ BinOp::Eq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Lt(ref mut _binding_0, ) => {
+ BinOp::Lt(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Le(ref mut _binding_0, ) => {
+ BinOp::Le(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Ne(ref mut _binding_0, ) => {
+ BinOp::Ne(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Ge(ref mut _binding_0, ) => {
+ BinOp::Ge(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Gt(ref mut _binding_0, ) => {
+ BinOp::Gt(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- AddEq(ref mut _binding_0, ) => {
+ BinOp::AddEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- SubEq(ref mut _binding_0, ) => {
+ BinOp::SubEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- MulEq(ref mut _binding_0, ) => {
+ BinOp::MulEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- DivEq(ref mut _binding_0, ) => {
+ BinOp::DivEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- RemEq(ref mut _binding_0, ) => {
+ BinOp::RemEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- BitXorEq(ref mut _binding_0, ) => {
+ BinOp::BitXorEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- BitAndEq(ref mut _binding_0, ) => {
+ BinOp::BitAndEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- BitOrEq(ref mut _binding_0, ) => {
+ BinOp::BitOrEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- ShlEq(ref mut _binding_0, ) => {
+ BinOp::ShlEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- ShrEq(ref mut _binding_0, ) => {
+ BinOp::ShrEq(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
}
@@ -580,12 +577,11 @@
}
pub fn visit_body_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Body) {
- use ::Body::*;
match *_i {
- Enum(ref mut _binding_0, ) => {
+ Body::Enum(ref mut _binding_0, ) => {
_visitor.visit_body_enum_mut(_binding_0);
}
- Struct(ref mut _binding_0, ) => {
+ Body::Struct(ref mut _binding_0, ) => {
_visitor.visit_body_struct_mut(_binding_0);
}
}
@@ -629,126 +625,125 @@
}
pub fn visit_expr_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
- use ::Expr::*;
match *_i {
- Box(ref mut _binding_0, ) => {
+ Expr::Box(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_box_mut(_binding_0));
}
- InPlace(ref mut _binding_0, ) => {
+ Expr::InPlace(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_in_place_mut(_binding_0));
}
- Array(ref mut _binding_0, ) => {
+ Expr::Array(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_array_mut(_binding_0));
}
- Call(ref mut _binding_0, ) => {
+ Expr::Call(ref mut _binding_0, ) => {
_visitor.visit_expr_call_mut(_binding_0);
}
- MethodCall(ref mut _binding_0, ) => {
+ Expr::MethodCall(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_method_call_mut(_binding_0));
}
- Tuple(ref mut _binding_0, ) => {
+ Expr::Tuple(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_tuple_mut(_binding_0));
}
- Binary(ref mut _binding_0, ) => {
+ Expr::Binary(ref mut _binding_0, ) => {
_visitor.visit_expr_binary_mut(_binding_0);
}
- Unary(ref mut _binding_0, ) => {
+ Expr::Unary(ref mut _binding_0, ) => {
_visitor.visit_expr_unary_mut(_binding_0);
}
- Lit(ref mut _binding_0, ) => {
+ Expr::Lit(ref mut _binding_0, ) => {
_visitor.visit_expr_lit_mut(_binding_0);
}
- Cast(ref mut _binding_0, ) => {
+ Expr::Cast(ref mut _binding_0, ) => {
_visitor.visit_expr_cast_mut(_binding_0);
}
- Type(ref mut _binding_0, ) => {
+ Expr::Type(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_type_mut(_binding_0));
}
- If(ref mut _binding_0, ) => {
+ Expr::If(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_if_mut(_binding_0));
}
- IfLet(ref mut _binding_0, ) => {
+ Expr::IfLet(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_if_let_mut(_binding_0));
}
- While(ref mut _binding_0, ) => {
+ Expr::While(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_while_mut(_binding_0));
}
- WhileLet(ref mut _binding_0, ) => {
+ Expr::WhileLet(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_while_let_mut(_binding_0));
}
- ForLoop(ref mut _binding_0, ) => {
+ Expr::ForLoop(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_for_loop_mut(_binding_0));
}
- Loop(ref mut _binding_0, ) => {
+ Expr::Loop(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_loop_mut(_binding_0));
}
- Match(ref mut _binding_0, ) => {
+ Expr::Match(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_match_mut(_binding_0));
}
- Closure(ref mut _binding_0, ) => {
+ Expr::Closure(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_closure_mut(_binding_0));
}
- Unsafe(ref mut _binding_0, ) => {
+ Expr::Unsafe(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_unsafe_mut(_binding_0));
}
- Block(ref mut _binding_0, ) => {
+ Expr::Block(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_block_mut(_binding_0));
}
- Assign(ref mut _binding_0, ) => {
+ Expr::Assign(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_assign_mut(_binding_0));
}
- AssignOp(ref mut _binding_0, ) => {
+ Expr::AssignOp(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_assign_op_mut(_binding_0));
}
- Field(ref mut _binding_0, ) => {
+ Expr::Field(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_field_mut(_binding_0));
}
- Index(ref mut _binding_0, ) => {
+ Expr::Index(ref mut _binding_0, ) => {
_visitor.visit_expr_index_mut(_binding_0);
}
- Range(ref mut _binding_0, ) => {
+ Expr::Range(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_range_mut(_binding_0));
}
- Path(ref mut _binding_0, ) => {
+ Expr::Path(ref mut _binding_0, ) => {
_visitor.visit_expr_path_mut(_binding_0);
}
- AddrOf(ref mut _binding_0, ) => {
+ Expr::AddrOf(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_addr_of_mut(_binding_0));
}
- Break(ref mut _binding_0, ) => {
+ Expr::Break(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_break_mut(_binding_0));
}
- Continue(ref mut _binding_0, ) => {
+ Expr::Continue(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_continue_mut(_binding_0));
}
- Return(ref mut _binding_0, ) => {
+ Expr::Return(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_return_mut(_binding_0));
}
- Macro(ref mut _binding_0, ) => {
+ Expr::Macro(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_macro_mut(_binding_0));
}
- Struct(ref mut _binding_0, ) => {
+ Expr::Struct(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_struct_mut(_binding_0));
}
- Repeat(ref mut _binding_0, ) => {
+ Expr::Repeat(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_repeat_mut(_binding_0));
}
- Paren(ref mut _binding_0, ) => {
+ Expr::Paren(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_paren_mut(_binding_0));
}
- Group(ref mut _binding_0, ) => {
+ Expr::Group(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_group_mut(_binding_0));
}
- Try(ref mut _binding_0, ) => {
+ Expr::Try(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_try_mut(_binding_0));
}
- Catch(ref mut _binding_0, ) => {
+ Expr::Catch(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_catch_mut(_binding_0));
}
- Yield(ref mut _binding_0, ) => {
+ Expr::Yield(ref mut _binding_0, ) => {
full!(_visitor.visit_expr_yield_mut(_binding_0));
}
- Verbatim(ref mut _binding_0, ) => {
+ Expr::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_expr_verbatim_mut(_binding_0);
}
}
@@ -1071,21 +1066,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_fn_arg_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FnArg) {
- use ::FnArg::*;
match *_i {
- SelfRef(ref mut _binding_0, ) => {
+ FnArg::SelfRef(ref mut _binding_0, ) => {
_visitor.visit_arg_self_ref_mut(_binding_0);
}
- SelfValue(ref mut _binding_0, ) => {
+ FnArg::SelfValue(ref mut _binding_0, ) => {
_visitor.visit_arg_self_mut(_binding_0);
}
- Captured(ref mut _binding_0, ) => {
+ FnArg::Captured(ref mut _binding_0, ) => {
_visitor.visit_arg_captured_mut(_binding_0);
}
- Inferred(ref mut _binding_0, ) => {
+ FnArg::Inferred(ref mut _binding_0, ) => {
_visitor.visit_pat_mut(_binding_0);
}
- Ignored(ref mut _binding_0, ) => {
+ FnArg::Ignored(ref mut _binding_0, ) => {
_visitor.visit_type_mut(_binding_0);
}
}
@@ -1101,18 +1095,17 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_foreign_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItem) {
- use ::ForeignItem::*;
match *_i {
- Fn(ref mut _binding_0, ) => {
+ ForeignItem::Fn(ref mut _binding_0, ) => {
_visitor.visit_foreign_item_fn_mut(_binding_0);
}
- Static(ref mut _binding_0, ) => {
+ ForeignItem::Static(ref mut _binding_0, ) => {
_visitor.visit_foreign_item_static_mut(_binding_0);
}
- Type(ref mut _binding_0, ) => {
+ ForeignItem::Type(ref mut _binding_0, ) => {
_visitor.visit_foreign_item_type_mut(_binding_0);
}
- Verbatim(ref mut _binding_0, ) => {
+ ForeignItem::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_foreign_item_verbatim_mut(_binding_0);
}
}
@@ -1150,45 +1143,42 @@
}
pub fn visit_generic_argument_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut GenericArgument) {
- use ::GenericArgument::*;
match *_i {
- Lifetime(ref mut _binding_0, ) => {
+ GenericArgument::Lifetime(ref mut _binding_0, ) => {
_visitor.visit_lifetime_mut(_binding_0);
}
- Type(ref mut _binding_0, ) => {
+ GenericArgument::Type(ref mut _binding_0, ) => {
_visitor.visit_type_mut(_binding_0);
}
- Binding(ref mut _binding_0, ) => {
+ GenericArgument::Binding(ref mut _binding_0, ) => {
_visitor.visit_binding_mut(_binding_0);
}
- Const(ref mut _binding_0, ) => {
+ GenericArgument::Const(ref mut _binding_0, ) => {
_visitor.visit_expr_mut(_binding_0);
}
}
}
# [ cfg ( feature = "full" ) ]
pub fn visit_generic_method_argument_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut GenericMethodArgument) {
- use ::GenericMethodArgument::*;
match *_i {
- Type(ref mut _binding_0, ) => {
+ GenericMethodArgument::Type(ref mut _binding_0, ) => {
_visitor.visit_type_mut(_binding_0);
}
- Const(ref mut _binding_0, ) => {
+ GenericMethodArgument::Const(ref mut _binding_0, ) => {
_visitor.visit_expr_mut(_binding_0);
}
}
}
pub fn visit_generic_param_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut GenericParam) {
- use ::GenericParam::*;
match *_i {
- Lifetime(ref mut _binding_0, ) => {
+ GenericParam::Lifetime(ref mut _binding_0, ) => {
_visitor.visit_lifetime_def_mut(_binding_0);
}
- Type(ref mut _binding_0, ) => {
+ GenericParam::Type(ref mut _binding_0, ) => {
_visitor.visit_type_param_mut(_binding_0);
}
- Const(ref mut _binding_0, ) => {
+ GenericParam::Const(ref mut _binding_0, ) => {
_visitor.visit_const_param_mut(_binding_0);
}
}
@@ -1207,21 +1197,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_impl_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItem) {
- use ::ImplItem::*;
match *_i {
- Const(ref mut _binding_0, ) => {
+ ImplItem::Const(ref mut _binding_0, ) => {
_visitor.visit_impl_item_const_mut(_binding_0);
}
- Method(ref mut _binding_0, ) => {
+ ImplItem::Method(ref mut _binding_0, ) => {
_visitor.visit_impl_item_method_mut(_binding_0);
}
- Type(ref mut _binding_0, ) => {
+ ImplItem::Type(ref mut _binding_0, ) => {
_visitor.visit_impl_item_type_mut(_binding_0);
}
- Macro(ref mut _binding_0, ) => {
+ ImplItem::Macro(ref mut _binding_0, ) => {
_visitor.visit_impl_item_macro_mut(_binding_0);
}
- Verbatim(ref mut _binding_0, ) => {
+ ImplItem::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_impl_item_verbatim_mut(_binding_0);
}
}
@@ -1276,54 +1265,53 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Item) {
- use ::Item::*;
match *_i {
- ExternCrate(ref mut _binding_0, ) => {
+ Item::ExternCrate(ref mut _binding_0, ) => {
_visitor.visit_item_extern_crate_mut(_binding_0);
}
- Use(ref mut _binding_0, ) => {
+ Item::Use(ref mut _binding_0, ) => {
_visitor.visit_item_use_mut(_binding_0);
}
- Static(ref mut _binding_0, ) => {
+ Item::Static(ref mut _binding_0, ) => {
_visitor.visit_item_static_mut(_binding_0);
}
- Const(ref mut _binding_0, ) => {
+ Item::Const(ref mut _binding_0, ) => {
_visitor.visit_item_const_mut(_binding_0);
}
- Fn(ref mut _binding_0, ) => {
+ Item::Fn(ref mut _binding_0, ) => {
_visitor.visit_item_fn_mut(_binding_0);
}
- Mod(ref mut _binding_0, ) => {
+ Item::Mod(ref mut _binding_0, ) => {
_visitor.visit_item_mod_mut(_binding_0);
}
- ForeignMod(ref mut _binding_0, ) => {
+ Item::ForeignMod(ref mut _binding_0, ) => {
_visitor.visit_item_foreign_mod_mut(_binding_0);
}
- Type(ref mut _binding_0, ) => {
+ Item::Type(ref mut _binding_0, ) => {
_visitor.visit_item_type_mut(_binding_0);
}
- Enum(ref mut _binding_0, ) => {
+ Item::Enum(ref mut _binding_0, ) => {
_visitor.visit_item_enum_mut(_binding_0);
}
- Struct(ref mut _binding_0, ) => {
+ Item::Struct(ref mut _binding_0, ) => {
_visitor.visit_item_struct_mut(_binding_0);
}
- Union(ref mut _binding_0, ) => {
+ Item::Union(ref mut _binding_0, ) => {
_visitor.visit_item_union_mut(_binding_0);
}
- Trait(ref mut _binding_0, ) => {
+ Item::Trait(ref mut _binding_0, ) => {
_visitor.visit_item_trait_mut(_binding_0);
}
- Impl(ref mut _binding_0, ) => {
+ Item::Impl(ref mut _binding_0, ) => {
_visitor.visit_item_impl_mut(_binding_0);
}
- Macro(ref mut _binding_0, ) => {
+ Item::Macro(ref mut _binding_0, ) => {
_visitor.visit_item_macro_mut(_binding_0);
}
- Macro2(ref mut _binding_0, ) => {
+ Item::Macro2(ref mut _binding_0, ) => {
_visitor.visit_item_macro2_mut(_binding_0);
}
- Verbatim(ref mut _binding_0, ) => {
+ Item::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_item_verbatim_mut(_binding_0);
}
}
@@ -1544,42 +1532,39 @@
}
pub fn visit_macro_delimiter_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MacroDelimiter) {
- use ::MacroDelimiter::*;
match *_i {
- Paren(ref mut _binding_0, ) => {
+ MacroDelimiter::Paren(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Brace(ref mut _binding_0, ) => {
+ MacroDelimiter::Brace(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Bracket(ref mut _binding_0, ) => {
+ MacroDelimiter::Bracket(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
}
}
pub fn visit_member_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Member) {
- use ::Member::*;
match *_i {
- Named(ref mut _binding_0, ) => {
+ Member::Named(ref mut _binding_0, ) => {
_visitor.visit_ident_mut(_binding_0);
}
- Unnamed(ref mut _binding_0, ) => {
+ Member::Unnamed(ref mut _binding_0, ) => {
_visitor.visit_index_mut(_binding_0);
}
}
}
pub fn visit_meta_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItem) {
- use ::MetaItem::*;
match *_i {
- Term(ref mut _binding_0, ) => {
+ MetaItem::Term(ref mut _binding_0, ) => {
_visitor.visit_ident_mut(_binding_0);
}
- List(ref mut _binding_0, ) => {
+ MetaItem::List(ref mut _binding_0, ) => {
_visitor.visit_meta_item_list_mut(_binding_0);
}
- NameValue(ref mut _binding_0, ) => {
+ MetaItem::NameValue(ref mut _binding_0, ) => {
_visitor.visit_meta_name_value_mut(_binding_0);
}
}
@@ -1613,12 +1598,11 @@
}
pub fn visit_nested_meta_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMetaItem) {
- use ::NestedMetaItem::*;
match *_i {
- MetaItem(ref mut _binding_0, ) => {
+ NestedMetaItem::MetaItem(ref mut _binding_0, ) => {
_visitor.visit_meta_item_mut(_binding_0);
}
- Literal(ref mut _binding_0, ) => {
+ NestedMetaItem::Literal(ref mut _binding_0, ) => {
_visitor.visit_lit_mut(_binding_0);
}
}
@@ -1631,45 +1615,44 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Pat) {
- use ::Pat::*;
match *_i {
- Wild(ref mut _binding_0, ) => {
+ Pat::Wild(ref mut _binding_0, ) => {
_visitor.visit_pat_wild_mut(_binding_0);
}
- Ident(ref mut _binding_0, ) => {
+ Pat::Ident(ref mut _binding_0, ) => {
_visitor.visit_pat_ident_mut(_binding_0);
}
- Struct(ref mut _binding_0, ) => {
+ Pat::Struct(ref mut _binding_0, ) => {
_visitor.visit_pat_struct_mut(_binding_0);
}
- TupleStruct(ref mut _binding_0, ) => {
+ Pat::TupleStruct(ref mut _binding_0, ) => {
_visitor.visit_pat_tuple_struct_mut(_binding_0);
}
- Path(ref mut _binding_0, ) => {
+ Pat::Path(ref mut _binding_0, ) => {
_visitor.visit_pat_path_mut(_binding_0);
}
- Tuple(ref mut _binding_0, ) => {
+ Pat::Tuple(ref mut _binding_0, ) => {
_visitor.visit_pat_tuple_mut(_binding_0);
}
- Box(ref mut _binding_0, ) => {
+ Pat::Box(ref mut _binding_0, ) => {
_visitor.visit_pat_box_mut(_binding_0);
}
- Ref(ref mut _binding_0, ) => {
+ Pat::Ref(ref mut _binding_0, ) => {
_visitor.visit_pat_ref_mut(_binding_0);
}
- Lit(ref mut _binding_0, ) => {
+ Pat::Lit(ref mut _binding_0, ) => {
_visitor.visit_pat_lit_mut(_binding_0);
}
- Range(ref mut _binding_0, ) => {
+ Pat::Range(ref mut _binding_0, ) => {
_visitor.visit_pat_range_mut(_binding_0);
}
- Slice(ref mut _binding_0, ) => {
+ Pat::Slice(ref mut _binding_0, ) => {
_visitor.visit_pat_slice_mut(_binding_0);
}
- Macro(ref mut _binding_0, ) => {
+ Pat::Macro(ref mut _binding_0, ) => {
_visitor.visit_pat_macro_mut(_binding_0);
}
- Verbatim(ref mut _binding_0, ) => {
+ Pat::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_pat_verbatim_mut(_binding_0);
}
}
@@ -1758,13 +1741,12 @@
}
pub fn visit_path_arguments_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathArguments) {
- use ::PathArguments::*;
match *_i {
- None => { }
- AngleBracketed(ref mut _binding_0, ) => {
+ PathArguments::None => { }
+ PathArguments::AngleBracketed(ref mut _binding_0, ) => {
_visitor.visit_angle_bracketed_generic_arguments_mut(_binding_0);
}
- Parenthesized(ref mut _binding_0, ) => {
+ PathArguments::Parenthesized(ref mut _binding_0, ) => {
_visitor.visit_parenthesized_generic_arguments_mut(_binding_0);
}
}
@@ -1789,22 +1771,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_range_limits_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut RangeLimits) {
- use ::RangeLimits::*;
match *_i {
- HalfOpen(ref mut _binding_0, ) => {
+ RangeLimits::HalfOpen(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Closed(ref mut _binding_0, ) => {
+ RangeLimits::Closed(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
}
}
pub fn visit_return_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ReturnType) {
- use ::ReturnType::*;
match *_i {
- Default => { }
- Type(ref mut _binding_0, ref mut _binding_1, ) => {
+ ReturnType::Default => { }
+ ReturnType::Type(ref mut _binding_0, ref mut _binding_1, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
_visitor.visit_type_mut(& mut * * _binding_1);
}
@@ -1815,18 +1795,17 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_stmt_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Stmt) {
- use ::Stmt::*;
match *_i {
- Local(ref mut _binding_0, ) => {
+ Stmt::Local(ref mut _binding_0, ) => {
_visitor.visit_local_mut(& mut * * _binding_0);
}
- Item(ref mut _binding_0, ) => {
+ Stmt::Item(ref mut _binding_0, ) => {
_visitor.visit_item_mut(& mut * * _binding_0);
}
- Expr(ref mut _binding_0, ) => {
+ Stmt::Expr(ref mut _binding_0, ) => {
_visitor.visit_expr_mut(& mut * * _binding_0);
}
- Semi(ref mut _binding_0, ref mut _binding_1, ) => {
+ Stmt::Semi(ref mut _binding_0, ref mut _binding_1, ) => {
_visitor.visit_expr_mut(& mut * * _binding_0);
tokens_helper(_visitor, &mut (_binding_1).0);
}
@@ -1834,31 +1813,29 @@
}
pub fn visit_trait_bound_modifier_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBoundModifier) {
- use ::TraitBoundModifier::*;
match *_i {
- None => { }
- Maybe(ref mut _binding_0, ) => {
+ TraitBoundModifier::None => { }
+ TraitBoundModifier::Maybe(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
}
}
# [ cfg ( feature = "full" ) ]
pub fn visit_trait_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItem) {
- use ::TraitItem::*;
match *_i {
- Const(ref mut _binding_0, ) => {
+ TraitItem::Const(ref mut _binding_0, ) => {
_visitor.visit_trait_item_const_mut(_binding_0);
}
- Method(ref mut _binding_0, ) => {
+ TraitItem::Method(ref mut _binding_0, ) => {
_visitor.visit_trait_item_method_mut(_binding_0);
}
- Type(ref mut _binding_0, ) => {
+ TraitItem::Type(ref mut _binding_0, ) => {
_visitor.visit_trait_item_type_mut(_binding_0);
}
- Macro(ref mut _binding_0, ) => {
+ TraitItem::Macro(ref mut _binding_0, ) => {
_visitor.visit_trait_item_macro_mut(_binding_0);
}
- Verbatim(ref mut _binding_0, ) => {
+ TraitItem::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_trait_item_verbatim_mut(_binding_0);
}
}
@@ -1909,51 +1886,50 @@
}
pub fn visit_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Type) {
- use ::Type::*;
match *_i {
- Slice(ref mut _binding_0, ) => {
+ Type::Slice(ref mut _binding_0, ) => {
_visitor.visit_type_slice_mut(_binding_0);
}
- Array(ref mut _binding_0, ) => {
+ Type::Array(ref mut _binding_0, ) => {
_visitor.visit_type_array_mut(_binding_0);
}
- Ptr(ref mut _binding_0, ) => {
+ Type::Ptr(ref mut _binding_0, ) => {
_visitor.visit_type_ptr_mut(_binding_0);
}
- Reference(ref mut _binding_0, ) => {
+ Type::Reference(ref mut _binding_0, ) => {
_visitor.visit_type_reference_mut(_binding_0);
}
- BareFn(ref mut _binding_0, ) => {
+ Type::BareFn(ref mut _binding_0, ) => {
_visitor.visit_type_bare_fn_mut(_binding_0);
}
- Never(ref mut _binding_0, ) => {
+ Type::Never(ref mut _binding_0, ) => {
_visitor.visit_type_never_mut(_binding_0);
}
- Tuple(ref mut _binding_0, ) => {
+ Type::Tuple(ref mut _binding_0, ) => {
_visitor.visit_type_tuple_mut(_binding_0);
}
- Path(ref mut _binding_0, ) => {
+ Type::Path(ref mut _binding_0, ) => {
_visitor.visit_type_path_mut(_binding_0);
}
- TraitObject(ref mut _binding_0, ) => {
+ Type::TraitObject(ref mut _binding_0, ) => {
_visitor.visit_type_trait_object_mut(_binding_0);
}
- ImplTrait(ref mut _binding_0, ) => {
+ Type::ImplTrait(ref mut _binding_0, ) => {
_visitor.visit_type_impl_trait_mut(_binding_0);
}
- Paren(ref mut _binding_0, ) => {
+ Type::Paren(ref mut _binding_0, ) => {
_visitor.visit_type_paren_mut(_binding_0);
}
- Group(ref mut _binding_0, ) => {
+ Type::Group(ref mut _binding_0, ) => {
_visitor.visit_type_group_mut(_binding_0);
}
- Infer(ref mut _binding_0, ) => {
+ Type::Infer(ref mut _binding_0, ) => {
_visitor.visit_type_infer_mut(_binding_0);
}
- Macro(ref mut _binding_0, ) => {
+ Type::Macro(ref mut _binding_0, ) => {
_visitor.visit_type_macro_mut(_binding_0);
}
- Verbatim(ref mut _binding_0, ) => {
+ Type::Verbatim(ref mut _binding_0, ) => {
_visitor.visit_type_verbatim_mut(_binding_0);
}
}
@@ -2009,13 +1985,12 @@
}
pub fn visit_type_param_bound_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParamBound) {
- use ::TypeParamBound::*;
match *_i {
- Trait(ref mut _binding_0, ref mut _binding_1, ) => {
+ TypeParamBound::Trait(ref mut _binding_0, ref mut _binding_1, ) => {
_visitor.visit_poly_trait_ref_mut(_binding_0);
_visitor.visit_trait_bound_modifier_mut(_binding_1);
}
- Region(ref mut _binding_0, ) => {
+ TypeParamBound::Region(ref mut _binding_0, ) => {
_visitor.visit_lifetime_mut(_binding_0);
}
}
@@ -2065,15 +2040,14 @@
}
pub fn visit_un_op_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut UnOp) {
- use ::UnOp::*;
match *_i {
- Deref(ref mut _binding_0, ) => {
+ UnOp::Deref(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Not(ref mut _binding_0, ) => {
+ UnOp::Not(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
- Neg(ref mut _binding_0, ) => {
+ UnOp::Neg(ref mut _binding_0, ) => {
tokens_helper(_visitor, &mut (_binding_0).0);
}
}
@@ -2097,15 +2071,14 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_use_tree_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut UseTree) {
- use ::UseTree::*;
match *_i {
- Path(ref mut _binding_0, ) => {
+ UseTree::Path(ref mut _binding_0, ) => {
_visitor.visit_use_path_mut(_binding_0);
}
- Glob(ref mut _binding_0, ) => {
+ UseTree::Glob(ref mut _binding_0, ) => {
_visitor.visit_use_glob_mut(_binding_0);
}
- List(ref mut _binding_0, ) => {
+ UseTree::List(ref mut _binding_0, ) => {
_visitor.visit_use_list_mut(_binding_0);
}
}
@@ -2122,17 +2095,16 @@
}
pub fn visit_variant_data_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VariantData) {
- use ::VariantData::*;
match *_i {
- Struct(ref mut _binding_0, ref mut _binding_1, ) => {
+ VariantData::Struct(ref mut _binding_0, ref mut _binding_1, ) => {
for mut el in _binding_0 { let it = el.item_mut(); _visitor.visit_field_mut(it) };
tokens_helper(_visitor, &mut (_binding_1).0);
}
- Tuple(ref mut _binding_0, ref mut _binding_1, ) => {
+ VariantData::Tuple(ref mut _binding_0, ref mut _binding_1, ) => {
for mut el in _binding_0 { let it = el.item_mut(); _visitor.visit_field_mut(it) };
tokens_helper(_visitor, &mut (_binding_1).0);
}
- Unit => { }
+ VariantData::Unit => { }
}
}
@@ -2154,18 +2126,17 @@
}
pub fn visit_visibility_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Visibility) {
- use ::Visibility::*;
match *_i {
- Public(ref mut _binding_0, ) => {
+ Visibility::Public(ref mut _binding_0, ) => {
_visitor.visit_vis_public_mut(_binding_0);
}
- Crate(ref mut _binding_0, ) => {
+ Visibility::Crate(ref mut _binding_0, ) => {
_visitor.visit_vis_crate_mut(_binding_0);
}
- Restricted(ref mut _binding_0, ) => {
+ Visibility::Restricted(ref mut _binding_0, ) => {
_visitor.visit_vis_restricted_mut(_binding_0);
}
- Inherited => { }
+ Visibility::Inherited => { }
}
}
@@ -2188,15 +2159,14 @@
}
pub fn visit_where_predicate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WherePredicate) {
- use ::WherePredicate::*;
match *_i {
- BoundPredicate(ref mut _binding_0, ) => {
+ WherePredicate::BoundPredicate(ref mut _binding_0, ) => {
_visitor.visit_where_bound_predicate_mut(_binding_0);
}
- RegionPredicate(ref mut _binding_0, ) => {
+ WherePredicate::RegionPredicate(ref mut _binding_0, ) => {
_visitor.visit_where_region_predicate_mut(_binding_0);
}
- EqPredicate(ref mut _binding_0, ) => {
+ WherePredicate::EqPredicate(ref mut _binding_0, ) => {
_visitor.visit_where_eq_predicate_mut(_binding_0);
}
}