diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index 4712b234..1920b3eb 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -593,7 +593,7 @@ macro_rules! array_impls {
                 fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
                     where D: Deserializer,
                 {
-                    deserializer.deserialize_fixed_size_array($len, $visitor::new())
+                    deserializer.deserialize_seq_fixed_size($len, $visitor::new())
                 }
             }
         )+
diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs
index 47033dde..c9eea554 100644
--- a/serde/src/de/mod.rs
+++ b/serde/src/de/mod.rs
@@ -10,6 +10,73 @@ use collections::{String, Vec};
 
 use core::fmt;
 
+///////////////////////////////////////////////////////////////////////////////
+/// Macro helper to not have to re-implement all the defaulted methods.
+/// Every given method ignores all arguments and forwards to `deserialize`.
+/// Note that `deserialize_enum` simply returns an `Error::invalid_type`.
+macro_rules! de_forward_to_deserialize {
+    ($($func:ident),*) => {
+        $(de_forward_to_deserialize!{func: $func})*
+    };
+    (func: deserialize_unit_struct) => {
+        de_forward_to_deserialize!{named: deserialize_unit_struct}
+    };
+    (func: deserialize_newtype_struct) => {
+        de_forward_to_deserialize!{named: deserialize_newtype_struct}
+    };
+    (func: deserialize_tuple) => {
+        de_forward_to_deserialize!{tup_fn: deserialize_tuple}
+    };
+    (func: deserialize_seq_fixed_size) => {
+        de_forward_to_deserialize!{tup_fn: deserialize_seq_fixed_size}
+    };
+    (func: deserialize_tuple_struct) => {
+        #[inline]
+        fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor {
+            self.deserialize(visitor)
+        }
+    };
+    (func: deserialize_struct) => {
+        #[inline]
+        fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor {
+            self.deserialize(visitor)
+        }
+    };
+    (func: deserialize_enum) => {
+        #[inline]
+        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> Result<__V::Value, Self::Error>
+            where __V: $crate::de::EnumVisitor {
+            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
+        }
+    };
+    (named: $func:ident) => {
+        #[inline]
+        fn $func<__V>(&mut self, _: &str, visitor: __V) -> Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor {
+            self.deserialize(visitor)
+        }
+    };
+    (tup_fn: $func: ident) => {
+        #[inline]
+        fn $func<__V>(&mut self, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor {
+            self.deserialize(visitor)
+        }
+    };
+    (func: $func:ident) => {
+        #[inline]
+        fn $func<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor {
+            self.deserialize(visitor)
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// modules come after macros
+
 pub mod impls;
 pub mod value;
 mod from_primitive;
@@ -243,278 +310,166 @@ pub trait Deserializer {
         where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `bool` value.
-    #[inline]
     fn deserialize_bool<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `usize` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_u64`.
     fn deserialize_usize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_u64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u8` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_u64`.
     fn deserialize_u8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_u64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u16` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_u64`.
     fn deserialize_u16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_u64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u32` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_u64`.
     fn deserialize_u32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_u64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `u64` value.
-    #[inline]
     fn deserialize_u64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `isize` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_i64`.
     fn deserialize_isize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_i64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i8` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_i64`.
     fn deserialize_i8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_i64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i16` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_i64`.
     fn deserialize_i16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_i64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i32` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_i64`.
     fn deserialize_i32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_i64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `i64` value.
-    #[inline]
     fn deserialize_i64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `f32` value.
-    #[inline]
+    /// A reasonable default is to forward to `deserialize_f64`.
     fn deserialize_f32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_f64(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `f64` value.
-    #[inline]
     fn deserialize_f64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `char` value.
-    #[inline]
     fn deserialize_char<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `&str` value.
-    #[inline]
     fn deserialize_str<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a `String` value.
-    #[inline]
     fn deserialize_string<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_str(visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting an `unit` value.
-    #[inline]
     fn deserialize_unit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        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)`.
-    #[inline]
     fn deserialize_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        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.
-    #[inline]
     fn deserialize_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        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.
-    ///
-    /// By default, this deserializes arrays from a sequence.
-    #[inline]
-    fn deserialize_fixed_size_array<V>(&mut self,
+    fn deserialize_seq_fixed_size<V>(&mut self,
                                        _len: usize,
                                        visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 
     /// 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.
-    #[inline]
     fn deserialize_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_seq(visitor)
-    }
+        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.
-    #[inline]
     fn deserialize_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        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.
-    #[inline]
     fn deserialize_unit_struct<V>(&mut self,
                                   _name: &'static str,
                                   visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_unit(visitor)
-    }
+        where V: Visitor;
 
     /// 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.
-    #[inline]
+    /// A reasonable default is to simply deserialize the expected value directly.
     fn deserialize_newtype_struct<V>(&mut self,
                                      name: &'static str,
                                      visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_tuple_struct(name, 1, visitor)
-    }
+        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.
-    #[inline]
     fn deserialize_tuple_struct<V>(&mut self,
                                    _name: &'static str,
                                    len: usize,
                                    visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_tuple(len, visitor)
-    }
+        where V: Visitor;
 
     /// This method hints that the `Deserialize` type is expecting a struct. This allows
     /// deserializers to parse sequences that aren't tagged as maps.
-    #[inline]
     fn deserialize_struct<V>(&mut self,
                              _name: &'static str,
                              _fields: &'static [&'static str],
                              visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_map(visitor)
-    }
+        where V: Visitor;
 
     /// 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.
-    #[inline]
     fn deserialize_struct_field<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize(visitor)
-    }
+        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.
-    #[inline]
     fn deserialize_tuple<V>(&mut self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.deserialize_seq(visitor)
-    }
+        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.
-    #[inline]
     fn deserialize_enum<V>(&mut self,
                            _enum: &'static str,
                            _variants: &'static [&'static str],
                            _visitor: V) -> Result<V::Value, Self::Error>
-        where V: EnumVisitor,
-    {
-        Err(Error::invalid_type(Type::Enum))
-    }
+        where V: EnumVisitor;
 
     /// This method hints that the `Deserialize` type needs to deserialize a value whose type
     /// doesn't matter because it is ignored.
-    #[inline]
     fn deserialize_ignored_any<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        self.deserialize(visitor)
-    }
+        where V: Visitor;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -870,33 +825,26 @@ pub trait VariantVisitor {
         Err(Error::invalid_type(Type::UnitVariant))
     }
 
-    /// `visit_newtype` is called when deserializing a variant with a single value. By default this
-    /// uses the `visit_tuple` method to deserialize the value.
-    #[inline]
+    /// `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>
-        where T: Deserialize,
-    {
-        let (value,) = try!(self.visit_tuple(1, impls::TupleVisitor1::new()));
-        Ok(value)
-    }
+        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,
                       _len: usize,
                       _visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        Err(Error::invalid_type(Type::TupleVariant))
-    }
+        where V: Visitor;
 
     /// `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,
                        _fields: &'static [&'static str],
                        _visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor
-    {
-        Err(Error::invalid_type(Type::StructVariant))
-    }
+        where V: Visitor;
 }
 
 impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index 65499ee3..f8e98bf8 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -174,6 +174,22 @@ impl<E> de::Deserializer for UnitDeserializer<E>
 {
     type Error = E;
 
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_enum,
+        deserialize_struct, deserialize_tuple_struct
+    }
+
     fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
@@ -209,6 +225,23 @@ macro_rules! primitive_deserializer {
         {
             type Error = E;
 
+            de_forward_to_deserialize!{
+                deserialize_bool,
+                deserialize_f64, deserialize_f32,
+                deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+                deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+                deserialize_char, deserialize_str, deserialize_string,
+                deserialize_ignored_any,
+                deserialize_bytes,
+                deserialize_unit_struct, deserialize_unit,
+                deserialize_seq, deserialize_seq_fixed_size,
+                deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+                deserialize_tuple,
+                deserialize_enum,
+                deserialize_struct, deserialize_tuple_struct,
+                deserialize_option
+            }
+
             fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
                 where V: de::Visitor,
             {
@@ -273,6 +306,22 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
     {
         visitor.visit(self)
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
 
 impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
@@ -289,6 +338,29 @@ impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
     fn visit_unit(&mut self) -> Result<(), Self::Error> {
         Ok(())
     }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: super::Deserialize,
+    {
+        let (value,) = try!(self.visit_tuple(1, super::impls::TupleVisitor1::new()));
+        Ok(value)
+    }
+
+    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))
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -331,6 +403,22 @@ impl<E> de::Deserializer for StringDeserializer<E>
     {
         visitor.visit(self)
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
 
 #[cfg(any(feature = "std", feature = "collections"))]
@@ -348,6 +436,29 @@ impl<'a, E> de::VariantVisitor for StringDeserializer<E>
     fn visit_unit(&mut self) -> Result<(), Self::Error> {
         Ok(())
     }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: super::Deserialize,
+    {
+        let (value,) = try!(self.visit_tuple(1, super::impls::TupleVisitor1::new()));
+        Ok(value)
+    }
+
+    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))
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -384,6 +495,23 @@ impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
     {
         visitor.visit_seq(self)
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_enum,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
 
 impl<I, T, E> de::SeqVisitor for SeqDeserializer<I, E>
@@ -490,6 +618,23 @@ impl<V_, E> de::Deserializer for SeqVisitorDeserializer<V_, E>
     fn deserialize<V: de::Visitor>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error> {
         visitor.visit_seq(&mut self.visitor)
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_enum,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -537,6 +682,23 @@ impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
     {
         visitor.visit_map(self)
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_enum,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
 
 impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
@@ -648,6 +810,23 @@ impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
     fn deserialize<V: de::Visitor>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error> {
         visitor.visit_map(&mut self.visitor)
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_enum,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -678,6 +857,23 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
             None => Err(de::Error::end_of_stream()),
         }
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_enum,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
 
 
@@ -712,4 +908,21 @@ impl<E> de::Deserializer for ByteBufDeserializer<E>
             None => Err(de::Error::end_of_stream()),
         }
     }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_enum,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
 }
diff --git a/serde_macros/tests/test.rs b/serde_macros/tests/test.rs
index e9211218..e0462787 100644
--- a/serde_macros/tests/test.rs
+++ b/serde_macros/tests/test.rs
@@ -1,7 +1,6 @@
 #![feature(test, custom_attribute, custom_derive, plugin)]
 #![plugin(serde_macros)]
 
-extern crate serde;
 extern crate test;
 
 include!("../../testing/tests/test.rs.in");
diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs
index 24dabe19..121dcd3d 100644
--- a/serde_test/src/de.rs
+++ b/serde_test/src/de.rs
@@ -110,6 +110,95 @@ impl<I> de::Deserializer for Deserializer<I>
 {
     type Error = Error;
 
+    fn deserialize_seq<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_map<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_bytes<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_string<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_char<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_i32<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_i8<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_u32<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_u8<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_f64<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_usize<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+
     fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
     {
@@ -241,7 +330,7 @@ impl<I> de::Deserializer for Deserializer<I>
         }
     }
 
-    fn deserialize_fixed_size_array<V>(&mut self,
+    fn deserialize_seq_fixed_size<V>(&mut self,
                                        len: usize,
                                        visitor: V) -> Result<V::Value, Error>
         where V: Visitor,
diff --git a/testing/tests/test.rs.in b/testing/tests/test.rs.in
index 32c00054..fca1ff46 100644
--- a/testing/tests/test.rs.in
+++ b/testing/tests/test.rs.in
@@ -1,3 +1,5 @@
+extern crate serde;
+
 #[macro_use]
 mod macros;
 
diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs
index b2e21b2e..cc30f149 100644
--- a/testing/tests/test_bytes.rs
+++ b/testing/tests/test_bytes.rs
@@ -1,20 +1,21 @@
 use std::fmt;
 use std::error;
 
-extern crate serde;
-use self::serde::Serialize;
-use self::serde::bytes::{ByteBuf, Bytes};
+use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::bytes::{ByteBuf, Bytes};
+use serde::ser;
+use serde::de;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #[derive(Debug, PartialEq)]
 struct Error;
 
-impl serde::ser::Error for Error {
+impl ser::Error for Error {
     fn custom<T: Into<String>>(_: T) -> Error { Error }
 }
 
-impl serde::de::Error for Error {
+impl de::Error for Error {
     fn custom<T: Into<String>>(_: T) -> Error { Error }
 
     fn end_of_stream() -> Error { Error }
@@ -50,7 +51,7 @@ impl BytesSerializer {
     }
 }
 
-impl serde::Serializer for BytesSerializer {
+impl Serializer for BytesSerializer {
     type Error = Error;
     type SeqState = ();
     type MapState = ();
@@ -137,19 +138,19 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_some<V>(&mut self, _value: V) -> Result<(), Error>
-        where V: serde::Serialize,
+        where V: Serialize,
     {
         Err(Error)
     }
 
     fn serialize_newtype_struct<V>(&mut self, _: &'static str, _value: V) -> Result<(), Error>
-        where V: serde::Serialize,
+        where V: Serialize,
     {
         Err(Error)
     }
 
     fn serialize_newtype_variant<V>(&mut self, _: &'static str, _: usize, _: &'static str, _value: V) -> Result<(), Error>
-        where V: serde::Serialize,
+        where V: Serialize,
     {
         Err(Error)
     }
@@ -165,7 +166,7 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_seq_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
-        where T: serde::Serialize
+        where T: Serialize
     {
         Err(Error)
     }
@@ -181,7 +182,7 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_tuple_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
-        where T: serde::Serialize
+        where T: Serialize
     {
         Err(Error)
     }
@@ -197,7 +198,7 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_tuple_struct_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
-        where T: serde::Serialize
+        where T: Serialize
     {
         Err(Error)
     }
@@ -213,7 +214,7 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_tuple_variant_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
-        where T: serde::Serialize
+        where T: Serialize
     {
         Err(Error)
     }
@@ -229,8 +230,8 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_map_elt<K, V>(&mut self, _: &mut (), _key: K, _value: V) -> Result<(), Error>
-        where K: serde::Serialize,
-              V: serde::Serialize,
+        where K: Serialize,
+              V: Serialize,
     {
         Err(Error)
     }
@@ -246,7 +247,7 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_struct_elt<V>(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error>
-        where V: serde::Serialize,
+        where V: Serialize,
     {
         Err(Error)
     }
@@ -262,7 +263,7 @@ impl serde::Serializer for BytesSerializer {
     }
 
     fn serialize_struct_variant_elt<V>(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error>
-        where V: serde::Serialize,
+        where V: Serialize,
     {
         Err(Error)
     }
@@ -292,20 +293,137 @@ impl BytesDeserializer {
     }
 }
 
-impl serde::Deserializer for BytesDeserializer {
+impl Deserializer for BytesDeserializer {
     type Error = Error;
 
     fn deserialize<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
-        where V: serde::de::Visitor,
+        where V: de::Visitor,
     {
         Err(Error)
     }
 
     fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: serde::de::Visitor,
+        where V: de::Visitor,
     {
         visitor.visit_byte_buf(self.bytes.take().unwrap())
     }
+
+    fn deserialize_seq<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_map<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_ignored_any<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_str<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_i64<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_i16<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_u64<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_u16<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_f32<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_bool<__V>(&mut 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>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
+        where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_option<__V>(&mut self, visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_seq_fixed_size<__V>(&mut self, _: usize, visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_unit_struct<__V>(&mut self, _: &str, visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_newtype_struct<__V>(&mut self, _: &str, visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_tuple<__V>(&mut self, _: usize, visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
+        self.deserialize(visitor)
+    }
+    fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _visitor: __V)
+     -> Result<__V::Value, Self::Error> where __V: de::EnumVisitor {
+        Err(Error)
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -328,10 +446,10 @@ fn test_bytes_ser_bytes() {
 #[test]
 fn test_byte_buf_de_bytes() {
     let mut de = BytesDeserializer::new(vec![]);
-    let bytes = serde::Deserialize::deserialize(&mut de);
+    let bytes = Deserialize::deserialize(&mut de);
     assert_eq!(bytes, Ok(ByteBuf::new()));
 
     let mut de = BytesDeserializer::new(vec![1, 2, 3]);
-    let bytes = serde::Deserialize::deserialize(&mut de);
+    let bytes = Deserialize::deserialize(&mut de);
     assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
 }
diff --git a/testing/tests/test_de.rs b/testing/tests/test_de.rs
index 8a73bf38..63b6b6f7 100644
--- a/testing/tests/test_de.rs
+++ b/testing/tests/test_de.rs
@@ -2,8 +2,7 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::net;
 use std::path::PathBuf;
 
-extern crate serde;
-use self::serde::Deserialize;
+use serde::Deserialize;
 
 extern crate fnv;
 use self::fnv::FnvHasher;