wip: refactor

serde2/src/de.rs

@@ -28,85 +28,85 @@ pub trait Deserializer<E> {
 }
 
 pub trait Visitor<S: Deserializer<E>, R, E: Error> {
-    fn visit_null(&mut self, state: &mut S) -> Result<R, E> {
+    fn visit_null(&mut self) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
-    fn visit_bool(&mut self, state: &mut S, _v: bool) -> Result<R, E> {
+    fn visit_bool(&mut self, _v: bool) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
-    fn visit_int(&mut self, state: &mut S, v: int) -> Result<R, E> {
-        self.visit_i64(state, v as i64)
+    fn visit_int(&mut self, v: int) -> Result<R, E> {
+        self.visit_i64(v as i64)
     }
 
-    fn visit_i8(&mut self, state: &mut S, v: i8) -> Result<R, E> {
-        self.visit_i64(state, v as i64)
+    fn visit_i8(&mut self, v: i8) -> Result<R, E> {
+        self.visit_i64(v as i64)
     }
 
-    fn visit_i16(&mut self, state: &mut S, v: i16) -> Result<R, E> {
-        self.visit_i64(state, v as i64)
+    fn visit_i16(&mut self, v: i16) -> Result<R, E> {
+        self.visit_i64(v as i64)
     }
 
-    fn visit_i32(&mut self, state: &mut S, v: i32) -> Result<R, E> {
-        self.visit_i64(state, v as i64)
+    fn visit_i32(&mut self, v: i32) -> Result<R, E> {
+        self.visit_i64(v as i64)
     }
 
-    fn visit_i64(&mut self, state: &mut S, _v: i64) -> Result<R, E> {
+    fn visit_i64(&mut self, _v: i64) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
-    fn visit_uint(&mut self, state: &mut S, v: uint) -> Result<R, E> {
-        self.visit_u64(state, v as u64)
+    fn visit_uint(&mut self, v: uint) -> Result<R, E> {
+        self.visit_u64(v as u64)
     }
 
-    fn visit_u8(&mut self, state: &mut S, v: u8) -> Result<R, E> {
-        self.visit_u64(state, v as u64)
+    fn visit_u8(&mut self, v: u8) -> Result<R, E> {
+        self.visit_u64(v as u64)
     }
 
-    fn visit_u16(&mut self, state: &mut S, v: u16) -> Result<R, E> {
-        self.visit_u64(state, v as u64)
+    fn visit_u16(&mut self, v: u16) -> Result<R, E> {
+        self.visit_u64(v as u64)
     }
 
-    fn visit_u32(&mut self, state: &mut S, v: u32) -> Result<R, E> {
-        self.visit_u64(state, v as u64)
+    fn visit_u32(&mut self, v: u32) -> Result<R, E> {
+        self.visit_u64(v as u64)
     }
 
-    fn visit_u64(&mut self, state: &mut S, _v: u64) -> Result<R, E> {
+    fn visit_u64(&mut self, _v: u64) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
-    fn visit_f32(&mut self, state: &mut S, v: f32) -> Result<R, E> {
-        self.visit_f64(state, v as f64)
+    fn visit_f32(&mut self, v: f32) -> Result<R, E> {
+        self.visit_f64(v as f64)
     }
 
-    fn visit_f64(&mut self, state: &mut S, _v: f64) -> Result<R, E> {
+    fn visit_f64(&mut self, _v: f64) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
-    fn visit_str(&mut self, state: &mut S, _v: &str) -> Result<R, E> {
+    fn visit_str(&mut self, _v: &str) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
-    fn visit_string(&mut self, state: &mut S, v: String) -> Result<R, E> {
-        self.visit_str(state, v.as_slice())
+    fn visit_string(&mut self, v: String) -> Result<R, E> {
+        self.visit_str(v.as_slice())
     }
 
     fn visit_option<
         V: OptionVisitor<S, E>,
-    >(&mut self, state: &mut S, _visitor: V) -> Result<R, E> {
+    >(&mut self, _visitor: V) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
     fn visit_seq<
         V: SeqVisitor<S, E>,
-    >(&mut self, state: &mut S, _visitor: V) -> Result<R, E> {
+    >(&mut self, _visitor: V) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 
     fn visit_map<
         V: MapVisitor<S, E>,
-    >(&mut self, state: &mut S, _visitor: V) -> Result<R, E> {
+    >(&mut self, _visitor: V) -> Result<R, E> {
         Err(Error::syntax_error())
     }
 }
@@ -114,18 +114,18 @@ pub trait Visitor<S: Deserializer<E>, R, E: Error> {
 pub trait OptionVisitor<S, E> {
     fn visit<
         T: Deserialize<S, E>,
-    >(&mut self, state: &mut S) -> Result<Option<T>, E>;
+    >(&mut self) -> Result<Option<T>, E>;
 }
 
 pub trait SeqVisitor<S, E> {
     fn visit<
         T: Deserialize<S, E>,
-    >(&mut self, state: &mut S) -> Result<Option<T>, E>;
+    >(&mut self) -> Result<Option<T>, E>;
 
-    fn end(&mut self, state: &mut S) -> Result<(), E>;
+    fn end(&mut self) -> Result<(), E>;
 
     #[inline]
-    fn size_hint(&self, _state: &mut S) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (uint, Option<uint>) {
         (0, None)
     }
 }
@@ -134,10 +134,10 @@ pub trait MapVisitor<S, E> {
     fn visit<
         K: Deserialize<S, E>,
         V: Deserialize<S, E>,
-    >(&mut self, state: &mut S) -> Result<Option<(K, V)>, E> {
-        match try!(self.visit_key(state)) {
+    >(&mut self) -> Result<Option<(K, V)>, E> {
+        match try!(self.visit_key()) {
             Some(key) => {
-                let value = try!(self.visit_value(state));
+                let value = try!(self.visit_value());
                 Ok(Some((key, value)))
             }
             None => Ok(None)
@@ -146,16 +146,16 @@ pub trait MapVisitor<S, E> {
 
     fn visit_key<
         K: Deserialize<S, E>,
-    >(&mut self, state: &mut S) -> Result<Option<K>, E>;
+    >(&mut self) -> Result<Option<K>, E>;
 
     fn visit_value<
         V: Deserialize<S, E>,
-    >(&mut self, state: &mut S) -> Result<V, E>;
+    >(&mut self) -> Result<V, E>;
 
-    fn end(&mut self, state: &mut S) -> Result<(), E>;
+    fn end(&mut self) -> Result<(), E>;
 
     #[inline]
-    fn size_hint(&self, _state: &mut S) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (uint, Option<uint>) {
         (0, None)
     }
 }
@@ -173,14 +173,14 @@ impl<
             S: Deserializer<E>,
             E: Error,
         > self::Visitor<S, (), E> for Visitor {
-            fn visit_null(&mut self, _state: &mut S) -> Result<(), E> {
+            fn visit_null(&mut self) -> Result<(), E> {
                 Ok(())
             }
 
             fn visit_seq<
                 V: SeqVisitor<S, E>,
-            >(&mut self, state: &mut S, mut visitor: V) -> Result<(), E> {
-                try!(visitor.end(state));
+            >(&mut self, mut visitor: V) -> Result<(), E> {
+                try!(visitor.end());
                 Ok(())
             }
         }
@@ -202,7 +202,7 @@ impl<
             S: Deserializer<E>,
             E: Error,
         > self::Visitor<S, bool, E> for Visitor {
-            fn visit_bool(&mut self, _state: &mut S, v: bool) -> Result<bool, E> {
+            fn visit_bool(&mut self, v: bool) -> Result<bool, E> {
                 Ok(v)
             }
         }
@@ -215,7 +215,7 @@ impl<
 
 macro_rules! impl_deserialize_num_method {
     ($src_ty:ty, $method:ident, $from_method:ident) => {
-        fn $method(&mut self, state: &mut S, v: $src_ty) -> Result<T, E> {
+        fn $method(&mut self, v: $src_ty) -> Result<T, E> {
             match FromPrimitive::$from_method(v) {
                 Some(v) => Ok(v),
                 None => Err(Error::syntax_error()),
@@ -294,11 +294,11 @@ impl<
             S: Deserializer<E>,
             E: Error,
         > self::Visitor<S, String, E> for Visitor {
-            fn visit_str(&mut self, _state: &mut S, v: &str) -> Result<String, E> {
+            fn visit_str(&mut self, v: &str) -> Result<String, E> {
                 Ok(v.to_string())
             }
 
-            fn visit_string(&mut self, _state: &mut S, v: String) -> Result<String, E> {
+            fn visit_string(&mut self, v: String) -> Result<String, E> {
                 Ok(v)
             }
         }
@@ -324,8 +324,8 @@ impl<
         > self::Visitor<S, Option<T>, E> for Visitor {
             fn visit_option<
                 V: OptionVisitor<S, E>,
-            >(&mut self, state: &mut S, mut visitor: V) -> Result<Option<T>, E> {
-                visitor.visit(state)
+            >(&mut self, mut visitor: V) -> Result<Option<T>, E> {
+                visitor.visit()
             }
         }
 
@@ -350,12 +350,12 @@ impl<
         > self::Visitor<S, Vec<T>, E> for Visitor {
             fn visit_seq<
                 V: SeqVisitor<S, E>,
-            >(&mut self, state: &mut S, mut visitor: V) -> Result<Vec<T>, E> {
-                let (len, _) = visitor.size_hint(state);
+            >(&mut self, mut visitor: V) -> Result<Vec<T>, E> {
+                let (len, _) = visitor.size_hint();
                 let mut values = Vec::with_capacity(len);
 
                 loop {
-                    match try!(visitor.visit(state)) {
+                    match try!(visitor.visit()) {
                         Some(value) => {
                             values.push(value);
                         }
@@ -403,15 +403,15 @@ macro_rules! impl_deserialize_tuple {
                 > self::Visitor<S, ($($name,)+), E> for Visitor {
                     fn visit_seq<
                         V: SeqVisitor<S, E>,
-                    >(&mut self, state: &mut S, mut visitor: V) -> Result<($($name,)+), E> {
+                    >(&mut self, mut visitor: V) -> Result<($($name,)+), E> {
                         $(
-                            let $name = match try!(visitor.visit(state)) {
+                            let $name = match try!(visitor.visit()) {
                                 Some(value) => value,
                                 None => { return Err(Error::end_of_stream_error()); }
                             };
                          )+;
 
-                        try!(visitor.end(state));
+                        try!(visitor.end());
 
                         Ok(($($name,)+))
                     }
@@ -444,12 +444,12 @@ impl<
         > self::Visitor<S, HashMap<K, V>, E> for Visitor {
             fn visit_map<
                 Visitor: MapVisitor<S, E>,
-            >(&mut self, state: &mut S, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
-                let (len, _) = visitor.size_hint(state);
+            >(&mut self, mut visitor: Visitor) -> Result<HashMap<K, V>, E> {
+                let (len, _) = visitor.size_hint();
                 let mut values = HashMap::with_capacity(len);
 
                 loop {
-                    match try!(visitor.visit(state)) {
+                    match try!(visitor.visit()) {
                         Some((key, value)) => {
                             values.insert(key, value);
                         }
@@ -484,11 +484,11 @@ impl<
         > self::Visitor<S, TreeMap<K, V>, E> for Visitor {
             fn visit_map<
                 Visitor: MapVisitor<S, E>,
-            >(&mut self, state: &mut S, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
+            >(&mut self, mut visitor: Visitor) -> Result<TreeMap<K, V>, E> {
                 let mut values = TreeMap::new();
 
                 loop {
-                    match try!(visitor.visit(state)) {
+                    match try!(visitor.visit()) {
                         Some((key, value)) => {
                             values.insert(key, value);
                         }