Reorder AST to match order of Rust syntax
diff --git a/src/attr.rs b/src/attr.rs
index fcaa7ee..6152635 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -13,8 +13,8 @@
ast_struct! {
/// Doc-comments are promoted to attributes that have `is_sugared_doc` = true
pub struct Attribute #manual_extra_traits {
- pub style: AttrStyle,
pub pound_token: Token![#],
+ pub style: AttrStyle,
pub bracket_token: token::Bracket,
/// The path of the attribute.
diff --git a/src/data.rs b/src/data.rs
index 600c8f1..3a7c025 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -4,19 +4,19 @@
ast_struct! {
/// An enum variant.
pub struct Variant {
- /// Name of the variant.
- pub ident: Ident,
-
/// Attributes tagged on the variant.
pub attrs: Vec<Attribute>,
+ /// Name of the variant.
+ pub ident: Ident,
+
/// Type of variant.
pub data: VariantData,
+ pub eq_token: Option<Token![=]>,
+
/// Explicit discriminant, e.g. `Foo = 1`
pub discriminant: Option<Expr>,
-
- pub eq_token: Option<Token![=]>,
}
}
@@ -58,21 +58,21 @@
ast_struct! {
/// A field of a struct or enum variant.
pub struct Field {
+ /// Attributes tagged on the field.
+ pub attrs: Vec<Attribute>,
+
+ /// Visibility of the field.
+ pub vis: Visibility,
+
/// Name of the field, if any.
///
/// Fields of tuple structs have no names.
pub ident: Option<Ident>,
- /// Visibility of the field.
- pub vis: Visibility,
-
- /// Attributes tagged on the field.
- pub attrs: Vec<Attribute>,
+ pub colon_token: Option<Token![:]>,
/// Type of the field.
pub ty: Type,
-
- pub colon_token: Option<Token![:]>,
}
}
diff --git a/src/derive.rs b/src/derive.rs
index 5d92a10..edadba2 100644
--- a/src/derive.rs
+++ b/src/derive.rs
@@ -4,14 +4,14 @@
ast_struct! {
/// Struct or enum sent to a `proc_macro_derive` macro.
pub struct DeriveInput {
- /// Name of the struct or enum.
- pub ident: Ident,
+ /// Attributes tagged on the whole struct or enum.
+ pub attrs: Vec<Attribute>,
/// Visibility of the struct or enum.
pub vis: Visibility,
- /// Attributes tagged on the whole struct or enum.
- pub attrs: Vec<Attribute>,
+ /// Name of the struct or enum.
+ pub ident: Ident,
/// Generics required to complete the definition.
pub generics: Generics,
diff --git a/src/expr.rs b/src/expr.rs
index b0007fe..8682f6a 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -8,11 +8,11 @@
ast_struct! {
/// An expression.
pub struct Expr {
- /// Type of the expression.
- pub node: ExprKind,
-
/// Attributes tagged on the expression.
pub attrs: Vec<Attribute>,
+
+ /// Type of the expression.
+ pub node: ExprKind,
}
}
@@ -29,8 +29,8 @@
pub enum ExprKind {
/// A `box x` expression.
pub Box(ExprBox #full {
- pub expr: Box<Expr>,
pub box_token: Token![box],
+ pub expr: Box<Expr>,
}),
/// E.g. 'place <- val' or `in place { val }`.
@@ -42,15 +42,15 @@
/// An array, e.g. `[a, b, c, d]`.
pub Array(ExprArray #full {
- pub exprs: Delimited<Expr, Token![,]>,
pub bracket_token: token::Bracket,
+ pub exprs: Delimited<Expr, Token![,]>,
}),
/// A function call.
pub Call(ExprCall {
pub func: Box<Expr>,
- pub args: Delimited<Expr, Token![,]>,
pub paren_token: token::Paren,
+ pub args: Delimited<Expr, Token![,]>,
}),
/// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
@@ -63,26 +63,26 @@
/// `ExprKind::MethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
pub MethodCall(ExprMethodCall #full {
pub expr: Box<Expr>,
- pub method: Ident,
- pub typarams: Delimited<Type, Token![,]>,
- pub args: Delimited<Expr, Token![,]>,
- pub paren_token: token::Paren,
pub dot_token: Token![.],
- pub lt_token: Option<Token![<]>,
+ pub method: Ident,
pub colon2_token: Option<Token![::]>,
+ pub lt_token: Option<Token![<]>,
+ pub typarams: Delimited<Type, Token![,]>,
pub gt_token: Option<Token![>]>,
+ pub paren_token: token::Paren,
+ pub args: Delimited<Expr, Token![,]>,
}),
/// A tuple, e.g. `(a, b, c, d)`.
pub Tuple(ExprTuple #full {
- pub args: Delimited<Expr, Token![,]>,
pub paren_token: token::Paren,
+ pub args: Delimited<Expr, Token![,]>,
}),
/// A binary operation, e.g. `a + b`, `a * b`.
pub Binary(ExprBinary {
- pub op: BinOp,
pub left: Box<Expr>,
+ pub op: BinOp,
pub right: Box<Expr>,
}),
@@ -113,11 +113,11 @@
///
/// E.g., `if expr { block } else { expr }`
pub If(ExprIf #full {
+ pub if_token: Token![if],
pub cond: Box<Expr>,
pub if_true: Block,
- pub if_false: Option<Box<Expr>>,
- pub if_token: Token![if],
pub else_token: Option<Token![else]>,
+ pub if_false: Option<Box<Expr>>,
}),
/// An `if let` expression with an optional else block
@@ -126,25 +126,25 @@
///
/// This is desugared to a `match` expression.
pub IfLet(ExprIfLet #full {
- pub pat: Box<Pat>,
- pub expr: Box<Expr>,
- pub if_true: Block,
- pub if_false: Option<Box<Expr>>,
pub if_token: Token![if],
pub let_token: Token![let],
+ pub pat: Box<Pat>,
pub eq_token: Token![=],
+ pub expr: Box<Expr>,
+ pub if_true: Block,
pub else_token: Option<Token![else]>,
+ pub if_false: Option<Box<Expr>>,
}),
/// A while loop, with an optional label
///
/// E.g., `'label: while expr { block }`
pub While(ExprWhile #full {
- pub cond: Box<Expr>,
- pub body: Block,
pub label: Option<Lifetime>,
pub colon_token: Option<Token![:]>,
pub while_token: Token![while],
+ pub cond: Box<Expr>,
+ pub body: Block,
}),
/// A while-let loop, with an optional label.
@@ -153,14 +153,14 @@
///
/// This is desugared to a combination of `loop` and `match` expressions.
pub WhileLet(ExprWhileLet #full {
- pub pat: Box<Pat>,
- pub expr: Box<Expr>,
- pub body: Block,
pub label: Option<Lifetime>,
pub colon_token: Option<Token![:]>,
pub while_token: Token![while],
pub let_token: Token![let],
+ pub pat: Box<Pat>,
pub eq_token: Token![=],
+ pub expr: Box<Expr>,
+ pub body: Block,
}),
/// A for loop, with an optional label.
@@ -169,30 +169,30 @@
///
/// This is desugared to a combination of `loop` and `match` expressions.
pub ForLoop(ExprForLoop #full {
+ pub label: Option<Lifetime>,
+ pub colon_token: Option<Token![:]>,
+ pub for_token: Token![for],
pub pat: Box<Pat>,
+ pub in_token: Token![in],
pub expr: Box<Expr>,
pub body: Block,
- pub label: Option<Lifetime>,
- pub for_token: Token![for],
- pub colon_token: Option<Token![:]>,
- pub in_token: Token![in],
}),
/// Conditionless loop with an optional label.
///
/// E.g. `'label: loop { block }`
pub Loop(ExprLoop #full {
- pub body: Block,
pub label: Option<Lifetime>,
- pub loop_token: Token![loop],
pub colon_token: Option<Token![:]>,
+ pub loop_token: Token![loop],
+ pub body: Block,
}),
/// A `match` block.
pub Match(ExprMatch #full {
pub match_token: Token![match],
- pub brace_token: token::Brace,
pub expr: Box<Expr>,
+ pub brace_token: token::Brace,
pub arms: Vec<Arm>,
}),
@@ -220,16 +220,16 @@
/// An assignment (`a = foo()`)
pub Assign(ExprAssign #full {
pub left: Box<Expr>,
- pub right: Box<Expr>,
pub eq_token: Token![=],
+ pub right: Box<Expr>,
}),
/// An assignment with an operator
///
/// For example, `a += 1`.
pub AssignOp(ExprAssignOp #full {
- pub op: BinOp,
pub left: Box<Expr>,
+ pub op: BinOp,
pub right: Box<Expr>,
}),
@@ -244,15 +244,15 @@
/// An indexing operation (`foo[2]`)
pub Index(ExprIndex {
pub expr: Box<Expr>,
- pub index: Box<Expr>,
pub bracket_token: token::Bracket,
+ pub index: Box<Expr>,
}),
/// A range (`1..2`, `1..`, `..2`, `1..=2`, `..=2`)
pub Range(ExprRange #full {
pub from: Option<Box<Expr>>,
- pub to: Option<Box<Expr>>,
pub limits: RangeLimits,
+ pub to: Option<Box<Expr>>,
}),
/// Variable reference, possibly containing `::` and/or type
@@ -274,21 +274,21 @@
/// A `break`, with an optional label to break, and an optional expression
pub Break(ExprBreak #full {
+ pub break_token: Token![break],
pub label: Option<Lifetime>,
pub expr: Option<Box<Expr>>,
- pub break_token: Token![break],
}),
/// A `continue`, with an optional label
pub Continue(ExprContinue #full {
- pub label: Option<Lifetime>,
pub continue_token: Token![continue],
+ pub label: Option<Lifetime>,
}),
/// A `return`, with an optional value to be returned
pub Ret(ExprRet #full {
- pub expr: Option<Box<Expr>>,
pub return_token: Token![return],
+ pub expr: Option<Box<Expr>>,
}),
/// A macro invocation; pre-expansion
@@ -300,10 +300,10 @@
/// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
pub Struct(ExprStruct #full {
pub path: Path,
- pub fields: Delimited<FieldValue, Token![,]>,
- pub rest: Option<Box<Expr>>,
- pub dot2_token: Option<Token![..]>,
pub brace_token: token::Brace,
+ pub fields: Delimited<FieldValue, Token![,]>,
+ pub dot2_token: Option<Token![..]>,
+ pub rest: Option<Box<Expr>>,
}),
/// An array literal constructed from one repeated element.
@@ -312,15 +312,15 @@
/// to be repeated; the second is the number of times to repeat it.
pub Repeat(ExprRepeat #full {
pub bracket_token: token::Bracket,
- pub semi_token: Token![;],
pub expr: Box<Expr>,
+ pub semi_token: Token![;],
pub amt: Box<Expr>,
}),
/// No-op: used solely so we can pretty-print faithfully
pub Paren(ExprParen {
- pub expr: Box<Expr>,
pub paren_token: token::Paren,
+ pub expr: Box<Expr>,
}),
/// No-op: used solely so we can pretty-print faithfully
@@ -329,8 +329,8 @@
/// `TokenStream` which affects the precidence of the resulting
/// expression. They are used for macro hygiene.
pub Group(ExprGroup {
- pub expr: Box<Expr>,
pub group_token: token::Group,
+ pub expr: Box<Expr>,
}),
/// `expr?`
@@ -451,17 +451,15 @@
ast_struct! {
/// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`
pub struct Local {
+ pub attrs: Vec<Attribute>,
pub let_token: Token![let],
- pub colon_token: Option<Token![:]>,
- pub eq_token: Option<Token![=]>,
- pub semi_token: Token![;],
-
pub pat: Box<Pat>,
+ pub colon_token: Option<Token![:]>,
pub ty: Option<Box<Type>>,
-
+ pub eq_token: Option<Token![=]>,
/// Initializer expression to set the value, if any
pub init: Option<Box<Expr>>,
- pub attrs: Vec<Attribute>,
+ pub semi_token: Token![;],
}
}
@@ -483,16 +481,16 @@
pub Ident(PatIdent {
pub mode: BindingMode,
pub ident: Ident,
- pub subpat: Option<Box<Pat>>,
pub at_token: Option<Token![@]>,
+ pub subpat: Option<Box<Pat>>,
}),
/// A struct or struct variant pattern, e.g. `Variant {x, y, ..}`.
/// The `bool` is `true` in the presence of a `..`.
pub Struct(PatStruct {
pub path: Path,
- pub fields: Delimited<FieldPat, Token![,]>,
pub brace_token: token::Brace,
+ pub fields: Delimited<FieldPat, Token![,]>,
pub dot2_token: Option<Token![..]>,
}),
@@ -517,22 +515,22 @@
/// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
/// 0 <= position <= subpats.len()
pub Tuple(PatTuple {
- pub pats: Delimited<Pat, Token![,]>,
- pub dots_pos: Option<usize>,
pub paren_token: token::Paren,
- pub dot2_token: Option<Token![..]>,
+ pub pats: Delimited<Pat, Token![,]>,
pub comma_token: Option<Token![,]>,
+ pub dots_pos: Option<usize>,
+ pub dot2_token: Option<Token![..]>,
}),
/// A `box` pattern
pub Box(PatBox {
- pub pat: Box<Pat>,
pub box_token: Token![box],
+ pub pat: Box<Pat>,
}),
/// A reference pattern, e.g. `&mut (a, b)`
pub Ref(PatRef {
- pub pat: Box<Pat>,
- pub mutbl: Mutability,
pub and_token: Token![&],
+ pub mutbl: Mutability,
+ pub pat: Box<Pat>,
}),
/// A literal
pub Lit(PatLit {
@@ -541,17 +539,17 @@
/// A range pattern, e.g. `1..=2`
pub Range(PatRange {
pub lo: Box<Expr>,
- pub hi: Box<Expr>,
pub limits: RangeLimits,
+ pub hi: Box<Expr>,
}),
/// `[a, b, i.., y, z]` is represented as:
pub Slice(PatSlice {
+ pub bracket_token: token::Bracket,
pub front: Delimited<Pat, Token![,]>,
pub middle: Option<Box<Pat>>,
- pub back: Delimited<Pat, Token![,]>,
- pub dot2_token: Option<Token![..]>,
pub comma_token: Option<Token![,]>,
- pub bracket_token: token::Bracket,
+ pub dot2_token: Option<Token![..]>,
+ pub back: Delimited<Pat, Token![,]>,
}),
/// A macro pattern; pre-expansion
pub Macro(Macro),
@@ -617,13 +615,13 @@
/// are treated the same as `x: x, y: ref y, z: ref mut z`,
/// except `is_shorthand` is true
pub struct FieldPat {
+ pub attrs: Vec<Attribute>,
/// The identifier for the field
pub member: Member,
+ pub colon_token: Option<Token![:]>,
/// The pattern the field is destructured to
pub pat: Box<Pat>,
pub is_shorthand: bool,
- pub colon_token: Option<Token![:]>,
- pub attrs: Vec<Attribute>,
}
}
@@ -1533,7 +1531,7 @@
arrow: punct!(->) >>
ty: syn!(Type) >>
body: syn!(Block) >>
- (ReturnType::Type(Box::new(ty), arrow),
+ (ReturnType::Type(arrow, Box::new(ty)),
ExprKind::Block(ExprBlock {
block: body,
}).into())
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 05694a4..09ec5ca 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -445,9 +445,9 @@
pub fn fold_arg_self_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgSelfRef) -> ArgSelfRef {
ArgSelfRef {
and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
- self_token: Token ! [ self ](tokens_helper(_visitor, &(_i . self_token).0)),
lifetime: (_i . lifetime).map(|it| { _visitor.fold_lifetime(it) }),
mutbl: _visitor.fold_mutability(_i . mutbl),
+ self_token: Token ! [ self ](tokens_helper(_visitor, &(_i . self_token).0)),
}
}
# [ cfg ( feature = "full" ) ]
@@ -477,8 +477,8 @@
pub fn fold_attribute<V: Folder + ?Sized>(_visitor: &mut V, _i: Attribute) -> Attribute {
Attribute {
- style: _visitor.fold_attr_style(_i . style),
pound_token: Token ! [ # ](tokens_helper(_visitor, &(_i . pound_token).0)),
+ style: _visitor.fold_attr_style(_i . style),
bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
path: _visitor.fold_path(_i . path),
tts: _i . tts,
@@ -514,10 +514,10 @@
pub fn fold_bare_fn_type<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnType) -> BareFnType {
BareFnType {
- lifetimes: (_i . lifetimes).map(|it| { _visitor.fold_bound_lifetimes(it) }),
unsafety: _visitor.fold_unsafety(_i . unsafety),
abi: (_i . abi).map(|it| { _visitor.fold_abi(it) }),
fn_token: Token ! [ fn ](tokens_helper(_visitor, &(_i . fn_token).0)),
+ lifetimes: (_i . lifetimes).map(|it| { _visitor.fold_bound_lifetimes(it) }),
paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
inputs: FoldHelper::lift(_i . inputs, |it| { _visitor.fold_bare_fn_arg(it) }),
variadic: (_i . variadic).map(|it| { Token ! [ ... ](tokens_helper(_visitor, &(it).0)) }),
@@ -786,9 +786,9 @@
pub fn fold_derive_input<V: Folder + ?Sized>(_visitor: &mut V, _i: DeriveInput) -> DeriveInput {
DeriveInput {
- ident: _visitor.fold_ident(_i . ident),
- vis: _visitor.fold_visibility(_i . vis),
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+ vis: _visitor.fold_visibility(_i . vis),
+ ident: _visitor.fold_ident(_i . ident),
generics: _visitor.fold_generics(_i . generics),
body: _visitor.fold_body(_i . body),
}
@@ -796,8 +796,8 @@
pub fn fold_expr<V: Folder + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr {
Expr {
- node: _visitor.fold_expr_kind(_i . node),
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+ node: _visitor.fold_expr_kind(_i . node),
}
}
# [ cfg ( feature = "full" ) ]
@@ -811,31 +811,31 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_array<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
ExprArray {
- exprs: FoldHelper::lift(_i . exprs, |it| { _visitor.fold_expr(it) }),
bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
+ exprs: FoldHelper::lift(_i . exprs, |it| { _visitor.fold_expr(it) }),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_assign<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAssign) -> ExprAssign {
ExprAssign {
left: Box::new(_visitor.fold_expr(* _i . left)),
- right: Box::new(_visitor.fold_expr(* _i . right)),
eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i . eq_token).0)),
+ right: Box::new(_visitor.fold_expr(* _i . right)),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_assign_op<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAssignOp) -> ExprAssignOp {
ExprAssignOp {
- op: _visitor.fold_bin_op(_i . op),
left: Box::new(_visitor.fold_expr(* _i . left)),
+ op: _visitor.fold_bin_op(_i . op),
right: Box::new(_visitor.fold_expr(* _i . right)),
}
}
pub fn fold_expr_binary<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBinary) -> ExprBinary {
ExprBinary {
- op: _visitor.fold_bin_op(_i . op),
left: Box::new(_visitor.fold_expr(* _i . left)),
+ op: _visitor.fold_bin_op(_i . op),
right: Box::new(_visitor.fold_expr(* _i . right)),
}
}
@@ -848,24 +848,24 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_box<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox {
ExprBox {
- expr: Box::new(_visitor.fold_expr(* _i . expr)),
box_token: Token ! [ box ](tokens_helper(_visitor, &(_i . box_token).0)),
+ expr: Box::new(_visitor.fold_expr(* _i . expr)),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_break<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBreak) -> ExprBreak {
ExprBreak {
+ break_token: Token ! [ break ](tokens_helper(_visitor, &(_i . break_token).0)),
label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
- break_token: Token ! [ break ](tokens_helper(_visitor, &(_i . break_token).0)),
}
}
pub fn fold_expr_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprCall {
ExprCall {
func: Box::new(_visitor.fold_expr(* _i . func)),
- args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
+ args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
}
}
@@ -898,8 +898,8 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_continue<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue {
ExprContinue {
- label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
continue_token: Token ! [ continue ](tokens_helper(_visitor, &(_i . continue_token).0)),
+ label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
}
}
# [ cfg ( feature = "full" ) ]
@@ -913,43 +913,43 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_for_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprForLoop) -> ExprForLoop {
ExprForLoop {
+ label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
+ colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
+ for_token: Token ! [ for ](tokens_helper(_visitor, &(_i . for_token).0)),
pat: Box::new(_visitor.fold_pat(* _i . pat)),
+ in_token: Token ! [ in ](tokens_helper(_visitor, &(_i . in_token).0)),
expr: Box::new(_visitor.fold_expr(* _i . expr)),
body: _visitor.fold_block(_i . body),
- label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
- for_token: Token ! [ for ](tokens_helper(_visitor, &(_i . for_token).0)),
- colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
- in_token: Token ! [ in ](tokens_helper(_visitor, &(_i . in_token).0)),
}
}
pub fn fold_expr_group<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup {
ExprGroup {
- expr: Box::new(_visitor.fold_expr(* _i . expr)),
group_token: Group(tokens_helper(_visitor, &(_i . group_token).0)),
+ expr: Box::new(_visitor.fold_expr(* _i . expr)),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_if<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIf) -> ExprIf {
ExprIf {
+ if_token: Token ! [ if ](tokens_helper(_visitor, &(_i . if_token).0)),
cond: Box::new(_visitor.fold_expr(* _i . cond)),
if_true: _visitor.fold_block(_i . if_true),
- if_false: (_i . if_false).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
- if_token: Token ! [ if ](tokens_helper(_visitor, &(_i . if_token).0)),
else_token: (_i . else_token).map(|it| { Token ! [ else ](tokens_helper(_visitor, &(it).0)) }),
+ if_false: (_i . if_false).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_if_let<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIfLet) -> ExprIfLet {
ExprIfLet {
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
- expr: Box::new(_visitor.fold_expr(* _i . expr)),
- if_true: _visitor.fold_block(_i . if_true),
- if_false: (_i . if_false).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
if_token: Token ! [ if ](tokens_helper(_visitor, &(_i . if_token).0)),
let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
+ pat: Box::new(_visitor.fold_pat(* _i . pat)),
eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i . eq_token).0)),
+ expr: Box::new(_visitor.fold_expr(* _i . expr)),
+ if_true: _visitor.fold_block(_i . if_true),
else_token: (_i . else_token).map(|it| { Token ! [ else ](tokens_helper(_visitor, &(it).0)) }),
+ if_false: (_i . if_false).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
}
}
# [ cfg ( feature = "full" ) ]
@@ -964,8 +964,8 @@
pub fn fold_expr_index<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> ExprIndex {
ExprIndex {
expr: Box::new(_visitor.fold_expr(* _i . expr)),
- index: Box::new(_visitor.fold_expr(* _i . index)),
bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
+ index: Box::new(_visitor.fold_expr(* _i . index)),
}
}
@@ -1172,18 +1172,18 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprLoop) -> ExprLoop {
ExprLoop {
- body: _visitor.fold_block(_i . body),
label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
- loop_token: Token ! [ loop ](tokens_helper(_visitor, &(_i . loop_token).0)),
colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
+ loop_token: Token ! [ loop ](tokens_helper(_visitor, &(_i . loop_token).0)),
+ body: _visitor.fold_block(_i . body),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_match<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMatch) -> ExprMatch {
ExprMatch {
match_token: Token ! [ match ](tokens_helper(_visitor, &(_i . match_token).0)),
- brace_token: Brace(tokens_helper(_visitor, &(_i . brace_token).0)),
expr: Box::new(_visitor.fold_expr(* _i . expr)),
+ brace_token: Brace(tokens_helper(_visitor, &(_i . brace_token).0)),
arms: FoldHelper::lift(_i . arms, |it| { _visitor.fold_arm(it) }),
}
}
@@ -1191,21 +1191,21 @@
pub fn fold_expr_method_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMethodCall) -> ExprMethodCall {
ExprMethodCall {
expr: Box::new(_visitor.fold_expr(* _i . expr)),
- method: _visitor.fold_ident(_i . method),
- typarams: FoldHelper::lift(_i . typarams, |it| { _visitor.fold_type(it) }),
- args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
- paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
dot_token: Token ! [ . ](tokens_helper(_visitor, &(_i . dot_token).0)),
- lt_token: (_i . lt_token).map(|it| { Token ! [ < ](tokens_helper(_visitor, &(it).0)) }),
+ method: _visitor.fold_ident(_i . method),
colon2_token: (_i . colon2_token).map(|it| { Token ! [ :: ](tokens_helper(_visitor, &(it).0)) }),
+ lt_token: (_i . lt_token).map(|it| { Token ! [ < ](tokens_helper(_visitor, &(it).0)) }),
+ typarams: FoldHelper::lift(_i . typarams, |it| { _visitor.fold_type(it) }),
gt_token: (_i . gt_token).map(|it| { Token ! [ > ](tokens_helper(_visitor, &(it).0)) }),
+ paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
+ args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
}
}
pub fn fold_expr_paren<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprParen) -> ExprParen {
ExprParen {
- expr: Box::new(_visitor.fold_expr(* _i . expr)),
paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
+ expr: Box::new(_visitor.fold_expr(* _i . expr)),
}
}
@@ -1219,34 +1219,34 @@
pub fn fold_expr_range<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRange) -> ExprRange {
ExprRange {
from: (_i . from).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
- to: (_i . to).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
limits: _visitor.fold_range_limits(_i . limits),
+ to: (_i . to).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_repeat<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat {
ExprRepeat {
bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
- semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
expr: Box::new(_visitor.fold_expr(* _i . expr)),
+ semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
amt: Box::new(_visitor.fold_expr(* _i . amt)),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_ret<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRet) -> ExprRet {
ExprRet {
- expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
return_token: Token ! [ return ](tokens_helper(_visitor, &(_i . return_token).0)),
+ expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprStruct) -> ExprStruct {
ExprStruct {
path: _visitor.fold_path(_i . path),
- fields: FoldHelper::lift(_i . fields, |it| { _visitor.fold_field_value(it) }),
- rest: (_i . rest).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
- dot2_token: (_i . dot2_token).map(|it| { Token ! [ .. ](tokens_helper(_visitor, &(it).0)) }),
brace_token: Brace(tokens_helper(_visitor, &(_i . brace_token).0)),
+ fields: FoldHelper::lift(_i . fields, |it| { _visitor.fold_field_value(it) }),
+ dot2_token: (_i . dot2_token).map(|it| { Token ! [ .. ](tokens_helper(_visitor, &(it).0)) }),
+ rest: (_i . rest).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
}
}
# [ cfg ( feature = "full" ) ]
@@ -1259,8 +1259,8 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_tuple<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTuple) -> ExprTuple {
ExprTuple {
- args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
+ args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
}
}
@@ -1288,24 +1288,24 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_while<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhile) -> ExprWhile {
ExprWhile {
- cond: Box::new(_visitor.fold_expr(* _i . cond)),
- body: _visitor.fold_block(_i . body),
label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
while_token: Token ! [ while ](tokens_helper(_visitor, &(_i . while_token).0)),
+ cond: Box::new(_visitor.fold_expr(* _i . cond)),
+ body: _visitor.fold_block(_i . body),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_expr_while_let<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhileLet) -> ExprWhileLet {
ExprWhileLet {
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
- expr: Box::new(_visitor.fold_expr(* _i . expr)),
- body: _visitor.fold_block(_i . body),
label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
while_token: Token ! [ while ](tokens_helper(_visitor, &(_i . while_token).0)),
let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
+ pat: Box::new(_visitor.fold_pat(* _i . pat)),
eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i . eq_token).0)),
+ expr: Box::new(_visitor.fold_expr(* _i . expr)),
+ body: _visitor.fold_block(_i . body),
}
}
# [ cfg ( feature = "full" ) ]
@@ -1318,21 +1318,21 @@
pub fn fold_field<V: Folder + ?Sized>(_visitor: &mut V, _i: Field) -> Field {
Field {
- ident: (_i . ident).map(|it| { _visitor.fold_ident(it) }),
- vis: _visitor.fold_visibility(_i . vis),
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
- ty: _visitor.fold_type(_i . ty),
+ vis: _visitor.fold_visibility(_i . vis),
+ ident: (_i . ident).map(|it| { _visitor.fold_ident(it) }),
colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
+ ty: _visitor.fold_type(_i . ty),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_field_pat<V: Folder + ?Sized>(_visitor: &mut V, _i: FieldPat) -> FieldPat {
FieldPat {
+ attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
member: _visitor.fold_member(_i . member),
+ colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
pat: Box::new(_visitor.fold_pat(* _i . pat)),
is_shorthand: _i . is_shorthand,
- colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
- attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
}
}
# [ cfg ( feature = "full" ) ]
@@ -1388,11 +1388,11 @@
pub fn fold_fn_decl<V: Folder + ?Sized>(_visitor: &mut V, _i: FnDecl) -> FnDecl {
FnDecl {
fn_token: Token ! [ fn ](tokens_helper(_visitor, &(_i . fn_token).0)),
+ generics: _visitor.fold_generics(_i . generics),
paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
inputs: FoldHelper::lift(_i . inputs, |it| { _visitor.fold_fn_arg(it) }),
- output: _visitor.fold_return_type(_i . output),
- generics: _visitor.fold_generics(_i . generics),
variadic: (_i . variadic).map(|it| { Token ! [ ... ](tokens_helper(_visitor, &(it).0)) }),
+ output: _visitor.fold_return_type(_i . output),
}
}
# [ cfg ( feature = "full" ) ]
@@ -1767,8 +1767,8 @@
constness: _visitor.fold_constness(_i . constness),
unsafety: _visitor.fold_unsafety(_i . unsafety),
abi: (_i . abi).map(|it| { _visitor.fold_abi(it) }),
- decl: Box::new(_visitor.fold_fn_decl(* _i . decl)),
ident: _visitor.fold_ident(_i . ident),
+ decl: Box::new(_visitor.fold_fn_decl(* _i . decl)),
block: Box::new(_visitor.fold_block(* _i . block)),
}
}
@@ -1938,14 +1938,14 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_local<V: Folder + ?Sized>(_visitor: &mut V, _i: Local) -> Local {
Local {
- let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
- colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
- eq_token: (_i . eq_token).map(|it| { Token ! [ = ](tokens_helper(_visitor, &(it).0)) }),
- semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
- ty: (_i . ty).map(|it| { Box::new(_visitor.fold_type(* it)) }),
- init: (_i . init).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+ let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
+ pat: Box::new(_visitor.fold_pat(* _i . pat)),
+ colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
+ ty: (_i . ty).map(|it| { Box::new(_visitor.fold_type(* it)) }),
+ eq_token: (_i . eq_token).map(|it| { Token ! [ = ](tokens_helper(_visitor, &(it).0)) }),
+ init: (_i . init).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
+ semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
}
}
@@ -2022,8 +2022,8 @@
pub fn fold_mut_type<V: Folder + ?Sized>(_visitor: &mut V, _i: MutType) -> MutType {
MutType {
- ty: _visitor.fold_type(_i . ty),
mutability: _visitor.fold_mutability(_i . mutability),
+ ty: _visitor.fold_type(_i . ty),
}
}
@@ -2131,8 +2131,8 @@
# [ cfg ( feature = "full" ) ]
pub fn fold_pat_box<V: Folder + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox {
PatBox {
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
box_token: Token ! [ box ](tokens_helper(_visitor, &(_i . box_token).0)),
+ pat: Box::new(_visitor.fold_pat(* _i . pat)),
}
}
# [ cfg ( feature = "full" ) ]
@@ -2140,8 +2140,8 @@
PatIdent {
mode: _visitor.fold_binding_mode(_i . mode),
ident: _visitor.fold_ident(_i . ident),
- subpat: (_i . subpat).map(|it| { Box::new(_visitor.fold_pat(* it)) }),
at_token: (_i . at_token).map(|it| { Token ! [ @ ](tokens_helper(_visitor, &(it).0)) }),
+ subpat: (_i . subpat).map(|it| { Box::new(_visitor.fold_pat(* it)) }),
}
}
# [ cfg ( feature = "full" ) ]
@@ -2161,46 +2161,46 @@
pub fn fold_pat_range<V: Folder + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRange {
PatRange {
lo: Box::new(_visitor.fold_expr(* _i . lo)),
- hi: Box::new(_visitor.fold_expr(* _i . hi)),
limits: _visitor.fold_range_limits(_i . limits),
+ hi: Box::new(_visitor.fold_expr(* _i . hi)),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_pat_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
PatRef {
- pat: Box::new(_visitor.fold_pat(* _i . pat)),
- mutbl: _visitor.fold_mutability(_i . mutbl),
and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
+ mutbl: _visitor.fold_mutability(_i . mutbl),
+ pat: Box::new(_visitor.fold_pat(* _i . pat)),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_pat_slice<V: Folder + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSlice {
PatSlice {
+ bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
front: FoldHelper::lift(_i . front, |it| { _visitor.fold_pat(it) }),
middle: (_i . middle).map(|it| { Box::new(_visitor.fold_pat(* it)) }),
- back: FoldHelper::lift(_i . back, |it| { _visitor.fold_pat(it) }),
- dot2_token: (_i . dot2_token).map(|it| { Token ! [ .. ](tokens_helper(_visitor, &(it).0)) }),
comma_token: (_i . comma_token).map(|it| { Token ! [ , ](tokens_helper(_visitor, &(it).0)) }),
- bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
+ dot2_token: (_i . dot2_token).map(|it| { Token ! [ .. ](tokens_helper(_visitor, &(it).0)) }),
+ back: FoldHelper::lift(_i . back, |it| { _visitor.fold_pat(it) }),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_pat_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: PatStruct) -> PatStruct {
PatStruct {
path: _visitor.fold_path(_i . path),
- fields: FoldHelper::lift(_i . fields, |it| { _visitor.fold_field_pat(it) }),
brace_token: Brace(tokens_helper(_visitor, &(_i . brace_token).0)),
+ fields: FoldHelper::lift(_i . fields, |it| { _visitor.fold_field_pat(it) }),
dot2_token: (_i . dot2_token).map(|it| { Token ! [ .. ](tokens_helper(_visitor, &(it).0)) }),
}
}
# [ cfg ( feature = "full" ) ]
pub fn fold_pat_tuple<V: Folder + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTuple {
PatTuple {
- pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
- dots_pos: _i . dots_pos,
paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
- dot2_token: (_i . dot2_token).map(|it| { Token ! [ .. ](tokens_helper(_visitor, &(it).0)) }),
+ pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
comma_token: (_i . comma_token).map(|it| { Token ! [ , ](tokens_helper(_visitor, &(it).0)) }),
+ dots_pos: _i . dots_pos,
+ dot2_token: (_i . dot2_token).map(|it| { Token ! [ .. ](tokens_helper(_visitor, &(it).0)) }),
}
}
# [ cfg ( feature = "full" ) ]
@@ -2287,8 +2287,8 @@
Default => { Default }
Type(_binding_0, _binding_1, ) => {
Type (
- Box::new(_visitor.fold_type(* _binding_0)),
- Token ! [ -> ](tokens_helper(_visitor, &(_binding_1).0)),
+ Token ! [ -> ](tokens_helper(_visitor, &(_binding_0).0)),
+ Box::new(_visitor.fold_type(* _binding_1)),
)
}
}
@@ -2596,8 +2596,8 @@
pub fn fold_type_slice<V: Folder + ?Sized>(_visitor: &mut V, _i: TypeSlice) -> TypeSlice {
TypeSlice {
- ty: Box::new(_visitor.fold_type(* _i . ty)),
bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
+ ty: Box::new(_visitor.fold_type(* _i . ty)),
}
}
@@ -2694,11 +2694,11 @@
pub fn fold_variant<V: Folder + ?Sized>(_visitor: &mut V, _i: Variant) -> Variant {
Variant {
- ident: _visitor.fold_ident(_i . ident),
attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+ ident: _visitor.fold_ident(_i . ident),
data: _visitor.fold_variant_data(_i . data),
- discriminant: (_i . discriminant).map(|it| { _visitor.fold_expr(it) }),
eq_token: (_i . eq_token).map(|it| { Token ! [ = ](tokens_helper(_visitor, &(it).0)) }),
+ discriminant: (_i . discriminant).map(|it| { _visitor.fold_expr(it) }),
}
}
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 12fd3b6..e63cffb 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -430,9 +430,9 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_arg_self_ref<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgSelfRef) {
tokens_helper(_visitor, &(& _i . and_token).0);
- tokens_helper(_visitor, &(& _i . self_token).0);
if let Some(ref it) = _i . lifetime { _visitor.visit_lifetime(it) };
_visitor.visit_mutability(& _i . mutbl);
+ tokens_helper(_visitor, &(& _i . self_token).0);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_arm<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Arm) {
@@ -456,8 +456,8 @@
}
pub fn visit_attribute<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Attribute) {
- _visitor.visit_attr_style(& _i . style);
tokens_helper(_visitor, &(& _i . pound_token).0);
+ _visitor.visit_attr_style(& _i . style);
tokens_helper(_visitor, &(& _i . bracket_token).0);
_visitor.visit_path(& _i . path);
// Skipped field _i . tts;
@@ -485,10 +485,10 @@
}
pub fn visit_bare_fn_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BareFnType) {
- if let Some(ref it) = _i . lifetimes { _visitor.visit_bound_lifetimes(it) };
_visitor.visit_unsafety(& _i . unsafety);
if let Some(ref it) = _i . abi { _visitor.visit_abi(it) };
tokens_helper(_visitor, &(& _i . fn_token).0);
+ if let Some(ref it) = _i . lifetimes { _visitor.visit_bound_lifetimes(it) };
tokens_helper(_visitor, &(& _i . paren_token).0);
for el in & _i . inputs { let it = el.item(); _visitor.visit_bare_fn_arg(it) };
if let Some(ref it) = _i . variadic { tokens_helper(_visitor, &(it).0) };
@@ -675,16 +675,16 @@
}
pub fn visit_derive_input<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DeriveInput) {
- _visitor.visit_ident(& _i . ident);
- _visitor.visit_visibility(& _i . vis);
for it in & _i . attrs { _visitor.visit_attribute(it) };
+ _visitor.visit_visibility(& _i . vis);
+ _visitor.visit_ident(& _i . ident);
_visitor.visit_generics(& _i . generics);
_visitor.visit_body(& _i . body);
}
pub fn visit_expr<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Expr) {
- _visitor.visit_expr_kind(& _i . node);
for it in & _i . attrs { _visitor.visit_attribute(it) };
+ _visitor.visit_expr_kind(& _i . node);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_addr_of<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAddrOf) {
@@ -694,25 +694,25 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_array<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprArray) {
- for el in & _i . exprs { let it = el.item(); _visitor.visit_expr(it) };
tokens_helper(_visitor, &(& _i . bracket_token).0);
+ for el in & _i . exprs { let it = el.item(); _visitor.visit_expr(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_assign<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAssign) {
_visitor.visit_expr(& * _i . left);
- _visitor.visit_expr(& * _i . right);
tokens_helper(_visitor, &(& _i . eq_token).0);
+ _visitor.visit_expr(& * _i . right);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_assign_op<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAssignOp) {
- _visitor.visit_bin_op(& _i . op);
_visitor.visit_expr(& * _i . left);
+ _visitor.visit_bin_op(& _i . op);
_visitor.visit_expr(& * _i . right);
}
pub fn visit_expr_binary<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBinary) {
- _visitor.visit_bin_op(& _i . op);
_visitor.visit_expr(& * _i . left);
+ _visitor.visit_bin_op(& _i . op);
_visitor.visit_expr(& * _i . right);
}
# [ cfg ( feature = "full" ) ]
@@ -721,20 +721,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_box<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBox) {
- _visitor.visit_expr(& * _i . expr);
tokens_helper(_visitor, &(& _i . box_token).0);
+ _visitor.visit_expr(& * _i . expr);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_break<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBreak) {
+ tokens_helper(_visitor, &(& _i . break_token).0);
if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
if let Some(ref it) = _i . expr { _visitor.visit_expr(& * * it) };
- tokens_helper(_visitor, &(& _i . break_token).0);
}
pub fn visit_expr_call<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCall) {
_visitor.visit_expr(& * _i . func);
- for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
tokens_helper(_visitor, &(& _i . paren_token).0);
+ for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
}
pub fn visit_expr_cast<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCast) {
@@ -759,8 +759,8 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_continue<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprContinue) {
- if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
tokens_helper(_visitor, &(& _i . continue_token).0);
+ if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_field<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprField) {
@@ -770,37 +770,37 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_for_loop<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprForLoop) {
+ if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
+ if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
+ tokens_helper(_visitor, &(& _i . for_token).0);
_visitor.visit_pat(& * _i . pat);
+ tokens_helper(_visitor, &(& _i . in_token).0);
_visitor.visit_expr(& * _i . expr);
_visitor.visit_block(& _i . body);
- if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
- tokens_helper(_visitor, &(& _i . for_token).0);
- if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
- tokens_helper(_visitor, &(& _i . in_token).0);
}
pub fn visit_expr_group<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprGroup) {
- _visitor.visit_expr(& * _i . expr);
tokens_helper(_visitor, &(& _i . group_token).0);
+ _visitor.visit_expr(& * _i . expr);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_if<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIf) {
+ tokens_helper(_visitor, &(& _i . if_token).0);
_visitor.visit_expr(& * _i . cond);
_visitor.visit_block(& _i . if_true);
- if let Some(ref it) = _i . if_false { _visitor.visit_expr(& * * it) };
- tokens_helper(_visitor, &(& _i . if_token).0);
if let Some(ref it) = _i . else_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . if_false { _visitor.visit_expr(& * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_if_let<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIfLet) {
- _visitor.visit_pat(& * _i . pat);
- _visitor.visit_expr(& * _i . expr);
- _visitor.visit_block(& _i . if_true);
- if let Some(ref it) = _i . if_false { _visitor.visit_expr(& * * it) };
tokens_helper(_visitor, &(& _i . if_token).0);
tokens_helper(_visitor, &(& _i . let_token).0);
+ _visitor.visit_pat(& * _i . pat);
tokens_helper(_visitor, &(& _i . eq_token).0);
+ _visitor.visit_expr(& * _i . expr);
+ _visitor.visit_block(& _i . if_true);
if let Some(ref it) = _i . else_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . if_false { _visitor.visit_expr(& * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_in_place<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprInPlace) {
@@ -811,8 +811,8 @@
pub fn visit_expr_index<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIndex) {
_visitor.visit_expr(& * _i . expr);
- _visitor.visit_expr(& * _i . index);
tokens_helper(_visitor, &(& _i . bracket_token).0);
+ _visitor.visit_expr(& * _i . index);
}
pub fn visit_expr_kind<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprKind) {
@@ -939,34 +939,34 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_loop<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLoop) {
- _visitor.visit_block(& _i . body);
if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
- tokens_helper(_visitor, &(& _i . loop_token).0);
if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
+ tokens_helper(_visitor, &(& _i . loop_token).0);
+ _visitor.visit_block(& _i . body);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_match<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMatch) {
tokens_helper(_visitor, &(& _i . match_token).0);
- tokens_helper(_visitor, &(& _i . brace_token).0);
_visitor.visit_expr(& * _i . expr);
+ tokens_helper(_visitor, &(& _i . brace_token).0);
for it in & _i . arms { _visitor.visit_arm(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_method_call<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMethodCall) {
_visitor.visit_expr(& * _i . expr);
- _visitor.visit_ident(& _i . method);
- for el in & _i . typarams { let it = el.item(); _visitor.visit_type(it) };
- for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
- tokens_helper(_visitor, &(& _i . paren_token).0);
tokens_helper(_visitor, &(& _i . dot_token).0);
- if let Some(ref it) = _i . lt_token { tokens_helper(_visitor, &(it).0) };
+ _visitor.visit_ident(& _i . method);
if let Some(ref it) = _i . colon2_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . lt_token { tokens_helper(_visitor, &(it).0) };
+ for el in & _i . typarams { let it = el.item(); _visitor.visit_type(it) };
if let Some(ref it) = _i . gt_token { tokens_helper(_visitor, &(it).0) };
+ tokens_helper(_visitor, &(& _i . paren_token).0);
+ for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
}
pub fn visit_expr_paren<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprParen) {
- _visitor.visit_expr(& * _i . expr);
tokens_helper(_visitor, &(& _i . paren_token).0);
+ _visitor.visit_expr(& * _i . expr);
}
pub fn visit_expr_path<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprPath) {
@@ -976,28 +976,28 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_range<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRange) {
if let Some(ref it) = _i . from { _visitor.visit_expr(& * * it) };
- if let Some(ref it) = _i . to { _visitor.visit_expr(& * * it) };
_visitor.visit_range_limits(& _i . limits);
+ if let Some(ref it) = _i . to { _visitor.visit_expr(& * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_repeat<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRepeat) {
tokens_helper(_visitor, &(& _i . bracket_token).0);
- tokens_helper(_visitor, &(& _i . semi_token).0);
_visitor.visit_expr(& * _i . expr);
+ tokens_helper(_visitor, &(& _i . semi_token).0);
_visitor.visit_expr(& * _i . amt);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_ret<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRet) {
- if let Some(ref it) = _i . expr { _visitor.visit_expr(& * * it) };
tokens_helper(_visitor, &(& _i . return_token).0);
+ if let Some(ref it) = _i . expr { _visitor.visit_expr(& * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_struct<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprStruct) {
_visitor.visit_path(& _i . path);
- for el in & _i . fields { let it = el.item(); _visitor.visit_field_value(it) };
- if let Some(ref it) = _i . rest { _visitor.visit_expr(& * * it) };
- if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
tokens_helper(_visitor, &(& _i . brace_token).0);
+ for el in & _i . fields { let it = el.item(); _visitor.visit_field_value(it) };
+ if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . rest { _visitor.visit_expr(& * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_try<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTry) {
@@ -1006,8 +1006,8 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTuple) {
- for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
tokens_helper(_visitor, &(& _i . paren_token).0);
+ for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
}
pub fn visit_expr_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprType) {
@@ -1027,22 +1027,22 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_while<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhile) {
- _visitor.visit_expr(& * _i . cond);
- _visitor.visit_block(& _i . body);
if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
tokens_helper(_visitor, &(& _i . while_token).0);
+ _visitor.visit_expr(& * _i . cond);
+ _visitor.visit_block(& _i . body);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_while_let<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhileLet) {
- _visitor.visit_pat(& * _i . pat);
- _visitor.visit_expr(& * _i . expr);
- _visitor.visit_block(& _i . body);
if let Some(ref it) = _i . label { _visitor.visit_lifetime(it) };
if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
tokens_helper(_visitor, &(& _i . while_token).0);
tokens_helper(_visitor, &(& _i . let_token).0);
+ _visitor.visit_pat(& * _i . pat);
tokens_helper(_visitor, &(& _i . eq_token).0);
+ _visitor.visit_expr(& * _i . expr);
+ _visitor.visit_block(& _i . body);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_yield<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprYield) {
@@ -1051,19 +1051,19 @@
}
pub fn visit_field<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Field) {
- if let Some(ref it) = _i . ident { _visitor.visit_ident(it) };
- _visitor.visit_visibility(& _i . vis);
for it in & _i . attrs { _visitor.visit_attribute(it) };
- _visitor.visit_type(& _i . ty);
+ _visitor.visit_visibility(& _i . vis);
+ if let Some(ref it) = _i . ident { _visitor.visit_ident(it) };
if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
+ _visitor.visit_type(& _i . ty);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_field_pat<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldPat) {
+ for it in & _i . attrs { _visitor.visit_attribute(it) };
_visitor.visit_member(& _i . member);
+ if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
_visitor.visit_pat(& * _i . pat);
// Skipped field _i . is_shorthand;
- if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
- for it in & _i . attrs { _visitor.visit_attribute(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_field_value<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldValue) {
@@ -1103,11 +1103,11 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_fn_decl<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FnDecl) {
tokens_helper(_visitor, &(& _i . fn_token).0);
+ _visitor.visit_generics(& _i . generics);
tokens_helper(_visitor, &(& _i . paren_token).0);
for el in & _i . inputs { let it = el.item(); _visitor.visit_fn_arg(it) };
- _visitor.visit_return_type(& _i . output);
- _visitor.visit_generics(& _i . generics);
if let Some(ref it) = _i . variadic { tokens_helper(_visitor, &(it).0) };
+ _visitor.visit_return_type(& _i . output);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_foreign_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ForeignItem) {
@@ -1386,8 +1386,8 @@
_visitor.visit_constness(& _i . constness);
_visitor.visit_unsafety(& _i . unsafety);
if let Some(ref it) = _i . abi { _visitor.visit_abi(it) };
- _visitor.visit_fn_decl(& * _i . decl);
_visitor.visit_ident(& _i . ident);
+ _visitor.visit_fn_decl(& * _i . decl);
_visitor.visit_block(& * _i . block);
}
# [ cfg ( feature = "full" ) ]
@@ -1527,14 +1527,14 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_local<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Local) {
- tokens_helper(_visitor, &(& _i . let_token).0);
- if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
- if let Some(ref it) = _i . eq_token { tokens_helper(_visitor, &(it).0) };
- tokens_helper(_visitor, &(& _i . semi_token).0);
- _visitor.visit_pat(& * _i . pat);
- if let Some(ref it) = _i . ty { _visitor.visit_type(& * * it) };
- if let Some(ref it) = _i . init { _visitor.visit_expr(& * * it) };
for it in & _i . attrs { _visitor.visit_attribute(it) };
+ tokens_helper(_visitor, &(& _i . let_token).0);
+ _visitor.visit_pat(& * _i . pat);
+ if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . ty { _visitor.visit_type(& * * it) };
+ if let Some(ref it) = _i . eq_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . init { _visitor.visit_expr(& * * it) };
+ tokens_helper(_visitor, &(& _i . semi_token).0);
}
pub fn visit_macro<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Macro) {
@@ -1591,8 +1591,8 @@
}
pub fn visit_mut_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MutType) {
- _visitor.visit_type(& _i . ty);
_visitor.visit_mutability(& _i . mutability);
+ _visitor.visit_type(& _i . ty);
}
pub fn visit_mutability<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Mutability) {
@@ -1666,15 +1666,15 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_box<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatBox) {
- _visitor.visit_pat(& * _i . pat);
tokens_helper(_visitor, &(& _i . box_token).0);
+ _visitor.visit_pat(& * _i . pat);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_ident<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatIdent) {
_visitor.visit_binding_mode(& _i . mode);
_visitor.visit_ident(& _i . ident);
- if let Some(ref it) = _i . subpat { _visitor.visit_pat(& * * it) };
if let Some(ref it) = _i . at_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . subpat { _visitor.visit_pat(& * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_lit<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatLit) {
@@ -1688,38 +1688,38 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_range<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRange) {
_visitor.visit_expr(& * _i . lo);
- _visitor.visit_expr(& * _i . hi);
_visitor.visit_range_limits(& _i . limits);
+ _visitor.visit_expr(& * _i . hi);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_ref<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRef) {
- _visitor.visit_pat(& * _i . pat);
- _visitor.visit_mutability(& _i . mutbl);
tokens_helper(_visitor, &(& _i . and_token).0);
+ _visitor.visit_mutability(& _i . mutbl);
+ _visitor.visit_pat(& * _i . pat);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_slice<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatSlice) {
+ tokens_helper(_visitor, &(& _i . bracket_token).0);
for el in & _i . front { let it = el.item(); _visitor.visit_pat(it) };
if let Some(ref it) = _i . middle { _visitor.visit_pat(& * * it) };
- for el in & _i . back { let it = el.item(); _visitor.visit_pat(it) };
- if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
if let Some(ref it) = _i . comma_token { tokens_helper(_visitor, &(it).0) };
- tokens_helper(_visitor, &(& _i . bracket_token).0);
+ if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
+ for el in & _i . back { let it = el.item(); _visitor.visit_pat(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_struct<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatStruct) {
_visitor.visit_path(& _i . path);
- for el in & _i . fields { let it = el.item(); _visitor.visit_field_pat(it) };
tokens_helper(_visitor, &(& _i . brace_token).0);
+ for el in & _i . fields { let it = el.item(); _visitor.visit_field_pat(it) };
if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTuple) {
- for el in & _i . pats { let it = el.item(); _visitor.visit_pat(it) };
- // Skipped field _i . dots_pos;
tokens_helper(_visitor, &(& _i . paren_token).0);
- if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
+ for el in & _i . pats { let it = el.item(); _visitor.visit_pat(it) };
if let Some(ref it) = _i . comma_token { tokens_helper(_visitor, &(it).0) };
+ // Skipped field _i . dots_pos;
+ if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_tuple_struct<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTupleStruct) {
@@ -1784,8 +1784,8 @@
match *_i {
Default => { }
Type(ref _binding_0, ref _binding_1, ) => {
- _visitor.visit_type(& * * _binding_0);
- tokens_helper(_visitor, &(_binding_1).0);
+ tokens_helper(_visitor, &(_binding_0).0);
+ _visitor.visit_type(& * * _binding_1);
}
}
}
@@ -2008,8 +2008,8 @@
}
pub fn visit_type_slice<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeSlice) {
- _visitor.visit_type(& * _i . ty);
tokens_helper(_visitor, &(& _i . bracket_token).0);
+ _visitor.visit_type(& * _i . ty);
}
pub fn visit_type_trait_object<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTraitObject) {
@@ -2080,11 +2080,11 @@
}
pub fn visit_variant<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Variant) {
- _visitor.visit_ident(& _i . ident);
for it in & _i . attrs { _visitor.visit_attribute(it) };
+ _visitor.visit_ident(& _i . ident);
_visitor.visit_variant_data(& _i . data);
- if let Some(ref it) = _i . discriminant { _visitor.visit_expr(it) };
if let Some(ref it) = _i . eq_token { tokens_helper(_visitor, &(it).0) };
+ if let Some(ref it) = _i . discriminant { _visitor.visit_expr(it) };
}
pub fn visit_variant_data<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VariantData) {
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 1f06b98..44a4a2e 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -430,9 +430,9 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_arg_self_ref_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelfRef) {
tokens_helper(_visitor, &mut (& mut _i . and_token).0);
- tokens_helper(_visitor, &mut (& mut _i . self_token).0);
if let Some(ref mut it) = _i . lifetime { _visitor.visit_lifetime_mut(it) };
_visitor.visit_mutability_mut(& mut _i . mutbl);
+ tokens_helper(_visitor, &mut (& mut _i . self_token).0);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_arm_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
@@ -456,8 +456,8 @@
}
pub fn visit_attribute_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Attribute) {
- _visitor.visit_attr_style_mut(& mut _i . style);
tokens_helper(_visitor, &mut (& mut _i . pound_token).0);
+ _visitor.visit_attr_style_mut(& mut _i . style);
tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
_visitor.visit_path_mut(& mut _i . path);
// Skipped field _i . tts;
@@ -485,10 +485,10 @@
}
pub fn visit_bare_fn_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnType) {
- if let Some(ref mut it) = _i . lifetimes { _visitor.visit_bound_lifetimes_mut(it) };
_visitor.visit_unsafety_mut(& mut _i . unsafety);
if let Some(ref mut it) = _i . abi { _visitor.visit_abi_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . fn_token).0);
+ if let Some(ref mut it) = _i . lifetimes { _visitor.visit_bound_lifetimes_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_bare_fn_arg_mut(it) };
if let Some(ref mut it) = _i . variadic { tokens_helper(_visitor, &mut (it).0) };
@@ -675,16 +675,16 @@
}
pub fn visit_derive_input_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut DeriveInput) {
- _visitor.visit_ident_mut(& mut _i . ident);
- _visitor.visit_visibility_mut(& mut _i . vis);
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+ _visitor.visit_visibility_mut(& mut _i . vis);
+ _visitor.visit_ident_mut(& mut _i . ident);
_visitor.visit_generics_mut(& mut _i . generics);
_visitor.visit_body_mut(& mut _i . body);
}
pub fn visit_expr_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
- _visitor.visit_expr_kind_mut(& mut _i . node);
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+ _visitor.visit_expr_kind_mut(& mut _i . node);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_addr_of_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAddrOf) {
@@ -694,25 +694,25 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_array_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
- for mut el in & mut _i . exprs { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
+ for mut el in & mut _i . exprs { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_assign_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) {
_visitor.visit_expr_mut(& mut * _i . left);
- _visitor.visit_expr_mut(& mut * _i . right);
tokens_helper(_visitor, &mut (& mut _i . eq_token).0);
+ _visitor.visit_expr_mut(& mut * _i . right);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_assign_op_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssignOp) {
- _visitor.visit_bin_op_mut(& mut _i . op);
_visitor.visit_expr_mut(& mut * _i . left);
+ _visitor.visit_bin_op_mut(& mut _i . op);
_visitor.visit_expr_mut(& mut * _i . right);
}
pub fn visit_expr_binary_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBinary) {
- _visitor.visit_bin_op_mut(& mut _i . op);
_visitor.visit_expr_mut(& mut * _i . left);
+ _visitor.visit_bin_op_mut(& mut _i . op);
_visitor.visit_expr_mut(& mut * _i . right);
}
# [ cfg ( feature = "full" ) ]
@@ -721,20 +721,20 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_box_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) {
- _visitor.visit_expr_mut(& mut * _i . expr);
tokens_helper(_visitor, &mut (& mut _i . box_token).0);
+ _visitor.visit_expr_mut(& mut * _i . expr);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_break_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBreak) {
+ tokens_helper(_visitor, &mut (& mut _i . break_token).0);
if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
if let Some(ref mut it) = _i . expr { _visitor.visit_expr_mut(& mut * * it) };
- tokens_helper(_visitor, &mut (& mut _i . break_token).0);
}
pub fn visit_expr_call_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) {
_visitor.visit_expr_mut(& mut * _i . func);
- for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
+ for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
}
pub fn visit_expr_cast_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCast) {
@@ -759,8 +759,8 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_continue_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) {
- if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . continue_token).0);
+ if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_field_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprField) {
@@ -770,37 +770,37 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_for_loop_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprForLoop) {
+ if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
+ if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
+ tokens_helper(_visitor, &mut (& mut _i . for_token).0);
_visitor.visit_pat_mut(& mut * _i . pat);
+ tokens_helper(_visitor, &mut (& mut _i . in_token).0);
_visitor.visit_expr_mut(& mut * _i . expr);
_visitor.visit_block_mut(& mut _i . body);
- if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
- tokens_helper(_visitor, &mut (& mut _i . for_token).0);
- if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
- tokens_helper(_visitor, &mut (& mut _i . in_token).0);
}
pub fn visit_expr_group_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) {
- _visitor.visit_expr_mut(& mut * _i . expr);
tokens_helper(_visitor, &mut (& mut _i . group_token).0);
+ _visitor.visit_expr_mut(& mut * _i . expr);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_if_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIf) {
+ tokens_helper(_visitor, &mut (& mut _i . if_token).0);
_visitor.visit_expr_mut(& mut * _i . cond);
_visitor.visit_block_mut(& mut _i . if_true);
- if let Some(ref mut it) = _i . if_false { _visitor.visit_expr_mut(& mut * * it) };
- tokens_helper(_visitor, &mut (& mut _i . if_token).0);
if let Some(ref mut it) = _i . else_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . if_false { _visitor.visit_expr_mut(& mut * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_if_let_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIfLet) {
- _visitor.visit_pat_mut(& mut * _i . pat);
- _visitor.visit_expr_mut(& mut * _i . expr);
- _visitor.visit_block_mut(& mut _i . if_true);
- if let Some(ref mut it) = _i . if_false { _visitor.visit_expr_mut(& mut * * it) };
tokens_helper(_visitor, &mut (& mut _i . if_token).0);
tokens_helper(_visitor, &mut (& mut _i . let_token).0);
+ _visitor.visit_pat_mut(& mut * _i . pat);
tokens_helper(_visitor, &mut (& mut _i . eq_token).0);
+ _visitor.visit_expr_mut(& mut * _i . expr);
+ _visitor.visit_block_mut(& mut _i . if_true);
if let Some(ref mut it) = _i . else_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . if_false { _visitor.visit_expr_mut(& mut * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_in_place_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprInPlace) {
@@ -811,8 +811,8 @@
pub fn visit_expr_index_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) {
_visitor.visit_expr_mut(& mut * _i . expr);
- _visitor.visit_expr_mut(& mut * _i . index);
tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
+ _visitor.visit_expr_mut(& mut * _i . index);
}
pub fn visit_expr_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprKind) {
@@ -939,34 +939,34 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_loop_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLoop) {
- _visitor.visit_block_mut(& mut _i . body);
if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
- tokens_helper(_visitor, &mut (& mut _i . loop_token).0);
if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
+ tokens_helper(_visitor, &mut (& mut _i . loop_token).0);
+ _visitor.visit_block_mut(& mut _i . body);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_match_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMatch) {
tokens_helper(_visitor, &mut (& mut _i . match_token).0);
- tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
_visitor.visit_expr_mut(& mut * _i . expr);
+ tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
for it in & mut _i . arms { _visitor.visit_arm_mut(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_method_call_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMethodCall) {
_visitor.visit_expr_mut(& mut * _i . expr);
- _visitor.visit_ident_mut(& mut _i . method);
- for mut el in & mut _i . typarams { let it = el.item_mut(); _visitor.visit_type_mut(it) };
- for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
- tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
tokens_helper(_visitor, &mut (& mut _i . dot_token).0);
- if let Some(ref mut it) = _i . lt_token { tokens_helper(_visitor, &mut (it).0) };
+ _visitor.visit_ident_mut(& mut _i . method);
if let Some(ref mut it) = _i . colon2_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . lt_token { tokens_helper(_visitor, &mut (it).0) };
+ for mut el in & mut _i . typarams { let it = el.item_mut(); _visitor.visit_type_mut(it) };
if let Some(ref mut it) = _i . gt_token { tokens_helper(_visitor, &mut (it).0) };
+ tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
+ for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
}
pub fn visit_expr_paren_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) {
- _visitor.visit_expr_mut(& mut * _i . expr);
tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
+ _visitor.visit_expr_mut(& mut * _i . expr);
}
pub fn visit_expr_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprPath) {
@@ -976,28 +976,28 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_range_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) {
if let Some(ref mut it) = _i . from { _visitor.visit_expr_mut(& mut * * it) };
- if let Some(ref mut it) = _i . to { _visitor.visit_expr_mut(& mut * * it) };
_visitor.visit_range_limits_mut(& mut _i . limits);
+ if let Some(ref mut it) = _i . to { _visitor.visit_expr_mut(& mut * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_repeat_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRepeat) {
tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
- tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
_visitor.visit_expr_mut(& mut * _i . expr);
+ tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
_visitor.visit_expr_mut(& mut * _i . amt);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_ret_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRet) {
- if let Some(ref mut it) = _i . expr { _visitor.visit_expr_mut(& mut * * it) };
tokens_helper(_visitor, &mut (& mut _i . return_token).0);
+ if let Some(ref mut it) = _i . expr { _visitor.visit_expr_mut(& mut * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprStruct) {
_visitor.visit_path_mut(& mut _i . path);
- for mut el in & mut _i . fields { let it = el.item_mut(); _visitor.visit_field_value_mut(it) };
- if let Some(ref mut it) = _i . rest { _visitor.visit_expr_mut(& mut * * it) };
- if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
+ for mut el in & mut _i . fields { let it = el.item_mut(); _visitor.visit_field_value_mut(it) };
+ if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . rest { _visitor.visit_expr_mut(& mut * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_try_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTry) {
@@ -1006,8 +1006,8 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTuple) {
- for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
+ for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
}
pub fn visit_expr_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) {
@@ -1027,22 +1027,22 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_while_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) {
- _visitor.visit_expr_mut(& mut * _i . cond);
- _visitor.visit_block_mut(& mut _i . body);
if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
tokens_helper(_visitor, &mut (& mut _i . while_token).0);
+ _visitor.visit_expr_mut(& mut * _i . cond);
+ _visitor.visit_block_mut(& mut _i . body);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_while_let_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhileLet) {
- _visitor.visit_pat_mut(& mut * _i . pat);
- _visitor.visit_expr_mut(& mut * _i . expr);
- _visitor.visit_block_mut(& mut _i . body);
if let Some(ref mut it) = _i . label { _visitor.visit_lifetime_mut(it) };
if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
tokens_helper(_visitor, &mut (& mut _i . while_token).0);
tokens_helper(_visitor, &mut (& mut _i . let_token).0);
+ _visitor.visit_pat_mut(& mut * _i . pat);
tokens_helper(_visitor, &mut (& mut _i . eq_token).0);
+ _visitor.visit_expr_mut(& mut * _i . expr);
+ _visitor.visit_block_mut(& mut _i . body);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_expr_yield_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) {
@@ -1051,19 +1051,19 @@
}
pub fn visit_field_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Field) {
- if let Some(ref mut it) = _i . ident { _visitor.visit_ident_mut(it) };
- _visitor.visit_visibility_mut(& mut _i . vis);
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
- _visitor.visit_type_mut(& mut _i . ty);
+ _visitor.visit_visibility_mut(& mut _i . vis);
+ if let Some(ref mut it) = _i . ident { _visitor.visit_ident_mut(it) };
if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
+ _visitor.visit_type_mut(& mut _i . ty);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_field_pat_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldPat) {
+ for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
_visitor.visit_member_mut(& mut _i . member);
+ if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
_visitor.visit_pat_mut(& mut * _i . pat);
// Skipped field _i . is_shorthand;
- if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
- for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_field_value_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldValue) {
@@ -1103,11 +1103,11 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_fn_decl_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FnDecl) {
tokens_helper(_visitor, &mut (& mut _i . fn_token).0);
+ _visitor.visit_generics_mut(& mut _i . generics);
tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_fn_arg_mut(it) };
- _visitor.visit_return_type_mut(& mut _i . output);
- _visitor.visit_generics_mut(& mut _i . generics);
if let Some(ref mut it) = _i . variadic { tokens_helper(_visitor, &mut (it).0) };
+ _visitor.visit_return_type_mut(& mut _i . output);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_foreign_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItem) {
@@ -1386,8 +1386,8 @@
_visitor.visit_constness_mut(& mut _i . constness);
_visitor.visit_unsafety_mut(& mut _i . unsafety);
if let Some(ref mut it) = _i . abi { _visitor.visit_abi_mut(it) };
- _visitor.visit_fn_decl_mut(& mut * _i . decl);
_visitor.visit_ident_mut(& mut _i . ident);
+ _visitor.visit_fn_decl_mut(& mut * _i . decl);
_visitor.visit_block_mut(& mut * _i . block);
}
# [ cfg ( feature = "full" ) ]
@@ -1527,14 +1527,14 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_local_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Local) {
- tokens_helper(_visitor, &mut (& mut _i . let_token).0);
- if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
- if let Some(ref mut it) = _i . eq_token { tokens_helper(_visitor, &mut (it).0) };
- tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
- _visitor.visit_pat_mut(& mut * _i . pat);
- if let Some(ref mut it) = _i . ty { _visitor.visit_type_mut(& mut * * it) };
- if let Some(ref mut it) = _i . init { _visitor.visit_expr_mut(& mut * * it) };
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+ tokens_helper(_visitor, &mut (& mut _i . let_token).0);
+ _visitor.visit_pat_mut(& mut * _i . pat);
+ if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . ty { _visitor.visit_type_mut(& mut * * it) };
+ if let Some(ref mut it) = _i . eq_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . init { _visitor.visit_expr_mut(& mut * * it) };
+ tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
}
pub fn visit_macro_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Macro) {
@@ -1591,8 +1591,8 @@
}
pub fn visit_mut_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MutType) {
- _visitor.visit_type_mut(& mut _i . ty);
_visitor.visit_mutability_mut(& mut _i . mutability);
+ _visitor.visit_type_mut(& mut _i . ty);
}
pub fn visit_mutability_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Mutability) {
@@ -1666,15 +1666,15 @@
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_box_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatBox) {
- _visitor.visit_pat_mut(& mut * _i . pat);
tokens_helper(_visitor, &mut (& mut _i . box_token).0);
+ _visitor.visit_pat_mut(& mut * _i . pat);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_ident_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) {
_visitor.visit_binding_mode_mut(& mut _i . mode);
_visitor.visit_ident_mut(& mut _i . ident);
- if let Some(ref mut it) = _i . subpat { _visitor.visit_pat_mut(& mut * * it) };
if let Some(ref mut it) = _i . at_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . subpat { _visitor.visit_pat_mut(& mut * * it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_lit_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatLit) {
@@ -1688,38 +1688,38 @@
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_range_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatRange) {
_visitor.visit_expr_mut(& mut * _i . lo);
- _visitor.visit_expr_mut(& mut * _i . hi);
_visitor.visit_range_limits_mut(& mut _i . limits);
+ _visitor.visit_expr_mut(& mut * _i . hi);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_ref_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) {
- _visitor.visit_pat_mut(& mut * _i . pat);
- _visitor.visit_mutability_mut(& mut _i . mutbl);
tokens_helper(_visitor, &mut (& mut _i . and_token).0);
+ _visitor.visit_mutability_mut(& mut _i . mutbl);
+ _visitor.visit_pat_mut(& mut * _i . pat);
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_slice_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) {
+ tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
for mut el in & mut _i . front { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
if let Some(ref mut it) = _i . middle { _visitor.visit_pat_mut(& mut * * it) };
- for mut el in & mut _i . back { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
- if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
if let Some(ref mut it) = _i . comma_token { tokens_helper(_visitor, &mut (it).0) };
- tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
+ if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
+ for mut el in & mut _i . back { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) {
_visitor.visit_path_mut(& mut _i . path);
- for mut el in & mut _i . fields { let it = el.item_mut(); _visitor.visit_field_pat_mut(it) };
tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
+ for mut el in & mut _i . fields { let it = el.item_mut(); _visitor.visit_field_pat_mut(it) };
if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) {
- for mut el in & mut _i . pats { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
- // Skipped field _i . dots_pos;
tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
- if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
+ for mut el in & mut _i . pats { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
if let Some(ref mut it) = _i . comma_token { tokens_helper(_visitor, &mut (it).0) };
+ // Skipped field _i . dots_pos;
+ if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
}
# [ cfg ( feature = "full" ) ]
pub fn visit_pat_tuple_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTupleStruct) {
@@ -1784,8 +1784,8 @@
match *_i {
Default => { }
Type(ref mut _binding_0, ref mut _binding_1, ) => {
- _visitor.visit_type_mut(& mut * * _binding_0);
- tokens_helper(_visitor, &mut (_binding_1).0);
+ tokens_helper(_visitor, &mut (_binding_0).0);
+ _visitor.visit_type_mut(& mut * * _binding_1);
}
}
}
@@ -2008,8 +2008,8 @@
}
pub fn visit_type_slice_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeSlice) {
- _visitor.visit_type_mut(& mut * _i . ty);
tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
+ _visitor.visit_type_mut(& mut * _i . ty);
}
pub fn visit_type_trait_object_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTraitObject) {
@@ -2080,11 +2080,11 @@
}
pub fn visit_variant_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Variant) {
- _visitor.visit_ident_mut(& mut _i . ident);
for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+ _visitor.visit_ident_mut(& mut _i . ident);
_visitor.visit_variant_data_mut(& mut _i . data);
- if let Some(ref mut it) = _i . discriminant { _visitor.visit_expr_mut(it) };
if let Some(ref mut it) = _i . eq_token { tokens_helper(_visitor, &mut (it).0) };
+ if let Some(ref mut it) = _i . discriminant { _visitor.visit_expr_mut(it) };
}
pub fn visit_variant_data_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VariantData) {
diff --git a/src/item.rs b/src/item.rs
index 1819782..bb3c892 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -72,8 +72,8 @@
pub constness: Constness,
pub unsafety: Unsafety,
pub abi: Option<Abi>,
- pub decl: Box<FnDecl>,
pub ident: Ident,
+ pub decl: Box<FnDecl>,
pub block: Box<Block>,
}),
/// A module declaration (`mod` or `pub mod`).
@@ -439,11 +439,11 @@
/// E.g. `fn foo(bar: baz)`
pub struct FnDecl {
pub fn_token: Token![fn],
+ pub generics: Generics,
pub paren_token: token::Paren,
pub inputs: Delimited<FnArg, Token![,]>,
- pub output: ReturnType,
- pub generics: Generics,
pub variadic: Option<Token![...]>,
+ pub output: ReturnType,
}
}
@@ -454,9 +454,9 @@
pub enum FnArg {
pub SelfRef(ArgSelfRef {
pub and_token: Token![&],
- pub self_token: Token![self],
pub lifetime: Option<Lifetime>,
pub mutbl: Mutability,
+ pub self_token: Token![self],
}),
pub SelfValue(ArgSelf {
pub mutbl: Mutability,
diff --git a/src/ty.rs b/src/ty.rs
index 625f5da..8176e76 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -6,8 +6,8 @@
pub enum Type {
/// A variable-length array (`[T]`)
pub Slice(TypeSlice {
- pub ty: Box<Type>,
pub bracket_token: token::Bracket,
+ pub ty: Box<Type>,
}),
/// A fixed length array (`[T; n]`)
pub Array(TypeArray {
@@ -83,8 +83,8 @@
ast_struct! {
pub struct MutType {
- pub ty: Type,
pub mutability: Mutability,
+ pub ty: Type,
}
}
@@ -276,10 +276,10 @@
ast_struct! {
pub struct BareFnType {
- pub lifetimes: Option<BoundLifetimes>,
pub unsafety: Unsafety,
pub abi: Option<Abi>,
pub fn_token: Token![fn],
+ pub lifetimes: Option<BoundLifetimes>,
pub paren_token: token::Paren,
pub inputs: Delimited<BareFnArg, Token![,]>,
pub variadic: Option<Token![...]>,
@@ -338,7 +338,7 @@
/// type would be inserted.
Default,
/// Everything else
- Type(Box<Type>, Token![->]),
+ Type(Token![->], Box<Type>),
}
}
@@ -595,7 +595,7 @@
do_parse!(
arrow: punct!(->) >>
ty: syn!(Type) >>
- (ReturnType::Type(Box::new(ty), arrow))
+ (ReturnType::Type(arrow, Box::new(ty)))
)
|
epsilon!() => { |_| ReturnType::Default }
@@ -1078,7 +1078,7 @@
fn to_tokens(&self, tokens: &mut Tokens) {
match *self {
ReturnType::Default => {}
- ReturnType::Type(ref ty, ref arrow) => {
+ ReturnType::Type(ref arrow, ref ty) => {
arrow.to_tokens(tokens);
ty.to_tokens(tokens);
}