diff --git a/src/expr.rs b/src/expr.rs
index 4cef442..225fc65 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -586,11 +586,9 @@
         pub attrs: Vec<Attribute>,
         pub let_token: Token![let],
         pub pat: Box<Pat>,
-        pub colon_token: Option<Token![:]>,
-        pub ty: Option<Box<Type>>,
-        pub eq_token: Option<Token![=]>,
+        pub ty: Option<(Token![:], Box<Type>)>,
         /// Initializer expression to set the value, if any
-        pub init: Option<Box<Expr>>,
+        pub init: Option<(Token![=], Box<Expr>)>,
         pub semi_token: Token![;],
     }
 }
@@ -614,8 +612,7 @@
             pub by_ref: Option<Token![ref]>,
             pub mutability: Option<Token![mut]>,
             pub ident: Ident,
-            pub at_token: Option<Token![@]>,
-            pub subpat: Option<Box<Pat>>,
+            pub subpat: Option<(Token![@], Box<Pat>)>,
         }),
 
         /// A struct or struct variant pattern, e.g. `Variant {x, y, ..}`.
@@ -735,8 +732,7 @@
     pub struct Arm {
         pub attrs: Vec<Attribute>,
         pub pats: Delimited<Pat, Token![|]>,
-        pub if_token: Option<Token![if]>,
-        pub guard: Option<Box<Expr>>,
+        pub guard: Option<(Token![if], Box<Expr>)>,
         pub rocket_token: Token![=>],
         pub body: Box<Expr>,
         pub comma: Option<Token![,]>,
@@ -1679,10 +1675,9 @@
             ) >>
             (Arm {
                 rocket_token: rocket,
-                if_token: guard.as_ref().map(|p| Token![if]((p.0).0)),
                 attrs: attrs,
                 pats: pats,
-                guard: guard.map(|p| Box::new(p.1)),
+                guard: guard.map(|(if_, guard)| (if_, Box::new(guard))),
                 body: Box::new(body.0),
                 comma: body.1,
             })
@@ -2062,14 +2057,12 @@
         init: option!(tuple!(punct!(=), syn!(Expr))) >>
         semi: punct!(;) >>
         (Stmt::Local(Box::new(Local {
-            let_token: let_,
-            semi_token: semi,
-            colon_token: ty.as_ref().map(|p| Token![:]((p.0).0)),
-            eq_token: init.as_ref().map(|p| Token![=]((p.0).0)),
-            pat: Box::new(pat),
-            ty: ty.map(|p| Box::new(p.1)),
-            init: init.map(|p| Box::new(p.1)),
             attrs: attrs,
+            let_token: let_,
+            pat: Box::new(pat),
+            ty: ty.map(|(colon, ty)| (colon, Box::new(ty))),
+            init: init.map(|(eq, expr)| (eq, Box::new(expr))),
+            semi_token: semi,
         })))
     ));
 
@@ -2172,8 +2165,7 @@
                 by_ref: by_ref,
                 mutability: mutability,
                 ident: name,
-                at_token: subpat.as_ref().map(|p| Token![@]((p.0).0)),
-                subpat: subpat.map(|p| Box::new(p.1)),
+                subpat: subpat.map(|(at, pat)| (at, Box::new(pat))),
             })
         ));
     }
@@ -2237,7 +2229,6 @@
                         mutability: mutability,
                         ident: ident,
                         subpat: None,
-                        at_token: None,
                     }.into();
                     if let Some(boxed) = boxed {
                         pat = PatBox {
@@ -2985,9 +2976,9 @@
         fn to_tokens(&self, tokens: &mut Tokens) {
             tokens.append_all(&self.attrs);
             self.pats.to_tokens(tokens);
-            if self.guard.is_some() {
-                TokensOrDefault(&self.if_token).to_tokens(tokens);
-                self.guard.to_tokens(tokens);
+            if let Some((ref if_token, ref guard)) = self.guard {
+                if_token.to_tokens(tokens);
+                guard.to_tokens(tokens);
             }
             self.rocket_token.to_tokens(tokens);
             self.body.to_tokens(tokens);
@@ -3008,9 +2999,9 @@
             self.by_ref.to_tokens(tokens);
             self.mutability.to_tokens(tokens);
             self.ident.to_tokens(tokens);
-            if self.subpat.is_some() {
-                TokensOrDefault(&self.at_token).to_tokens(tokens);
-                self.subpat.to_tokens(tokens);
+            if let Some((ref at_token, ref subpat)) = self.subpat {
+                at_token.to_tokens(tokens);
+                subpat.to_tokens(tokens);
             }
         }
     }
@@ -3193,13 +3184,13 @@
             tokens.append_all(self.attrs.outer());
             self.let_token.to_tokens(tokens);
             self.pat.to_tokens(tokens);
-            if self.ty.is_some() {
-                TokensOrDefault(&self.colon_token).to_tokens(tokens);
-                self.ty.to_tokens(tokens);
+            if let Some((ref colon_token, ref ty)) = self.ty {
+                colon_token.to_tokens(tokens);
+                ty.to_tokens(tokens);
             }
-            if self.init.is_some() {
-                TokensOrDefault(&self.eq_token).to_tokens(tokens);
-                self.init.to_tokens(tokens);
+            if let Some((ref eq_token, ref init)) = self.init {
+                eq_token.to_tokens(tokens);
+                init.to_tokens(tokens);
             }
             self.semi_token.to_tokens(tokens);
         }
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 1f60d88..3013ab5 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -453,8 +453,10 @@
     Arm {
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
-        if_token: (_i . if_token).map(|it| { Token ! [ if ](tokens_helper(_visitor, &(it).0)) }),
-        guard: (_i . guard).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
+        guard: (_i . guard).map(|it| { (
+            Token ! [ if ](tokens_helper(_visitor, &(( it ) . 0).0)),
+            Box::new(_visitor.fold_expr(* ( it ) . 1)),
+        ) }),
         rocket_token: Token ! [ => ](tokens_helper(_visitor, &(_i . rocket_token).0)),
         body: Box::new(_visitor.fold_expr(* _i . body)),
         comma: (_i . comma).map(|it| { Token ! [ , ](tokens_helper(_visitor, &(it).0)) }),
@@ -1928,10 +1930,14 @@
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         let_token: Token ! [ let ](tokens_helper(_visitor, &(_i . let_token).0)),
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
-        colon_token: (_i . colon_token).map(|it| { Token ! [ : ](tokens_helper(_visitor, &(it).0)) }),
-        ty: (_i . ty).map(|it| { Box::new(_visitor.fold_type(* it)) }),
-        eq_token: (_i . eq_token).map(|it| { Token ! [ = ](tokens_helper(_visitor, &(it).0)) }),
-        init: (_i . init).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
+        ty: (_i . ty).map(|it| { (
+            Token ! [ : ](tokens_helper(_visitor, &(( it ) . 0).0)),
+            Box::new(_visitor.fold_type(* ( it ) . 1)),
+        ) }),
+        init: (_i . init).map(|it| { (
+            Token ! [ = ](tokens_helper(_visitor, &(( it ) . 0).0)),
+            Box::new(_visitor.fold_expr(* ( it ) . 1)),
+        ) }),
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i . semi_token).0)),
     }
 }
@@ -2123,8 +2129,10 @@
         by_ref: (_i . by_ref).map(|it| { Token ! [ ref ](tokens_helper(_visitor, &(it).0)) }),
         mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         ident: _visitor.fold_ident(_i . ident),
-        at_token: (_i . at_token).map(|it| { Token ! [ @ ](tokens_helper(_visitor, &(it).0)) }),
-        subpat: (_i . subpat).map(|it| { Box::new(_visitor.fold_pat(* it)) }),
+        subpat: (_i . subpat).map(|it| { (
+            Token ! [ @ ](tokens_helper(_visitor, &(( it ) . 0).0)),
+            Box::new(_visitor.fold_pat(* ( it ) . 1)),
+        ) }),
     }
 }
 # [ cfg ( feature = "full" ) ]
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index df1f9d6..120d1fd 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -428,8 +428,10 @@
 pub fn visit_arm<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Arm) {
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     for el in & _i . pats { let it = el.item(); _visitor.visit_pat(it) };
-    if let Some(ref it) = _i . if_token { tokens_helper(_visitor, &(it).0) };
-    if let Some(ref it) = _i . guard { _visitor.visit_expr(& * * it) };
+    if let Some(ref it) = _i . guard { 
+            tokens_helper(_visitor, &(& ( it ) . 0).0);
+            _visitor.visit_expr(& * ( it ) . 1);
+         };
     tokens_helper(_visitor, &(& _i . rocket_token).0);
     _visitor.visit_expr(& * _i . body);
     if let Some(ref it) = _i . comma { tokens_helper(_visitor, &(it).0) };
@@ -1519,10 +1521,14 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     tokens_helper(_visitor, &(& _i . let_token).0);
     _visitor.visit_pat(& * _i . pat);
-    if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
-    if let Some(ref it) = _i . ty { _visitor.visit_type(& * * it) };
-    if let Some(ref it) = _i . eq_token { tokens_helper(_visitor, &(it).0) };
-    if let Some(ref it) = _i . init { _visitor.visit_expr(& * * it) };
+    if let Some(ref it) = _i . ty { 
+            tokens_helper(_visitor, &(& ( it ) . 0).0);
+            _visitor.visit_type(& * ( it ) . 1);
+         };
+    if let Some(ref it) = _i . init { 
+            tokens_helper(_visitor, &(& ( it ) . 0).0);
+            _visitor.visit_expr(& * ( it ) . 1);
+         };
     tokens_helper(_visitor, &(& _i . semi_token).0);
 }
 
@@ -1658,8 +1664,10 @@
     if let Some(ref it) = _i . by_ref { tokens_helper(_visitor, &(it).0) };
     if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_ident(& _i . ident);
-    if let Some(ref it) = _i . at_token { tokens_helper(_visitor, &(it).0) };
-    if let Some(ref it) = _i . subpat { _visitor.visit_pat(& * * it) };
+    if let Some(ref it) = _i . subpat { 
+            tokens_helper(_visitor, &(& ( it ) . 0).0);
+            _visitor.visit_pat(& * ( it ) . 1);
+         };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_lit<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatLit) {
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index d8f10fa..00d9c17 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -428,8 +428,10 @@
 pub fn visit_arm_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     for mut el in & mut _i . pats { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
-    if let Some(ref mut it) = _i . if_token { tokens_helper(_visitor, &mut (it).0) };
-    if let Some(ref mut it) = _i . guard { _visitor.visit_expr_mut(& mut * * it) };
+    if let Some(ref mut it) = _i . guard { 
+            tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
+            _visitor.visit_expr_mut(& mut * ( it ) . 1);
+         };
     tokens_helper(_visitor, &mut (& mut _i . rocket_token).0);
     _visitor.visit_expr_mut(& mut * _i . body);
     if let Some(ref mut it) = _i . comma { tokens_helper(_visitor, &mut (it).0) };
@@ -1519,10 +1521,14 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . let_token).0);
     _visitor.visit_pat_mut(& mut * _i . pat);
-    if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
-    if let Some(ref mut it) = _i . ty { _visitor.visit_type_mut(& mut * * it) };
-    if let Some(ref mut it) = _i . eq_token { tokens_helper(_visitor, &mut (it).0) };
-    if let Some(ref mut it) = _i . init { _visitor.visit_expr_mut(& mut * * it) };
+    if let Some(ref mut it) = _i . ty { 
+            tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
+            _visitor.visit_type_mut(& mut * ( it ) . 1);
+         };
+    if let Some(ref mut it) = _i . init { 
+            tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
+            _visitor.visit_expr_mut(& mut * ( it ) . 1);
+         };
     tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
 }
 
@@ -1658,8 +1664,10 @@
     if let Some(ref mut it) = _i . by_ref { tokens_helper(_visitor, &mut (it).0) };
     if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_ident_mut(& mut _i . ident);
-    if let Some(ref mut it) = _i . at_token { tokens_helper(_visitor, &mut (it).0) };
-    if let Some(ref mut it) = _i . subpat { _visitor.visit_pat_mut(& mut * * it) };
+    if let Some(ref mut it) = _i . subpat { 
+            tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
+            _visitor.visit_pat_mut(& mut * ( it ) . 1);
+         };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_lit_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatLit) {
diff --git a/tests/test_expr.rs b/tests/test_expr.rs
index 66da76e..821e37a 100644
--- a/tests/test_expr.rs
+++ b/tests/test_expr.rs
@@ -94,7 +94,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!(Local { init: Some((_, ref init_expr)), .. } = **local; {
                 assert_let!(Expr::Catch(..) = **init_expr);
             });
         });