diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index 0b43eed3..aaaaed96 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -916,11 +916,11 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
             {
                 match try!(visitor.visit_variant()) {
                     Field::Ok => {
-                        let (value,) = try!(visitor.visit_seq(1, TupleVisitor1::new()));
+                        let (value,) = try!(visitor.visit_tuple(1, TupleVisitor1::new()));
                         Ok(Ok(value))
                     }
                     Field::Err => {
-                        let (value,) = try!(visitor.visit_seq(1, TupleVisitor1::new()));
+                        let (value,) = try!(visitor.visit_tuple(1, TupleVisitor1::new()));
                         Ok(Err(value))
                     }
                 }
diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs
index 611c8c8e..54ca9e67 100644
--- a/serde/src/de/mod.rs
+++ b/serde/src/de/mod.rs
@@ -584,17 +584,19 @@ pub trait VariantVisitor {
         Err(Error::syntax_error())
     }
 
-    /// `visit_seq` is called when deserializing a tuple-like variant.
-    fn visit_seq<V>(&mut self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
+    /// `visit_tuple` is called when deserializing a tuple-like variant.
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      _visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor
     {
         Err(Error::syntax_error())
     }
 
-    /// `visit_map` is called when deserializing a struct-like variant.
-    fn visit_map<V>(&mut self,
-                    _fields: &'static [&'static str],
-                    _visitor: V) -> Result<V::Value, Self::Error>
+    /// `visit_struct` is called when deserializing a struct-like variant.
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       _visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor
     {
         Err(Error::syntax_error())
@@ -618,18 +620,20 @@ impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
         (**self).visit_simple()
     }
 
-    fn visit_seq<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, T::Error>
+    fn visit_tuple<V>(&mut self,
+                      len: usize,
+                      visitor: V) -> Result<V::Value, T::Error>
         where V: Visitor,
     {
-        (**self).visit_seq(len, visitor)
+        (**self).visit_tuple(len, visitor)
     }
 
-    fn visit_map<V>(&mut self,
+    fn visit_struct<V>(&mut self,
                     fields: &'static [&'static str],
                     visitor: V) -> Result<V::Value, T::Error>
         where V: Visitor,
     {
-        (**self).visit_map(fields, visitor)
+        (**self).visit_struct(fields, visitor)
     }
 }
 
diff --git a/serde_codegen/src/de.rs b/serde_codegen/src/de.rs
index ab8adced..d1e114de 100644
--- a/serde_codegen/src/de.rs
+++ b/serde_codegen/src/de.rs
@@ -641,7 +641,7 @@ fn deserialize_tuple_variant(
             }
         }
 
-        visitor.visit_seq($fields, $visitor_expr)
+        visitor.visit_tuple($fields, $visitor_expr)
     })
 }
 
@@ -708,7 +708,7 @@ fn deserialize_struct_variant(
 
         $fields_stmt
 
-        visitor.visit_map(FIELDS, $visitor_expr)
+        visitor.visit_struct(FIELDS, $visitor_expr)
     })
 }
 
diff --git a/serde_json/src/de.rs b/serde_json/src/de.rs
index dc0ce34d..5fbbfb1c 100644
--- a/serde_json/src/de.rs
+++ b/serde_json/src/de.rs
@@ -648,17 +648,17 @@ impl<Iter> de::VariantVisitor for Deserializer<Iter>
         de::Deserialize::deserialize(self)
     }
 
-    fn visit_seq<V>(&mut self,
-                    _len: usize,
-                    visitor: V) -> Result<V::Value, Error>
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      visitor: V) -> Result<V::Value, Error>
         where V: de::Visitor,
     {
         de::Deserializer::visit(self, visitor)
     }
 
-    fn visit_map<V>(&mut self,
-                    _fields: &'static [&'static str],
-                    visitor: V) -> Result<V::Value, Error>
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Error>
         where V: de::Visitor,
     {
         de::Deserializer::visit(self, visitor)
diff --git a/serde_json/src/value.rs b/serde_json/src/value.rs
index 061c80ab..42356be2 100644
--- a/serde_json/src/value.rs
+++ b/serde_json/src/value.rs
@@ -753,9 +753,9 @@ impl<'a> de::VariantVisitor for VariantDeserializer<'a> {
         de::Deserialize::deserialize(&mut Deserializer::new(self.val.take().unwrap()))
     }
 
-    fn visit_seq<V>(&mut self,
-                    _len: usize,
-                    visitor: V) -> Result<V::Value, Error>
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      visitor: V) -> Result<V::Value, Error>
         where V: de::Visitor,
     {
         if let Value::Array(fields) = self.val.take().unwrap() {
@@ -772,9 +772,9 @@ impl<'a> de::VariantVisitor for VariantDeserializer<'a> {
         }
     }
 
-    fn visit_map<V>(&mut self,
-                    _fields: &'static[&'static str],
-                    visitor: V) -> Result<V::Value, Error>
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static[&'static str],
+                       visitor: V) -> Result<V::Value, Error>
         where V: de::Visitor,
     {
         if let Value::Object(fields) = self.val.take().unwrap() {
diff --git a/serde_tests/tests/test_de.rs b/serde_tests/tests/test_de.rs
index 67ad4c74..0e3834a6 100644
--- a/serde_tests/tests/test_de.rs
+++ b/serde_tests/tests/test_de.rs
@@ -327,17 +327,17 @@ impl<'a> de::VariantVisitor for TokenDeserializerVariantVisitor<'a> {
         de::Deserialize::deserialize(self.de)
     }
 
-    fn visit_seq<V>(&mut self,
-                    _len: usize,
-                    visitor: V) -> Result<V::Value, Error>
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      visitor: V) -> Result<V::Value, Error>
         where V: de::Visitor,
     {
         de::Deserializer::visit(self.de, visitor)
     }
 
-    fn visit_map<V>(&mut self,
-                    _fields: &'static [&'static str],
-                    visitor: V) -> Result<V::Value, Error>
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Error>
         where V: de::Visitor,
     {
         de::Deserializer::visit(self.de, visitor)