diff --git a/src/expr.rs b/src/expr.rs
index 2213966..7c46224 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -270,7 +270,7 @@
         pub AddrOf(ExprAddrOf #full {
             pub attrs: Vec<Attribute>,
             pub and_token: Token![&],
-            pub mutbl: Mutability,
+            pub mutability: Option<Token![mut]>,
             pub expr: Box<Expr>,
         }),
 
@@ -573,8 +573,8 @@
         /// field must be `None`). Disambiguation cannot be done with parser alone, so it happens
         /// during name resolution.
         pub Ident(PatIdent {
-            pub mode: Option<Token![ref]>,
-            pub mutability: Mutability,
+            pub by_ref: Option<Token![ref]>,
+            pub mutability: Option<Token![mut]>,
             pub ident: Ident,
             pub at_token: Option<Token![@]>,
             pub subpat: Option<Box<Pat>>,
@@ -624,7 +624,7 @@
         /// A reference pattern, e.g. `&mut (a, b)`
         pub Ref(PatRef {
             pub and_token: Token![&],
-            pub mutbl: Mutability,
+            pub mutability: Option<Token![mut]>,
             pub pat: Box<Pat>,
         }),
         /// A literal
@@ -1118,12 +1118,12 @@
         |
         do_parse!(
             and: punct!(&) >>
-            mutability: syn!(Mutability) >>
+            mutability: option!(keyword!(mut)) >>
             expr: call!(unary_expr, allow_struct, true) >>
             (ExprAddrOf {
                 attrs: Vec::new(),
                 and_token: and,
-                mutbl: mutability,
+                mutability: mutability,
                 expr: Box::new(expr.into()),
             }.into())
         )
@@ -2087,8 +2087,8 @@
     #[cfg(feature = "full")]
     impl Synom for PatIdent {
         named!(parse -> Self, do_parse!(
-            mode: option!(keyword!(ref)) >>
-            mutability: syn!(Mutability) >>
+            by_ref: option!(keyword!(ref)) >>
+            mutability: option!(keyword!(mut)) >>
             name: alt!(
                 syn!(Ident)
                 |
@@ -2098,7 +2098,7 @@
             not!(punct!(::)) >>
             subpat: option!(tuple!(punct!(@), syn!(Pat))) >>
             (PatIdent {
-                mode: mode,
+                by_ref: by_ref,
                 mutability: mutability,
                 ident: name,
                 at_token: subpat.as_ref().map(|p| Token![@]((p.0).0)),
@@ -2157,12 +2157,12 @@
             |
             do_parse!(
                 boxed: option!(keyword!(box)) >>
-                mode: option!(keyword!(ref)) >>
-                mutability: syn!(Mutability) >>
+                by_ref: option!(keyword!(ref)) >>
+                mutability: option!(keyword!(mut)) >>
                 ident: syn!(Ident) >>
                 ({
                     let mut pat: Pat = PatIdent {
-                        mode: mode,
+                        by_ref: by_ref,
                         mutability: mutability,
                         ident: ident,
                         subpat: None,
@@ -2257,11 +2257,11 @@
     impl Synom for PatRef {
         named!(parse -> Self, do_parse!(
             and: punct!(&) >>
-            mutability: syn!(Mutability) >>
+            mutability: option!(keyword!(mut)) >>
             pat: syn!(Pat) >>
             (PatRef {
                 pat: Box::new(pat),
-                mutbl: mutability,
+                mutability: mutability,
                 and_token: and,
             })
         ));
@@ -2794,7 +2794,7 @@
         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.mutability.to_tokens(tokens);
             self.expr.to_tokens(tokens);
         }
     }
@@ -2927,7 +2927,7 @@
     #[cfg(feature = "full")]
     impl ToTokens for PatIdent {
         fn to_tokens(&self, tokens: &mut Tokens) {
-            self.mode.to_tokens(tokens);
+            self.by_ref.to_tokens(tokens);
             self.mutability.to_tokens(tokens);
             self.ident.to_tokens(tokens);
             if self.subpat.is_some() {
@@ -3001,7 +3001,7 @@
     impl ToTokens for PatRef {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.and_token.to_tokens(tokens);
-            self.mutbl.to_tokens(tokens);
+            self.mutability.to_tokens(tokens);
             self.pat.to_tokens(tokens);
         }
     }
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index e623a0e..0e93754 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -266,8 +266,6 @@
 
 fn fold_mut_type(&mut self, i: MutType) -> MutType { fold_mut_type(self, i) }
 
-fn fold_mutability(&mut self, i: Mutability) -> Mutability { fold_mutability(self, i) }
-
 fn fold_nested_meta_item(&mut self, i: NestedMetaItem) -> NestedMetaItem { fold_nested_meta_item(self, i) }
 
 fn fold_parenthesized_generic_arguments(&mut self, i: ParenthesizedGenericArguments) -> ParenthesizedGenericArguments { fold_parenthesized_generic_arguments(self, i) }
@@ -445,7 +443,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_arg_self<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgSelf) -> ArgSelf {
     ArgSelf {
-        mutbl: _visitor.fold_mutability(_i . mutbl),
+        mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         self_token: Token ! [ self ](tokens_helper(_visitor, &(_i . self_token).0)),
     }
 }
@@ -454,7 +452,7 @@
     ArgSelfRef {
         and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
         lifetime: (_i . lifetime).map(|it| { _visitor.fold_lifetime(it) }),
-        mutbl: _visitor.fold_mutability(_i . mutbl),
+        mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         self_token: Token ! [ self ](tokens_helper(_visitor, &(_i . self_token).0)),
     }
 }
@@ -978,7 +976,7 @@
     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),
+        mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
     }
 }
@@ -1454,7 +1452,7 @@
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         vis: _visitor.fold_visibility(_i . vis),
         static_token: Token ! [ static ](tokens_helper(_visitor, &(_i . static_token).0)),
-        mutbl: _visitor.fold_mutability(_i . mutbl),
+        mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         ident: _visitor.fold_ident(_i . ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i . colon_token).0)),
         ty: Box::new(_visitor.fold_type(* _i . ty)),
@@ -1854,7 +1852,7 @@
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         vis: _visitor.fold_visibility(_i . vis),
         static_token: Token ! [ static ](tokens_helper(_visitor, &(_i . static_token).0)),
-        mutbl: _visitor.fold_mutability(_i . mutbl),
+        mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         ident: _visitor.fold_ident(_i . ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i . colon_token).0)),
         ty: Box::new(_visitor.fold_type(* _i . ty)),
@@ -2039,23 +2037,11 @@
 
 pub fn fold_mut_type<V: Folder + ?Sized>(_visitor: &mut V, _i: MutType) -> MutType {
     MutType {
-        mutability: _visitor.fold_mutability(_i . mutability),
+        mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         ty: _visitor.fold_type(_i . ty),
     }
 }
 
-pub fn fold_mutability<V: Folder + ?Sized>(_visitor: &mut V, _i: Mutability) -> Mutability {
-    use ::Mutability::*;
-    match _i {
-        Mutable(_binding_0, ) => {
-            Mutable (
-                Token ! [ mut ](tokens_helper(_visitor, &(_binding_0).0)),
-            )
-        }
-        Immutable => { Immutable }
-    }
-}
-
 pub fn fold_nested_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: NestedMetaItem) -> NestedMetaItem {
     use ::NestedMetaItem::*;
     match _i {
@@ -2155,8 +2141,8 @@
 # [ cfg ( feature = "full" ) ]
 pub fn fold_pat_ident<V: Folder + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatIdent {
     PatIdent {
-        mode: (_i . mode).map(|it| { Token ! [ ref ](tokens_helper(_visitor, &(it).0)) }),
-        mutability: _visitor.fold_mutability(_i . mutability),
+        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)) }),
@@ -2187,7 +2173,7 @@
 pub fn fold_pat_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
     PatRef {
         and_token: Token ! [ & ](tokens_helper(_visitor, &(_i . and_token).0)),
-        mutbl: _visitor.fold_mutability(_i . mutbl),
+        mutability: (_i . mutability).map(|it| { Token ! [ mut ](tokens_helper(_visitor, &(it).0)) }),
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
     }
 }
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index bf8739e..2f3f414 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -262,8 +262,6 @@
 
 fn visit_mut_type(&mut self, i: &'ast MutType) { visit_mut_type(self, i) }
 
-fn visit_mutability(&mut self, i: &'ast Mutability) { visit_mutability(self, i) }
-
 fn visit_nested_meta_item(&mut self, i: &'ast NestedMetaItem) { visit_nested_meta_item(self, i) }
 
 fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) { visit_parenthesized_generic_arguments(self, i) }
@@ -422,14 +420,14 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_arg_self<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgSelf) {
-    _visitor.visit_mutability(& _i . mutbl);
+    if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     tokens_helper(_visitor, &(& _i . self_token).0);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_arg_self_ref<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgSelfRef) {
     tokens_helper(_visitor, &(& _i . and_token).0);
     if let Some(ref it) = _i . lifetime { _visitor.visit_lifetime(it) };
-    _visitor.visit_mutability(& _i . mutbl);
+    if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     tokens_helper(_visitor, &(& _i . self_token).0);
 }
 # [ cfg ( feature = "full" ) ]
@@ -783,7 +781,7 @@
 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);
+    if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_expr(& * _i . expr);
 }
 # [ cfg ( feature = "full" ) ]
@@ -1153,7 +1151,7 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_visibility(& _i . vis);
     tokens_helper(_visitor, &(& _i . static_token).0);
-    _visitor.visit_mutability(& _i . mutbl);
+    if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_ident(& _i . ident);
     tokens_helper(_visitor, &(& _i . colon_token).0);
     _visitor.visit_type(& * _i . ty);
@@ -1462,7 +1460,7 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_visibility(& _i . vis);
     tokens_helper(_visitor, &(& _i . static_token).0);
-    _visitor.visit_mutability(& _i . mutbl);
+    if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_ident(& _i . ident);
     tokens_helper(_visitor, &(& _i . colon_token).0);
     _visitor.visit_type(& * _i . ty);
@@ -1614,20 +1612,10 @@
 }
 
 pub fn visit_mut_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MutType) {
-    _visitor.visit_mutability(& _i . mutability);
+    if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_type(& _i . ty);
 }
 
-pub fn visit_mutability<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Mutability) {
-    use ::Mutability::*;
-    match *_i {
-        Mutable(ref _binding_0, ) => {
-            tokens_helper(_visitor, &(_binding_0).0);
-        }
-        Immutable => { }
-    }
-}
-
 pub fn visit_nested_meta_item<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast NestedMetaItem) {
     use ::NestedMetaItem::*;
     match *_i {
@@ -1694,8 +1682,8 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_ident<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatIdent) {
-    if let Some(ref it) = _i . mode { tokens_helper(_visitor, &(it).0) };
-    _visitor.visit_mutability(& _i . mutability);
+    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) };
@@ -1718,7 +1706,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_ref<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRef) {
     tokens_helper(_visitor, &(& _i . and_token).0);
-    _visitor.visit_mutability(& _i . mutbl);
+    if let Some(ref it) = _i . mutability { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_pat(& * _i . pat);
 }
 # [ cfg ( feature = "full" ) ]
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 6debf1d..a9dc75a 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -262,8 +262,6 @@
 
 fn visit_mut_type_mut(&mut self, i: &mut MutType) { visit_mut_type_mut(self, i) }
 
-fn visit_mutability_mut(&mut self, i: &mut Mutability) { visit_mutability_mut(self, i) }
-
 fn visit_nested_meta_item_mut(&mut self, i: &mut NestedMetaItem) { visit_nested_meta_item_mut(self, i) }
 
 fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) { visit_parenthesized_generic_arguments_mut(self, i) }
@@ -422,14 +420,14 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_arg_self_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelf) {
-    _visitor.visit_mutability_mut(& mut _i . mutbl);
+    if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     tokens_helper(_visitor, &mut (& mut _i . self_token).0);
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_arg_self_ref_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelfRef) {
     tokens_helper(_visitor, &mut (& mut _i . and_token).0);
     if let Some(ref mut it) = _i . lifetime { _visitor.visit_lifetime_mut(it) };
-    _visitor.visit_mutability_mut(& mut _i . mutbl);
+    if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     tokens_helper(_visitor, &mut (& mut _i . self_token).0);
 }
 # [ cfg ( feature = "full" ) ]
@@ -783,7 +781,7 @@
 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);
+    if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_expr_mut(& mut * _i . expr);
 }
 # [ cfg ( feature = "full" ) ]
@@ -1153,7 +1151,7 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_visibility_mut(& mut _i . vis);
     tokens_helper(_visitor, &mut (& mut _i . static_token).0);
-    _visitor.visit_mutability_mut(& mut _i . mutbl);
+    if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_ident_mut(& mut _i . ident);
     tokens_helper(_visitor, &mut (& mut _i . colon_token).0);
     _visitor.visit_type_mut(& mut * _i . ty);
@@ -1462,7 +1460,7 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_visibility_mut(& mut _i . vis);
     tokens_helper(_visitor, &mut (& mut _i . static_token).0);
-    _visitor.visit_mutability_mut(& mut _i . mutbl);
+    if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_ident_mut(& mut _i . ident);
     tokens_helper(_visitor, &mut (& mut _i . colon_token).0);
     _visitor.visit_type_mut(& mut * _i . ty);
@@ -1614,20 +1612,10 @@
 }
 
 pub fn visit_mut_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MutType) {
-    _visitor.visit_mutability_mut(& mut _i . mutability);
+    if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_type_mut(& mut _i . ty);
 }
 
-pub fn visit_mutability_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Mutability) {
-    use ::Mutability::*;
-    match *_i {
-        Mutable(ref mut _binding_0, ) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
-        }
-        Immutable => { }
-    }
-}
-
 pub fn visit_nested_meta_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMetaItem) {
     use ::NestedMetaItem::*;
     match *_i {
@@ -1694,8 +1682,8 @@
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_ident_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) {
-    if let Some(ref mut it) = _i . mode { tokens_helper(_visitor, &mut (it).0) };
-    _visitor.visit_mutability_mut(& mut _i . mutability);
+    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) };
@@ -1718,7 +1706,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_ref_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) {
     tokens_helper(_visitor, &mut (& mut _i . and_token).0);
-    _visitor.visit_mutability_mut(& mut _i . mutbl);
+    if let Some(ref mut it) = _i . mutability { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_pat_mut(& mut * _i . pat);
 }
 # [ cfg ( feature = "full" ) ]
diff --git a/src/helper.rs b/src/helper.rs
index d15332e..a8c06c1 100644
--- a/src/helper.rs
+++ b/src/helper.rs
@@ -82,7 +82,10 @@
 /// #[macro_use]
 /// extern crate syn;
 ///
-/// use syn::Mutability;
+/// enum Mutability {
+///     Mutable(Token![mut]),
+///     Immutable,
+/// }
 ///
 /// named!(mutability -> Mutability, alt!(
 ///     keyword!(mut) => { Mutability::Mutable }
diff --git a/src/item.rs b/src/item.rs
index bb3c892..96655cf 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -41,7 +41,7 @@
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
             pub static_token: Token![static],
-            pub mutbl: Mutability,
+            pub mutability: Option<Token![mut]>,
             pub ident: Ident,
             pub colon_token: Token![:],
             pub ty: Box<Type>,
@@ -315,7 +315,7 @@
             pub attrs: Vec<Attribute>,
             pub vis: Visibility,
             pub static_token: Token![static],
-            pub mutbl: Mutability,
+            pub mutability: Option<Token![mut]>,
             pub ident: Ident,
             pub colon_token: Token![:],
             pub ty: Box<Type>,
@@ -455,11 +455,11 @@
         pub SelfRef(ArgSelfRef {
             pub and_token: Token![&],
             pub lifetime: Option<Lifetime>,
-            pub mutbl: Mutability,
+            pub mutability: Option<Token![mut]>,
             pub self_token: Token![self],
         }),
         pub SelfValue(ArgSelf {
-            pub mutbl: Mutability,
+            pub mutability: Option<Token![mut]>,
             pub self_token: Token![self],
         }),
         pub Captured(ArgCaptured {
@@ -656,7 +656,7 @@
         attrs: many0!(Attribute::parse_outer) >>
         vis: syn!(Visibility) >>
         static_: keyword!(static) >>
-        mutability: syn!(Mutability) >>
+        mutability: option!(keyword!(mut)) >>
         ident: syn!(Ident) >>
         colon: punct!(:) >>
         ty: syn!(Type) >>
@@ -667,7 +667,7 @@
             attrs: attrs,
             vis: vis,
             static_token: static_,
-            mutbl: mutability,
+            mutability: mutability,
             ident: ident,
             colon_token: colon,
             ty: Box::new(ty),
@@ -750,23 +750,23 @@
             do_parse!(
                 and: punct!(&) >>
                 lt: option!(syn!(Lifetime)) >>
-                mutability: syn!(Mutability) >>
+                mutability: option!(keyword!(mut)) >>
                 self_: keyword!(self) >>
                 not!(punct!(:)) >>
                 (ArgSelfRef {
                     lifetime: lt,
-                    mutbl: mutability,
+                    mutability: mutability,
                     and_token: and,
                     self_token: self_,
                 }.into())
             )
             |
             do_parse!(
-                mutability: syn!(Mutability) >>
+                mutability: option!(keyword!(mut)) >>
                 self_: keyword!(self) >>
                 not!(punct!(:)) >>
                 (ArgSelf {
-                    mutbl: mutability,
+                    mutability: mutability,
                     self_token: self_,
                 }.into())
             )
@@ -885,7 +885,7 @@
         attrs: many0!(Attribute::parse_outer) >>
         vis: syn!(Visibility) >>
         static_: keyword!(static) >>
-        mutability: syn!(Mutability) >>
+        mutability: option!(keyword!(mut)) >>
         ident: syn!(Ident) >>
         colon: punct!(:) >>
         ty: syn!(Type) >>
@@ -895,7 +895,7 @@
             attrs: attrs,
             semi_token: semi,
             ty: Box::new(ty),
-            mutbl: mutability,
+            mutability: mutability,
             static_token: static_,
             colon_token: colon,
             vis: vis,
@@ -1375,7 +1375,7 @@
             tokens.append_all(self.attrs.outer());
             self.vis.to_tokens(tokens);
             self.static_token.to_tokens(tokens);
-            self.mutbl.to_tokens(tokens);
+            self.mutability.to_tokens(tokens);
             self.ident.to_tokens(tokens);
             self.colon_token.to_tokens(tokens);
             self.ty.to_tokens(tokens);
@@ -1730,7 +1730,7 @@
             tokens.append_all(self.attrs.outer());
             self.vis.to_tokens(tokens);
             self.static_token.to_tokens(tokens);
-            self.mutbl.to_tokens(tokens);
+            self.mutability.to_tokens(tokens);
             self.ident.to_tokens(tokens);
             self.colon_token.to_tokens(tokens);
             self.ty.to_tokens(tokens);
@@ -1780,14 +1780,14 @@
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.and_token.to_tokens(tokens);
             self.lifetime.to_tokens(tokens);
-            self.mutbl.to_tokens(tokens);
+            self.mutability.to_tokens(tokens);
             self.self_token.to_tokens(tokens);
         }
     }
 
     impl ToTokens for ArgSelf {
         fn to_tokens(&self, tokens: &mut Tokens) {
-            self.mutbl.to_tokens(tokens);
+            self.mutability.to_tokens(tokens);
             self.self_token.to_tokens(tokens);
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index 7c5cde1..b63974e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -88,7 +88,7 @@
 
 mod ty;
 pub use ty::{Abi, AbiKind, AngleBracketedGenericArguments, BareFnArg, BareFnArgName, BareFnType,
-             GenericArgument, MutType, Mutability, ParenthesizedGenericArguments, Path,
+             GenericArgument, MutType, ParenthesizedGenericArguments, Path,
              PathArguments, PathSegment, PolyTraitRef, QSelf, ReturnType, Type, TypeArray,
              TypeBareFn, TypeBinding, TypeGroup, TypeImplTrait, TypeInfer, TypeNever, TypeParen,
              TypePath, TypePtr, TypeReference, TypeSlice, TypeTraitObject, TypeTuple, Unsafety};
diff --git a/src/ty.rs b/src/ty.rs
index a474156..e780540 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -83,19 +83,11 @@
 
 ast_struct! {
     pub struct MutType {
-        pub mutability: Mutability,
+        pub mutability: Option<Token![mut]>,
         pub ty: Type,
     }
 }
 
-ast_enum! {
-    #[cfg_attr(feature = "clone-impls", derive(Copy))]
-    pub enum Mutability {
-        Mutable(Token![mut]),
-        Immutable,
-    }
-}
-
 ast_struct! {
     /// A "Path" is essentially Rust's notion of a name.
     ///
@@ -431,9 +423,9 @@
         named!(parse -> Self, do_parse!(
             star: punct!(*) >>
             mutability: alt!(
-                keyword!(const) => { |c| (Mutability::Immutable, Some(c)) }
+                keyword!(const) => { |c| (None, Some(c)) }
                 |
-                keyword!(mut) => { |m| (Mutability::Mutable(m), None) }
+                keyword!(mut) => { |m| (Some(m), None) }
             ) >>
             target: call!(Type::without_plus) >>
             (TypePtr {
@@ -451,7 +443,7 @@
         named!(parse -> Self, do_parse!(
             amp: punct!(&) >>
             life: option!(syn!(Lifetime)) >>
-            mutability: syn!(Mutability) >>
+            mutability: option!(keyword!(mut)) >>
             // & binds tighter than +, so we don't allow + here.
             target: call!(Type::without_plus) >>
             (TypeReference {
@@ -651,14 +643,6 @@
         ));
     }
 
-    impl Synom for Mutability {
-        named!(parse -> Self, alt!(
-            keyword!(mut) => { Mutability::Mutable }
-            |
-            epsilon!() => { |_| Mutability::Immutable }
-        ));
-    }
-
     impl Synom for Path {
         named!(parse -> Self, do_parse!(
             colon: option!(punct!(::)) >>
@@ -868,8 +852,8 @@
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.star_token.to_tokens(tokens);
             match self.ty.mutability {
-                Mutability::Mutable(ref tok) => tok.to_tokens(tokens),
-                Mutability::Immutable => {
+                Some(ref tok) => tok.to_tokens(tokens),
+                None => {
                     TokensOrDefault(&self.const_token).to_tokens(tokens);
                 }
             }
@@ -986,14 +970,6 @@
         }
     }
 
-    impl ToTokens for Mutability {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            if let Mutability::Mutable(ref t) = *self {
-                t.to_tokens(tokens);
-            }
-        }
-    }
-
     impl ToTokens for Path {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.leading_colon.to_tokens(tokens);
diff --git a/tests/test_expr.rs b/tests/test_expr.rs
index 4a76669..66da76e 100644
--- a/tests/test_expr.rs
+++ b/tests/test_expr.rs
@@ -100,7 +100,7 @@
         });
 
         assert_let!(Stmt::Local(ref local) = block.stmts[2]; {
-            assert_let!(Pat::Ident(PatIdent { mode: BindingMode::ByValue(Mutability::Mutable(_)), ref ident, .. }) = *local.pat; {
+            assert_let!(Pat::Ident(PatIdent { by_ref: None, mutability: Some(_), ref ident, .. }) = *local.pat; {
                 assert_eq!(ident, "catch");
             });
         });