Fix tests, make Deserializer::visit take a value not a reference

serde2/benches/bench_log.rs

@@ -68,7 +68,7 @@ impl de::Deserialize for HttpProtocol {
     fn deserialize<
         S: Deserializer,
     >(state: &mut S) -> Result<HttpProtocol, S::Error> {
-        state.visit(&mut de::PrimitiveVisitor::new())
+        state.visit(de::PrimitiveVisitor::new())
     }
 }
 
@@ -116,7 +116,7 @@ impl de::Deserialize for HttpMethod {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<HttpMethod, S::Error> {
-        state.visit(&mut de::PrimitiveVisitor::new())
+        state.visit(de::PrimitiveVisitor::new())
     }
 }
 
@@ -157,7 +157,7 @@ impl de::Deserialize for CacheStatus {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<CacheStatus, S::Error> {
-        state.visit(&mut de::PrimitiveVisitor::new())
+        state.visit(de::PrimitiveVisitor::new())
     }
 }
 
@@ -207,7 +207,7 @@ impl de::Deserialize for OriginProtocol {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<OriginProtocol, S::Error> {
-        state.visit(&mut de::PrimitiveVisitor::new())
+        state.visit(de::PrimitiveVisitor::new())
     }
 }
 
@@ -249,7 +249,7 @@ impl de::Deserialize for ZonePlan {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<ZonePlan, S::Error> {
-        state.visit(&mut de::PrimitiveVisitor::new())
+        state.visit(de::PrimitiveVisitor::new())
     }
 }
 
@@ -542,7 +542,7 @@ impl de::Deserialize for Country {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<Country, S::Error> {
-        state.visit(&mut de::PrimitiveVisitor::new())
+        state.visit(de::PrimitiveVisitor::new())
     }
 }
 

serde2/serde2_macros/src/lib.rs

@@ -585,13 +585,13 @@ pub fn expand_derive_deserialize(
                 generics: LifetimeBounds {
                     lifetimes: Vec::new(),
                     bounds: vec![
-                        ("__S", vec![Path::new(vec!["serde2", "de", "Deserializer"])]),
+                        ("__D", vec![Path::new(vec!["serde2", "de", "Deserializer"])]),
                     ],
                 },
                 explicit_self: None,
                 args: vec![
                     Ty::Ptr(
-                        Box::new(Ty::Literal(Path::new_local("__S"))),
+                        Box::new(Ty::Literal(Path::new_local("__D"))),
                         Borrowed(None, MutMutable)
                     ),
                 ],
@@ -601,7 +601,7 @@ pub fn expand_derive_deserialize(
                         None,
                         vec![
                             Box::new(Ty::Self_),
-                            Box::new(Ty::Literal(Path::new_(vec!["__S", "Error"],
+                            Box::new(Ty::Literal(Path::new_(vec!["__D", "Error"],
                                                             None,
                                                             vec![],
                                                             false))),
@@ -729,7 +729,7 @@ fn deserialize_struct_empty_fields(
             }
         }
 
-        $state.visit(&mut __Visitor)
+        $state.visit(__Visitor)
     })
 }
 
@@ -778,7 +778,7 @@ fn deserialize_struct_unnamed_fields(
             }
         }
 
-        $state.visit(&mut __Visitor)
+        $state.visit(__Visitor)
     })
 }
 
@@ -876,7 +876,7 @@ fn deserialize_struct_named_fields(
             }
         }
 
-        $state.visit(&mut __Visitor)
+        $state.visit(__Visitor)
     })
 }
 
@@ -986,7 +986,7 @@ fn declare_map_field_deserializer(
                 fn deserialize<
                     __S: ::serde2::de::Deserializer,
                 >(state: &mut __S) -> Result<__Field, __S::Error> {
-                    state.visit(&mut __FieldVisitor)
+                    state.visit(__FieldVisitor)
                 }
             }
         ).unwrap(),
@@ -1143,7 +1143,7 @@ fn deserialize_enum(
             }
         }
 
-        $state.visit(&mut __Visitor)
+        $state.visit(__Visitor)
     })
 }
 
@@ -1193,7 +1193,7 @@ fn deserialize_enum_variant(
                         }
                     }
 
-                    $state.visit_seq(&mut __Visitor)
+                    $state.visit_seq(__Visitor)
                 })
             }
         }
@@ -1241,7 +1241,7 @@ fn deserialize_enum_variant(
                     }
                 }
 
-                $state.visit_map(&mut __Visitor)
+                $state.visit_map(__Visitor)
             })
         }
     }

serde2/src/de.rs

@@ -25,7 +25,7 @@ pub trait Deserializer {
 
     fn visit<
         V: Visitor,
-    >(&mut self, visitor: &mut V) -> Result<V::Value, Self::Error>;
+    >(&mut self, visitor: V) -> Result<V::Value, Self::Error>;
 
     /// The `visit_option` method allows a `Deserialize` type to inform the
     /// `Deserializer` that it's expecting an optional value. This allows
@@ -35,7 +35,7 @@ pub trait Deserializer {
     #[inline]
     fn visit_option<
         V: Visitor,
-    >(&mut self, visitor: &mut V) -> Result<V::Value, Self::Error> {
+    >(&mut self, visitor: V) -> Result<V::Value, Self::Error> {
         self.visit(visitor)
     }
 }
@@ -264,13 +264,13 @@ pub trait EnumVisitor {
 
     fn visit_seq<
         V: EnumSeqVisitor,
-    >(&mut self, _visitor: &mut V) -> Result<V::Value, Self::Error> {
+    >(&mut self, _visitor: V) -> Result<V::Value, Self::Error> {
         Err(Error::syntax_error())
     }
 
     fn visit_map<
         V: EnumMapVisitor,
-    >(&mut self, _visitor: &mut V) -> Result<V::Value, Self::Error> {
+    >(&mut self, _visitor: V) -> Result<V::Value, Self::Error> {
         Err(Error::syntax_error())
     }
 }
@@ -315,7 +315,7 @@ impl Deserialize for () {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<(), D::Error> {
-        deserializer.visit(&mut UnitVisitor)
+        deserializer.visit(UnitVisitor)
     }
 }
 
@@ -337,7 +337,7 @@ impl Deserialize for bool {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<bool, D::Error> {
-        deserializer.visit(&mut BoolVisitor)
+        deserializer.visit(BoolVisitor)
     }
 }
 
@@ -396,7 +396,7 @@ macro_rules! impl_deserialize_num {
             fn deserialize<
                 D: Deserializer,
             >(deserializer: &mut D) -> Result<$ty, D::Error> {
-                deserializer.visit(&mut PrimitiveVisitor::new())
+                deserializer.visit(PrimitiveVisitor::new())
             }
         }
     }
@@ -451,7 +451,7 @@ impl Deserialize for char {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<char, D::Error> {
-        deserializer.visit(&mut CharVisitor)
+        deserializer.visit(CharVisitor)
     }
 }
 
@@ -479,7 +479,7 @@ impl Deserialize for String {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<String, D::Error> {
-        deserializer.visit(&mut StringVisitor)
+        deserializer.visit(StringVisitor)
     }
 }
 
@@ -513,7 +513,7 @@ impl<T> Deserialize for Option<T> where T: Deserialize {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<Option<T>, D::Error> {
-        deserializer.visit_option(&mut OptionVisitor { marker: PhantomData })
+        deserializer.visit_option(OptionVisitor { marker: PhantomData })
     }
 }
 
@@ -526,6 +526,7 @@ struct VecVisitor<T> {
 impl<T> Visitor for VecVisitor<T> where T: Deserialize {
     type Value = Vec<T>;
 
+    #[inline]
     fn visit_seq<
         V: SeqVisitor,
     >(&mut self, mut visitor: V) -> Result<Vec<T>, V::Error> {
@@ -544,7 +545,7 @@ impl<T: Deserialize> Deserialize for Vec<T> {
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<Vec<T>, D::Error> {
-        deserializer.visit(&mut VecVisitor { marker: PhantomData })
+        deserializer.visit(VecVisitor { marker: PhantomData })
     }
 }
 
@@ -588,7 +589,7 @@ macro_rules! tuple_impls {
                 fn deserialize<
                     D: Deserializer,
                 >(deserializer: &mut D) -> Result<($($name,)+), D::Error> {
-                    deserializer.visit(&mut $visitor { marker: PhantomData })
+                    deserializer.visit($visitor { marker: PhantomData })
                 }
             }
         )+
@@ -644,7 +645,7 @@ impl<K, V> Deserialize for HashMap<K, V>
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error> {
-        deserializer.visit(&mut HashMapVisitor { marker: PhantomData })
+        deserializer.visit(HashMapVisitor { marker: PhantomData })
     }
 }
 
@@ -681,7 +682,7 @@ impl<
     fn deserialize<
         D: Deserializer,
     >(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
-        deserializer.visit(&mut BTreeMapVisitor { marker: PhantomData })
+        deserializer.visit(BTreeMapVisitor { marker: PhantomData })
     }
 }
 
@@ -764,7 +765,7 @@ mod tests {
 
         fn visit<
             V: Visitor,
-        >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+        >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
             match self.tokens.next() {
                 Some(Token::Bool(v)) => visitor.visit_bool(v),
                 Some(Token::Isize(v)) => visitor.visit_isize(v),
@@ -829,7 +830,7 @@ mod tests {
         #[inline]
         fn visit_option<
             V: Visitor,
-        >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+        >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
             match self.tokens.peek() {
                 Some(&Token::Option(false)) => {
                     self.tokens.next();
@@ -959,7 +960,7 @@ mod tests {
 
         fn visit_seq<
             V: super::EnumSeqVisitor,
-        >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+        >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
             let token = self.de.tokens.next();
             match token {
                 Some(Token::SeqStart(len)) => {
@@ -982,7 +983,7 @@ mod tests {
 
         fn visit_map<
             V: super::EnumMapVisitor,
-        >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+        >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
             match self.de.tokens.next() {
                 Some(Token::MapStart(len)) => {
                     let value = try!(visitor.visit(TokenDeserializerMapVisitor {
@@ -1012,7 +1013,7 @@ mod tests {
         fn deserialize<
             D: Deserializer,
         >(deserializer: &mut D) -> Result<NamedUnit, D::Error> {
-            deserializer.visit(&mut NamedUnitVisitor)
+            deserializer.visit(NamedUnitVisitor)
         }
     }
 
@@ -1054,7 +1055,7 @@ mod tests {
         fn deserialize<
             D: Deserializer,
         >(deserializer: &mut D) -> Result<NamedSeq, D::Error> {
-            deserializer.visit(&mut NamedSeqVisitor)
+            deserializer.visit(NamedSeqVisitor)
         }
     }
 
@@ -1110,7 +1111,7 @@ mod tests {
         fn deserialize<
             D: Deserializer,
         >(deserializer: &mut D) -> Result<NamedMap, D::Error> {
-            deserializer.visit(&mut NamedMapVisitor)
+            deserializer.visit(NamedMapVisitor)
         }
     }
 
@@ -1161,7 +1162,7 @@ mod tests {
         fn deserialize<
             D: Deserializer,
         >(deserializer: &mut D) -> Result<NamedMapField, D::Error> {
-            deserializer.visit(&mut NamedMapFieldVisitor)
+            deserializer.visit(NamedMapFieldVisitor)
         }
     }
 
@@ -1195,7 +1196,7 @@ mod tests {
         fn deserialize<
             D: Deserializer,
         >(deserializer: &mut D) -> Result<Enum, D::Error> {
-            deserializer.visit(&mut EnumVisitor)
+            deserializer.visit(EnumVisitor)
         }
     }
 
@@ -1222,8 +1223,8 @@ mod tests {
                     try!(visitor.visit_unit());
                     Ok(Enum::Unit)
                 }
-                "Seq" => visitor.visit_seq(&mut EnumSeqVisitor),
-                "Map" => visitor.visit_map(&mut EnumMapVisitor),
+                "Seq" => visitor.visit_seq(EnumSeqVisitor),
+                "Map" => visitor.visit_map(EnumMapVisitor),
                 _ => Err(super::Error::syntax_error()),
             }
         }
@@ -1295,7 +1296,7 @@ mod tests {
         fn deserialize<
             D: Deserializer,
         >(deserializer: &mut D) -> Result<EnumMapField, D::Error> {
-            deserializer.visit(&mut EnumMapFieldVisitor)
+            deserializer.visit(EnumMapFieldVisitor)
         }
     }
 

serde2/src/json/de.rs

@@ -83,7 +83,7 @@ impl<Iter: Iterator<Item=u8>> Deserializer<Iter> {
     #[inline]
     fn parse_value<
         V: de::Visitor,
-    >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
         self.parse_whitespace();
 
         if self.eof() {
@@ -142,7 +142,7 @@ impl<Iter: Iterator<Item=u8>> Deserializer<Iter> {
     #[inline]
     fn parse_number<
         V: de::Visitor,
-    >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
         let mut neg = 1;
 
         if self.ch_is(b'-') {
@@ -389,7 +389,7 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer for Deserializer<Iter> {
     #[inline]
     fn visit<
         V: de::Visitor,
-    >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+    >(&mut self, visitor: V) -> Result<V::Value, Error> {
         self.parse_value(visitor)
     }
 }

serde2/src/json/value.rs

@@ -267,7 +267,7 @@ impl de::Deserializer for Deserializer {
     #[inline]
     fn visit<
         V: de::Visitor,
-    >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
         let value = match self.value.take() {
             Some(value) => value,
             None => { return Err(de::Error::end_of_stream_error()); }
@@ -302,7 +302,7 @@ impl de::Deserializer for Deserializer {
     #[inline]
     fn visit_option<
         V: de::Visitor,
-    >(&mut self, visitor: &mut V) -> Result<V::Value, Error> {
+    >(&mut self, mut visitor: V) -> Result<V::Value, Error> {
         match self.value {
             Some(Value::Null) => visitor.visit_none(),
             Some(_) => visitor.visit_some(self),

serde2/tests/test_macros.rs

@@ -31,4 +31,6 @@ enum Enum<'a, A: 'a, B: /* Trait + */ 'a, C> where C: /* Trait + */ 'a {
     },
 }
 
-fn main() {}
+#[test]
+fn test() {
+}