diff --git a/src/expr.rs b/src/expr.rs
index 8682f6a..780d090 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -5,36 +5,19 @@
 #[cfg(feature = "full")]
 use std::hash::{Hash, Hasher};
 
-ast_struct! {
-    /// An expression.
-    pub struct Expr {
-        /// Attributes tagged on the expression.
-        pub attrs: Vec<Attribute>,
-
-        /// Type of the expression.
-        pub node: ExprKind,
-    }
-}
-
-impl From<ExprKind> for Expr {
-    fn from(node: ExprKind) -> Expr {
-        Expr {
-            node: node,
-            attrs: Vec::new(),
-        }
-    }
-}
-
 ast_enum_of_structs! {
-    pub enum ExprKind {
+    /// An expression.
+    pub enum Expr {
         /// A `box x` expression.
         pub Box(ExprBox #full {
+            pub attrs: Vec<Attribute>,
             pub box_token: Token![box],
             pub expr: Box<Expr>,
         }),
 
         /// E.g. 'place <- val' or `in place { val }`.
         pub InPlace(ExprInPlace #full {
+            pub attrs: Vec<Attribute>,
             pub place: Box<Expr>,
             pub kind: InPlaceKind,
             pub value: Box<Expr>,
@@ -42,12 +25,14 @@
 
         /// An array, e.g. `[a, b, c, d]`.
         pub Array(ExprArray #full {
+            pub attrs: Vec<Attribute>,
             pub bracket_token: token::Bracket,
             pub exprs: Delimited<Expr, Token![,]>,
         }),
 
         /// A function call.
         pub Call(ExprCall {
+            pub attrs: Vec<Attribute>,
             pub func: Box<Expr>,
             pub paren_token: token::Paren,
             pub args: Delimited<Expr, Token![,]>,
@@ -58,10 +43,8 @@
         /// The `Ident` is the identifier for the method name.
         /// The vector of `Type`s are the ascripted type parameters for the method
         /// (within the angle brackets).
-        ///
-        /// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
-        /// `ExprKind::MethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
         pub MethodCall(ExprMethodCall #full {
+            pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
             pub dot_token: Token![.],
             pub method: Ident,
@@ -75,12 +58,14 @@
 
         /// A tuple, e.g. `(a, b, c, d)`.
         pub Tuple(ExprTuple #full {
+            pub attrs: Vec<Attribute>,
             pub paren_token: token::Paren,
             pub args: Delimited<Expr, Token![,]>,
         }),
 
         /// A binary operation, e.g. `a + b`, `a * b`.
         pub Binary(ExprBinary {
+            pub attrs: Vec<Attribute>,
             pub left: Box<Expr>,
             pub op: BinOp,
             pub right: Box<Expr>,
@@ -88,15 +73,20 @@
 
         /// A unary operation, e.g. `!x`, `*x`.
         pub Unary(ExprUnary {
+            pub attrs: Vec<Attribute>,
             pub op: UnOp,
             pub expr: Box<Expr>,
         }),
 
         /// A literal, e.g. `1`, `"foo"`.
-        pub Lit(Lit),
+        pub Lit(ExprLit {
+            pub attrs: Vec<Attribute>,
+            pub lit: Lit,
+        }),
 
         /// A cast, e.g. `foo as f64`.
         pub Cast(ExprCast {
+            pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
             pub as_token: Token![as],
             pub ty: Box<Type>,
@@ -104,6 +94,7 @@
 
         /// A type ascription, e.g. `foo: f64`.
         pub Type(ExprType {
+            pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
             pub colon_token: Token![:],
             pub ty: Box<Type>,
@@ -113,6 +104,7 @@
         ///
         /// E.g., `if expr { block } else { expr }`
         pub If(ExprIf #full {
+            pub attrs: Vec<Attribute>,
             pub if_token: Token![if],
             pub cond: Box<Expr>,
             pub if_true: Block,
@@ -126,6 +118,7 @@
         ///
         /// This is desugared to a `match` expression.
         pub IfLet(ExprIfLet #full {
+            pub attrs: Vec<Attribute>,
             pub if_token: Token![if],
             pub let_token: Token![let],
             pub pat: Box<Pat>,
@@ -140,6 +133,7 @@
         ///
         /// E.g., `'label: while expr { block }`
         pub While(ExprWhile #full {
+            pub attrs: Vec<Attribute>,
             pub label: Option<Lifetime>,
             pub colon_token: Option<Token![:]>,
             pub while_token: Token![while],
@@ -153,6 +147,7 @@
         ///
         /// This is desugared to a combination of `loop` and `match` expressions.
         pub WhileLet(ExprWhileLet #full {
+            pub attrs: Vec<Attribute>,
             pub label: Option<Lifetime>,
             pub colon_token: Option<Token![:]>,
             pub while_token: Token![while],
@@ -169,6 +164,7 @@
         ///
         /// This is desugared to a combination of `loop` and `match` expressions.
         pub ForLoop(ExprForLoop #full {
+            pub attrs: Vec<Attribute>,
             pub label: Option<Lifetime>,
             pub colon_token: Option<Token![:]>,
             pub for_token: Token![for],
@@ -182,6 +178,7 @@
         ///
         /// E.g. `'label: loop { block }`
         pub Loop(ExprLoop #full {
+            pub attrs: Vec<Attribute>,
             pub label: Option<Lifetime>,
             pub colon_token: Option<Token![:]>,
             pub loop_token: Token![loop],
@@ -190,6 +187,7 @@
 
         /// A `match` block.
         pub Match(ExprMatch #full {
+            pub attrs: Vec<Attribute>,
             pub match_token: Token![match],
             pub expr: Box<Expr>,
             pub brace_token: token::Brace,
@@ -198,6 +196,7 @@
 
         /// A closure (for example, `move |a, b, c| a + b + c`)
         pub Closure(ExprClosure #full {
+            pub attrs: Vec<Attribute>,
             pub capture: CaptureBy,
             pub or1_token: Token![|],
             pub inputs: Delimited<FnArg, Token![,]>,
@@ -208,17 +207,20 @@
 
         /// An unsafe block (`unsafe { ... }`)
         pub Unsafe(ExprUnsafe #full {
+            pub attrs: Vec<Attribute>,
             pub unsafe_token: Token![unsafe],
             pub block: Block,
         }),
 
         /// A block (`{ ... }`)
         pub Block(ExprBlock #full {
+            pub attrs: Vec<Attribute>,
             pub block: Block,
         }),
 
         /// An assignment (`a = foo()`)
         pub Assign(ExprAssign #full {
+            pub attrs: Vec<Attribute>,
             pub left: Box<Expr>,
             pub eq_token: Token![=],
             pub right: Box<Expr>,
@@ -228,6 +230,7 @@
         ///
         /// For example, `a += 1`.
         pub AssignOp(ExprAssignOp #full {
+            pub attrs: Vec<Attribute>,
             pub left: Box<Expr>,
             pub op: BinOp,
             pub right: Box<Expr>,
@@ -236,6 +239,7 @@
         /// Access of a named struct field (`obj.foo`) or unnamed tuple struct
         /// field (`obj.0`).
         pub Field(ExprField #full {
+            pub attrs: Vec<Attribute>,
             pub base: Box<Expr>,
             pub dot_token: Token![.],
             pub member: Member,
@@ -243,6 +247,7 @@
 
         /// An indexing operation (`foo[2]`)
         pub Index(ExprIndex {
+            pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
             pub bracket_token: token::Bracket,
             pub index: Box<Expr>,
@@ -250,6 +255,7 @@
 
         /// A range (`1..2`, `1..`, `..2`, `1..=2`, `..=2`)
         pub Range(ExprRange #full {
+            pub attrs: Vec<Attribute>,
             pub from: Option<Box<Expr>>,
             pub limits: RangeLimits,
             pub to: Option<Box<Expr>>,
@@ -261,12 +267,14 @@
         /// Optionally "qualified",
         /// E.g. `<Vec<T> as SomeTrait>::SomeType`.
         pub Path(ExprPath {
+            pub attrs: Vec<Attribute>,
             pub qself: Option<QSelf>,
             pub path: Path,
         }),
 
         /// A referencing operation (`&a` or `&mut a`)
         pub AddrOf(ExprAddrOf #full {
+            pub attrs: Vec<Attribute>,
             pub and_token: Token![&],
             pub mutbl: Mutability,
             pub expr: Box<Expr>,
@@ -274,6 +282,7 @@
 
         /// A `break`, with an optional label to break, and an optional expression
         pub Break(ExprBreak #full {
+            pub attrs: Vec<Attribute>,
             pub break_token: Token![break],
             pub label: Option<Lifetime>,
             pub expr: Option<Box<Expr>>,
@@ -281,24 +290,30 @@
 
         /// A `continue`, with an optional label
         pub Continue(ExprContinue #full {
+            pub attrs: Vec<Attribute>,
             pub continue_token: Token![continue],
             pub label: Option<Lifetime>,
         }),
 
         /// A `return`, with an optional value to be returned
         pub Ret(ExprRet #full {
+            pub attrs: Vec<Attribute>,
             pub return_token: Token![return],
             pub expr: Option<Box<Expr>>,
         }),
 
         /// A macro invocation; pre-expansion
-        pub Macro(Macro),
+        pub Macro(ExprMacro #full {
+            pub attrs: Vec<Attribute>,
+            pub mac: Macro,
+        }),
 
         /// A struct literal expression.
         ///
         /// For example, `Foo {x: 1, y: 2}`, or
         /// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
         pub Struct(ExprStruct #full {
+            pub attrs: Vec<Attribute>,
             pub path: Path,
             pub brace_token: token::Brace,
             pub fields: Delimited<FieldValue, Token![,]>,
@@ -311,6 +326,7 @@
         /// For example, `[1; 5]`. The first expression is the element
         /// to be repeated; the second is the number of times to repeat it.
         pub Repeat(ExprRepeat #full {
+            pub attrs: Vec<Attribute>,
             pub bracket_token: token::Bracket,
             pub expr: Box<Expr>,
             pub semi_token: Token![;],
@@ -319,6 +335,7 @@
 
         /// No-op: used solely so we can pretty-print faithfully
         pub Paren(ExprParen {
+            pub attrs: Vec<Attribute>,
             pub paren_token: token::Paren,
             pub expr: Box<Expr>,
         }),
@@ -329,12 +346,14 @@
         /// `TokenStream` which affects the precidence of the resulting
         /// expression. They are used for macro hygiene.
         pub Group(ExprGroup {
+            pub attrs: Vec<Attribute>,
             pub group_token: token::Group,
             pub expr: Box<Expr>,
         }),
 
         /// `expr?`
         pub Try(ExprTry #full {
+            pub attrs: Vec<Attribute>,
             pub expr: Box<Expr>,
             pub question_token: Token![?],
         }),
@@ -343,6 +362,7 @@
         ///
         /// E.g. `do catch { block }`
         pub Catch(ExprCatch #full {
+            pub attrs: Vec<Attribute>,
             pub do_token: Token![do],
             pub catch_token: Token![catch],
             pub block: Block,
@@ -352,12 +372,61 @@
         ///
         /// E.g. `yield expr`
         pub Yield(ExprYield #full {
+            pub attrs: Vec<Attribute>,
             pub yield_token: Token![yield],
             pub expr: Option<Box<Expr>>,
         }),
     }
 }
 
+impl Expr {
+    // Not public API.
+    #[doc(hidden)]
+    pub fn attrs_mut(&mut self) -> &mut Vec<Attribute> {
+        match *self {
+            Expr::Box(ExprBox { ref mut attrs, .. }) |
+            Expr::InPlace(ExprInPlace { ref mut attrs, .. }) |
+            Expr::Array(ExprArray { ref mut attrs, .. }) |
+            Expr::Call(ExprCall { ref mut attrs, .. }) |
+            Expr::MethodCall(ExprMethodCall { ref mut attrs, .. }) |
+            Expr::Tuple(ExprTuple { ref mut attrs, .. }) |
+            Expr::Binary(ExprBinary { ref mut attrs, .. }) |
+            Expr::Unary(ExprUnary { ref mut attrs, .. }) |
+            Expr::Lit(ExprLit { ref mut attrs, .. }) |
+            Expr::Cast(ExprCast { ref mut attrs, .. }) |
+            Expr::Type(ExprType { ref mut attrs, .. }) |
+            Expr::If(ExprIf { ref mut attrs, .. }) |
+            Expr::IfLet(ExprIfLet { ref mut attrs, .. }) |
+            Expr::While(ExprWhile { ref mut attrs, .. }) |
+            Expr::WhileLet(ExprWhileLet { ref mut attrs, .. }) |
+            Expr::ForLoop(ExprForLoop { ref mut attrs, .. }) |
+            Expr::Loop(ExprLoop { ref mut attrs, .. }) |
+            Expr::Match(ExprMatch { ref mut attrs, .. }) |
+            Expr::Closure(ExprClosure { ref mut attrs, .. }) |
+            Expr::Unsafe(ExprUnsafe { ref mut attrs, .. }) |
+            Expr::Block(ExprBlock { ref mut attrs, .. }) |
+            Expr::Assign(ExprAssign { ref mut attrs, .. }) |
+            Expr::AssignOp(ExprAssignOp { ref mut attrs, .. }) |
+            Expr::Field(ExprField { ref mut attrs, .. }) |
+            Expr::Index(ExprIndex { ref mut attrs, .. }) |
+            Expr::Range(ExprRange { ref mut attrs, .. }) |
+            Expr::Path(ExprPath { ref mut attrs, .. }) |
+            Expr::AddrOf(ExprAddrOf { ref mut attrs, .. }) |
+            Expr::Break(ExprBreak { ref mut attrs, .. }) |
+            Expr::Continue(ExprContinue { ref mut attrs, .. }) |
+            Expr::Ret(ExprRet { ref mut attrs, .. }) |
+            Expr::Macro(ExprMacro { ref mut attrs, .. }) |
+            Expr::Struct(ExprStruct { ref mut attrs, .. }) |
+            Expr::Repeat(ExprRepeat { ref mut attrs, .. }) |
+            Expr::Paren(ExprParen { ref mut attrs, .. }) |
+            Expr::Group(ExprGroup { ref mut attrs, .. }) |
+            Expr::Try(ExprTry { ref mut attrs, .. }) |
+            Expr::Catch(ExprCatch { ref mut attrs, .. }) |
+            Expr::Yield(ExprYield { ref mut attrs, .. }) => attrs,
+        }
+    }
+}
+
 #[cfg(feature = "full")]
 ast_enum! {
     /// A struct or tuple struct field accessed in a struct literal or field
@@ -648,17 +717,17 @@
 fn arm_expr_requires_comma(expr: &Expr) -> bool {
     // see https://github.com/rust-lang/rust/blob/eb8f2586e
     //                       /src/libsyntax/parse/classify.rs#L17-L37
-    match expr.node {
-        ExprKind::Unsafe(..)
-        | ExprKind::Block(..)
-        | ExprKind::If(..)
-        | ExprKind::IfLet(..)
-        | ExprKind::Match(..)
-        | ExprKind::While(..)
-        | ExprKind::WhileLet(..)
-        | ExprKind::Loop(..)
-        | ExprKind::ForLoop(..)
-        | ExprKind::Catch(..) => false,
+    match *expr {
+        Expr::Unsafe(..)
+        | Expr::Block(..)
+        | Expr::If(..)
+        | Expr::IfLet(..)
+        | Expr::Match(..)
+        | Expr::While(..)
+        | Expr::WhileLet(..)
+        | Expr::Loop(..)
+        | Expr::ForLoop(..)
+        | Expr::Catch(..) => false,
         _ => true,
     }
 }
@@ -719,22 +788,14 @@
     // Parse an arbitrary expression.
     #[cfg(feature = "full")]
     fn ambiguous_expr(i: Cursor, allow_struct: bool, allow_block: bool) -> PResult<Expr> {
-        map!(
-            i,
-            call!(assign_expr, allow_struct, allow_block),
-            ExprKind::into
-        )
+        call!(i, assign_expr, allow_struct, allow_block)
     }
 
     #[cfg(not(feature = "full"))]
     fn ambiguous_expr(i: Cursor, allow_struct: bool, allow_block: bool) -> PResult<Expr> {
-        map!(
-            i,
-            // NOTE: We intentionally skip assign_expr, placement_expr, and
-            // range_expr, as they are not parsed in non-full mode.
-            call!(or_expr, allow_struct, allow_block),
-            ExprKind::into
-        )
+        // NOTE: We intentionally skip assign_expr, placement_expr, and
+        // range_expr, as they are not parsed in non-full mode.
+        call!(i, or_expr, allow_struct, allow_block)
     }
 
     // Parse a left-associative binary operator.
@@ -744,13 +805,14 @@
             $next: ident,
             $submac: ident!( $($args:tt)* )
         ) => {
-            named!($name(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
+            named!($name(allow_struct: bool, allow_block: bool) -> Expr, do_parse!(
                 mut e: call!($next, allow_struct, allow_block) >>
                 many0!(do_parse!(
                     op: $submac!($($args)*) >>
                     rhs: call!($next, allow_struct, true) >>
                     ({
                         e = ExprBinary {
+                            attrs: Vec::new(),
                             left: Box::new(e.into()),
                             op: op,
                             right: Box::new(rhs.into()),
@@ -776,7 +838,7 @@
     //
     // NOTE: This operator is right-associative.
     #[cfg(feature = "full")]
-    named!(assign_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
+    named!(assign_expr(allow_struct: bool, allow_block: bool) -> Expr, do_parse!(
         mut e: call!(placement_expr, allow_struct, allow_block) >>
         alt!(
             do_parse!(
@@ -785,6 +847,7 @@
                 rhs: call!(assign_expr, allow_struct, true) >>
                 ({
                     e = ExprAssign {
+                        attrs: Vec::new(),
                         left: Box::new(e.into()),
                         eq_token: eq,
                         right: Box::new(rhs.into()),
@@ -798,6 +861,7 @@
                 rhs: call!(assign_expr, allow_struct, true) >>
                 ({
                     e = ExprAssignOp {
+                        attrs: Vec::new(),
                         left: Box::new(e.into()),
                         op: op,
                         right: Box::new(rhs.into()),
@@ -817,7 +881,7 @@
     //
     // NOTE: This operator is right-associative.
     #[cfg(feature = "full")]
-    named!(placement_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
+    named!(placement_expr(allow_struct: bool, allow_block: bool) -> Expr, do_parse!(
         mut e: call!(range_expr, allow_struct, allow_block) >>
         alt!(
             do_parse!(
@@ -826,6 +890,7 @@
                 rhs: call!(placement_expr, allow_struct, true) >>
                 ({
                     e = ExprInPlace {
+                        attrs: Vec::new(),
                         // op: BinOp::Place(larrow),
                         place: Box::new(e.into()),
                         kind: InPlaceKind::Arrow(arrow),
@@ -851,7 +916,7 @@
     // NOTE: The form of ranges which don't include a preceding expression are
     // parsed by `atom_expr`, rather than by this function.
     #[cfg(feature = "full")]
-    named!(range_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
+    named!(range_expr(allow_struct: bool, allow_block: bool) -> Expr, do_parse!(
         mut e: call!(or_expr, allow_struct, allow_block) >>
         many0!(do_parse!(
             limits: syn!(RangeLimits) >>
@@ -860,6 +925,7 @@
             hi: option!(call!(or_expr, allow_struct, allow_struct)) >>
             ({
                 e = ExprRange {
+                    attrs: Vec::new(),
                     from: Some(Box::new(e.into())),
                     limits: limits,
                     to: hi.map(|e| Box::new(e.into())),
@@ -977,7 +1043,7 @@
 
     // <unary> as <ty>
     // <unary> : <ty>
-    named!(cast_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
+    named!(cast_expr(allow_struct: bool, allow_block: bool) -> Expr, do_parse!(
         mut e: call!(unary_expr, allow_struct, allow_block) >>
         many0!(alt!(
             do_parse!(
@@ -987,6 +1053,7 @@
                 ty: call!(Type::without_plus) >>
                 ({
                     e = ExprCast {
+                        attrs: Vec::new(),
                         expr: Box::new(e.into()),
                         as_token: as_,
                         ty: Box::new(ty),
@@ -1001,6 +1068,7 @@
                 ty: call!(Type::without_plus) >>
                 ({
                     e = ExprType {
+                        attrs: Vec::new(),
                         expr: Box::new(e.into()),
                         colon_token: colon,
                         ty: Box::new(ty),
@@ -1016,11 +1084,12 @@
     // &mut <trailer>
     // box <trailer>
     #[cfg(feature = "full")]
-    named!(unary_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!(
+    named!(unary_expr(allow_struct: bool, allow_block: bool) -> Expr, alt!(
         do_parse!(
             op: syn!(UnOp) >>
             expr: call!(unary_expr, allow_struct, true) >>
             (ExprUnary {
+                attrs: Vec::new(),
                 op: op,
                 expr: Box::new(expr.into()),
             }.into())
@@ -1031,6 +1100,7 @@
             mutability: syn!(Mutability) >>
             expr: call!(unary_expr, allow_struct, true) >>
             (ExprAddrOf {
+                attrs: Vec::new(),
                 and_token: and,
                 mutbl: mutability,
                 expr: Box::new(expr.into()),
@@ -1041,6 +1111,7 @@
             box_: keyword!(box) >>
             expr: call!(unary_expr, allow_struct, true) >>
             (ExprBox {
+                attrs: Vec::new(),
                 box_token: box_,
                 expr: Box::new(expr.into()),
             }.into())
@@ -1051,11 +1122,12 @@
 
     // XXX: This duplication is ugly
     #[cfg(not(feature = "full"))]
-    named!(unary_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!(
+    named!(unary_expr(allow_struct: bool, allow_block: bool) -> Expr, alt!(
         do_parse!(
             op: syn!(UnOp) >>
             expr: call!(unary_expr, allow_struct, true) >>
             (ExprUnary {
+                attrs: Vec::new(),
                 op: op,
                 expr: Box::new(expr.into()),
             }.into())
@@ -1071,12 +1143,13 @@
     // <atom> [ <expr> ] ...
     // <atom> ? ...
     #[cfg(feature = "full")]
-    named!(trailer_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
+    named!(trailer_expr(allow_struct: bool, allow_block: bool) -> Expr, do_parse!(
         mut e: call!(atom_expr, allow_struct, allow_block) >>
         many0!(alt!(
             tap!(args: and_call => {
                 let (args, paren) = args;
                 e = ExprCall {
+                    attrs: Vec::new(),
                     func: Box::new(e.into()),
                     args: args,
                     paren_token: paren,
@@ -1092,6 +1165,7 @@
             tap!(field: and_field => {
                 let (token, member) = field;
                 e = ExprField {
+                    attrs: Vec::new(),
                     base: Box::new(e.into()),
                     dot_token: token,
                     member: member,
@@ -1101,6 +1175,7 @@
             tap!(i: and_index => {
                 let (i, token) = i;
                 e = ExprIndex {
+                    attrs: Vec::new(),
                     expr: Box::new(e.into()),
                     bracket_token: token,
                     index: Box::new(i),
@@ -1109,6 +1184,7 @@
             |
             tap!(question: punct!(?) => {
                 e = ExprTry {
+                    attrs: Vec::new(),
                     expr: Box::new(e.into()),
                     question_token: question,
                 }.into();
@@ -1119,12 +1195,13 @@
 
     // XXX: Duplication == ugly
     #[cfg(not(feature = "full"))]
-    named!(trailer_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!(
+    named!(trailer_expr(allow_struct: bool, allow_block: bool) -> Expr, do_parse!(
         mut e: call!(atom_expr, allow_struct, allow_block) >>
         many0!(alt!(
             tap!(args: and_call => {
                 let (args, paren) = args;
                 e = ExprCall {
+                    attrs: Vec::new(),
                     func: Box::new(e.into()),
                     args: args,
                     paren_token: paren,
@@ -1134,6 +1211,7 @@
             tap!(i: and_index => {
                 let (i, token) = i;
                 e = ExprIndex {
+                    attrs: Vec::new(),
                     expr: Box::new(e.into()),
                     bracket_token: token,
                     index: Box::new(i),
@@ -1146,105 +1224,125 @@
     // Parse all atomic expressions which don't have to worry about precidence
     // interactions, as they are fully contained.
     #[cfg(feature = "full")]
-    named!(atom_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!(
-        syn!(ExprGroup) => { ExprKind::Group } // must be placed first
+    named!(atom_expr(allow_struct: bool, allow_block: bool) -> Expr, alt!(
+        syn!(ExprGroup) => { Expr::Group } // must be placed first
         |
-        syn!(Lit) => { ExprKind::Lit } // must be before expr_struct
+        syn!(ExprLit) => { Expr::Lit } // must be before expr_struct
         |
         // must be before expr_path
-        cond_reduce!(allow_struct, map!(syn!(ExprStruct), ExprKind::Struct))
+        cond_reduce!(allow_struct, map!(syn!(ExprStruct), Expr::Struct))
         |
-        syn!(ExprParen) => { ExprKind::Paren } // must be before expr_tup
+        syn!(ExprParen) => { Expr::Paren } // must be before expr_tup
         |
-        syn!(Macro) => { ExprKind::Macro } // must be before expr_path
+        syn!(ExprMacro) => { Expr::Macro } // must be before expr_path
         |
         call!(expr_break, allow_struct) // must be before expr_path
         |
-        syn!(ExprContinue) => { ExprKind::Continue } // must be before expr_path
+        syn!(ExprContinue) => { Expr::Continue } // must be before expr_path
         |
         call!(expr_ret, allow_struct) // must be before expr_path
         |
         // NOTE: The `in place { expr }` form. `place <- expr` is parsed above.
-        syn!(ExprInPlace) => { ExprKind::InPlace }
+        syn!(ExprInPlace) => { Expr::InPlace }
         |
-        syn!(ExprArray) => { ExprKind::Array }
+        syn!(ExprArray) => { Expr::Array }
         |
-        syn!(ExprTuple) => { ExprKind::Tuple }
+        syn!(ExprTuple) => { Expr::Tuple }
         |
-        syn!(ExprIf) => { ExprKind::If }
+        syn!(ExprIf) => { Expr::If }
         |
-        syn!(ExprIfLet) => { ExprKind::IfLet }
+        syn!(ExprIfLet) => { Expr::IfLet }
         |
-        syn!(ExprWhile) => { ExprKind::While }
+        syn!(ExprWhile) => { Expr::While }
         |
-        syn!(ExprWhileLet) => { ExprKind::WhileLet }
+        syn!(ExprWhileLet) => { Expr::WhileLet }
         |
-        syn!(ExprForLoop) => { ExprKind::ForLoop }
+        syn!(ExprForLoop) => { Expr::ForLoop }
         |
-        syn!(ExprLoop) => { ExprKind::Loop }
+        syn!(ExprLoop) => { Expr::Loop }
         |
-        syn!(ExprMatch) => { ExprKind::Match }
+        syn!(ExprMatch) => { Expr::Match }
         |
-        syn!(ExprCatch) => { ExprKind::Catch }
+        syn!(ExprCatch) => { Expr::Catch }
         |
-        syn!(ExprYield) => { ExprKind::Yield }
+        syn!(ExprYield) => { Expr::Yield }
         |
-        syn!(ExprUnsafe) => { ExprKind::Unsafe }
+        syn!(ExprUnsafe) => { Expr::Unsafe }
         |
         call!(expr_closure, allow_struct)
         |
-        cond_reduce!(allow_block, map!(syn!(ExprBlock), ExprKind::Block))
+        cond_reduce!(allow_block, map!(syn!(ExprBlock), Expr::Block))
         |
         // NOTE: This is the prefix-form of range
         call!(expr_range, allow_struct)
         |
-        syn!(ExprPath) => { ExprKind::Path }
+        syn!(ExprPath) => { Expr::Path }
         |
-        syn!(ExprRepeat) => { ExprKind::Repeat }
+        syn!(ExprRepeat) => { Expr::Repeat }
     ));
 
     #[cfg(not(feature = "full"))]
-    named!(atom_expr(_allow_struct: bool, _allow_block: bool) -> ExprKind, alt!(
-        syn!(ExprGroup) => { ExprKind::Group } // must be placed first
+    named!(atom_expr(_allow_struct: bool, _allow_block: bool) -> Expr, alt!(
+        syn!(ExprGroup) => { Expr::Group } // must be placed first
         |
-        syn!(Lit) => { ExprKind::Lit } // must be before expr_struct
+        syn!(ExprLit) => { Expr::Lit } // must be before expr_struct
         |
-        syn!(ExprParen) => { ExprKind::Paren } // must be before expr_tup
+        syn!(ExprParen) => { Expr::Paren } // must be before expr_tup
         |
-        syn!(Macro) => { ExprKind::Macro } // must be before expr_path
-        |
-        syn!(ExprPath) => { ExprKind::Path }
+        syn!(ExprPath) => { Expr::Path }
     ));
 
     #[cfg(feature = "full")]
     named!(expr_nosemi -> Expr, map!(alt!(
-        syn!(ExprIf) => { ExprKind::If }
+        syn!(ExprIf) => { Expr::If }
         |
-        syn!(ExprIfLet) => { ExprKind::IfLet }
+        syn!(ExprIfLet) => { Expr::IfLet }
         |
-        syn!(ExprWhile) => { ExprKind::While }
+        syn!(ExprWhile) => { Expr::While }
         |
-        syn!(ExprWhileLet) => { ExprKind::WhileLet }
+        syn!(ExprWhileLet) => { Expr::WhileLet }
         |
-        syn!(ExprForLoop) => { ExprKind::ForLoop }
+        syn!(ExprForLoop) => { Expr::ForLoop }
         |
-        syn!(ExprLoop) => { ExprKind::Loop }
+        syn!(ExprLoop) => { Expr::Loop }
         |
-        syn!(ExprMatch) => { ExprKind::Match }
+        syn!(ExprMatch) => { Expr::Match }
         |
-        syn!(ExprCatch) => { ExprKind::Catch }
+        syn!(ExprCatch) => { Expr::Catch }
         |
-        syn!(ExprYield) => { ExprKind::Yield }
+        syn!(ExprYield) => { Expr::Yield }
         |
-        syn!(ExprUnsafe) => { ExprKind::Unsafe }
+        syn!(ExprUnsafe) => { Expr::Unsafe }
         |
-        syn!(ExprBlock) => { ExprKind::Block }
+        syn!(ExprBlock) => { Expr::Block }
     ), Expr::from));
 
+    impl Synom for ExprLit {
+        named!(parse -> Self, do_parse!(
+            lit: syn!(Lit) >>
+            (ExprLit {
+                attrs: Vec::new(),
+                lit: lit,
+            })
+        ));
+    }
+
+    #[cfg(feature = "full")]
+    impl Synom for ExprMacro {
+        named!(parse -> Self, do_parse!(
+            mac: syn!(Macro) >>
+            (ExprMacro {
+                attrs: Vec::new(),
+                mac: mac,
+            })
+        ));
+    }
+
     impl Synom for ExprGroup {
         named!(parse -> Self, do_parse!(
             e: grouped!(syn!(Expr)) >>
             (ExprGroup {
+                attrs: Vec::new(),
                 expr: Box::new(e.0),
                 group_token: e.1,
             })
@@ -1255,6 +1353,7 @@
         named!(parse -> Self, do_parse!(
             e: parens!(syn!(Expr)) >>
             (ExprParen {
+                attrs: Vec::new(),
                 expr: Box::new(e.0),
                 paren_token: e.1,
             })
@@ -1268,17 +1367,16 @@
             place: expr_no_struct >>
             value: braces!(call!(Block::parse_within)) >>
             (ExprInPlace {
+                attrs: Vec::new(),
                 place: Box::new(place),
                 kind: InPlaceKind::In(in_),
-                value: Box::new(Expr {
-                    node: ExprBlock {
-                        block: Block {
-                            stmts: value.0,
-                            brace_token: value.1,
-                        },
-                    }.into(),
+                value: Box::new(ExprBlock {
                     attrs: Vec::new(),
-                }),
+                    block: Block {
+                        stmts: value.0,
+                        brace_token: value.1,
+                    },
+                }.into()),
             })
         ));
     }
@@ -1288,6 +1386,7 @@
         named!(parse -> Self, do_parse!(
             elems: brackets!(call!(Delimited::parse_terminated)) >>
             (ExprArray {
+                attrs: Vec::new(),
                 exprs: elems.0,
                 bracket_token: elems.1,
             })
@@ -1315,10 +1414,14 @@
                 None => (None, None, None, None),
             };
             ExprMethodCall {
+                attrs: Vec::new(),
                 // this expr will get overwritten after being returned
-                expr: Box::new(ExprKind::Lit(Lit {
-                    span: Span::default(),
-                    value: LitKind::Bool(false),
+                expr: Box::new(Expr::Lit(ExprLit {
+                    attrs: Vec::new(),
+                    lit: Lit {
+                        span: Span::default(),
+                        value: LitKind::Bool(false),
+                    },
                 }).into()),
 
                 method: method,
@@ -1338,6 +1441,7 @@
         named!(parse -> Self, do_parse!(
             elems: parens!(call!(Delimited::parse_terminated)) >>
             (ExprTuple {
+                attrs: Vec::new(),
                 args: elems.0,
                 paren_token: elems.1,
             })
@@ -1355,6 +1459,7 @@
             then_block: braces!(call!(Block::parse_within)) >>
             else_block: option!(else_block) >>
             (ExprIfLet {
+                attrs: Vec::new(),
                 pat: Box::new(pat),
                 let_token: let_,
                 eq_token: eq,
@@ -1378,6 +1483,7 @@
             then_block: braces!(call!(Block::parse_within)) >>
             else_block: option!(else_block) >>
             (ExprIf {
+                attrs: Vec::new(),
                 cond: Box::new(cond),
                 if_true: Block {
                     stmts: then_block.0,
@@ -1391,16 +1497,17 @@
     }
 
     #[cfg(feature = "full")]
-    named!(else_block -> (Token![else], ExprKind), do_parse!(
+    named!(else_block -> (Token![else], Expr), do_parse!(
         else_: keyword!(else) >>
         expr: alt!(
-            syn!(ExprIf) => { ExprKind::If }
+            syn!(ExprIf) => { Expr::If }
             |
-            syn!(ExprIfLet) => { ExprKind::IfLet }
+            syn!(ExprIfLet) => { Expr::IfLet }
             |
             do_parse!(
                 else_block: braces!(call!(Block::parse_within)) >>
-                (ExprKind::Block(ExprBlock {
+                (Expr::Block(ExprBlock {
+                    attrs: Vec::new(),
                     block: Block {
                         stmts: else_block.0,
                         brace_token: else_block.1,
@@ -1421,6 +1528,7 @@
             expr: expr_no_struct >>
             loop_block: syn!(Block) >>
             (ExprForLoop {
+                attrs: Vec::new(),
                 for_token: for_,
                 in_token: in_,
                 pat: Box::new(pat),
@@ -1439,6 +1547,7 @@
             loop_: keyword!(loop) >>
             loop_block: syn!(Block) >>
             (ExprLoop {
+                attrs: Vec::new(),
                 loop_token: loop_,
                 body: loop_block,
                 colon_token: lbl.as_ref().map(|p| Token![:]((p.1).0)),
@@ -1456,6 +1565,7 @@
             ({
                 let (arms, brace) = res;
                 ExprMatch {
+                    attrs: Vec::new(),
                     expr: Box::new(obj),
                     match_token: match_,
                     brace_token: brace,
@@ -1472,6 +1582,7 @@
             catch_: keyword!(catch) >>
             catch_block: syn!(Block) >>
             (ExprCatch {
+                attrs: Vec::new(),
                 block: catch_block,
                 do_token: do_,
                 catch_token: catch_,
@@ -1485,6 +1596,7 @@
             yield_: keyword!(yield) >>
             expr: option!(syn!(Expr)) >>
             (ExprYield {
+                attrs: Vec::new(),
                 yield_token: yield_,
                 expr: expr.map(Box::new),
             })
@@ -1521,7 +1633,7 @@
     }
 
     #[cfg(feature = "full")]
-    named!(expr_closure(allow_struct: bool) -> ExprKind, do_parse!(
+    named!(expr_closure(allow_struct: bool) -> Expr, do_parse!(
         capture: syn!(CaptureBy) >>
         or1: punct!(|) >>
         inputs: call!(Delimited::parse_terminated_with, fn_arg) >>
@@ -1532,7 +1644,8 @@
                 ty: syn!(Type) >>
                 body: syn!(Block) >>
                 (ReturnType::Type(arrow, Box::new(ty)),
-                 ExprKind::Block(ExprBlock {
+                 Expr::Block(ExprBlock {
+                     attrs: Vec::new(),
                     block: body,
                 }).into())
             )
@@ -1540,6 +1653,7 @@
             map!(ambiguous_expr!(allow_struct), |e| (ReturnType::Default, e))
         ) >>
         (ExprClosure {
+            attrs: Vec::new(),
             capture: capture,
             or1_token: or1,
             inputs: inputs,
@@ -1574,6 +1688,7 @@
             cond: expr_no_struct >>
             while_block: syn!(Block) >>
             (ExprWhile {
+                attrs: Vec::new(),
                 while_token: while_,
                 colon_token: lbl.as_ref().map(|p| Token![:]((p.1).0)),
                 cond: Box::new(cond),
@@ -1594,6 +1709,7 @@
             value: expr_no_struct >>
             while_block: syn!(Block) >>
             (ExprWhileLet {
+                attrs: Vec::new(),
                 eq_token: eq,
                 let_token: let_,
                 while_token: while_,
@@ -1612,6 +1728,7 @@
             cont: keyword!(continue) >>
             lbl: option!(syn!(Lifetime)) >>
             (ExprContinue {
+                attrs: Vec::new(),
                 continue_token: cont,
                 label: lbl,
             })
@@ -1619,13 +1736,14 @@
     }
 
     #[cfg(feature = "full")]
-    named!(expr_break(allow_struct: bool) -> ExprKind, do_parse!(
+    named!(expr_break(allow_struct: bool) -> Expr, do_parse!(
         break_: keyword!(break) >>
         lbl: option!(syn!(Lifetime)) >>
         // We can't allow blocks after a `break` expression when we wouldn't
         // allow structs, as this expression is ambiguous.
         val: opt_ambiguous_expr!(allow_struct) >>
         (ExprBreak {
+            attrs: Vec::new(),
             label: lbl,
             expr: val.map(Box::new),
             break_token: break_,
@@ -1633,7 +1751,7 @@
     ));
 
     #[cfg(feature = "full")]
-    named!(expr_ret(allow_struct: bool) -> ExprKind, do_parse!(
+    named!(expr_ret(allow_struct: bool) -> Expr, do_parse!(
         return_: keyword!(return) >>
         // NOTE: return is greedy and eats blocks after it even when in a
         // position where structs are not allowed, such as in if statement
@@ -1642,6 +1760,7 @@
         // if return { println!("A") } {} // Prints "A"
         ret_value: option!(ambiguous_expr!(allow_struct)) >>
         (ExprRet {
+            attrs: Vec::new(),
             expr: ret_value.map(Box::new),
             return_token: return_,
         }.into())
@@ -1671,6 +1790,7 @@
                     None => (None, None),
                 };
                 ExprStruct {
+                    attrs: Vec::new(),
                     brace_token: brace,
                     path: path,
                     fields: fields,
@@ -1699,7 +1819,11 @@
             |
             map!(syn!(Ident), |name| FieldValue {
                 member: Member::Named(name),
-                expr: ExprKind::Path(ExprPath { qself: None, path: name.into() }).into(),
+                expr: Expr::Path(ExprPath {
+                    attrs: Vec::new(),
+                    qself: None,
+                    path: name.into(),
+                }).into(),
                 is_shorthand: true,
                 attrs: Vec::new(),
                 colon_token: None,
@@ -1717,6 +1841,7 @@
                 (value, semi, times)
             )) >>
             (ExprRepeat {
+                attrs: Vec::new(),
                 expr: Box::new((data.0).0),
                 amt: Box::new((data.0).2),
                 bracket_token: data.1,
@@ -1731,6 +1856,7 @@
             unsafe_: keyword!(unsafe) >>
             b: syn!(Block) >>
             (ExprUnsafe {
+                attrs: Vec::new(),
                 unsafe_token: unsafe_,
                 block: b,
             })
@@ -1742,16 +1868,22 @@
         named!(parse -> Self, do_parse!(
             b: syn!(Block) >>
             (ExprBlock {
+                attrs: Vec::new(),
                 block: b,
             })
         ));
     }
 
     #[cfg(feature = "full")]
-    named!(expr_range(allow_struct: bool) -> ExprKind, do_parse!(
+    named!(expr_range(allow_struct: bool) -> Expr, do_parse!(
         limits: syn!(RangeLimits) >>
         hi: opt_ambiguous_expr!(allow_struct) >>
-        (ExprRange { from: None, to: hi.map(Box::new), limits: limits }.into())
+        (ExprRange {
+            attrs: Vec::new(),
+            from: None,
+            to: hi.map(Box::new),
+            limits: limits,
+        }.into())
     ));
 
     #[cfg(feature = "full")]
@@ -1771,6 +1903,7 @@
         named!(parse -> Self, do_parse!(
             pair: qpath >>
             (ExprPath {
+                attrs: Vec::new(),
                 qself: pair.0,
                 path: pair.1,
             })
@@ -1802,7 +1935,7 @@
                 attrs: many0!(Attribute::parse_outer) >>
                 mut e: syn!(Expr) >>
                 ({
-                    e.attrs = attrs;
+                    *e.attrs_mut() = attrs;
                     Stmt::Expr(Box::new(e))
                 })
             )) >>
@@ -1888,7 +2021,7 @@
         not!(punct!(?)) >>
         semi: option!(punct!(;)) >>
         ({
-            e.attrs = attrs;
+            *e.attrs_mut() = attrs;
             if let Some(semi) = semi {
                 Stmt::Semi(Box::new(e), semi)
             } else {
@@ -1903,7 +2036,7 @@
         mut e: syn!(Expr) >>
         semi: punct!(;) >>
         ({
-            e.attrs = attrs;
+            *e.attrs_mut() = attrs;
             Stmt::Semi(Box::new(e), semi)
         })
     ));
@@ -2158,7 +2291,7 @@
     impl Synom for PatLit {
         named!(parse -> Self, do_parse!(
             lit: pat_lit_expr >>
-            (if let ExprKind::Path(_) = lit.node {
+            (if let Expr::Path(_) = lit {
                 return parse_error(); // these need to be parsed by pat_path
             } else {
                 PatLit {
@@ -2186,12 +2319,13 @@
     named!(pat_lit_expr -> Expr, do_parse!(
         neg: option!(punct!(-)) >>
         v: alt!(
-            syn!(Lit) => { ExprKind::Lit }
+            syn!(ExprLit) => { Expr::Lit }
             |
-            syn!(ExprPath) => { ExprKind::Path }
+            syn!(ExprPath) => { Expr::Path }
         ) >>
         (if let Some(neg) = neg {
-            ExprKind::Unary(ExprUnary {
+            Expr::Unary(ExprUnary {
+                attrs: Vec::new(),
                 op: UnOp::Neg(neg),
                 expr: Box::new(v.into())
             }).into()
@@ -2266,7 +2400,7 @@
     // before appending it to `Tokens`.
     #[cfg(feature = "full")]
     fn wrap_bare_struct(tokens: &mut Tokens, e: &Expr) {
-        if let ExprKind::Struct(_) = e.node {
+        if let Expr::Struct(_) = *e {
             token::Paren::default().surround(tokens, |tokens| {
                 e.to_tokens(tokens);
             });
@@ -2275,22 +2409,19 @@
         }
     }
 
-    impl ToTokens for Expr {
-        #[cfg(feature = "full")]
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            tokens.append_all(self.attrs.outer());
-            self.node.to_tokens(tokens)
-        }
+    #[cfg(feature = "full")]
+    fn attrs_to_tokens(attrs: &[Attribute], tokens: &mut Tokens) {
+        tokens.append_all(attrs.outer());
+    }
 
-        #[cfg(not(feature = "full"))]
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.node.to_tokens(tokens)
-        }
+    #[cfg(not(feature = "full"))]
+    fn attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut Tokens) {
     }
 
     #[cfg(feature = "full")]
     impl ToTokens for ExprBox {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.box_token.to_tokens(tokens);
             self.expr.to_tokens(tokens);
         }
@@ -2299,6 +2430,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprInPlace {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             match self.kind {
                 InPlaceKind::Arrow(ref arrow) => {
                     self.place.to_tokens(tokens);
@@ -2310,7 +2442,7 @@
                     self.place.to_tokens(tokens);
                     // NOTE: The second operand must be in a block, add one if
                     // it is not present.
-                    if let ExprKind::Block(_) = self.value.node {
+                    if let Expr::Block(_) = *self.value {
                         self.value.to_tokens(tokens);
                     } else {
                         token::Brace::default().surround(tokens, |tokens| {
@@ -2325,6 +2457,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprArray {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.bracket_token.surround(tokens, |tokens| {
                 self.exprs.to_tokens(tokens);
             })
@@ -2333,6 +2466,7 @@
 
     impl ToTokens for ExprCall {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.func.to_tokens(tokens);
             self.paren_token.surround(tokens, |tokens| {
                 self.args.to_tokens(tokens);
@@ -2343,6 +2477,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprMethodCall {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.expr.to_tokens(tokens);
             self.dot_token.to_tokens(tokens);
             self.method.to_tokens(tokens);
@@ -2361,6 +2496,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprTuple {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.paren_token.surround(tokens, |tokens| {
                 self.args.to_tokens(tokens);
                 // If we only have one argument, we need a trailing comma to
@@ -2374,6 +2510,7 @@
 
     impl ToTokens for ExprBinary {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.left.to_tokens(tokens);
             self.op.to_tokens(tokens);
             self.right.to_tokens(tokens);
@@ -2382,13 +2519,22 @@
 
     impl ToTokens for ExprUnary {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.op.to_tokens(tokens);
             self.expr.to_tokens(tokens);
         }
     }
 
+    impl ToTokens for ExprLit {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
+            self.lit.to_tokens(tokens);
+        }
+    }
+
     impl ToTokens for ExprCast {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.expr.to_tokens(tokens);
             self.as_token.to_tokens(tokens);
             self.ty.to_tokens(tokens);
@@ -2397,6 +2543,7 @@
 
     impl ToTokens for ExprType {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.expr.to_tokens(tokens);
             self.colon_token.to_tokens(tokens);
             self.ty.to_tokens(tokens);
@@ -2414,8 +2561,8 @@
 
             // If we are not one of the valid expressions to exist in an else
             // clause, wrap ourselves in a block.
-            match if_false.node {
-                ExprKind::If(_) | ExprKind::IfLet(_) | ExprKind::Block(_) => {
+            match **if_false {
+                Expr::If(_) | Expr::IfLet(_) | Expr::Block(_) => {
                     if_false.to_tokens(tokens);
                 }
                 _ => {
@@ -2430,6 +2577,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprIf {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.if_token.to_tokens(tokens);
             wrap_bare_struct(tokens, &self.cond);
             self.if_true.to_tokens(tokens);
@@ -2440,6 +2588,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprIfLet {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.if_token.to_tokens(tokens);
             self.let_token.to_tokens(tokens);
             self.pat.to_tokens(tokens);
@@ -2453,6 +2602,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprWhile {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             if self.label.is_some() {
                 self.label.to_tokens(tokens);
                 TokensOrDefault(&self.colon_token).to_tokens(tokens);
@@ -2466,6 +2616,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprWhileLet {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             if self.label.is_some() {
                 self.label.to_tokens(tokens);
                 TokensOrDefault(&self.colon_token).to_tokens(tokens);
@@ -2482,6 +2633,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprForLoop {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             if self.label.is_some() {
                 self.label.to_tokens(tokens);
                 TokensOrDefault(&self.colon_token).to_tokens(tokens);
@@ -2497,6 +2649,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprLoop {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             if self.label.is_some() {
                 self.label.to_tokens(tokens);
                 TokensOrDefault(&self.colon_token).to_tokens(tokens);
@@ -2509,6 +2662,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprMatch {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.match_token.to_tokens(tokens);
             wrap_bare_struct(tokens, &self.expr);
             self.brace_token.surround(tokens, |tokens| {
@@ -2528,6 +2682,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprCatch {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.do_token.to_tokens(tokens);
             self.catch_token.to_tokens(tokens);
             self.block.to_tokens(tokens);
@@ -2537,6 +2692,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprYield {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.yield_token.to_tokens(tokens);
             self.expr.to_tokens(tokens);
         }
@@ -2545,6 +2701,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprClosure {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.capture.to_tokens(tokens);
             self.or1_token.to_tokens(tokens);
             for item in self.inputs.iter() {
@@ -2569,6 +2726,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprUnsafe {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.unsafe_token.to_tokens(tokens);
             self.block.to_tokens(tokens);
         }
@@ -2577,6 +2735,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprBlock {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.block.to_tokens(tokens);
         }
     }
@@ -2584,6 +2743,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprAssign {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.left.to_tokens(tokens);
             self.eq_token.to_tokens(tokens);
             self.right.to_tokens(tokens);
@@ -2593,6 +2753,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprAssignOp {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.left.to_tokens(tokens);
             self.op.to_tokens(tokens);
             self.right.to_tokens(tokens);
@@ -2602,6 +2763,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprField {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.base.to_tokens(tokens);
             self.dot_token.to_tokens(tokens);
             self.member.to_tokens(tokens);
@@ -2630,6 +2792,7 @@
 
     impl ToTokens for ExprIndex {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.expr.to_tokens(tokens);
             self.bracket_token.surround(tokens, |tokens| {
                 self.index.to_tokens(tokens);
@@ -2640,6 +2803,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprRange {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.from.to_tokens(tokens);
             match self.limits {
                 RangeLimits::HalfOpen(ref t) => t.to_tokens(tokens),
@@ -2651,6 +2815,7 @@
 
     impl ToTokens for ExprPath {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             ::PathTokens(&self.qself, &self.path).to_tokens(tokens)
         }
     }
@@ -2658,6 +2823,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprAddrOf {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.and_token.to_tokens(tokens);
             self.mutbl.to_tokens(tokens);
             self.expr.to_tokens(tokens);
@@ -2667,6 +2833,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprBreak {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.break_token.to_tokens(tokens);
             self.label.to_tokens(tokens);
             self.expr.to_tokens(tokens);
@@ -2676,6 +2843,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprContinue {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.continue_token.to_tokens(tokens);
             self.label.to_tokens(tokens);
         }
@@ -2684,14 +2852,24 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprRet {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.return_token.to_tokens(tokens);
             self.expr.to_tokens(tokens);
         }
     }
 
     #[cfg(feature = "full")]
+    impl ToTokens for ExprMacro {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
+            self.mac.to_tokens(tokens);
+        }
+    }
+
+    #[cfg(feature = "full")]
     impl ToTokens for ExprStruct {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.path.to_tokens(tokens);
             self.brace_token.surround(tokens, |tokens| {
                 self.fields.to_tokens(tokens);
@@ -2706,6 +2884,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprRepeat {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.bracket_token.surround(tokens, |tokens| {
                 self.expr.to_tokens(tokens);
                 self.semi_token.to_tokens(tokens);
@@ -2716,6 +2895,7 @@
 
     impl ToTokens for ExprGroup {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.group_token.surround(tokens, |tokens| {
                 self.expr.to_tokens(tokens);
             });
@@ -2724,6 +2904,7 @@
 
     impl ToTokens for ExprParen {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            attrs_to_tokens(&self.attrs, tokens);
             self.paren_token.surround(tokens, |tokens| {
                 self.expr.to_tokens(tokens);
             });
@@ -2733,6 +2914,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for ExprTry {
         fn to_tokens(&self, tokens: &mut Tokens) {
+            tokens.append_all(self.attrs.outer());
             self.expr.to_tokens(tokens);
             self.question_token.to_tokens(tokens);
         }
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 3c7cefc..cdc1a47 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -130,10 +130,12 @@
 
 fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex { fold_expr_index(self, i) }
 
-fn fold_expr_kind(&mut self, i: ExprKind) -> ExprKind { fold_expr_kind(self, i) }
+fn fold_expr_lit(&mut self, i: ExprLit) -> ExprLit { fold_expr_lit(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop { fold_expr_loop(self, i) }
 # [ cfg ( feature = "full" ) ]
+fn fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro { fold_expr_macro(self, i) }
+# [ cfg ( feature = "full" ) ]
 fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch { fold_expr_match(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall { fold_expr_method_call(self, i) }
@@ -793,182 +795,7 @@
 }
 
 pub fn fold_expr<V: Folder + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr {
-    Expr {
-        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
-        node: _visitor.fold_expr_kind(_i . node),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_addr_of<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAddrOf) -> ExprAddrOf {
-    ExprAddrOf {
-        and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
-        mutbl: _visitor.fold_mutability(_i . mutbl),
-        expr: Box::new(_visitor.fold_expr(* _i . expr)),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_array<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
-    ExprArray {
-        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)),
-        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 {
-        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 {
-        left: Box::new(_visitor.fold_expr(* _i . left)),
-        op: _visitor.fold_bin_op(_i . op),
-        right: Box::new(_visitor.fold_expr(* _i . right)),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_block<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBlock) -> ExprBlock {
-    ExprBlock {
-        block: _visitor.fold_block(_i . block),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_box<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox {
-    ExprBox {
-        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)) }),
-    }
-}
-
-pub fn fold_expr_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprCall {
-    ExprCall {
-        func: Box::new(_visitor.fold_expr(* _i . func)),
-        paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
-        args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
-    }
-}
-
-pub fn fold_expr_cast<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCast) -> ExprCast {
-    ExprCast {
-        expr: Box::new(_visitor.fold_expr(* _i . expr)),
-        as_token: Token ! [ as ](tokens_helper(_visitor, &(_i . as_token).0)),
-        ty: Box::new(_visitor.fold_type(* _i . ty)),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_catch<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCatch) -> ExprCatch {
-    ExprCatch {
-        do_token: Token ! [ do ](tokens_helper(_visitor, &(_i . do_token).0)),
-        catch_token: Token ! [ catch ](tokens_helper(_visitor, &(_i . catch_token).0)),
-        block: _visitor.fold_block(_i . block),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_closure<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure {
-    ExprClosure {
-        capture: _visitor.fold_capture_by(_i . capture),
-        or1_token: Token ! [ | ](tokens_helper(_visitor, &(_i . or1_token).0)),
-        inputs: FoldHelper::lift(_i . inputs, |it| { _visitor.fold_fn_arg(it) }),
-        or2_token: Token ! [ | ](tokens_helper(_visitor, &(_i . or2_token).0)),
-        output: _visitor.fold_return_type(_i . output),
-        body: Box::new(_visitor.fold_expr(* _i . body)),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_continue<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue {
-    ExprContinue {
-        continue_token: Token ! [ continue ](tokens_helper(_visitor, &(_i . continue_token).0)),
-        label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
-    }
-}
-# [ cfg ( feature = "full" ) ]
-pub fn fold_expr_field<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprField) -> ExprField {
-    ExprField {
-        base: Box::new(_visitor.fold_expr(* _i . base)),
-        dot_token: Token ! [ . ](tokens_helper(_visitor, &(_i . dot_token).0)),
-        member: _visitor.fold_member(_i . member),
-    }
-}
-# [ 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),
-    }
-}
-
-pub fn fold_expr_group<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup {
-    ExprGroup {
-        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),
-        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 {
-        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" ) ]
-pub fn fold_expr_in_place<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprInPlace) -> ExprInPlace {
-    ExprInPlace {
-        place: Box::new(_visitor.fold_expr(* _i . place)),
-        kind: _visitor.fold_in_place_kind(_i . kind),
-        value: Box::new(_visitor.fold_expr(* _i . value)),
-    }
-}
-
-pub fn fold_expr_index<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> ExprIndex {
-    ExprIndex {
-        expr: Box::new(_visitor.fold_expr(* _i . expr)),
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
-        index: Box::new(_visitor.fold_expr(* _i . index)),
-    }
-}
-
-pub fn fold_expr_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprKind) -> ExprKind {
-    use ::ExprKind::*;
+    use ::Expr::*;
     match _i {
         Box(_binding_0, ) => {
             Box (
@@ -1012,7 +839,7 @@
         }
         Lit(_binding_0, ) => {
             Lit (
-                _visitor.fold_lit(_binding_0),
+                _visitor.fold_expr_lit(_binding_0),
             )
         }
         Cast(_binding_0, ) => {
@@ -1127,7 +954,7 @@
         }
         Macro(_binding_0, ) => {
             Macro (
-                _visitor.fold_macro(_binding_0),
+                full!(_visitor.fold_expr_macro(_binding_0)),
             )
         }
         Struct(_binding_0, ) => {
@@ -1168,8 +995,204 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
+pub fn fold_expr_addr_of<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAddrOf) -> ExprAddrOf {
+    ExprAddrOf {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
+        mutbl: _visitor.fold_mutability(_i . mutbl),
+        expr: Box::new(_visitor.fold_expr(* _i . expr)),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_array<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
+    ExprArray {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(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 {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        left: Box::new(_visitor.fold_expr(* _i . left)),
+        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 {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        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 {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        left: Box::new(_visitor.fold_expr(* _i . left)),
+        op: _visitor.fold_bin_op(_i . op),
+        right: Box::new(_visitor.fold_expr(* _i . right)),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_block<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBlock) -> ExprBlock {
+    ExprBlock {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        block: _visitor.fold_block(_i . block),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_box<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox {
+    ExprBox {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        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 {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        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)) }),
+    }
+}
+
+pub fn fold_expr_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprCall {
+    ExprCall {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        func: Box::new(_visitor.fold_expr(* _i . func)),
+        paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
+        args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
+    }
+}
+
+pub fn fold_expr_cast<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCast) -> ExprCast {
+    ExprCast {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        expr: Box::new(_visitor.fold_expr(* _i . expr)),
+        as_token: Token ! [ as ](tokens_helper(_visitor, &(_i . as_token).0)),
+        ty: Box::new(_visitor.fold_type(* _i . ty)),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_catch<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCatch) -> ExprCatch {
+    ExprCatch {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        do_token: Token ! [ do ](tokens_helper(_visitor, &(_i . do_token).0)),
+        catch_token: Token ! [ catch ](tokens_helper(_visitor, &(_i . catch_token).0)),
+        block: _visitor.fold_block(_i . block),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_closure<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure {
+    ExprClosure {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        capture: _visitor.fold_capture_by(_i . capture),
+        or1_token: Token ! [ | ](tokens_helper(_visitor, &(_i . or1_token).0)),
+        inputs: FoldHelper::lift(_i . inputs, |it| { _visitor.fold_fn_arg(it) }),
+        or2_token: Token ! [ | ](tokens_helper(_visitor, &(_i . or2_token).0)),
+        output: _visitor.fold_return_type(_i . output),
+        body: Box::new(_visitor.fold_expr(* _i . body)),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_continue<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue {
+    ExprContinue {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        continue_token: Token ! [ continue ](tokens_helper(_visitor, &(_i . continue_token).0)),
+        label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_field<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprField) -> ExprField {
+    ExprField {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        base: Box::new(_visitor.fold_expr(* _i . base)),
+        dot_token: Token ! [ . ](tokens_helper(_visitor, &(_i . dot_token).0)),
+        member: _visitor.fold_member(_i . member),
+    }
+}
+# [ cfg ( feature = "full" ) ]
+pub fn fold_expr_for_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprForLoop) -> ExprForLoop {
+    ExprForLoop {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        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),
+    }
+}
+
+pub fn fold_expr_group<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup {
+    ExprGroup {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        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 {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        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),
+        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 {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(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" ) ]
+pub fn fold_expr_in_place<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprInPlace) -> ExprInPlace {
+    ExprInPlace {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        place: Box::new(_visitor.fold_expr(* _i . place)),
+        kind: _visitor.fold_in_place_kind(_i . kind),
+        value: Box::new(_visitor.fold_expr(* _i . value)),
+    }
+}
+
+pub fn fold_expr_index<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> ExprIndex {
+    ExprIndex {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        expr: Box::new(_visitor.fold_expr(* _i . expr)),
+        bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
+        index: Box::new(_visitor.fold_expr(* _i . index)),
+    }
+}
+
+pub fn fold_expr_lit<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprLit) -> ExprLit {
+    ExprLit {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        lit: _visitor.fold_lit(_i . lit),
+    }
+}
+# [ cfg ( feature = "full" ) ]
 pub fn fold_expr_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprLoop) -> ExprLoop {
     ExprLoop {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         label: (_i . label).map(|it| { _visitor.fold_lifetime(it) }),
         colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
         loop_token: Token ! [ loop ](tokens_helper(_visitor, &(_i . loop_token).0)),
@@ -1177,8 +1200,16 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
+pub fn fold_expr_macro<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMacro) -> ExprMacro {
+    ExprMacro {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
+        mac: _visitor.fold_macro(_i . mac),
+    }
+}
+# [ cfg ( feature = "full" ) ]
 pub fn fold_expr_match<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMatch) -> ExprMatch {
     ExprMatch {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         match_token: Token ! [ match ](tokens_helper(_visitor, &(_i . match_token).0)),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         brace_token: Brace(tokens_helper(_visitor, &(_i . brace_token).0)),
@@ -1188,6 +1219,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_method_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMethodCall) -> ExprMethodCall {
     ExprMethodCall {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         dot_token: Token ! [ . ](tokens_helper(_visitor, &(_i . dot_token).0)),
         method: _visitor.fold_ident(_i . method),
@@ -1202,6 +1234,7 @@
 
 pub fn fold_expr_paren<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprParen) -> ExprParen {
     ExprParen {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
     }
@@ -1209,6 +1242,7 @@
 
 pub fn fold_expr_path<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprPath) -> ExprPath {
     ExprPath {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         qself: (_i . qself).map(|it| { _visitor.fold_qself(it) }),
         path: _visitor.fold_path(_i . path),
     }
@@ -1216,6 +1250,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_range<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRange) -> ExprRange {
     ExprRange {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         from: (_i . from).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)) }),
@@ -1224,6 +1259,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_repeat<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat {
     ExprRepeat {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         bracket_token: Bracket(tokens_helper(_visitor, &(_i . bracket_token).0)),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
@@ -1233,6 +1269,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_ret<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRet) -> ExprRet {
     ExprRet {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         return_token: Token ! [ return ](tokens_helper(_visitor, &(_i . return_token).0)),
         expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
     }
@@ -1240,6 +1277,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprStruct) -> ExprStruct {
     ExprStruct {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         path: _visitor.fold_path(_i . path),
         brace_token: Brace(tokens_helper(_visitor, &(_i . brace_token).0)),
         fields: FoldHelper::lift(_i . fields, |it| { _visitor.fold_field_value(it) }),
@@ -1250,6 +1288,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_try<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTry) -> ExprTry {
     ExprTry {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         question_token: Token ! [ ? ](tokens_helper(_visitor, &(_i . question_token).0)),
     }
@@ -1257,6 +1296,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_tuple<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTuple) -> ExprTuple {
     ExprTuple {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         paren_token: Paren(tokens_helper(_visitor, &(_i . paren_token).0)),
         args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
     }
@@ -1264,6 +1304,7 @@
 
 pub fn fold_expr_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprType) -> ExprType {
     ExprType {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i . colon_token).0)),
         ty: Box::new(_visitor.fold_type(* _i . ty)),
@@ -1272,6 +1313,7 @@
 
 pub fn fold_expr_unary<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprUnary) -> ExprUnary {
     ExprUnary {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         op: _visitor.fold_un_op(_i . op),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
     }
@@ -1279,6 +1321,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_unsafe<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprUnsafe) -> ExprUnsafe {
     ExprUnsafe {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         unsafe_token: Token ! [ unsafe ](tokens_helper(_visitor, &(_i . unsafe_token).0)),
         block: _visitor.fold_block(_i . block),
     }
@@ -1286,6 +1329,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_while<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhile) -> ExprWhile {
     ExprWhile {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         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)),
@@ -1296,6 +1340,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_while_let<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhileLet) -> ExprWhileLet {
     ExprWhileLet {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         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)),
@@ -1309,6 +1354,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_expr_yield<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprYield) -> ExprYield {
     ExprYield {
+        attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         yield_token: Token ! [ yield ](tokens_helper(_visitor, &(_i . yield_token).0)),
         expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
     }
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 63f6ae9..c9d7649 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -126,10 +126,12 @@
 
 fn visit_expr_index(&mut self, i: &'ast ExprIndex) { visit_expr_index(self, i) }
 
-fn visit_expr_kind(&mut self, i: &'ast ExprKind) { visit_expr_kind(self, i) }
+fn visit_expr_lit(&mut self, i: &'ast ExprLit) { visit_expr_lit(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_loop(&mut self, i: &'ast ExprLoop) { visit_expr_loop(self, i) }
 # [ cfg ( feature = "full" ) ]
+fn visit_expr_macro(&mut self, i: &'ast ExprMacro) { visit_expr_macro(self, i) }
+# [ cfg ( feature = "full" ) ]
 fn visit_expr_match(&mut self, i: &'ast ExprMatch) { visit_expr_match(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) { visit_expr_method_call(self, i) }
@@ -681,140 +683,7 @@
 }
 
 pub fn visit_expr<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Expr) {
-    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) {
-    tokens_helper(_visitor, &(& _i . and_token).0);
-    _visitor.visit_mutability(& _i . mutbl);
-    _visitor.visit_expr(& * _i . expr);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_array<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprArray) {
-    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);
-    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_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_expr(& * _i . left);
-    _visitor.visit_bin_op(& _i . op);
-    _visitor.visit_expr(& * _i . right);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_block<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBlock) {
-    _visitor.visit_block(& _i . block);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_box<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBox) {
-    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) };
-}
-
-pub fn visit_expr_call<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCall) {
-    _visitor.visit_expr(& * _i . func);
-    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) {
-    _visitor.visit_expr(& * _i . expr);
-    tokens_helper(_visitor, &(& _i . as_token).0);
-    _visitor.visit_type(& * _i . ty);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_catch<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCatch) {
-    tokens_helper(_visitor, &(& _i . do_token).0);
-    tokens_helper(_visitor, &(& _i . catch_token).0);
-    _visitor.visit_block(& _i . block);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_closure<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprClosure) {
-    _visitor.visit_capture_by(& _i . capture);
-    tokens_helper(_visitor, &(& _i . or1_token).0);
-    for el in & _i . inputs { let it = el.item(); _visitor.visit_fn_arg(it) };
-    tokens_helper(_visitor, &(& _i . or2_token).0);
-    _visitor.visit_return_type(& _i . output);
-    _visitor.visit_expr(& * _i . body);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_continue<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprContinue) {
-    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) {
-    _visitor.visit_expr(& * _i . base);
-    tokens_helper(_visitor, &(& _i . dot_token).0);
-    _visitor.visit_member(& _i . member);
-}
-# [ 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);
-}
-
-pub fn visit_expr_group<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprGroup) {
-    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 . 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) {
-    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) {
-    _visitor.visit_expr(& * _i . place);
-    _visitor.visit_in_place_kind(& _i . kind);
-    _visitor.visit_expr(& * _i . value);
-}
-
-pub fn visit_expr_index<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIndex) {
-    _visitor.visit_expr(& * _i . expr);
-    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) {
-    use ::ExprKind::*;
+    use ::Expr::*;
     match *_i {
         Box(ref _binding_0, ) => {
             full!(_visitor.visit_expr_box(_binding_0));
@@ -841,7 +710,7 @@
             _visitor.visit_expr_unary(_binding_0);
         }
         Lit(ref _binding_0, ) => {
-            _visitor.visit_lit(_binding_0);
+            _visitor.visit_expr_lit(_binding_0);
         }
         Cast(ref _binding_0, ) => {
             _visitor.visit_expr_cast(_binding_0);
@@ -910,7 +779,7 @@
             full!(_visitor.visit_expr_ret(_binding_0));
         }
         Macro(ref _binding_0, ) => {
-            _visitor.visit_macro(_binding_0);
+            full!(_visitor.visit_expr_macro(_binding_0));
         }
         Struct(ref _binding_0, ) => {
             full!(_visitor.visit_expr_struct(_binding_0));
@@ -936,14 +805,174 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
+pub fn visit_expr_addr_of<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAddrOf) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    tokens_helper(_visitor, &(& _i . and_token).0);
+    _visitor.visit_mutability(& _i . mutbl);
+    _visitor.visit_expr(& * _i . expr);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_array<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprArray) {
+    for it in & _i . attrs { _visitor.visit_attribute(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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_expr(& * _i . left);
+    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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_expr(& * _i . left);
+    _visitor.visit_bin_op(& _i . op);
+    _visitor.visit_expr(& * _i . right);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_block<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBlock) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_block(& _i . block);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_box<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBox) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    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) };
+}
+
+pub fn visit_expr_call<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCall) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_expr(& * _i . func);
+    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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_expr(& * _i . expr);
+    tokens_helper(_visitor, &(& _i . as_token).0);
+    _visitor.visit_type(& * _i . ty);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_catch<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCatch) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    tokens_helper(_visitor, &(& _i . do_token).0);
+    tokens_helper(_visitor, &(& _i . catch_token).0);
+    _visitor.visit_block(& _i . block);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_closure<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprClosure) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_capture_by(& _i . capture);
+    tokens_helper(_visitor, &(& _i . or1_token).0);
+    for el in & _i . inputs { let it = el.item(); _visitor.visit_fn_arg(it) };
+    tokens_helper(_visitor, &(& _i . or2_token).0);
+    _visitor.visit_return_type(& _i . output);
+    _visitor.visit_expr(& * _i . body);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_continue<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprContinue) {
+    for it in & _i . attrs { _visitor.visit_attribute(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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_expr(& * _i . base);
+    tokens_helper(_visitor, &(& _i . dot_token).0);
+    _visitor.visit_member(& _i . member);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_for_loop<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprForLoop) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    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);
+}
+
+pub fn visit_expr_group<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprGroup) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    tokens_helper(_visitor, &(& _i . if_token).0);
+    _visitor.visit_expr(& * _i . cond);
+    _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_if_let<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIfLet) {
+    for it in & _i . attrs { _visitor.visit_attribute(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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_expr(& * _i . place);
+    _visitor.visit_in_place_kind(& _i . kind);
+    _visitor.visit_expr(& * _i . value);
+}
+
+pub fn visit_expr_index<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIndex) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_expr(& * _i . expr);
+    tokens_helper(_visitor, &(& _i . bracket_token).0);
+    _visitor.visit_expr(& * _i . index);
+}
+
+pub fn visit_expr_lit<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLit) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_lit(& _i . lit);
+}
+# [ cfg ( feature = "full" ) ]
 pub fn visit_expr_loop<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLoop) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     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 . loop_token).0);
     _visitor.visit_block(& _i . body);
 }
 # [ cfg ( feature = "full" ) ]
+pub fn visit_expr_macro<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMacro) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
+    _visitor.visit_macro(& _i . mac);
+}
+# [ cfg ( feature = "full" ) ]
 pub fn visit_expr_match<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMatch) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     tokens_helper(_visitor, &(& _i . match_token).0);
     _visitor.visit_expr(& * _i . expr);
     tokens_helper(_visitor, &(& _i . brace_token).0);
@@ -951,6 +980,7 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_method_call<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMethodCall) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_expr(& * _i . expr);
     tokens_helper(_visitor, &(& _i . dot_token).0);
     _visitor.visit_ident(& _i . method);
@@ -963,22 +993,26 @@
 }
 
 pub fn visit_expr_paren<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprParen) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     if let Some(ref it) = _i . qself { _visitor.visit_qself(it) };
     _visitor.visit_path(& _i . path);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_range<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRange) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     if let Some(ref it) = _i . from { _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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     tokens_helper(_visitor, &(& _i . bracket_token).0);
     _visitor.visit_expr(& * _i . expr);
     tokens_helper(_visitor, &(& _i . semi_token).0);
@@ -986,11 +1020,13 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_ret<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRet) {
+    for it in & _i . attrs { _visitor.visit_attribute(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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_path(& _i . path);
     tokens_helper(_visitor, &(& _i . brace_token).0);
     for el in & _i . fields { let it = el.item(); _visitor.visit_field_value(it) };
@@ -999,32 +1035,38 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_try<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTry) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_expr(& * _i . expr);
     tokens_helper(_visitor, &(& _i . question_token).0);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTuple) {
+    for it in & _i . attrs { _visitor.visit_attribute(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) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_expr(& * _i . expr);
     tokens_helper(_visitor, &(& _i . colon_token).0);
     _visitor.visit_type(& * _i . ty);
 }
 
 pub fn visit_expr_unary<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprUnary) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_un_op(& _i . op);
     _visitor.visit_expr(& * _i . expr);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_unsafe<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprUnsafe) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     tokens_helper(_visitor, &(& _i . unsafe_token).0);
     _visitor.visit_block(& _i . block);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_while<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhile) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     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);
@@ -1033,6 +1075,7 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_while_let<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhileLet) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     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);
@@ -1044,6 +1087,7 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_yield<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprYield) {
+    for it in & _i . attrs { _visitor.visit_attribute(it) };
     tokens_helper(_visitor, &(& _i . yield_token).0);
     if let Some(ref it) = _i . expr { _visitor.visit_expr(& * * it) };
 }
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index f9117f2..c732b4c 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -126,10 +126,12 @@
 
 fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) { visit_expr_index_mut(self, i) }
 
-fn visit_expr_kind_mut(&mut self, i: &mut ExprKind) { visit_expr_kind_mut(self, i) }
+fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) { visit_expr_lit_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) { visit_expr_loop_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
+fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) { visit_expr_macro_mut(self, i) }
+# [ cfg ( feature = "full" ) ]
 fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) { visit_expr_match_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
 fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) { visit_expr_method_call_mut(self, i) }
@@ -681,140 +683,7 @@
 }
 
 pub fn visit_expr_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
-    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) {
-    tokens_helper(_visitor, &mut (& mut _i . and_token).0);
-    _visitor.visit_mutability_mut(& mut _i . mutbl);
-    _visitor.visit_expr_mut(& mut * _i . expr);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_array_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
-    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);
-    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_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_expr_mut(& mut * _i . left);
-    _visitor.visit_bin_op_mut(& mut _i . op);
-    _visitor.visit_expr_mut(& mut * _i . right);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_block_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBlock) {
-    _visitor.visit_block_mut(& mut _i . block);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_box_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) {
-    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) };
-}
-
-pub fn visit_expr_call_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) {
-    _visitor.visit_expr_mut(& mut * _i . func);
-    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) {
-    _visitor.visit_expr_mut(& mut * _i . expr);
-    tokens_helper(_visitor, &mut (& mut _i . as_token).0);
-    _visitor.visit_type_mut(& mut * _i . ty);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_catch_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCatch) {
-    tokens_helper(_visitor, &mut (& mut _i . do_token).0);
-    tokens_helper(_visitor, &mut (& mut _i . catch_token).0);
-    _visitor.visit_block_mut(& mut _i . block);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_closure_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) {
-    _visitor.visit_capture_by_mut(& mut _i . capture);
-    tokens_helper(_visitor, &mut (& mut _i . or1_token).0);
-    for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_fn_arg_mut(it) };
-    tokens_helper(_visitor, &mut (& mut _i . or2_token).0);
-    _visitor.visit_return_type_mut(& mut _i . output);
-    _visitor.visit_expr_mut(& mut * _i . body);
-}
-# [ cfg ( feature = "full" ) ]
-pub fn visit_expr_continue_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) {
-    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) {
-    _visitor.visit_expr_mut(& mut * _i . base);
-    tokens_helper(_visitor, &mut (& mut _i . dot_token).0);
-    _visitor.visit_member_mut(& mut _i . member);
-}
-# [ 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);
-}
-
-pub fn visit_expr_group_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) {
-    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 . 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) {
-    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) {
-    _visitor.visit_expr_mut(& mut * _i . place);
-    _visitor.visit_in_place_kind_mut(& mut _i . kind);
-    _visitor.visit_expr_mut(& mut * _i . value);
-}
-
-pub fn visit_expr_index_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) {
-    _visitor.visit_expr_mut(& mut * _i . expr);
-    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) {
-    use ::ExprKind::*;
+    use ::Expr::*;
     match *_i {
         Box(ref mut _binding_0, ) => {
             full!(_visitor.visit_expr_box_mut(_binding_0));
@@ -841,7 +710,7 @@
             _visitor.visit_expr_unary_mut(_binding_0);
         }
         Lit(ref mut _binding_0, ) => {
-            _visitor.visit_lit_mut(_binding_0);
+            _visitor.visit_expr_lit_mut(_binding_0);
         }
         Cast(ref mut _binding_0, ) => {
             _visitor.visit_expr_cast_mut(_binding_0);
@@ -910,7 +779,7 @@
             full!(_visitor.visit_expr_ret_mut(_binding_0));
         }
         Macro(ref mut _binding_0, ) => {
-            _visitor.visit_macro_mut(_binding_0);
+            full!(_visitor.visit_expr_macro_mut(_binding_0));
         }
         Struct(ref mut _binding_0, ) => {
             full!(_visitor.visit_expr_struct_mut(_binding_0));
@@ -936,14 +805,174 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
+pub fn visit_expr_addr_of_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAddrOf) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    tokens_helper(_visitor, &mut (& mut _i . and_token).0);
+    _visitor.visit_mutability_mut(& mut _i . mutbl);
+    _visitor.visit_expr_mut(& mut * _i . expr);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_array_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_expr_mut(& mut * _i . left);
+    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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _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" ) ]
+pub fn visit_expr_block_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBlock) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_block_mut(& mut _i . block);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_box_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    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) };
+}
+
+pub fn visit_expr_call_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_expr_mut(& mut * _i . func);
+    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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_expr_mut(& mut * _i . expr);
+    tokens_helper(_visitor, &mut (& mut _i . as_token).0);
+    _visitor.visit_type_mut(& mut * _i . ty);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_catch_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCatch) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    tokens_helper(_visitor, &mut (& mut _i . do_token).0);
+    tokens_helper(_visitor, &mut (& mut _i . catch_token).0);
+    _visitor.visit_block_mut(& mut _i . block);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_closure_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_capture_by_mut(& mut _i . capture);
+    tokens_helper(_visitor, &mut (& mut _i . or1_token).0);
+    for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_fn_arg_mut(it) };
+    tokens_helper(_visitor, &mut (& mut _i . or2_token).0);
+    _visitor.visit_return_type_mut(& mut _i . output);
+    _visitor.visit_expr_mut(& mut * _i . body);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_continue_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_expr_mut(& mut * _i . base);
+    tokens_helper(_visitor, &mut (& mut _i . dot_token).0);
+    _visitor.visit_member_mut(& mut _i . member);
+}
+# [ cfg ( feature = "full" ) ]
+pub fn visit_expr_for_loop_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprForLoop) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    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);
+}
+
+pub fn visit_expr_group_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    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 . 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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_expr_mut(& mut * _i . place);
+    _visitor.visit_in_place_kind_mut(& mut _i . kind);
+    _visitor.visit_expr_mut(& mut * _i . value);
+}
+
+pub fn visit_expr_index_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_expr_mut(& mut * _i . expr);
+    tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
+    _visitor.visit_expr_mut(& mut * _i . index);
+}
+
+pub fn visit_expr_lit_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLit) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_lit_mut(& mut _i . lit);
+}
+# [ cfg ( feature = "full" ) ]
 pub fn visit_expr_loop_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLoop) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     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 . loop_token).0);
     _visitor.visit_block_mut(& mut _i . body);
 }
 # [ cfg ( feature = "full" ) ]
+pub fn visit_expr_macro_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMacro) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
+    _visitor.visit_macro_mut(& mut _i . mac);
+}
+# [ cfg ( feature = "full" ) ]
 pub fn visit_expr_match_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMatch) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . match_token).0);
     _visitor.visit_expr_mut(& mut * _i . expr);
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
@@ -951,6 +980,7 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_method_call_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMethodCall) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_expr_mut(& mut * _i . expr);
     tokens_helper(_visitor, &mut (& mut _i . dot_token).0);
     _visitor.visit_ident_mut(& mut _i . method);
@@ -963,22 +993,26 @@
 }
 
 pub fn visit_expr_paren_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     if let Some(ref mut it) = _i . qself { _visitor.visit_qself_mut(it) };
     _visitor.visit_path_mut(& mut _i . path);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_range_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     if let Some(ref mut it) = _i . from { _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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
     _visitor.visit_expr_mut(& mut * _i . expr);
     tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
@@ -986,11 +1020,13 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_ret_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRet) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_path_mut(& mut _i . path);
     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) };
@@ -999,32 +1035,38 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_try_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTry) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_expr_mut(& mut * _i . expr);
     tokens_helper(_visitor, &mut (& mut _i . question_token).0);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTuple) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_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) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_expr_mut(& mut * _i . expr);
     tokens_helper(_visitor, &mut (& mut _i . colon_token).0);
     _visitor.visit_type_mut(& mut * _i . ty);
 }
 
 pub fn visit_expr_unary_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnary) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_un_op_mut(& mut _i . op);
     _visitor.visit_expr_mut(& mut * _i . expr);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_unsafe_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnsafe) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . unsafe_token).0);
     _visitor.visit_block_mut(& mut _i . block);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_while_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     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);
@@ -1033,6 +1075,7 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_while_let_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhileLet) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     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);
@@ -1044,6 +1087,7 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_yield_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) {
+    for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . yield_token).0);
     if let Some(ref mut it) = _i . expr { _visitor.visit_expr_mut(& mut * * it) };
 }
diff --git a/src/helper.rs b/src/helper.rs
index 93df003..d15332e 100644
--- a/src/helper.rs
+++ b/src/helper.rs
@@ -116,14 +116,12 @@
 /// named!(expr_with_arrow_call -> Expr, do_parse!(
 ///     mut e: syn!(Expr) >>
 ///     many0!(tap!(arg: tuple!(punct!(->), syn!(Expr)) => {
-///         e = Expr {
-///             node: ExprCall {
-///                 func: Box::new(e),
-///                 args: vec![arg.1].into(),
-///                 paren_token: Default::default(),
-///             }.into(),
+///         e = Expr::Call(ExprCall {
 ///             attrs: Vec::new(),
-///         };
+///             func: Box::new(e),
+///             args: vec![arg.1].into(),
+///             paren_token: Default::default(),
+///         });
 ///     })) >>
 ///     (e)
 /// ));
diff --git a/src/lib.rs b/src/lib.rs
index 8fd6e0a..ef57cf5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -36,7 +36,7 @@
 pub use expr::{Expr, ExprAddrOf, ExprArray, ExprAssign, ExprAssignOp, ExprBinary, ExprBlock,
                ExprBox, ExprBreak, ExprCall, ExprCast, ExprCatch, ExprClosure, ExprContinue,
                ExprField, ExprForLoop, ExprGroup, ExprIf, ExprIfLet, ExprInPlace, ExprIndex,
-               ExprKind, ExprLoop, ExprMatch, ExprMethodCall, ExprParen, ExprPath, ExprRange,
+               ExprLit, ExprLoop, ExprMacro, ExprMatch, ExprMethodCall, ExprParen, ExprPath, ExprRange,
                ExprRepeat, ExprRet, ExprStruct, ExprTry, ExprTuple, ExprType,
                ExprUnary, ExprUnsafe, ExprWhile, ExprWhileLet, ExprYield};
 
diff --git a/src/ty.rs b/src/ty.rs
index 8176e76..c95bc86 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -695,9 +695,9 @@
             |
             syn!(TypeBinding) => { GenericArgument::TypeBinding }
             |
-            syn!(Lit) => { |l| GenericArgument::Const(ExprKind::Lit(l).into()) }
+            syn!(ExprLit) => { |l| GenericArgument::Const(Expr::Lit(l).into()) }
             |
-            syn!(ExprBlock) => { |b| GenericArgument::Const(ExprKind::Block(b).into()) }
+            syn!(ExprBlock) => { |b| GenericArgument::Const(Expr::Block(b).into()) }
         ));
     }
 
@@ -1029,14 +1029,14 @@
                 GenericArgument::Lifetime(ref lt) => lt.to_tokens(tokens),
                 GenericArgument::Type(ref ty) => ty.to_tokens(tokens),
                 GenericArgument::TypeBinding(ref tb) => tb.to_tokens(tokens),
-                GenericArgument::Const(ref e) => match e.node {
-                    ExprKind::Lit(_) => e.to_tokens(tokens),
+                GenericArgument::Const(ref e) => match *e {
+                    Expr::Lit(_) => e.to_tokens(tokens),
 
                     // NOTE: We should probably support parsing blocks with only
                     // expressions in them without the full feature for const
                     // generics.
                     #[cfg(feature = "full")]
-                    ExprKind::Block(_) => e.to_tokens(tokens),
+                    Expr::Block(_) => e.to_tokens(tokens),
 
                     // ERROR CORRECTION: Add braces to make sure that the
                     // generated code is valid.
diff --git a/tests/test_derive_input.rs b/tests/test_derive_input.rs
index 34c88bb..e0318ff 100644
--- a/tests/test_derive_input.rs
+++ b/tests/test_derive_input.rs
@@ -271,13 +271,13 @@
                     data: VariantData::Unit,
                     discriminant: Some((
                         Default::default(),
-                        Expr {
-                            node: Lit {
+                        Expr::Lit(ExprLit {
+                            attrs: Vec::new(),
+                            lit: Lit {
                                 value: LitKind::Other(Literal::isize(0)),
                                 span: Default::default(),
-                            }.into(),
-                            attrs: Vec::new(),
-                        },
+                            },
+                        }),
                     )),
                 },
                 Variant {
@@ -286,38 +286,34 @@
                     data: VariantData::Unit,
                     discriminant: Some((
                         Default::default(),
-                        Expr {
-                            node: ExprField {
-                                base: Box::new(Expr {
-                                    node: ExprTuple {
-                                        paren_token: Default::default(),
-                                        args: vec![
-                                            Expr {
-                                                node: ExprKind::Lit(Lit {
-                                                    value: LitKind::Other(Literal::integer(0)),
-                                                    span: Default::default(),
-                                                }),
-                                                attrs: Vec::new(),
-                                            },
-                                            Expr {
-                                                node: ExprKind::Lit(Lit {
-                                                    value: LitKind::Other(Literal::string("data")),
-                                                    span: Default::default(),
-                                                }),
-                                                attrs: Vec::new(),
-                                            },
-                                        ].into(),
-                                    }.into(),
-                                    attrs: Vec::new(),
-                                }),
-                                dot_token: Default::default(),
-                                member: Member::Unnamed(Index {
-                                    index: 0,
-                                    span: Default::default(),
-                                }),
-                            }.into(),
+                        Expr::Field(ExprField {
                             attrs: Vec::new(),
-                        },
+                            base: Box::new(Expr::Tuple(ExprTuple {
+                                attrs: Vec::new(),
+                                paren_token: Default::default(),
+                                args: vec![
+                                    Expr::Lit(ExprLit {
+                                        attrs: Vec::new(),
+                                        lit: Lit {
+                                            value: LitKind::Other(Literal::integer(0)),
+                                            span: Default::default(),
+                                        },
+                                    }),
+                                    Expr::Lit(ExprLit {
+                                        attrs: Vec::new(),
+                                        lit: Lit {
+                                            value: LitKind::Other(Literal::string("data")),
+                                            span: Default::default(),
+                                        },
+                                    }),
+                                ].into(),
+                            })),
+                            dot_token: Default::default(),
+                            member: Member::Unnamed(Index {
+                                index: 0,
+                                span: Default::default(),
+                            }),
+                        }),
                     )),
                 },
             ].into(),
diff --git a/tests/test_expr.rs b/tests/test_expr.rs
index 5967aa6..4a76669 100644
--- a/tests/test_expr.rs
+++ b/tests/test_expr.rs
@@ -95,7 +95,7 @@
     assert_let!(Item::Fn(ItemFn { ref block, .. }) = actual.items[1]; {
         assert_let!(Stmt::Local(ref local) = block.stmts[0]; {
             assert_let!(Local { init: Some(ref init_expr), .. } = **local; {
-                assert_let!(Expr { node: ExprKind::Catch(..), .. } = **init_expr);
+                assert_let!(Expr::Catch(..) = **init_expr);
             });
         });
 
@@ -106,21 +106,21 @@
         });
 
         assert_let!(Stmt::Expr(ref expr) = block.stmts[3]; {
-            assert_let!(Expr { node: ExprKind::While(ExprWhile { ref cond, .. }), .. } = **expr; {
-                assert_let!(Expr { node: ExprKind::Path(ExprPath { qself: None, ref path }), .. } = **cond; {
+            assert_let!(Expr::While(ExprWhile { ref cond, .. }) = **expr; {
+                assert_let!(Expr::Path(ExprPath { qself: None, ref path, .. }) = **cond; {
                     assert_eq!(*path, "catch".into());
                 });
             });
         });
 
         assert_let!(Stmt::Semi(ref expr, _) = block.stmts[5]; {
-            assert_let!(Expr { node: ExprKind::Assign(ExprAssign { ref left, ref right, .. }), .. } = **expr; {
-                assert_let!(Expr { node: ExprKind::Path(ExprPath { qself: None, ref path }), .. } = **left; {
+            assert_let!(Expr::Assign(ExprAssign { ref left, ref right, .. }) = **expr; {
+                assert_let!(Expr::Path(ExprPath { qself: None, ref path, .. }) = **left; {
                     assert_eq!(*path, "catch".into());
                 });
 
-                assert_let!(Expr { node: ExprKind::If(ExprIf { ref cond, .. }), .. } = **right; {
-                    assert_let!(Expr { node: ExprKind::Path(ExprPath { qself: None, ref path }), .. } = **cond; {
+                assert_let!(Expr::If(ExprIf { ref cond, .. }) = **right; {
+                    assert_let!(Expr::Path(ExprPath { qself: None, ref path, .. }) = **cond; {
                         assert_eq!(*path, "catch".into());
                     });
                 });
@@ -128,8 +128,8 @@
         });
 
         assert_let!(Stmt::Semi(ref expr, _) = block.stmts[7]; {
-            assert_let!(Expr { node: ExprKind::Match(ExprMatch { ref expr, .. }), .. } = **expr; {
-                assert_let!(Expr { node: ExprKind::Path(ExprPath { qself: None, ref path }), .. } = **expr; {
+            assert_let!(Expr::Match(ExprMatch { ref expr, .. }) = **expr; {
+                assert_let!(Expr::Path(ExprPath { qself: None, ref path, .. }) = **expr; {
                     assert_eq!(*path, "catch".into());
                 });
             });
diff --git a/tests/test_grouping.rs b/tests/test_grouping.rs
index f532639..b09225e 100644
--- a/tests/test_grouping.rs
+++ b/tests/test_grouping.rs
@@ -3,7 +3,7 @@
 
 #[macro_use]
 extern crate syn;
-use syn::{BinOp, Expr, ExprBinary, ExprGroup, ExprKind, Lit, LitKind};
+use syn::{BinOp, Expr, ExprBinary, ExprGroup, ExprLit, Lit, LitKind};
 use syn::token::Group;
 
 extern crate proc_macro2;
@@ -18,14 +18,17 @@
     }
 }
 
-fn expr<T: Into<ExprKind>>(t: T) -> Expr {
-    t.into().into()
+fn expr<T: Into<Expr>>(t: T) -> Expr {
+    t.into()
 }
 
 fn lit<T: Into<Literal>>(t: T) -> Expr {
-    expr(Lit {
-        value: LitKind::Other(t.into()),
-        span: Span::default(),
+    Expr::Lit(ExprLit {
+        attrs: Vec::new(),
+        lit: Lit {
+            value: LitKind::Other(t.into()),
+            span: Span::default(),
+        },
     })
 }
 
@@ -53,12 +56,16 @@
     assert_eq!(
         common::parse::syn::<Expr>(raw),
         expr(ExprBinary {
+            attrs: Vec::new(),
             left: Box::new(lit(Literal::i32(1))),
             op: BinOp::Add(<Token![+]>::default()),
             right: Box::new(expr(ExprBinary {
+                attrs: Vec::new(),
                 left: Box::new(expr(ExprGroup {
+                    attrs: Vec::new(),
                     group_token: Group::default(),
                     expr: Box::new(expr(ExprBinary {
+                        attrs: Vec::new(),
                         left: Box::new(lit(Literal::i32(2))),
                         op: BinOp::Add(<Token![+]>::default()),
                         right: Box::new(lit(Literal::i32(3))),
@@ -95,13 +102,16 @@
     assert_eq!(
         common::parse::syn::<Expr>(raw),
         expr(ExprBinary {
+            attrs: Vec::new(),
             left: Box::new(expr(ExprBinary {
+                attrs: Vec::new(),
                 left: Box::new(lit(Literal::i32(1))),
                 op: BinOp::Add(<Token![+]>::default()),
                 right: Box::new(lit(Literal::i32(2))),
             })),
             op: BinOp::Add(<Token![+]>::default()),
             right: Box::new(expr(ExprBinary {
+                attrs: Vec::new(),
                 left: Box::new(lit(Literal::i32(3))),
                 op: BinOp::Mul(<Token![*]>::default()),
                 right: Box::new(lit(Literal::i32(4))),
diff --git a/tests/test_precedence.rs b/tests/test_precedence.rs
index d8dc4ed..9071b04 100644
--- a/tests/test_precedence.rs
+++ b/tests/test_precedence.rs
@@ -292,15 +292,15 @@
 fn syn_brackets(syn_expr: syn::Expr) -> syn::Expr {
     use syn::*;
     use syn::fold::*;
+    use std::mem;
 
-    fn paren(folder: &mut BracketsFolder, node: ExprKind) -> ExprKind {
-        ExprKind::Paren(ExprParen {
+    fn paren(folder: &mut BracketsFolder, mut node: Expr) -> Expr {
+        let attrs = mem::replace(node.attrs_mut(), Vec::new());
+        Expr::Paren(ExprParen {
+            attrs: attrs,
             expr: Box::new(fold_expr(
                 folder,
-                Expr {
-                    node: node,
-                    attrs: vec![],
-                },
+                node,
             )),
             paren_token: token::Paren::default(),
         })
@@ -309,19 +309,17 @@
     struct BracketsFolder;
     impl Folder for BracketsFolder {
         fn fold_expr(&mut self, expr: Expr) -> Expr {
-            let kind = match expr.node {
-                ExprKind::Group(_) => unreachable!(),
-                ExprKind::Paren(p) => paren(self, p.expr.node),
-                ExprKind::If(..)
-                | ExprKind::Unsafe(..)
-                | ExprKind::Block(..)
-                | ExprKind::IfLet(..) => {
+            match expr {
+                Expr::Group(_) => unreachable!(),
+                Expr::Paren(p) => paren(self, *p.expr),
+                Expr::If(..)
+                | Expr::Unsafe(..)
+                | Expr::Block(..)
+                | Expr::IfLet(..) => {
                     return fold_expr(self, expr);
                 }
                 node => paren(self, node),
-            };
-
-            Expr { node: kind, ..expr }
+            }
         }
 
         fn fold_stmt(&mut self, stmt: Stmt) -> Stmt {
@@ -360,13 +358,11 @@
         fn fold_expr(&mut self, expr: Expr) -> Expr {
             self.0.push(expr);
 
-            Expr {
-                node: ExprKind::Tuple(ExprTuple {
-                    args: Delimited::new(),
-                    paren_token: token::Paren::default(),
-                }),
+            Expr::Tuple(ExprTuple {
                 attrs: vec![],
-            }
+                args: Delimited::new(),
+                paren_token: token::Paren::default(),
+            })
         }
     }