Rename Serialize::visit to Serialize::serialize

benches/bench_log.rs

@@ -56,7 +56,7 @@ impl rustc_serialize::Decodable for HttpProtocol {
 
 impl ser::Serialize for HttpProtocol {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         serializer.visit_u8(*self as u8)
@@ -104,7 +104,7 @@ impl rustc_serialize::Decodable for HttpMethod {
 
 impl ser::Serialize for HttpMethod {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         serializer.visit_u8(*self as u8)
@@ -145,7 +145,7 @@ impl rustc_serialize::Decodable for CacheStatus {
 
 impl ser::Serialize for CacheStatus {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         serializer.visit_u8(*self as u8)
@@ -195,7 +195,7 @@ impl rustc_serialize::Decodable for OriginProtocol {
 
 impl ser::Serialize for OriginProtocol {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         serializer.visit_u8(*self as u8)
@@ -237,7 +237,7 @@ impl rustc_serialize::Decodable for ZonePlan {
 
 impl ser::Serialize for ZonePlan {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         serializer.visit_u8(*self as u8)
@@ -530,7 +530,7 @@ impl rustc_serialize::Decodable for Country {
 
 impl ser::Serialize for Country {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         serializer.visit_u8(*self as u8)
@@ -757,7 +757,7 @@ fn test_serializer_vec() {
     let log = Log::new();
     let wr = Vec::with_capacity(1024);
     let mut serializer = json::Serializer::new(wr);
-    log.visit(&mut serializer).unwrap();
+    log.serialize(&mut serializer).unwrap();
 
     let json = serializer.into_inner();
     assert_eq!(&json, &JSON_STR.as_bytes());
@@ -775,7 +775,7 @@ fn bench_serializer_vec(b: &mut Bencher) {
         wr.clear();
 
         let mut serializer = json::Serializer::new(wr.by_ref());
-        log.visit(&mut serializer).unwrap();
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }
@@ -793,7 +793,7 @@ fn bench_serializer_slice(b: &mut Bencher) {
         let mut wr = &mut buf[..];
 
         let mut serializer = json::Serializer::new(wr.by_ref());
-        log.visit(&mut serializer).unwrap();
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }
@@ -806,7 +806,7 @@ fn test_serializer_my_mem_writer0() {
 
     {
         let mut serializer = json::Serializer::new(wr.by_ref());
-        log.visit(&mut serializer).unwrap();
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     }
 
@@ -825,7 +825,7 @@ fn bench_serializer_my_mem_writer0(b: &mut Bencher) {
         wr.buf.clear();
 
         let mut serializer = json::Serializer::new(wr.by_ref());
-        log.visit(&mut serializer).unwrap();
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }
@@ -838,7 +838,7 @@ fn test_serializer_my_mem_writer1() {
 
     {
         let mut serializer = json::Serializer::new(wr.by_ref());
-        log.visit(&mut serializer).unwrap();
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     }
 
@@ -857,7 +857,7 @@ fn bench_serializer_my_mem_writer1(b: &mut Bencher) {
         wr.buf.clear();
 
         let mut serializer = json::Serializer::new(wr.by_ref());
-        log.visit(&mut serializer).unwrap();
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }

serde_macros/src/lib.rs

@@ -78,7 +78,7 @@ fn expand_derive_serialize(
         associated_types: vec![],
         methods: vec![
             MethodDef {
-                name: "visit",
+                name: "serialize",
                 generics: LifetimeBounds {
                     lifetimes: Vec::new(),
                     bounds: vec![

src/json/ser.rs

@@ -183,7 +183,7 @@ impl<W> ser::Serializer for Serializer<W>
     fn visit_some<V>(&mut self, value: V) -> io::Result<()>
         where V: ser::Serialize
     {
-        value.visit(self)
+        value.serialize(self)
     }
 
     #[inline]
@@ -236,7 +236,7 @@ impl<W> ser::Serializer for Serializer<W>
     {
         try!(self.serialize_sep(first));
 
-        value.visit(self)
+        value.serialize(self)
     }
 
     #[inline]
@@ -272,9 +272,9 @@ impl<W> ser::Serializer for Serializer<W>
               V: ser::Serialize,
     {
         try!(self.serialize_sep(first));
-        try!(key.visit(self));
+        try!(key.serialize(self));
         try!(self.serialize_colon());
-        value.visit(self)
+        value.serialize(self)
     }
 }
 
@@ -356,7 +356,7 @@ pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
           T: ser::Serialize,
 {
     let mut ser = Serializer::new(writer);
-    try!(value.visit(&mut ser));
+    try!(value.serialize(&mut ser));
     Ok(())
 }
 
@@ -367,7 +367,7 @@ pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
           T: ser::Serialize,
 {
     let mut ser = Serializer::new_pretty(writer);
-    try!(value.visit(&mut ser));
+    try!(value.serialize(&mut ser));
     Ok(())
 }
 

src/json/value.rs

@@ -21,7 +21,7 @@ pub enum Value {
 
 impl ser::Serialize for Value {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer,
     {
         match *self {
@@ -30,8 +30,8 @@ impl ser::Serialize for Value {
             Value::I64(v) => serializer.visit_i64(v),
             Value::F64(v) => serializer.visit_f64(v),
             Value::String(ref v) => serializer.visit_str(&v),
-            Value::Array(ref v) => v.visit(serializer),
-            Value::Object(ref v) => v.visit(serializer),
+            Value::Array(ref v) => v.serialize(serializer),
+            Value::Object(ref v) => v.serialize(serializer),
         }
     }
 }
@@ -210,7 +210,7 @@ impl ser::Serializer for Serializer {
     fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
         where V: ser::Serialize,
     {
-        value.visit(self)
+        value.serialize(self)
     }
 
     #[inline]
@@ -278,7 +278,7 @@ impl ser::Serializer for Serializer {
     fn visit_seq_elt<T>(&mut self, _first: bool, value: T) -> Result<(), ()>
         where T: ser::Serialize,
     {
-        try!(value.visit(self));
+        try!(value.serialize(self));
 
         let value = match self.state.pop().unwrap() {
             State::Value(value) => value,
@@ -338,14 +338,14 @@ impl ser::Serializer for Serializer {
         where K: ser::Serialize,
               V: ser::Serialize,
     {
-        try!(key.visit(self));
+        try!(key.serialize(self));
 
         let key = match self.state.pop().unwrap() {
             State::Value(Value::String(value)) => value,
             state => panic!("expected key, found {:?}", state),
         };
 
-        try!(value.visit(self));
+        try!(value.serialize(self));
 
         let value = match self.state.pop().unwrap() {
             State::Value(value) => value,
@@ -577,7 +577,7 @@ pub fn to_value<T>(value: &T) -> Value
     where T: ser::Serialize
 {
     let mut ser = Serializer::new();
-    value.visit(&mut ser).ok().unwrap();
+    value.serialize(&mut ser).ok().unwrap();
     ser.unwrap()
 }
 

src/ser.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 ///////////////////////////////////////////////////////////////////////////////
 
 pub trait Serialize {
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer;
 }
 
@@ -185,7 +185,7 @@ macro_rules! impl_visit {
     ($ty:ty, $method:ident) => {
         impl Serialize for $ty {
             #[inline]
-            fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
                 where S: Serializer,
             {
                 serializer.$method(*self)
@@ -213,7 +213,7 @@ impl_visit!(char, visit_char);
 
 impl<'a> Serialize for &'a str {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_str(*self)
@@ -222,10 +222,10 @@ impl<'a> Serialize for &'a str {
 
 impl Serialize for String {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (&self[..]).visit(serializer)
+        (&self[..]).serialize(serializer)
     }
 }
 
@@ -233,7 +233,7 @@ impl Serialize for String {
 
 impl<T> Serialize for Option<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         match *self {
@@ -294,7 +294,7 @@ impl<'a, T> Serialize for &'a [T]
     where T: Serialize,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -303,16 +303,16 @@ impl<'a, T> Serialize for &'a [T]
 
 impl<T> Serialize for Vec<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (&self[..]).visit(serializer)
+        (&self[..]).serialize(serializer)
     }
 }
 
 impl<T> Serialize for BTreeSet<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -324,7 +324,7 @@ impl<T, H> Serialize for HashSet<T, H>
           H: HashState,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_seq(SeqIteratorVisitor::new(self.iter()))
@@ -335,7 +335,7 @@ impl<T, H> Serialize for HashSet<T, H>
 
 impl Serialize for () {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_unit()
@@ -403,7 +403,7 @@ macro_rules! tuple_impls {
                 where $($T: Serialize),+
             {
                 #[inline]
-                fn visit<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
+                fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
                     serializer.visit_seq($TupleVisitor::new(self))
                 }
             }
@@ -569,7 +569,7 @@ impl<K, V> Serialize for BTreeMap<K, V>
           V: Serialize,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_map(MapIteratorVisitor::new(self.iter()))
@@ -582,7 +582,7 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
           H: HashState,
 {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
         serializer.visit_map(MapIteratorVisitor::new(self.iter()))
@@ -593,63 +593,63 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
 
 impl<'a, T> Serialize for &'a T where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<'a, T> Serialize for &'a mut T where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<T> Serialize for Box<T> where T: Serialize {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<T> Serialize for Rc<T> where T: Serialize, {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 impl<T> Serialize for Arc<T> where T: Serialize, {
     #[inline]
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        (**self).visit(serializer)
+        (**self).serialize(serializer)
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 impl Serialize for path::Path {
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        self.to_str().unwrap().visit(serializer)
+        self.to_str().unwrap().serialize(serializer)
     }
 }
 
 impl Serialize for path::PathBuf {
-    fn visit<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        self.to_str().unwrap().visit(serializer)
+        self.to_str().unwrap().serialize(serializer)
     }
 }

tests/test_ser.rs

@@ -180,7 +180,7 @@ impl<'a> Serializer for AssertSerializer<'a> {
         where V: Serialize,
     {
         assert_eq!(self.iter.next(), Some(Token::Option(true)));
-        value.visit(self)
+        value.serialize(self)
     }
 
 
@@ -221,7 +221,7 @@ impl<'a> Serializer for AssertSerializer<'a> {
         where T: Serialize
     {
         assert_eq!(self.iter.next(), Some(Token::SeqSep(first)));
-        value.visit(self)
+        value.serialize(self)
     }
 
     fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
@@ -266,8 +266,8 @@ impl<'a> Serializer for AssertSerializer<'a> {
     {
         assert_eq!(self.iter.next(), Some(Token::MapSep(first)));
 
-        try!(key.visit(self));
-        value.visit(self)
+        try!(key.serialize(self));
+        value.serialize(self)
     }
 }
 
@@ -314,7 +314,7 @@ macro_rules! declare_test {
         fn $name() {
             $(
                 let mut ser = AssertSerializer::new($tokens);
-                assert_eq!($value.visit(&mut ser), Ok(()));
+                assert_eq!($value.serialize(&mut ser), Ok(()));
             )+
         }
     }