diff --git a/serde/src/bytes.rs b/serde/src/bytes.rs
index 5fa995fb..84c30866 100644
--- a/serde/src/bytes.rs
+++ b/serde/src/bytes.rs
@@ -182,14 +182,14 @@ mod bytebuf {
         type Value = ByteBuf;
 
         #[inline]
-        fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
+        fn visit_unit<E>(self) -> Result<ByteBuf, E>
             where E: de::Error,
         {
             Ok(ByteBuf::new())
         }
 
         #[inline]
-        fn visit_seq<V>(&mut self, mut visitor: V) -> Result<ByteBuf, V::Error>
+        fn visit_seq<V>(self, mut visitor: V) -> Result<ByteBuf, V::Error>
             where V: de::SeqVisitor,
         {
             let (len, _) = visitor.size_hint();
@@ -203,26 +203,26 @@ mod bytebuf {
         }
 
         #[inline]
-        fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
+        fn visit_bytes<E>(self, v: &[u8]) -> Result<ByteBuf, E>
             where E: de::Error,
         {
             Ok(ByteBuf::from(v))
         }
 
         #[inline]
-        fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
+        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<ByteBuf, E>
             where E: de::Error,
         {
             Ok(ByteBuf::from(v))
         }
 
-        fn visit_str<E>(&mut self, v: &str) -> Result<ByteBuf, E>
+        fn visit_str<E>(self, v: &str) -> Result<ByteBuf, E>
             where E: de::Error,
         {
             Ok(ByteBuf::from(v))
         }
 
-        fn visit_string<E>(&mut self, v: String) -> Result<ByteBuf, E>
+        fn visit_string<E>(self, v: String) -> Result<ByteBuf, E>
             where E: de::Error,
         {
             Ok(ByteBuf::from(v))
@@ -231,7 +231,7 @@ mod bytebuf {
 
     impl de::Deserialize for ByteBuf {
         #[inline]
-        fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
+        fn deserialize<D>(deserializer: D) -> Result<ByteBuf, D::Error>
             where D: de::Deserializer
         {
             deserializer.deserialize_bytes(ByteBufVisitor)
diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index 5f70466f..ea17afd2 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -65,6 +65,7 @@ use core::num::Zero;
 use de::{
     Deserialize,
     Deserializer,
+    EnumVisitor,
     Error,
     MapVisitor,
     SeqVisitor,
@@ -82,13 +83,13 @@ pub struct UnitVisitor;
 impl Visitor for UnitVisitor {
     type Value = ();
 
-    fn visit_unit<E>(&mut self) -> Result<(), E>
+    fn visit_unit<E>(self) -> Result<(), E>
         where E: Error,
     {
         Ok(())
     }
 
-    fn visit_seq<V>(&mut self, _: V) -> Result<(), V::Error>
+    fn visit_seq<V>(self, _: V) -> Result<(), V::Error>
         where V: SeqVisitor,
     {
         Ok(())
@@ -96,7 +97,7 @@ impl Visitor for UnitVisitor {
 }
 
 impl Deserialize for () {
-    fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<(), D::Error>
         where D: Deserializer,
     {
         deserializer.deserialize_unit(UnitVisitor)
@@ -111,13 +112,13 @@ pub struct BoolVisitor;
 impl Visitor for BoolVisitor {
     type Value = bool;
 
-    fn visit_bool<E>(&mut self, v: bool) -> Result<bool, E>
+    fn visit_bool<E>(self, v: bool) -> Result<bool, E>
         where E: Error,
     {
         Ok(v)
     }
 
-    fn visit_str<E>(&mut self, s: &str) -> Result<bool, E>
+    fn visit_str<E>(self, s: &str) -> Result<bool, E>
         where E: Error,
     {
         match s.trim_matches(::utils::Pattern_White_Space) {
@@ -129,7 +130,7 @@ impl Visitor for BoolVisitor {
 }
 
 impl Deserialize for bool {
-    fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<bool, D::Error>
         where D: Deserializer,
     {
         deserializer.deserialize_bool(BoolVisitor)
@@ -141,7 +142,7 @@ impl Deserialize for bool {
 macro_rules! impl_deserialize_num_method {
     ($src_ty:ty, $method:ident, $from_method:ident, $ty:expr) => {
         #[inline]
-        fn $method<E>(&mut self, v: $src_ty) -> Result<T, E>
+        fn $method<E>(self, v: $src_ty) -> Result<T, E>
             where E: Error,
         {
             match FromPrimitive::$from_method(v) {
@@ -186,7 +187,7 @@ impl<T> Visitor for PrimitiveVisitor<T>
     impl_deserialize_num_method!(f64, visit_f64, from_f64, Type::F64);
 
     #[inline]
-    fn visit_str<E>(&mut self, s: &str) -> Result<T, E>
+    fn visit_str<E>(self, s: &str) -> Result<T, E>
         where E: Error,
     {
         str::FromStr::from_str(s.trim_matches(::utils::Pattern_White_Space)).or_else(|_| {
@@ -199,7 +200,7 @@ macro_rules! impl_deserialize_num {
     ($ty:ty, $method:ident) => {
         impl Deserialize for $ty {
             #[inline]
-            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
                 where D: Deserializer,
             {
                 deserializer.$method(PrimitiveVisitor::new())
@@ -229,14 +230,14 @@ impl Visitor for CharVisitor {
     type Value = char;
 
     #[inline]
-    fn visit_char<E>(&mut self, v: char) -> Result<char, E>
+    fn visit_char<E>(self, v: char) -> Result<char, E>
         where E: Error,
     {
         Ok(v)
     }
 
     #[inline]
-    fn visit_str<E>(&mut self, v: &str) -> Result<char, E>
+    fn visit_str<E>(self, v: &str) -> Result<char, E>
         where E: Error,
     {
         let mut iter = v.chars();
@@ -254,7 +255,7 @@ impl Visitor for CharVisitor {
 
 impl Deserialize for char {
     #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<char, D::Error>
         where D: Deserializer,
     {
         deserializer.deserialize_char(CharVisitor)
@@ -270,25 +271,25 @@ struct StringVisitor;
 impl Visitor for StringVisitor {
     type Value = String;
 
-    fn visit_str<E>(&mut self, v: &str) -> Result<String, E>
+    fn visit_str<E>(self, v: &str) -> Result<String, E>
         where E: Error,
     {
         Ok(v.to_owned())
     }
 
-    fn visit_string<E>(&mut self, v: String) -> Result<String, E>
+    fn visit_string<E>(self, v: String) -> Result<String, E>
         where E: Error,
     {
         Ok(v)
     }
 
-    fn visit_unit<E>(&mut self) -> Result<String, E>
+    fn visit_unit<E>(self) -> Result<String, E>
         where E: Error,
     {
         Ok(String::new())
     }
 
-    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<String, E>
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<String, E>
         where E: Error,
     {
         match str::from_utf8(v) {
@@ -297,7 +298,7 @@ impl Visitor for StringVisitor {
         }
     }
 
-    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<String, E>
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<String, E>
         where E: Error,
     {
         match String::from_utf8(v) {
@@ -309,7 +310,7 @@ impl Visitor for StringVisitor {
 
 #[cfg(any(feature = "std", feature = "collections"))]
 impl Deserialize for String {
-    fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<String, D::Error>
         where D: Deserializer,
     {
         deserializer.deserialize_string(StringVisitor)
@@ -328,21 +329,21 @@ impl<
     type Value = Option<T>;
 
     #[inline]
-    fn visit_unit<E>(&mut self) -> Result<Option<T>, E>
+    fn visit_unit<E>(self) -> Result<Option<T>, E>
         where E: Error,
     {
         Ok(None)
     }
 
     #[inline]
-    fn visit_none<E>(&mut self) -> Result<Option<T>, E>
+    fn visit_none<E>(self) -> Result<Option<T>, E>
         where E: Error,
     {
         Ok(None)
     }
 
     #[inline]
-    fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Option<T>, D::Error>
+    fn visit_some<D>(self, deserializer: D) -> Result<Option<T>, D::Error>
         where D: Deserializer,
     {
         Ok(Some(try!(Deserialize::deserialize(deserializer))))
@@ -350,7 +351,7 @@ impl<
 }
 
 impl<T> Deserialize for Option<T> where T: Deserialize {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Option<T>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Option<T>, D::Error>
         where D: Deserializer,
     {
         deserializer.deserialize_option(OptionVisitor { marker: PhantomData })
@@ -368,7 +369,7 @@ impl<T> Visitor for PhantomDataVisitor<T> {
     type Value = PhantomData<T>;
 
     #[inline]
-    fn visit_unit<E>(&mut self) -> Result<PhantomData<T>, E>
+    fn visit_unit<E>(self) -> Result<PhantomData<T>, E>
         where E: Error,
     {
         Ok(PhantomData)
@@ -376,7 +377,7 @@ impl<T> Visitor for PhantomDataVisitor<T> {
 }
 
 impl<T> Deserialize for PhantomData<T> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<PhantomData<T>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<PhantomData<T>, D::Error>
         where D: Deserializer,
     {
         let visitor = PhantomDataVisitor { marker: PhantomData };
@@ -417,14 +418,14 @@ macro_rules! seq_impl {
             type Value = $ty;
 
             #[inline]
-            fn visit_unit<E>(&mut self) -> Result<$ty, E>
+            fn visit_unit<E>(self) -> Result<$ty, E>
                 where E: Error,
             {
                 Ok($ctor)
             }
 
             #[inline]
-            fn visit_seq<V>(&mut self, mut $visitor: V) -> Result<$ty, V::Error>
+            fn visit_seq<V>(self, mut $visitor: V) -> Result<$ty, V::Error>
                 where V: SeqVisitor,
             {
                 let mut values = $with_capacity;
@@ -440,7 +441,7 @@ macro_rules! seq_impl {
         impl<$($typaram),*> Deserialize for $ty
             where $($typaram: $bound1 $(+ $bound2)*),*
         {
-            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
                 where D: Deserializer,
             {
                 deserializer.deserialize_seq($visitor_ty::new())
@@ -531,14 +532,14 @@ impl<T> Visitor for ArrayVisitor<[T; 0]> where T: Deserialize {
     type Value = [T; 0];
 
     #[inline]
-    fn visit_unit<E>(&mut self) -> Result<[T; 0], E>
+    fn visit_unit<E>(self) -> Result<[T; 0], E>
         where E: Error,
     {
         Ok([])
     }
 
     #[inline]
-    fn visit_seq<V>(&mut self, _: V) -> Result<[T; 0], V::Error>
+    fn visit_seq<V>(self, _: V) -> Result<[T; 0], V::Error>
         where V: SeqVisitor,
     {
         Ok([])
@@ -548,7 +549,7 @@ impl<T> Visitor for ArrayVisitor<[T; 0]> where T: Deserialize {
 impl<T> Deserialize for [T; 0]
     where T: Deserialize
 {
-    fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<[T; 0], D::Error>
         where D: Deserializer,
     {
         deserializer.deserialize_seq_fixed_size(0, ArrayVisitor::<[T; 0]>::new())
@@ -562,7 +563,7 @@ macro_rules! array_impls {
                 type Value = [T; $len];
 
                 #[inline]
-                fn visit_seq<V>(&mut self, mut visitor: V) -> Result<[T; $len], V::Error>
+                fn visit_seq<V>(self, mut visitor: V) -> Result<[T; $len], V::Error>
                     where V: SeqVisitor,
                 {
                     $(
@@ -579,7 +580,7 @@ macro_rules! array_impls {
             impl<T> Deserialize for [T; $len]
                 where T: Deserialize,
             {
-                fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
+                fn deserialize<D>(deserializer: D) -> Result<[T; $len], D::Error>
                     where D: Deserializer,
                 {
                     deserializer.deserialize_seq_fixed_size($len, ArrayVisitor::<[T; $len]>::new())
@@ -646,7 +647,7 @@ macro_rules! tuple_impls {
 
                 #[inline]
                 #[allow(non_snake_case)]
-                fn visit_seq<V>(&mut self, mut visitor: V) -> Result<($($name,)+), V::Error>
+                fn visit_seq<V>(self, mut visitor: V) -> Result<($($name,)+), V::Error>
                     where V: SeqVisitor,
                 {
                     $(
@@ -662,7 +663,7 @@ macro_rules! tuple_impls {
 
             impl<$($name: Deserialize),+> Deserialize for ($($name,)+) {
                 #[inline]
-                fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
+                fn deserialize<D>(deserializer: D) -> Result<($($name,)+), D::Error>
                     where D: Deserializer,
                 {
                     deserializer.deserialize_tuple($len, $visitor::new())
@@ -723,14 +724,14 @@ macro_rules! map_impl {
             type Value = $ty;
 
             #[inline]
-            fn visit_unit<E>(&mut self) -> Result<$ty, E>
+            fn visit_unit<E>(self) -> Result<$ty, E>
                 where E: Error,
             {
                 Ok($ctor)
             }
 
             #[inline]
-            fn visit_map<Visitor>(&mut self, mut $visitor: Visitor) -> Result<$ty, Visitor::Error>
+            fn visit_map<Visitor>(self, mut $visitor: Visitor) -> Result<$ty, Visitor::Error>
                 where Visitor: MapVisitor,
             {
                 let mut values = $with_capacity;
@@ -746,7 +747,7 @@ macro_rules! map_impl {
         impl<$($typaram),*> Deserialize for $ty
             where $($typaram: $bound1 $(+ $bound2)*),*
         {
-            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
                 where D: Deserializer,
             {
                 deserializer.deserialize_map($visitor_ty::new())
@@ -778,7 +779,7 @@ map_impl!(
 
 #[cfg(feature = "std")]
 impl Deserialize for net::IpAddr {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
         let s = try!(String::deserialize(deserializer));
@@ -791,7 +792,7 @@ impl Deserialize for net::IpAddr {
 
 #[cfg(feature = "std")]
 impl Deserialize for net::Ipv4Addr {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
         let s = try!(String::deserialize(deserializer));
@@ -804,7 +805,7 @@ impl Deserialize for net::Ipv4Addr {
 
 #[cfg(feature = "std")]
 impl Deserialize for net::Ipv6Addr {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
         let s = try!(String::deserialize(deserializer));
@@ -819,7 +820,7 @@ impl Deserialize for net::Ipv6Addr {
 
 #[cfg(feature = "std")]
 impl Deserialize for net::SocketAddr {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
         let s = try!(String::deserialize(deserializer));
@@ -832,7 +833,7 @@ impl Deserialize for net::SocketAddr {
 
 #[cfg(feature = "std")]
 impl Deserialize for net::SocketAddrV4 {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
         let s = try!(String::deserialize(deserializer));
@@ -845,7 +846,7 @@ impl Deserialize for net::SocketAddrV4 {
 
 #[cfg(feature = "std")]
 impl Deserialize for net::SocketAddrV6 {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
         let s = try!(String::deserialize(deserializer));
@@ -865,13 +866,13 @@ struct PathBufVisitor;
 impl Visitor for PathBufVisitor {
     type Value = path::PathBuf;
 
-    fn visit_str<E>(&mut self, v: &str) -> Result<path::PathBuf, E>
+    fn visit_str<E>(self, v: &str) -> Result<path::PathBuf, E>
         where E: Error,
     {
         Ok(From::from(v))
     }
 
-    fn visit_string<E>(&mut self, v: String) -> Result<path::PathBuf, E>
+    fn visit_string<E>(self, v: String) -> Result<path::PathBuf, E>
         where E: Error,
     {
         self.visit_str(&v)
@@ -880,7 +881,7 @@ impl Visitor for PathBufVisitor {
 
 #[cfg(feature = "std")]
 impl Deserialize for path::PathBuf {
-    fn deserialize<D>(deserializer: &mut D) -> Result<path::PathBuf, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<path::PathBuf, D::Error>
         where D: Deserializer,
     {
         deserializer.deserialize_string(PathBufVisitor)
@@ -891,7 +892,7 @@ impl Deserialize for path::PathBuf {
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Box<T> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Box<T>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Box<T>, D::Error>
         where D: Deserializer,
     {
         let val = try!(Deserialize::deserialize(deserializer));
@@ -901,7 +902,7 @@ impl<T: Deserialize> Deserialize for Box<T> {
 
 #[cfg(any(feature = "std", feature = "collections"))]
 impl<T: Deserialize> Deserialize for Box<[T]> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Box<[T]>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Box<[T]>, D::Error>
         where D: Deserializer,
     {
         let v: Vec<T> = try!(Deserialize::deserialize(deserializer));
@@ -911,7 +912,7 @@ impl<T: Deserialize> Deserialize for Box<[T]> {
 
 #[cfg(any(feature = "std", feature = "collections"))]
 impl Deserialize for Box<str> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer
     {
         let s = try!(String::deserialize(deserializer));
@@ -921,7 +922,7 @@ impl Deserialize for Box<str> {
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Arc<T> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Arc<T>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Arc<T>, D::Error>
         where D: Deserializer,
     {
         let val = try!(Deserialize::deserialize(deserializer));
@@ -931,7 +932,7 @@ impl<T: Deserialize> Deserialize for Arc<T> {
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Rc<T> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Rc<T>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Rc<T>, D::Error>
         where D: Deserializer,
     {
         let val = try!(Deserialize::deserialize(deserializer));
@@ -942,7 +943,7 @@ impl<T: Deserialize> Deserialize for Rc<T> {
 #[cfg(any(feature = "std", feature = "collections"))]
 impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where T: ToOwned, T::Owned: Deserialize, {
     #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<Cow<'a, T>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Cow<'a, T>, D::Error>
         where D: Deserializer,
     {
         let val = try!(Deserialize::deserialize(deserializer));
@@ -962,13 +963,13 @@ impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where T: ToOwned, T::Owned: Deser
 //     }
 #[cfg(feature = "std")]
 impl Deserialize for Duration {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer,
     {
         enum Field { Secs, Nanos };
 
         impl Deserialize for Field {
-            fn deserialize<D>(deserializer: &mut D) -> Result<Field, D::Error>
+            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
                 where D: Deserializer,
             {
                 struct FieldVisitor;
@@ -976,7 +977,7 @@ impl Deserialize for Duration {
                 impl Visitor for FieldVisitor {
                     type Value = Field;
 
-                    fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E>
+                    fn visit_usize<E>(self, value: usize) -> Result<Field, E>
                         where E: Error,
                     {
                         match value {
@@ -986,7 +987,7 @@ impl Deserialize for Duration {
                         }
                     }
 
-                    fn visit_str<E>(&mut self, value: &str) -> Result<Field, E>
+                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
                         where E: Error,
                     {
                         match value {
@@ -996,7 +997,7 @@ impl Deserialize for Duration {
                         }
                     }
 
-                    fn visit_bytes<E>(&mut self, value: &[u8]) -> Result<Field, E>
+                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Field, E>
                         where E: Error,
                     {
                         match value {
@@ -1019,7 +1020,7 @@ impl Deserialize for Duration {
         impl Visitor for DurationVisitor {
             type Value = Duration;
 
-            fn visit_seq<V>(&mut self, mut visitor: V) -> Result<Duration, V::Error>
+            fn visit_seq<V>(self, mut visitor: V) -> Result<Duration, V::Error>
                 where V: SeqVisitor,
             {
                 let secs: u64 = match try!(visitor.visit()) {
@@ -1037,7 +1038,7 @@ impl Deserialize for Duration {
                 Ok(Duration::new(secs, nanos))
             }
 
-            fn visit_map<V>(&mut self, mut visitor: V) -> Result<Duration, V::Error>
+            fn visit_map<V>(self, mut visitor: V) -> Result<Duration, V::Error>
                 where V: MapVisitor,
             {
                 let mut secs: Option<u64> = None;
@@ -1079,7 +1080,7 @@ impl Deserialize for Duration {
 
 #[cfg(feature = "unstable")]
 impl<T> Deserialize for NonZero<T> where T: Deserialize + PartialEq + Zeroable + Zero {
-    fn deserialize<D>(deserializer: &mut D) -> Result<NonZero<T>, D::Error> where D: Deserializer {
+    fn deserialize<D>(deserializer: D) -> Result<NonZero<T>, D::Error> where D: Deserializer {
         let value = try!(Deserialize::deserialize(deserializer));
         if value == Zero::zero() {
             return Err(Error::invalid_value("expected a non-zero value"))
@@ -1094,7 +1095,7 @@ impl<T> Deserialize for NonZero<T> where T: Deserialize + PartialEq + Zeroable +
 
 
 impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Result<T, E>, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Result<T, E>, D::Error>
                       where D: Deserializer {
         enum Field {
             Ok,
@@ -1103,7 +1104,7 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
 
         impl Deserialize for Field {
             #[inline]
-            fn deserialize<D>(deserializer: &mut D) -> Result<Field, D::Error>
+            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
                 where D: Deserializer
             {
                 struct FieldVisitor;
@@ -1112,7 +1113,7 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                     type Value = Field;
 
                     #[cfg(any(feature = "std", feature = "collections"))]
-                    fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E> where E: Error {
+                    fn visit_usize<E>(self, value: usize) -> Result<Field, E> where E: Error {
                         #[cfg(feature = "collections")]
                         use collections::string::ToString;
                         match value {
@@ -1123,7 +1124,7 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                     }
 
                     #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-                    fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E> where E: Error {
+                    fn visit_usize<E>(self, value: usize) -> Result<Field, E> where E: Error {
                         match value {
                             0 => Ok(Field::Ok),
                             1 => Ok(Field::Err),
@@ -1131,7 +1132,7 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                         }
                     }
 
-                    fn visit_str<E>(&mut self, value: &str) -> Result<Field, E> where E: Error {
+                    fn visit_str<E>(self, value: &str) -> Result<Field, E> where E: Error {
                         match value {
                             "Ok" => Ok(Field::Ok),
                             "Err" => Ok(Field::Err),
@@ -1139,7 +1140,7 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                         }
                     }
 
-                    fn visit_bytes<E>(&mut self, value: &[u8]) -> Result<Field, E> where E: Error {
+                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Field, E> where E: Error {
                         match value {
                             b"Ok" => Ok(Field::Ok),
                             b"Err" => Ok(Field::Err),
@@ -1165,18 +1166,12 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
         {
             type Value = Result<T, E>;
 
-            fn visit_enum<V>(&mut self, mut visitor: V) -> Result<Result<T, E>, V::Error>
-                where V: VariantVisitor
+            fn visit_enum<V>(self, visitor: V) -> Result<Result<T, E>, V::Error>
+                where V: EnumVisitor
             {
                 match try!(visitor.visit_variant()) {
-                    Field::Ok => {
-                        let value = try!(visitor.visit_newtype());
-                        Ok(Ok(value))
-                    }
-                    Field::Err => {
-                        let value = try!(visitor.visit_newtype());
-                        Ok(Err(value))
-                    }
+                    (Field::Ok, variant) => variant.visit_newtype().map(Ok),
+                    (Field::Err, variant) => variant.visit_newtype().map(Err),
                 }
             }
         }
@@ -1195,7 +1190,7 @@ pub struct IgnoredAny;
 
 impl Deserialize for IgnoredAny {
     #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<IgnoredAny, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
         where D: Deserializer,
     {
         struct IgnoredAnyVisitor;
@@ -1204,58 +1199,58 @@ impl Deserialize for IgnoredAny {
             type Value = IgnoredAny;
 
             #[inline]
-            fn visit_bool<E>(&mut self, _: bool) -> Result<IgnoredAny, E> {
+            fn visit_bool<E>(self, _: bool) -> Result<IgnoredAny, E> {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_i64<E>(&mut self, _: i64) -> Result<IgnoredAny, E> {
+            fn visit_i64<E>(self, _: i64) -> Result<IgnoredAny, E> {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_u64<E>(&mut self, _: u64) -> Result<IgnoredAny, E> {
+            fn visit_u64<E>(self, _: u64) -> Result<IgnoredAny, E> {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_f64<E>(&mut self, _: f64) -> Result<IgnoredAny, E> {
+            fn visit_f64<E>(self, _: f64) -> Result<IgnoredAny, E> {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_str<E>(&mut self, _: &str) -> Result<IgnoredAny, E>
+            fn visit_str<E>(self, _: &str) -> Result<IgnoredAny, E>
                 where E: Error,
             {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_none<E>(&mut self) -> Result<IgnoredAny, E> {
+            fn visit_none<E>(self) -> Result<IgnoredAny, E> {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_some<D>(&mut self, _: &mut D) -> Result<IgnoredAny, D::Error>
+            fn visit_some<D>(self, _: D) -> Result<IgnoredAny, D::Error>
                 where D: Deserializer,
             {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_newtype_struct<D>(&mut self, _: &mut D) -> Result<IgnoredAny, D::Error>
+            fn visit_newtype_struct<D>(self, _: D) -> Result<IgnoredAny, D::Error>
                 where D: Deserializer,
             {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_unit<E>(&mut self) -> Result<IgnoredAny, E> {
+            fn visit_unit<E>(self) -> Result<IgnoredAny, E> {
                 Ok(IgnoredAny)
             }
 
             #[inline]
-            fn visit_seq<V>(&mut self, mut visitor: V) -> Result<IgnoredAny, V::Error>
+            fn visit_seq<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
                 where V: SeqVisitor,
             {
                 while let Some(_) = try!(visitor.visit::<IgnoredAny>()) {
@@ -1265,7 +1260,7 @@ impl Deserialize for IgnoredAny {
             }
 
             #[inline]
-            fn visit_map<V>(&mut self, mut visitor: V) -> Result<IgnoredAny, V::Error>
+            fn visit_map<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
                 where V: MapVisitor,
             {
                 while let Some((_, _)) = try!(visitor.visit::<IgnoredAny, IgnoredAny>()) {
@@ -1275,7 +1270,7 @@ impl Deserialize for IgnoredAny {
             }
 
             #[inline]
-            fn visit_bytes<E>(&mut self, _: &[u8]) -> Result<IgnoredAny, E>
+            fn visit_bytes<E>(self, _: &[u8]) -> Result<IgnoredAny, E>
                 where E: Error,
             {
                 Ok(IgnoredAny)
diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs
index bd3b2a7c..af488dd4 100644
--- a/serde/src/de/mod.rs
+++ b/serde/src/de/mod.rs
@@ -222,7 +222,7 @@ impl fmt::Display for Type {
 /// `Deserialize` represents a type that can be deserialized.
 pub trait Deserialize: Sized {
     /// Deserialize this value given this `Deserializer`.
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
         where D: Deserializer;
 }
 
@@ -245,100 +245,100 @@ pub trait Deserializer {
     type Error: Error;
 
     /// This method walks a visitor through a value as it is being deserialized.
-    fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `bool` value.
-    fn deserialize_bool<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `usize` value.
     /// A reasonable default is to forward to `deserialize_u64`.
-    fn deserialize_usize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_usize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u8` value.
     /// A reasonable default is to forward to `deserialize_u64`.
-    fn deserialize_u8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u16` value.
     /// A reasonable default is to forward to `deserialize_u64`.
-    fn deserialize_u16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u32` value.
     /// A reasonable default is to forward to `deserialize_u64`.
-    fn deserialize_u32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u64` value.
-    fn deserialize_u64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `isize` value.
     /// A reasonable default is to forward to `deserialize_i64`.
-    fn deserialize_isize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_isize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i8` value.
     /// A reasonable default is to forward to `deserialize_i64`.
-    fn deserialize_i8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i16` value.
     /// A reasonable default is to forward to `deserialize_i64`.
-    fn deserialize_i16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i32` value.
     /// A reasonable default is to forward to `deserialize_i64`.
-    fn deserialize_i32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i64` value.
-    fn deserialize_i64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `f32` value.
     /// A reasonable default is to forward to `deserialize_f64`.
-    fn deserialize_f32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `f64` value.
-    fn deserialize_f64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `char` value.
-    fn deserialize_char<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `&str` value.
-    fn deserialize_str<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `String` value.
-    fn deserialize_string<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `unit` value.
-    fn deserialize_unit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `Option` value. This allows
     /// deserializers that encode an optional value as a nullable value to convert the null value
     /// into a `None`, and a regular value as `Some(value)`.
-    fn deserialize_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a sequence value. This allows
     /// deserializers to parse sequences that aren't tagged as sequences.
-    fn deserialize_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a fixed size array. This allows
     /// deserializers to parse arrays that aren't tagged as arrays.
-    fn deserialize_seq_fixed_size<V>(&mut self,
+    fn deserialize_seq_fixed_size<V>(self,
                                      len: usize,
                                      visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
@@ -346,17 +346,17 @@ pub trait Deserializer {
     /// This method hints that the `Deserialize` type is expecting a `Vec<u8>`. This allows
     /// deserializers that provide a custom byte vector serialization to properly deserialize the
     /// type.
-    fn deserialize_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a map of values. This allows
     /// deserializers to parse sequences that aren't tagged as maps.
-    fn deserialize_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a unit struct. This allows
     /// deserializers to a unit struct that aren't tagged as a unit struct.
-    fn deserialize_unit_struct<V>(&mut self,
+    fn deserialize_unit_struct<V>(self,
                                   name: &'static str,
                                   visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
@@ -364,14 +364,14 @@ pub trait Deserializer {
     /// This method hints that the `Deserialize` type is expecting a newtype struct. This allows
     /// deserializers to a newtype struct that aren't tagged as a newtype struct.
     /// A reasonable default is to simply deserialize the expected value directly.
-    fn deserialize_newtype_struct<V>(&mut self,
+    fn deserialize_newtype_struct<V>(self,
                                      name: &'static str,
                                      visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a tuple struct. This allows
     /// deserializers to parse sequences that aren't tagged as sequences.
-    fn deserialize_tuple_struct<V>(&mut self,
+    fn deserialize_tuple_struct<V>(self,
                                    name: &'static str,
                                    len: usize,
                                    visitor: V) -> Result<V::Value, Self::Error>
@@ -379,7 +379,7 @@ pub trait Deserializer {
 
     /// This method hints that the `Deserialize` type is expecting a struct. This allows
     /// deserializers to parse sequences that aren't tagged as maps.
-    fn deserialize_struct<V>(&mut self,
+    fn deserialize_struct<V>(self,
                              name: &'static str,
                              fields: &'static [&'static str],
                              visitor: V) -> Result<V::Value, Self::Error>
@@ -388,18 +388,18 @@ pub trait Deserializer {
     /// This method hints that the `Deserialize` type is expecting some sort of struct field
     /// name.  This allows deserializers to choose between &str, usize, or &[u8] to properly
     /// deserialize a struct field.
-    fn deserialize_struct_field<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_struct_field<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a tuple value. This allows
     /// deserializers that provide a custom tuple serialization to properly deserialize the type.
-    fn deserialize_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an enum value. This allows
     /// deserializers that provide a custom enumeration serialization to properly deserialize the
     /// type.
-    fn deserialize_enum<V>(&mut self,
+    fn deserialize_enum<V>(self,
                            name: &'static str,
                            variants: &'static [&'static str],
                            visitor: V) -> Result<V::Value, Self::Error>
@@ -407,19 +407,19 @@ pub trait Deserializer {
 
     /// This method hints that the `Deserialize` type needs to deserialize a value whose type
     /// doesn't matter because it is ignored.
-    fn deserialize_ignored_any<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /// This trait represents a visitor that walks through a deserializer.
-pub trait Visitor {
+pub trait Visitor: Sized {
     /// The value produced by this visitor.
     type Value;
 
     /// `visit_bool` deserializes a `bool` into a `Value`.
-    fn visit_bool<E>(&mut self, v: bool) -> Result<Self::Value, E>
+    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
         where E: Error,
     {
         let _ = v;
@@ -427,35 +427,35 @@ pub trait Visitor {
     }
 
     /// `visit_isize` deserializes a `isize` into a `Value`.
-    fn visit_isize<E>(&mut self, v: isize) -> Result<Self::Value, E>
+    fn visit_isize<E>(self, v: isize) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_i64(v as i64)
     }
 
     /// `visit_i8` deserializes a `i8` into a `Value`.
-    fn visit_i8<E>(&mut self, v: i8) -> Result<Self::Value, E>
+    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_i64(v as i64)
     }
 
     /// `visit_i16` deserializes a `i16` into a `Value`.
-    fn visit_i16<E>(&mut self, v: i16) -> Result<Self::Value, E>
+    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_i64(v as i64)
     }
 
     /// `visit_i32` deserializes a `i32` into a `Value`.
-    fn visit_i32<E>(&mut self, v: i32) -> Result<Self::Value, E>
+    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_i64(v as i64)
     }
 
     /// `visit_i64` deserializes a `i64` into a `Value`.
-    fn visit_i64<E>(&mut self, v: i64) -> Result<Self::Value, E>
+    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
         where E: Error,
     {
         let _ = v;
@@ -463,35 +463,35 @@ pub trait Visitor {
     }
 
     /// `visit_usize` deserializes a `usize` into a `Value`.
-    fn visit_usize<E>(&mut self, v: usize) -> Result<Self::Value, E>
+    fn visit_usize<E>(self, v: usize) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_u64(v as u64)
     }
 
     /// `visit_u8` deserializes a `u8` into a `Value`.
-    fn visit_u8<E>(&mut self, v: u8) -> Result<Self::Value, E>
+    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_u64(v as u64)
     }
 
     /// `visit_u16` deserializes a `u16` into a `Value`.
-    fn visit_u16<E>(&mut self, v: u16) -> Result<Self::Value, E>
+    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_u64(v as u64)
     }
 
     /// `visit_u32` deserializes a `u32` into a `Value`.
-    fn visit_u32<E>(&mut self, v: u32) -> Result<Self::Value, E>
+    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_u64(v as u64)
     }
 
     /// `visit_u64` deserializes a `u64` into a `Value`.
-    fn visit_u64<E>(&mut self, v: u64) -> Result<Self::Value, E>
+    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
         where E: Error,
     {
         let _ = v;
@@ -499,14 +499,14 @@ pub trait Visitor {
     }
 
     /// `visit_f32` deserializes a `f32` into a `Value`.
-    fn visit_f32<E>(&mut self, v: f32) -> Result<Self::Value, E>
+    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_f64(v as f64)
     }
 
     /// `visit_f64` deserializes a `f64` into a `Value`.
-    fn visit_f64<E>(&mut self, v: f64) -> Result<Self::Value, E>
+    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
         where E: Error,
     {
         let _ = v;
@@ -515,14 +515,14 @@ pub trait Visitor {
 
     /// `visit_char` deserializes a `char` into a `Value`.
     #[inline]
-    fn visit_char<E>(&mut self, v: char) -> Result<Self::Value, E>
+    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_str(::utils::encode_utf8(v).as_str())
     }
 
     /// `visit_str` deserializes a `&str` into a `Value`.
-    fn visit_str<E>(&mut self, v: &str) -> Result<Self::Value, E>
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
         where E: Error,
     {
         let _ = v;
@@ -534,14 +534,14 @@ pub trait Visitor {
     /// to the `visit_str` method.
     #[inline]
     #[cfg(any(feature = "std", feature = "collections"))]
-    fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_str(&v)
     }
 
     /// `visit_unit` deserializes a `()` into a `Value`.
-    fn visit_unit<E>(&mut self) -> Result<Self::Value, E>
+    fn visit_unit<E>(self) -> Result<Self::Value, E>
         where E: Error,
     {
         Err(Error::invalid_type(Type::Unit))
@@ -549,7 +549,7 @@ pub trait Visitor {
 
     /// `visit_unit_struct` deserializes a unit struct into a `Value`.
     #[inline]
-    fn visit_unit_struct<E>(&mut self, name: &'static str) -> Result<Self::Value, E>
+    fn visit_unit_struct<E>(self, name: &'static str) -> Result<Self::Value, E>
         where E: Error,
     {
         let _ = name;
@@ -557,14 +557,14 @@ pub trait Visitor {
     }
 
     /// `visit_none` deserializes a none value into a `Value`.
-    fn visit_none<E>(&mut self) -> Result<Self::Value, E>
+    fn visit_none<E>(self) -> Result<Self::Value, E>
         where E: Error,
     {
         Err(Error::invalid_type(Type::Option))
     }
 
     /// `visit_some` deserializes a value into a `Value`.
-    fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Self::Value, D::Error>
+    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
         where D: Deserializer,
     {
         let _ = deserializer;
@@ -572,7 +572,7 @@ pub trait Visitor {
     }
 
     /// `visit_newtype_struct` deserializes a value into a `Value`.
-    fn visit_newtype_struct<D>(&mut self, deserializer: &mut D) -> Result<Self::Value, D::Error>
+    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
         where D: Deserializer,
     {
         let _ = deserializer;
@@ -580,7 +580,7 @@ pub trait Visitor {
     }
 
     /// `visit_seq` deserializes a `SeqVisitor` into a `Value`.
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+    fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
         where V: SeqVisitor,
     {
         let _ = visitor;
@@ -588,23 +588,23 @@ pub trait Visitor {
     }
 
     /// `visit_map` deserializes a `MapVisitor` into a `Value`.
-    fn visit_map<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+    fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
         where V: MapVisitor,
     {
         let _ = visitor;
         Err(Error::invalid_type(Type::Map))
     }
 
-    /// `visit_enum` deserializes a `VariantVisitor` into a `Value`.
-    fn visit_enum<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
-        where V: VariantVisitor,
+    /// `visit_enum` deserializes a `EnumVisitor` into a `Value`.
+    fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
+        where V: EnumVisitor,
     {
         let _ = visitor;
         Err(Error::invalid_type(Type::Enum))
     }
 
     /// `visit_bytes` deserializes a `&[u8]` into a `Value`.
-    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<Self::Value, E>
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
         where E: Error,
     {
         let _ = v;
@@ -613,7 +613,7 @@ pub trait Visitor {
 
     /// `visit_byte_buf` deserializes a `Vec<u8>` into a `Value`.
     #[cfg(any(feature = "std", feature = "collections"))]
-    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<Self::Value, E>
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
         where E: Error,
     {
         self.visit_bytes(&v)
@@ -746,28 +746,40 @@ impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/// `VariantVisitor` is a visitor that is created by the `Deserializer` and passed to the
-/// `Deserialize` in order to deserialize a specific enum variant.
+/// `EnumVisitor` is a visitor that is created by the `Deserializer` and passed
+/// to the `Deserialize` in order to identify which variant of an enum to
+/// deserialize.
+pub trait EnumVisitor {
+    /// The error type that can be returned if some error occurs during deserialization.
+    type Error: Error;
+    /// The `Visitor` that will be used to deserialize the content of the enum
+    /// variant.
+    type Variant: VariantVisitor<Error=Self::Error>;
+
+    /// `visit_variant` is called to identify which variant to deserialize.
+    fn visit_variant<V>(self) -> Result<(V, Self::Variant), Self::Error>
+        where V: Deserialize;
+}
+
+/// `VariantVisitor` is a visitor that is created by the `Deserializer` and
+/// passed to the `Deserialize` to deserialize the content of a particular enum
+/// variant.
 pub trait VariantVisitor {
     /// The error type that can be returned if some error occurs during deserialization.
     type Error: Error;
 
-    /// `visit_variant` is called to identify which variant to deserialize.
-    fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
-        where V: Deserialize;
-
     /// `visit_unit` is called when deserializing a variant with no values.
-    fn visit_unit(&mut self) -> Result<(), Self::Error>;
+    fn visit_unit(self) -> Result<(), Self::Error>;
 
     /// `visit_newtype` is called when deserializing a variant with a single value.
     /// A good default is often to use the `visit_tuple` method to deserialize a `(value,)`.
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+    fn visit_newtype<T>(self) -> Result<T, Self::Error>
         where T: Deserialize;
 
     /// `visit_tuple` is called when deserializing a tuple-like variant.
     /// If no tuple variants are expected, yield a
     /// `Err(serde::de::Error::invalid_type(serde::de::Type::TupleVariant))`
-    fn visit_tuple<V>(&mut self,
+    fn visit_tuple<V>(self,
                       len: usize,
                       visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
@@ -775,44 +787,8 @@ pub trait VariantVisitor {
     /// `visit_struct` is called when deserializing a struct-like variant.
     /// If no struct variants are expected, yield a
     /// `Err(serde::de::Error::invalid_type(serde::de::Type::StructVariant))`
-    fn visit_struct<V>(&mut self,
+    fn visit_struct<V>(self,
                        fields: &'static [&'static str],
                        visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor;
 }
-
-impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
-    type Error = T::Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, T::Error>
-        where V: Deserialize
-    {
-        (**self).visit_variant()
-    }
-
-    fn visit_unit(&mut self) -> Result<(), T::Error> {
-        (**self).visit_unit()
-    }
-
-    fn visit_newtype<D>(&mut self) -> Result<D, T::Error>
-        where D: Deserialize,
-    {
-        (**self).visit_newtype()
-    }
-
-    fn visit_tuple<V>(&mut self,
-                      len: usize,
-                      visitor: V) -> Result<V::Value, T::Error>
-        where V: Visitor,
-    {
-        (**self).visit_tuple(len, visitor)
-    }
-
-    fn visit_struct<V>(&mut self,
-                       fields: &'static [&'static str],
-                       visitor: V) -> Result<V::Value, T::Error>
-        where V: Visitor,
-    {
-        (**self).visit_struct(fields, visitor)
-    }
-}
diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index c97e70b7..52342cec 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -184,13 +184,13 @@ impl<E> de::Deserializer for UnitDeserializer<E>
         tuple_struct struct struct_field tuple enum ignored_any
     }
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_unit()
     }
 
-    fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_none()
@@ -202,7 +202,7 @@ impl<E> de::Deserializer for UnitDeserializer<E>
 macro_rules! primitive_deserializer {
     ($ty:ty, $name:ident, $method:ident) => {
         /// A helper deserializer that deserializes a number.
-        pub struct $name<E>(Option<$ty>, PhantomData<E>);
+        pub struct $name<E>($ty, PhantomData<E>);
 
         impl<E> ValueDeserializer<E> for $ty
             where E: de::Error,
@@ -210,7 +210,7 @@ macro_rules! primitive_deserializer {
             type Deserializer = $name<E>;
 
             fn into_deserializer(self) -> $name<E> {
-                $name(Some(self), PhantomData)
+                $name(self, PhantomData)
             }
         }
 
@@ -226,13 +226,10 @@ macro_rules! primitive_deserializer {
                 ignored_any
             }
 
-            fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+            fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
                 where V: de::Visitor,
             {
-                match self.0.take() {
-                    Some(v) => visitor.$method(v),
-                    None => Err(de::Error::end_of_stream()),
-                }
+                visitor.$method(self.0)
             }
         }
     }
@@ -256,7 +253,7 @@ primitive_deserializer!(char, CharDeserializer, visit_char);
 ///////////////////////////////////////////////////////////////////////////////
 
 /// A helper deserializer that deserializes a `&str`.
-pub struct StrDeserializer<'a, E>(Option<&'a str>, PhantomData<E>);
+pub struct StrDeserializer<'a, E>(&'a str, PhantomData<E>);
 
 impl<'a, E> ValueDeserializer<E> for &'a str
     where E: de::Error,
@@ -264,7 +261,7 @@ impl<'a, E> ValueDeserializer<E> for &'a str
     type Deserializer = StrDeserializer<'a, E>;
 
     fn into_deserializer(self) -> StrDeserializer<'a, E> {
-        StrDeserializer(Some(self), PhantomData)
+        StrDeserializer(self, PhantomData)
     }
 }
 
@@ -273,19 +270,16 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
 {
     type Error = E;
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        match self.0.take() {
-            Some(v) => visitor.visit_str(v),
-            None => Err(de::Error::end_of_stream()),
-        }
+        visitor.visit_str(self.0)
     }
 
-    fn deserialize_enum<V>(&mut self,
+    fn deserialize_enum<V>(self,
                      _name: &str,
                      _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Self::Error>
+                     visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_enum(self)
@@ -298,41 +292,16 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
     }
 }
 
-impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
+impl<'a, E> de::EnumVisitor for StrDeserializer<'a, E>
     where E: de::Error,
 {
     type Error = E;
+    type Variant = private::UnitOnly<E>;
 
-    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
+    fn visit_variant<T>(self) -> Result<(T, Self::Variant), Self::Error>
         where T: de::Deserialize,
     {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
-        where T: super::Deserialize,
-    {
-        Err(super::Error::invalid_type(super::Type::NewtypeVariant))
-    }
-
-    fn visit_tuple<V>(&mut self,
-                      _len: usize,
-                      _visitor: V) -> Result<V::Value, Self::Error>
-        where V: super::Visitor
-    {
-        Err(super::Error::invalid_type(super::Type::TupleVariant))
-    }
-
-    fn visit_struct<V>(&mut self,
-                       _fields: &'static [&'static str],
-                       _visitor: V) -> Result<V::Value, Self::Error>
-        where V: super::Visitor
-    {
-        Err(super::Error::invalid_type(super::Type::StructVariant))
+        de::Deserialize::deserialize(self).map(private::unit_only)
     }
 }
 
@@ -340,7 +309,7 @@ impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
 
 /// A helper deserializer that deserializes a `String`.
 #[cfg(any(feature = "std", feature = "collections"))]
-pub struct StringDeserializer<E>(Option<String>, PhantomData<E>);
+pub struct StringDeserializer<E>(String, PhantomData<E>);
 
 #[cfg(any(feature = "std", feature = "collections"))]
 impl<E> ValueDeserializer<E> for String
@@ -349,7 +318,7 @@ impl<E> ValueDeserializer<E> for String
     type Deserializer = StringDeserializer<E>;
 
     fn into_deserializer(self) -> StringDeserializer<E> {
-        StringDeserializer(Some(self), PhantomData)
+        StringDeserializer(self, PhantomData)
     }
 }
 
@@ -359,19 +328,16 @@ impl<E> de::Deserializer for StringDeserializer<E>
 {
     type Error = E;
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        match self.0.take() {
-            Some(string) => visitor.visit_string(string),
-            None => Err(de::Error::end_of_stream()),
-        }
+        visitor.visit_string(self.0)
     }
 
-    fn deserialize_enum<V>(&mut self,
+    fn deserialize_enum<V>(self,
                      _name: &str,
                      _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Self::Error>
+                     visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_enum(self)
@@ -385,41 +351,16 @@ impl<E> de::Deserializer for StringDeserializer<E>
 }
 
 #[cfg(any(feature = "std", feature = "collections"))]
-impl<'a, E> de::VariantVisitor for StringDeserializer<E>
+impl<'a, E> de::EnumVisitor for StringDeserializer<E>
     where E: de::Error,
 {
     type Error = E;
+    type Variant = private::UnitOnly<E>;
 
-    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
+    fn visit_variant<T>(self) -> Result<(T, Self::Variant), Self::Error>
         where T: de::Deserialize,
     {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
-        where T: super::Deserialize,
-    {
-        Err(super::Error::invalid_type(super::Type::NewtypeVariant))
-    }
-
-    fn visit_tuple<V>(&mut self,
-                      _len: usize,
-                      _visitor: V) -> Result<V::Value, Self::Error>
-        where V: super::Visitor
-    {
-        Err(super::Error::invalid_type(super::Type::TupleVariant))
-    }
-
-    fn visit_struct<V>(&mut self,
-                       _fields: &'static [&'static str],
-                       _visitor: V) -> Result<V::Value, Self::Error>
-        where V: super::Visitor
-    {
-        Err(super::Error::invalid_type(super::Type::StructVariant))
+        de::Deserialize::deserialize(self).map(private::unit_only)
     }
 }
 
@@ -427,7 +368,7 @@ impl<'a, E> de::VariantVisitor for StringDeserializer<E>
 
 /// A helper deserializer that deserializes a `String`.
 #[cfg(any(feature = "std", feature = "collections"))]
-pub struct CowStrDeserializer<'a, E>(Option<Cow<'a, str>>, PhantomData<E>);
+pub struct CowStrDeserializer<'a, E>(Cow<'a, str>, PhantomData<E>);
 
 #[cfg(any(feature = "std", feature = "collections"))]
 impl<'a, E> ValueDeserializer<E> for Cow<'a, str>
@@ -436,7 +377,7 @@ impl<'a, E> ValueDeserializer<E> for Cow<'a, str>
     type Deserializer = CowStrDeserializer<'a, E>;
 
     fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
-        CowStrDeserializer(Some(self), PhantomData)
+        CowStrDeserializer(self, PhantomData)
     }
 }
 
@@ -446,20 +387,19 @@ impl<'a, E> de::Deserializer for CowStrDeserializer<'a, E>
 {
     type Error = E;
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        match self.0.take() {
-            Some(Cow::Borrowed(string)) => visitor.visit_str(string),
-            Some(Cow::Owned(string)) => visitor.visit_string(string),
-            None => Err(de::Error::end_of_stream()),
+        match self.0 {
+            Cow::Borrowed(string) => visitor.visit_str(string),
+            Cow::Owned(string) => visitor.visit_string(string),
         }
     }
 
-    fn deserialize_enum<V>(&mut self,
+    fn deserialize_enum<V>(self,
                      _name: &str,
                      _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Self::Error>
+                     visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_enum(self)
@@ -473,41 +413,16 @@ impl<'a, E> de::Deserializer for CowStrDeserializer<'a, E>
 }
 
 #[cfg(any(feature = "std", feature = "collections"))]
-impl<'a, E> de::VariantVisitor for CowStrDeserializer<'a, E>
+impl<'a, E> de::EnumVisitor for CowStrDeserializer<'a, E>
     where E: de::Error,
 {
     type Error = E;
+    type Variant = private::UnitOnly<E>;
 
-    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
+    fn visit_variant<T>(self) -> Result<(T, Self::Variant), Self::Error>
         where T: de::Deserialize,
     {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
-        where T: super::Deserialize,
-    {
-        Err(super::Error::invalid_type(super::Type::NewtypeVariant))
-    }
-
-    fn visit_tuple<V>(&mut self,
-                      _len: usize,
-                      _visitor: V) -> Result<V::Value, Self::Error>
-        where V: super::Visitor
-    {
-        Err(super::Error::invalid_type(super::Type::TupleVariant))
-    }
-
-    fn visit_struct<V>(&mut self,
-                       _fields: &'static [&'static str],
-                       _visitor: V) -> Result<V::Value, Self::Error>
-        where V: super::Visitor
-    {
-        Err(super::Error::invalid_type(super::Type::StructVariant))
+        de::Deserialize::deserialize(self).map(private::unit_only)
     }
 }
 
@@ -540,10 +455,10 @@ impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
 {
     type Error = E;
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        let v = try!(visitor.visit_seq(&mut *self));
+        let v = try!(visitor.visit_seq(&mut self));
         if self.len == 0 {
             Ok(v)
         } else {
@@ -571,8 +486,7 @@ impl<I, T, E> de::SeqVisitor for SeqDeserializer<I, E>
         match self.iter.next() {
             Some(value) => {
                 self.len -= 1;
-                let mut de = value.into_deserializer();
-                Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
+                de::Deserialize::deserialize(value.into_deserializer()).map(Some)
             }
             None => Ok(None),
         }
@@ -651,8 +565,8 @@ impl<V_, E> de::Deserializer for SeqVisitorDeserializer<V_, E>
 {
     type Error = E;
 
-    fn deserialize<V: de::Visitor>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error> {
-        visitor.visit_seq(&mut self.visitor)
+    fn deserialize<V: de::Visitor>(self, visitor: V) -> Result<V::Value, Self::Error> {
+        visitor.visit_seq(self.visitor)
     }
 
     forward_to_deserialize! {
@@ -729,29 +643,29 @@ impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
 {
     type Error = E;
 
-    fn deserialize<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
+    fn deserialize<V_>(mut self, visitor: V_) -> Result<V_::Value, Self::Error>
         where V_: de::Visitor,
     {
-        let value = try!(visitor.visit_map(&mut *self));
+        let value = try!(visitor.visit_map(&mut self));
         try!(self.end());
         Ok(value)
     }
 
-    fn deserialize_seq<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
+    fn deserialize_seq<V_>(mut self, visitor: V_) -> Result<V_::Value, Self::Error>
         where V_: de::Visitor,
     {
-        let value = try!(visitor.visit_seq(&mut *self));
+        let value = try!(visitor.visit_seq(&mut self));
         try!(self.end());
         Ok(value)
     }
 
-    fn deserialize_seq_fixed_size<V_>(&mut self, len: usize, mut visitor: V_) -> Result<V_::Value, Self::Error>
+    fn deserialize_seq_fixed_size<V_>(mut self, len: usize, visitor: V_) -> Result<V_::Value, Self::Error>
         where V_: de::Visitor,
     {
         match self.len {
             Some(map_len) if map_len != len => Err(de::Error::invalid_length(len)),
             _ => {
-                let value = try!(visitor.visit_seq(&mut *self));
+                let value = try!(visitor.visit_seq(&mut self));
                 try!(self.end());
                 Ok(value)
             }
@@ -779,8 +693,7 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
         match self.next() {
             Some((key, value)) => {
                 self.value = Some(value);
-                let mut de = key.into_deserializer();
-                de::Deserialize::deserialize(&mut de).map(Some)
+                de::Deserialize::deserialize(key.into_deserializer()).map(Some)
             }
             None => Ok(None),
         }
@@ -791,8 +704,7 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
     {
         match self.value.take() {
             Some(value) => {
-                let mut de = value.into_deserializer();
-                de::Deserialize::deserialize(&mut de)
+                de::Deserialize::deserialize(value.into_deserializer())
             }
             None => {
                 Err(de::Error::end_of_stream())
@@ -800,6 +712,20 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
         }
     }
 
+    fn visit<TK, TV>(&mut self) -> Result<Option<(TK, TV)>, Self::Error>
+        where TK: de::Deserialize,
+              TV: de::Deserialize
+    {
+        match self.next() {
+            Some((key, value)) => {
+                let key = try!(de::Deserialize::deserialize(key.into_deserializer()));
+                let value = try!(de::Deserialize::deserialize(value.into_deserializer()));
+                Ok(Some((key, value)))
+            }
+            None => Ok(None)
+        }
+    }
+
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.len.map_or_else(
             || self.iter.size_hint(),
@@ -819,9 +745,9 @@ impl<I, K, V, E> de::SeqVisitor for MapDeserializer<I, K, V, E>
         where T: de::Deserialize,
     {
         match self.next() {
-            Some(kv) => {
-                let mut de = PairDeserializer(Some(kv), PhantomData);
-                de::Deserialize::deserialize(&mut de).map(Some)
+            Some((k, v)) => {
+                let de = PairDeserializer(k, v, PhantomData);
+                de::Deserialize::deserialize(de).map(Some)
             }
             None => Ok(None),
         }
@@ -834,7 +760,7 @@ impl<I, K, V, E> de::SeqVisitor for MapDeserializer<I, K, V, E>
 
 // Used in the `impl SeqVisitor for MapDeserializer` to visit the map as a
 // sequence of pairs.
-struct PairDeserializer<A, B, E>(Option<(A, B)>, PhantomData<E>);
+struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
 
 impl<A, B, E> de::Deserializer for PairDeserializer<A, B, E>
     where A: ValueDeserializer<E>,
@@ -849,30 +775,25 @@ impl<A, B, E> de::Deserializer for PairDeserializer<A, B, E>
         struct_field tuple enum ignored_any
     }
 
-    fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         self.deserialize_seq(visitor)
     }
 
-    fn deserialize_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        match self.0.take() {
-            Some((k, v)) => {
-                let mut pair_visitor = PairVisitor(Some(k), Some(v), PhantomData);
-                let pair = try!(visitor.visit_seq(&mut pair_visitor));
-                if pair_visitor.1.is_none() {
-                    Ok(pair)
-                } else {
-                    Err(de::Error::invalid_length(pair_visitor.size_hint().0))
-                }
-            }
-            None => Err(de::Error::end_of_stream()),
+        let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData);
+        let pair = try!(visitor.visit_seq(&mut pair_visitor));
+        if pair_visitor.1.is_none() {
+            Ok(pair)
+        } else {
+            Err(de::Error::invalid_length(pair_visitor.size_hint().0))
         }
     }
 
-    fn deserialize_seq_fixed_size<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_seq_fixed_size<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         if len == 2 {
@@ -896,11 +817,9 @@ impl<A, B, E> de::SeqVisitor for PairVisitor<A, B, E>
         where T: de::Deserialize,
     {
         if let Some(k) = self.0.take() {
-            let mut de = k.into_deserializer();
-            de::Deserialize::deserialize(&mut de).map(Some)
+            de::Deserialize::deserialize(k.into_deserializer()).map(Some)
         } else if let Some(v) = self.1.take() {
-            let mut de = v.into_deserializer();
-            de::Deserialize::deserialize(&mut de).map(Some)
+            de::Deserialize::deserialize(v.into_deserializer()).map(Some)
         } else {
             Ok(None)
         }
@@ -975,8 +894,8 @@ impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
 {
     type Error = E;
 
-    fn deserialize<V: de::Visitor>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error> {
-        visitor.visit_map(&mut self.visitor)
+    fn deserialize<V: de::Visitor>(self, visitor: V) -> Result<V::Value, Self::Error> {
+        visitor.visit_map(self.visitor)
     }
 
     forward_to_deserialize! {
@@ -994,25 +913,22 @@ impl<'a, E> ValueDeserializer<E> for bytes::Bytes<'a>
     type Deserializer = BytesDeserializer<'a, E>;
 
     fn into_deserializer(self) -> BytesDeserializer<'a, E> {
-        BytesDeserializer(Some(self.into()), PhantomData)
+        BytesDeserializer(self.into(), PhantomData)
     }
 }
 
 /// A helper deserializer that deserializes a `&[u8]`.
-pub struct BytesDeserializer<'a, E> (Option<&'a [u8]>, PhantomData<E>);
+pub struct BytesDeserializer<'a, E>(&'a [u8], PhantomData<E>);
 
 impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
     where E: de::Error
 {
     type Error = E;
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        match self.0.take() {
-            Some(bytes) => visitor.visit_bytes(bytes),
-            None => Err(de::Error::end_of_stream()),
-        }
+        visitor.visit_bytes(self.0)
     }
 
     forward_to_deserialize! {
@@ -1031,13 +947,13 @@ impl<E> ValueDeserializer<E> for bytes::ByteBuf
     type Deserializer = ByteBufDeserializer<E>;
 
     fn into_deserializer(self) -> Self::Deserializer {
-        ByteBufDeserializer(Some(self.into()), PhantomData)
+        ByteBufDeserializer(self.into(), PhantomData)
     }
 }
 
 /// A helper deserializer that deserializes a `Vec<u8>`.
 #[cfg(any(feature = "std", feature = "collections"))]
-pub struct ByteBufDeserializer<E>(Option<Vec<u8>>, PhantomData<E>);
+pub struct ByteBufDeserializer<E>(Vec<u8>, PhantomData<E>);
 
 #[cfg(any(feature = "std", feature = "collections"))]
 impl<E> de::Deserializer for ByteBufDeserializer<E>
@@ -1045,13 +961,10 @@ impl<E> de::Deserializer for ByteBufDeserializer<E>
 {
     type Error = E;
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
-        match self.0.take() {
-            Some(bytes) => visitor.visit_byte_buf(bytes),
-            None => Err(de::Error::end_of_stream()),
-        }
+        visitor.visit_byte_buf(self.0)
     }
 
     forward_to_deserialize! {
@@ -1060,3 +973,48 @@ impl<E> de::Deserializer for ByteBufDeserializer<E>
         tuple_struct struct struct_field tuple enum ignored_any
     }
 }
+
+///////////////////////////////////////////////////////////////////////////////
+
+mod private {
+    use de;
+    use core::marker::PhantomData;
+
+    pub struct UnitOnly<E>(PhantomData<E>);
+
+    pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
+        (t, UnitOnly(PhantomData))
+    }
+
+    impl<E> de::VariantVisitor for UnitOnly<E>
+        where E: de::Error
+    {
+        type Error = E;
+
+        fn visit_unit(self) -> Result<(), Self::Error> {
+            Ok(())
+        }
+
+        fn visit_newtype<T>(self) -> Result<T, Self::Error>
+            where T: de::Deserialize,
+        {
+            Err(de::Error::invalid_type(de::Type::NewtypeVariant))
+        }
+
+        fn visit_tuple<V>(self,
+                        _len: usize,
+                        _visitor: V) -> Result<V::Value, Self::Error>
+            where V: de::Visitor
+        {
+            Err(de::Error::invalid_type(de::Type::TupleVariant))
+        }
+
+        fn visit_struct<V>(self,
+                        _fields: &'static [&'static str],
+                        _visitor: V) -> Result<V::Value, Self::Error>
+            where V: de::Visitor
+        {
+            Err(de::Error::invalid_type(de::Type::StructVariant))
+        }
+    }
+}
diff --git a/serde/src/macros.rs b/serde/src/macros.rs
index d8673ca4..2580980f 100644
--- a/serde/src/macros.rs
+++ b/serde/src/macros.rs
@@ -4,7 +4,7 @@
 macro_rules! forward_to_deserialize_method {
     ($func:ident($($arg:ty),*)) => {
         #[inline]
-        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::std::result::Result<__V::Value, Self::Error>
+        fn $func<__V>(self, $(_: $arg,)* visitor: __V) -> ::std::result::Result<__V::Value, Self::Error>
             where __V: $crate::de::Visitor
         {
             self.deserialize(visitor)
@@ -18,7 +18,7 @@ macro_rules! forward_to_deserialize_method {
 macro_rules! forward_to_deserialize_method {
     ($func:ident($($arg:ty),*)) => {
         #[inline]
-        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::core::result::Result<__V::Value, Self::Error>
+        fn $func<__V>(self, $(_: $arg,)* visitor: __V) -> ::core::result::Result<__V::Value, Self::Error>
             where __V: $crate::de::Visitor
         {
             self.deserialize(visitor)
@@ -128,7 +128,7 @@ macro_rules! forward_to_deserialize_helper {
 ///
 /// ```rust,ignore
 /// impl Deserializer for MyDeserializer {
-///     fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+///     fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
 ///         where V: Visitor
 ///     {
 ///         /* ... */
diff --git a/serde_codegen/src/de.rs b/serde_codegen/src/de.rs
index 808bdabc..32f186ee 100644
--- a/serde_codegen/src/de.rs
+++ b/serde_codegen/src/de.rs
@@ -36,7 +36,7 @@ pub fn expand_derive_deserialize(item: &syn::MacroInput) -> Result<Tokens, Strin
             extern crate serde as _serde;
             #[automatically_derived]
             impl #impl_generics _serde::Deserialize for #ty #where_clause {
-                fn deserialize<__D>(deserializer: &mut __D) -> ::std::result::Result<#ty, __D::Error>
+                fn deserialize<__D>(deserializer: __D) -> ::std::result::Result<#ty, __D::Error>
                     where __D: _serde::Deserializer
                 #body
             }
@@ -207,14 +207,14 @@ fn deserialize_unit_struct(
             type Value = #type_ident;
 
             #[inline]
-            fn visit_unit<__E>(&mut self) -> ::std::result::Result<#type_ident, __E>
+            fn visit_unit<__E>(self) -> ::std::result::Result<#type_ident, __E>
                 where __E: _serde::de::Error,
             {
                 Ok(#type_ident)
             }
 
             #[inline]
-            fn visit_seq<__V>(&mut self, _: __V) -> ::std::result::Result<#type_ident, __V::Error>
+            fn visit_seq<__V>(self, _: __V) -> ::std::result::Result<#type_ident, __V::Error>
                 where __V: _serde::de::SeqVisitor,
             {
                 Ok(#type_ident)
@@ -265,7 +265,7 @@ fn deserialize_tuple(
     );
 
     let dispatch = if is_enum {
-        quote!(visitor.visit_tuple(#nfields, #visitor_expr))
+        quote!(_serde::de::VariantVisitor::visit_tuple(visitor, #nfields, #visitor_expr))
     } else if nfields == 1 {
         let type_name = item_attrs.name().deserialize_name();
         quote!(deserializer.deserialize_newtype_struct(#type_name, #visitor_expr))
@@ -290,7 +290,7 @@ fn deserialize_tuple(
             #visit_newtype_struct
 
             #[inline]
-            fn visit_seq<__V>(&mut self, #visitor_var: __V) -> ::std::result::Result<#ty, __V::Error>
+            fn visit_seq<__V>(self, #visitor_var: __V) -> ::std::result::Result<#ty, __V::Error>
                 where __V: _serde::de::SeqVisitor
             {
                 #visit_seq
@@ -389,7 +389,7 @@ fn deserialize_newtype_struct(
     };
     quote! {
         #[inline]
-        fn visit_newtype_struct<__E>(&mut self, __e: &mut __E) -> ::std::result::Result<Self::Value, __E::Error>
+        fn visit_newtype_struct<__E>(self, __e: __E) -> ::std::result::Result<Self::Value, __E::Error>
             where __E: _serde::Deserializer,
         {
             Ok(#type_path(#value))
@@ -433,7 +433,7 @@ fn deserialize_struct(
     let is_enum = variant_ident.is_some();
     let dispatch = if is_enum {
         quote! {
-            visitor.visit_struct(FIELDS, #visitor_expr)
+            _serde::de::VariantVisitor::visit_struct(visitor, FIELDS, #visitor_expr)
         }
     } else {
         let type_name = item_attrs.name().deserialize_name();
@@ -458,14 +458,14 @@ fn deserialize_struct(
             type Value = #ty;
 
             #[inline]
-            fn visit_seq<__V>(&mut self, #visitor_var: __V) -> ::std::result::Result<#ty, __V::Error>
+            fn visit_seq<__V>(self, #visitor_var: __V) -> ::std::result::Result<#ty, __V::Error>
                 where __V: _serde::de::SeqVisitor
             {
                 #visit_seq
             }
 
             #[inline]
-            fn visit_map<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<#ty, __V::Error>
+            fn visit_map<__V>(self, mut visitor: __V) -> ::std::result::Result<#ty, __V::Error>
                 where __V: _serde::de::MapVisitor
             {
                 #visit_map
@@ -523,7 +523,7 @@ fn deserialize_item_enum(
             );
 
             quote! {
-                __Field::#variant_name => #block
+                (__Field::#variant_name, visitor) => #block
             }
         });
 
@@ -535,7 +535,7 @@ fn deserialize_item_enum(
             // FIXME: Once we drop support for Rust 1.15:
             // let Err(err) = visitor.visit_variant::<__Field>();
             // Err(err)
-            visitor.visit_variant::<__Field>().map(|impossible| match impossible {})
+            visitor.visit_variant::<__Field>().map(|(impossible, _)| match impossible {})
         }
     } else {
         quote! {
@@ -555,8 +555,8 @@ fn deserialize_item_enum(
         impl #impl_generics _serde::de::Visitor for #visitor_ty #where_clause {
             type Value = #ty;
 
-            fn visit_enum<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<#ty, __V::Error>
-                where __V: _serde::de::VariantVisitor,
+            fn visit_enum<__V>(self, visitor: __V) -> ::std::result::Result<#ty, __V::Error>
+                where __V: _serde::de::EnumVisitor,
             {
                 #match_variant
             }
@@ -580,7 +580,7 @@ fn deserialize_variant(
     match variant.style {
         Style::Unit => {
             quote!({
-                try!(visitor.visit_unit());
+                try!(_serde::de::VariantVisitor::visit_unit(visitor));
                 Ok(#type_ident::#variant_ident)
             })
         }
@@ -624,7 +624,9 @@ fn deserialize_newtype_variant(
     let visit = match field.attrs.deserialize_with() {
         None => {
             let field_ty = &field.ty;
-            quote!(try!(visitor.visit_newtype::<#field_ty>()))
+            quote! {
+                try!(_serde::de::VariantVisitor::visit_newtype::<#field_ty>(visitor))
+            }
         }
         Some(path) => {
             let (wrapper, wrapper_impl, wrapper_ty) = wrap_deserialize_with(
@@ -632,7 +634,7 @@ fn deserialize_newtype_variant(
             quote!({
                 #wrapper
                 #wrapper_impl
-                try!(visitor.visit_newtype::<#wrapper_ty>()).value
+                try!(_serde::de::VariantVisitor::visit_newtype::<#wrapper_ty>(visitor)).value
             })
         }
     };
@@ -678,7 +680,7 @@ fn deserialize_field_visitor(
 
         impl _serde::Deserialize for __Field {
             #[inline]
-            fn deserialize<__D>(deserializer: &mut __D) -> ::std::result::Result<__Field, __D::Error>
+            fn deserialize<__D>(deserializer: __D) -> ::std::result::Result<__Field, __D::Error>
                 where __D: _serde::Deserializer,
             {
                 struct __FieldVisitor;
@@ -686,7 +688,7 @@ fn deserialize_field_visitor(
                 impl _serde::de::Visitor for __FieldVisitor {
                     type Value = __Field;
 
-                    fn visit_str<__E>(&mut self, value: &str) -> ::std::result::Result<__Field, __E>
+                    fn visit_str<__E>(self, value: &str) -> ::std::result::Result<__Field, __E>
                         where __E: _serde::de::Error
                     {
                         match value {
@@ -896,7 +898,7 @@ fn wrap_deserialize_with(
         },
         quote! {
             impl #impl_generics _serde::Deserialize for #wrapper_ty #where_clause {
-                fn deserialize<__D>(__d: &mut __D) -> ::std::result::Result<Self, __D::Error>
+                fn deserialize<__D>(__d: __D) -> ::std::result::Result<Self, __D::Error>
                     where __D: _serde::Deserializer
                 {
                     let value = try!(#deserialize_with(__d));
diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs
index 559e9972..80ba9e80 100644
--- a/serde_test/src/de.rs
+++ b/serde_test/src/de.rs
@@ -3,11 +3,13 @@ use std::iter;
 use serde::de::{
     self,
     Deserialize,
+    EnumVisitor,
     MapVisitor,
     SeqVisitor,
     VariantVisitor,
     Visitor,
 };
+use serde::de::value::ValueDeserializer;
 
 use error::Error;
 use token::Token;
@@ -44,7 +46,7 @@ impl<I> Deserializer<I>
         }
     }
 
-    fn visit_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_seq<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_seq(DeserializerSeqVisitor {
@@ -55,7 +57,7 @@ impl<I> Deserializer<I>
         Ok(value)
     }
 
-    fn visit_array<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_array<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_seq(DeserializerArrayVisitor {
@@ -66,7 +68,7 @@ impl<I> Deserializer<I>
         Ok(value)
     }
 
-    fn visit_tuple<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_seq(DeserializerTupleVisitor {
@@ -77,7 +79,7 @@ impl<I> Deserializer<I>
         Ok(value)
     }
 
-    fn visit_tuple_struct<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_tuple_struct<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_seq(DeserializerTupleStructVisitor {
@@ -88,7 +90,7 @@ impl<I> Deserializer<I>
         Ok(value)
     }
 
-    fn visit_variant_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_variant_seq<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_seq(DeserializerVariantSeqVisitor {
@@ -99,7 +101,7 @@ impl<I> Deserializer<I>
         Ok(value)
     }
 
-    fn visit_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_map<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_map(DeserializerMapVisitor {
@@ -110,7 +112,7 @@ impl<I> Deserializer<I>
         Ok(value)
     }
 
-    fn visit_struct<V>(&mut self, fields: &'static [&'static str], mut visitor: V) -> Result<V::Value, Error>
+    fn visit_struct<V>(&mut self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_map(DeserializerStructVisitor {
@@ -121,7 +123,7 @@ impl<I> Deserializer<I>
         Ok(value)
     }
 
-    fn visit_variant_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_variant_map<V>(&mut self, len: Option<usize>, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         let value = try!(visitor.visit_map(DeserializerVariantMapVisitor {
@@ -133,101 +135,101 @@ impl<I> Deserializer<I>
     }
 }
 
-impl<I> de::Deserializer for Deserializer<I>
+impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
-    fn deserialize_seq<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_seq<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_struct_field<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_struct_field<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_map<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_map<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_unit<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_unit<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_bytes<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_bytes<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_ignored_any<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_ignored_any<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_string<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_string<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_str<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_str<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_char<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_char<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_i64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_i64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_i32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_i32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_i16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_i16<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_i8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_i8<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_u64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_u64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_u32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_u32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_u16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_u16<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_u8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_u8<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_f32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_f32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_f64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_f64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_bool<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_bool<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_usize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_usize<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
-    fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+    fn deserialize_isize<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error>
         where __V: de::Visitor {
         self.deserialize(visitor)
     }
 
-    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         match self.tokens.next() {
@@ -271,7 +273,7 @@ impl<I> de::Deserializer for Deserializer<I>
 
     /// Hook into `Option` deserializing so we can treat `Unit` as a
     /// `None`, or a regular value as `Some(value)`.
-    fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         match self.tokens.peek() {
@@ -292,17 +294,17 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_enum<V>(&mut self,
+    fn deserialize_enum<V>(self,
                      name: &str,
                      _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Error>
+                     visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::EnumStart(n)) if name == n => {
                 self.tokens.next();
 
-                visitor.visit_enum(DeserializerVariantVisitor {
+                visitor.visit_enum(DeserializerEnumVisitor {
                     de: self,
                 })
             }
@@ -310,7 +312,7 @@ impl<I> de::Deserializer for Deserializer<I>
             | Some(&Token::EnumNewType(n, _))
             | Some(&Token::EnumSeqStart(n, _, _))
             | Some(&Token::EnumMapStart(n, _, _)) if name == n => {
-                visitor.visit_enum(DeserializerVariantVisitor {
+                visitor.visit_enum(DeserializerEnumVisitor {
                     de: self,
                 })
             }
@@ -322,7 +324,7 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_unit_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize_unit_struct<V>(self, name: &str, visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         match self.tokens.peek() {
@@ -339,9 +341,9 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_newtype_struct<V>(&mut self,
+    fn deserialize_newtype_struct<V>(self,
                                      name: &str,
-                                     mut visitor: V) -> Result<V::Value, Error>
+                                     visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         match self.tokens.peek() {
@@ -358,7 +360,7 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_seq_fixed_size<V>(&mut self,
+    fn deserialize_seq_fixed_size<V>(self,
                                        len: usize,
                                        visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
@@ -373,9 +375,9 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_tuple<V>(&mut self,
+    fn deserialize_tuple<V>(self,
                             len: usize,
-                            mut visitor: V) -> Result<V::Value, Error>
+                            visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         match self.tokens.peek() {
@@ -408,10 +410,10 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_tuple_struct<V>(&mut self,
+    fn deserialize_tuple_struct<V>(self,
                                    name: &str,
                                    len: usize,
-                                   mut visitor: V) -> Result<V::Value, Error>
+                                   visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
         match self.tokens.peek() {
@@ -452,7 +454,7 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_struct<V>(&mut self,
+    fn deserialize_struct<V>(self,
                              name: &str,
                              fields: &'static [&'static str],
                              visitor: V) -> Result<V::Value, Error>
@@ -496,7 +498,7 @@ impl<'a, I> SeqVisitor for DeserializerSeqVisitor<'a, I>
             Some(&Token::SeqSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| len - 1);
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::SeqEnd) => Ok(None),
             Some(_) => {
@@ -532,7 +534,7 @@ impl<'a, I> SeqVisitor for DeserializerArrayVisitor<'a, I>
             Some(&Token::SeqSep) => {
                 self.de.tokens.next();
                 self.len -= 1;
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::SeqEnd) => Ok(None),
             Some(_) => {
@@ -567,7 +569,7 @@ impl<'a, I> SeqVisitor for DeserializerTupleVisitor<'a, I>
             Some(&Token::TupleSep) => {
                 self.de.tokens.next();
                 self.len -= 1;
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::TupleEnd) => Ok(None),
             Some(_) => {
@@ -602,7 +604,7 @@ impl<'a, I> SeqVisitor for DeserializerTupleStructVisitor<'a, I>
             Some(&Token::TupleStructSep) => {
                 self.de.tokens.next();
                 self.len -= 1;
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::TupleStructEnd) => Ok(None),
             Some(_) => {
@@ -637,7 +639,7 @@ impl<'a, I> SeqVisitor for DeserializerVariantSeqVisitor<'a, I>
             Some(&Token::EnumSeqSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| len - 1);
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::EnumSeqEnd) => Ok(None),
             Some(_) => {
@@ -673,7 +675,7 @@ impl<'a, I> MapVisitor for DeserializerMapVisitor<'a, I>
             Some(&Token::MapSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 });
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::MapEnd) => Ok(None),
             Some(_) => {
@@ -687,7 +689,7 @@ impl<'a, I> MapVisitor for DeserializerMapVisitor<'a, I>
     fn visit_value<V>(&mut self) -> Result<V, Error>
         where V: Deserialize,
     {
-        Ok(try!(Deserialize::deserialize(self.de)))
+        Deserialize::deserialize(&mut *self.de)
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -715,7 +717,7 @@ impl<'a, I> MapVisitor for DeserializerStructVisitor<'a, I>
             Some(&Token::StructSep) => {
                 self.de.tokens.next();
                 self.len = self.len.saturating_sub(1);
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::StructEnd) => Ok(None),
             Some(_) => {
@@ -729,7 +731,7 @@ impl<'a, I> MapVisitor for DeserializerStructVisitor<'a, I>
     fn visit_value<V>(&mut self) -> Result<V, Error>
         where V: Deserialize,
     {
-        Ok(try!(Deserialize::deserialize(self.de)))
+        Deserialize::deserialize(&mut *self.de)
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -739,16 +741,17 @@ impl<'a, I> MapVisitor for DeserializerStructVisitor<'a, I>
 
 //////////////////////////////////////////////////////////////////////////
 
-struct DeserializerVariantVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
+struct DeserializerEnumVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
     de: &'a mut Deserializer<I>,
 }
 
-impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
+impl<'a, I> EnumVisitor for DeserializerEnumVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
+    type Variant = Self;
 
-    fn visit_variant<V>(&mut self) -> Result<V, Error>
+    fn visit_variant<V>(self) -> Result<(V, Self), Error>
         where V: Deserialize,
     {
         match self.de.tokens.peek() {
@@ -756,18 +759,25 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
             | Some(&Token::EnumNewType(_, v))
             | Some(&Token::EnumSeqStart(_, v, _))
             | Some(&Token::EnumMapStart(_, v, _)) => {
-                let mut de = de::value::ValueDeserializer::<Error>::into_deserializer(v);
-                let value = try!(Deserialize::deserialize(&mut de));
-                Ok(value)
+                let de = v.into_deserializer();
+                let value = try!(Deserialize::deserialize(de));
+                Ok((value, self))
             }
             Some(_) => {
-                Deserialize::deserialize(self.de)
+                let value = try!(Deserialize::deserialize(&mut *self.de));
+                Ok((value, self))
             }
             None => Err(Error::EndOfStream),
         }
     }
+}
 
-    fn visit_unit(&mut self) -> Result<(), Error> {
+impl<'a, I> VariantVisitor for DeserializerEnumVisitor<'a, I>
+    where I: Iterator<Item=Token<'static>>
+{
+    type Error = Error;
+
+    fn visit_unit(self) -> Result<(), Error> {
         match self.de.tokens.peek() {
             Some(&Token::EnumUnit(_, _)) => {
                 self.de.tokens.next();
@@ -780,7 +790,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
         }
     }
 
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+    fn visit_newtype<T>(self) -> Result<T, Self::Error>
         where T: Deserialize,
     {
         match self.de.tokens.peek() {
@@ -795,7 +805,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
         }
     }
 
-    fn visit_tuple<V>(&mut self,
+    fn visit_tuple<V>(self,
                       len: usize,
                       visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
@@ -826,7 +836,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
         }
     }
 
-    fn visit_struct<V>(&mut self,
+    fn visit_struct<V>(self,
                        fields: &'static [&'static str],
                        visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
@@ -877,7 +887,7 @@ impl<'a, I> MapVisitor for DeserializerVariantMapVisitor<'a, I>
             Some(&Token::EnumMapSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 });
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
+                Deserialize::deserialize(&mut *self.de).map(Some)
             }
             Some(&Token::EnumMapEnd) => Ok(None),
             Some(_) => {
@@ -891,7 +901,7 @@ impl<'a, I> MapVisitor for DeserializerVariantMapVisitor<'a, I>
     fn visit_value<V>(&mut self) -> Result<V, Error>
         where V: Deserialize,
     {
-        Ok(try!(Deserialize::deserialize(self.de)))
+        Deserialize::deserialize(&mut *self.de)
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
diff --git a/testing/tests/test_annotations.rs b/testing/tests/test_annotations.rs
index ba77f8f9..b2971fea 100644
--- a/testing/tests/test_annotations.rs
+++ b/testing/tests/test_annotations.rs
@@ -25,7 +25,7 @@ trait SerializeWith: Sized {
 }
 
 trait DeserializeWith: Sized {
-    fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
+    fn deserialize_with<D>(de: D) -> Result<Self, D::Error>
         where D: Deserializer;
 }
 
@@ -50,7 +50,7 @@ impl SerializeWith for i32 {
 }
 
 impl DeserializeWith for i32 {
-    fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
+    fn deserialize_with<D>(de: D) -> Result<Self, D::Error>
         where D: Deserializer
     {
         if try!(Deserialize::deserialize(de)) {
@@ -239,7 +239,7 @@ impl Default for NotDeserializeStruct {
 }
 
 impl DeserializeWith for NotDeserializeStruct {
-    fn deserialize_with<D>(_: &mut D) -> Result<Self, D::Error>
+    fn deserialize_with<D>(_: D) -> Result<Self, D::Error>
         where D: Deserializer
     {
         panic!()
diff --git a/testing/tests/test_gen.rs b/testing/tests/test_gen.rs
index 24338312..3945a924 100644
--- a/testing/tests/test_gen.rs
+++ b/testing/tests/test_gen.rs
@@ -299,7 +299,7 @@ trait SerializeWith {
 }
 
 trait DeserializeWith: Sized {
-    fn deserialize_with<D: Deserializer>(_: &mut D) -> StdResult<Self, D::Error>;
+    fn deserialize_with<D: Deserializer>(_: D) -> StdResult<Self, D::Error>;
 }
 
 // Implements neither Serialize nor Deserialize
@@ -309,7 +309,7 @@ fn ser_x<S: Serializer>(_: &X, _: &mut S) -> StdResult<(), S::Error> {
     unimplemented!()
 }
 
-fn de_x<D: Deserializer>(_: &mut D) -> StdResult<X, D::Error> {
+fn de_x<D: Deserializer>(_: D) -> StdResult<X, D::Error> {
     unimplemented!()
 }
 
@@ -320,7 +320,7 @@ impl SerializeWith for X {
 }
 
 impl DeserializeWith for X {
-    fn deserialize_with<D: Deserializer>(_: &mut D) -> StdResult<Self, D::Error> {
+    fn deserialize_with<D: Deserializer>(_: D) -> StdResult<Self, D::Error> {
         unimplemented!()
     }
 }