Clippy

kornelski · kornelski · commit 4f355162706d · 2023-07-21T15:36:17.000+01:00
diff --git a/rmp-serde/src/decode.rs b/rmp-serde/src/decode.rs
@@ -307,7 +307,7 @@ impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
     fn read_str_data<V>(&mut self, len: u32, visitor: V) -> Result<V::Value, Error>
         where V: Visitor<'de>
     {
-        match read_bin_data(&mut self.rd, len as u32)? {
+        match read_bin_data(&mut self.rd, len)? {
             Reference::Borrowed(buf) => {
                 match str::from_utf8(buf) {
                     Ok(s) => visitor.visit_borrowed_str(s),
@@ -384,7 +384,7 @@ fn ext_len<R: Read>(rd: &mut R, marker: Marker) -> Result<u32, Error> {
         Marker::FixExt16 => 16,
         Marker::Ext8 => read_u8(rd)? as u32,
         Marker::Ext16 => read_u16(rd)? as u32,
-        Marker::Ext32 => read_u32(rd)? as u32,
+        Marker::Ext32 => read_u32(rd)?,
         _ => return Err(Error::TypeMismatch(marker)),
     })
 }
@@ -625,7 +625,7 @@ impl<'de, 'a, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de> f
                     self.marker = None;
                     visitor.visit_enum(VariantAccess::new(self))
                 }
-                n => Err(Error::LengthMismatch(n as u32)),
+                n => Err(Error::LengthMismatch(n)),
             },
             // TODO: Check this is a string
             Err(_) => visitor.visit_enum(UnitVariantAccess::new(self)),
diff --git a/rmp-serde/src/lib.rs b/rmp-serde/src/lib.rs
@@ -327,8 +327,8 @@ impl<'a> Serialize for RawRef<'a> {
         S: serde::Serializer,
     {
         match self.s {
-            Ok(ref s) => se.serialize_str(s),
-            Err((ref b, ..)) => se.serialize_bytes(b),
+            Ok(s) => se.serialize_str(s),
+            Err((b, ..)) => se.serialize_bytes(b),
         }
     }
 }
diff --git a/rmp/src/marker.rs b/rmp/src/marker.rs
@@ -151,9 +151,9 @@ impl From<u8> for Marker {
     }
 }
 
-impl Into<u8> for Marker {
+impl From<Marker> for u8 {
     #[inline]
-    fn into(self) -> u8 {
-        self.to_u8()
+    fn from(val: Marker) -> Self {
+        val.to_u8()
     }
 }
diff --git a/rmp/tests/func/decode/bool.rs b/rmp/tests/func/decode/bool.rs
@@ -7,7 +7,7 @@ fn from_bool_false() {
     let buf = [0xc2];
     let mut cur = Cursor::new(&buf[..]);
 
-    assert_eq!(false, read_bool(&mut cur).unwrap());
+    assert!(!read_bool(&mut cur).unwrap());
     assert_eq!(1, cur.position());
 }
 
diff --git a/rmpv/src/decode/mod.rs b/rmpv/src/decode/mod.rs
@@ -91,13 +91,13 @@ impl From<ValueReadError> for Error {
     }
 }
 
-impl Into<io::Error> for Error {
+impl From<Error> for io::Error {
     #[cold]
-    fn into(self) -> io::Error {
-        match self {
+    fn from(val: Error) -> Self {
+        match val {
             Error::InvalidMarkerRead(err) |
             Error::InvalidDataRead(err) => err,
-            Error::DepthLimitExceeded => io::Error::new(self.kind(), self),
+            Error::DepthLimitExceeded => io::Error::new(val.kind(), val),
         }
     }
 }
diff --git a/rmpv/src/encode/value.rs b/rmpv/src/encode/value.rs
@@ -57,7 +57,7 @@ pub fn write_value<W>(wr: &mut W, val: &Value) -> Result<(), Error>
         }
         Value::Map(ref map) => {
             write_map_len(wr, map.len() as u32)?;
-            for &(ref key, ref val) in map {
+            for (key, val) in map {
                 write_value(wr, key)?;
                 write_value(wr, val)?;
             }
diff --git a/rmpv/src/encode/value_ref.rs b/rmpv/src/encode/value_ref.rs
@@ -69,7 +69,7 @@ pub fn write_value_ref<W>(wr: &mut W, val: &ValueRef<'_>) -> Result<(), Error>
         }
         ValueRef::Map(ref map) => {
             write_map_len(wr, map.len() as u32)?;
-            for &(ref key, ref val) in map {
+            for (key, val) in map {
                 write_value_ref(wr, key)?;
                 write_value_ref(wr, val)?;
             }
diff --git a/rmpv/src/ext/de.rs b/rmpv/src/ext/de.rs
@@ -570,7 +570,7 @@ impl<'de> Deserializer<'de> for &'de ValueRef<'de> {
         where V: Visitor<'de>
     {
         match self {
-            &ValueRef::Array(ref v) => {
+            ValueRef::Array(v) => {
                 let len = v.len();
                 let mut iter = v.iter();
                 if !(len == 1 || len == 2) {
@@ -614,7 +614,7 @@ impl<'de> Deserializer<'de> for &'de ValueRef<'de> {
         where V: Visitor<'de>
     {
         match self {
-            &ValueRef::Array(ref v) => {
+            ValueRef::Array(v) => {
                 if v.is_empty() {
                     visitor.visit_unit()
                 } else {
@@ -968,7 +968,7 @@ impl<'de> de::MapAccess<'de> for MapRefDeserializer<'de> {
         where T: DeserializeSeed<'de>
     {
         match self.iter.next() {
-            Some(&(ref key, ref val)) => {
+            Some((key, val)) => {
                 self.val = Some(val);
                 seed.deserialize(key).map(Some)
             }
@@ -1040,7 +1040,7 @@ impl<'de> de::VariantAccess<'de> for VariantRefDeserializer<'de> {
     fn unit_variant(self) -> Result<(), Error> {
         // Can accept only [u32].
         match self.value {
-            Some(&ValueRef::Array(ref v)) => {
+            Some(ValueRef::Array(v)) => {
                 if v.is_empty() {
                     Ok(())
                 } else {
@@ -1057,7 +1057,7 @@ impl<'de> de::VariantAccess<'de> for VariantRefDeserializer<'de> {
     {
         // Can accept both [u32, T...] and [u32, [T]] cases.
         match self.value {
-            Some(&ValueRef::Array(ref v)) => {
+            Some(ValueRef::Array(v)) => {
                 let len = v.len();
                 let mut iter = v.iter();
                 if len > 1 {
@@ -1085,7 +1085,7 @@ impl<'de> de::VariantAccess<'de> for VariantRefDeserializer<'de> {
     {
         // Can accept [u32, [T...]].
         match self.value {
-            Some(&ValueRef::Array(ref v)) => {
+            Some(ValueRef::Array(v)) => {
                 Deserializer::deserialize_any(SeqDeserializer::new(v.iter()), visitor)
             }
             Some(v) => Err(de::Error::invalid_type(v.unexpected(), &"tuple variant")),
@@ -1097,10 +1097,10 @@ impl<'de> de::VariantAccess<'de> for VariantRefDeserializer<'de> {
         where V: Visitor<'de>,
     {
         match self.value {
-            Some(&ValueRef::Array(ref v)) => {
+            Some(ValueRef::Array(v)) => {
                 Deserializer::deserialize_any(SeqDeserializer::new(v.iter()), visitor)
             }
-            Some(&ValueRef::Map(ref v)) => {
+            Some(ValueRef::Map(v)) => {
                 Deserializer::deserialize_any(MapRefDeserializer::new(v.iter()), visitor)
             }
             Some(v) => Err(de::Error::invalid_type(v.unexpected(), &"struct variant")),
diff --git a/rmpv/src/ext/se.rs b/rmpv/src/ext/se.rs
@@ -42,7 +42,7 @@ impl Serialize for Value {
             }
             Value::Map(ref map) => {
                 let mut state = s.serialize_map(Some(map.len()))?;
-                for &(ref key, ref val) in map {
+                for (key, val) in map {
                     state.serialize_entry(key, val)?;
                 }
                 state.end()
@@ -696,7 +696,7 @@ impl SerializeSeq for SerializeVec {
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
         where T: Serialize
     {
-        self.vec.push(to_value(&value)?);
+        self.vec.push(to_value(value)?);
         Ok(())
     }
 
@@ -748,7 +748,7 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
         where T: Serialize
     {
-        self.vec.push(to_value(&value)?);
+        self.vec.push(to_value(value)?);
         Ok(())
     }
 
@@ -777,7 +777,7 @@ impl ser::SerializeMap for DefaultSerializeMap {
         // expected failure.
         let key = self.next_key.take()
             .expect("`serialize_value` called before `serialize_key`");
-        self.map.push((key, to_value(&value)?));
+        self.map.push((key, to_value(value)?));
         Ok(())
     }
 
@@ -812,7 +812,7 @@ impl ser::SerializeStructVariant for SerializeStructVariant {
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<(), Error>
         where T: Serialize
     {
-        self.vec.push(to_value(&value)?);
+        self.vec.push(to_value(value)?);
         Ok(())
     }
 
diff --git a/rmpv/src/lib.rs b/rmpv/src/lib.rs
@@ -142,7 +142,7 @@ impl From<u32> for Integer {
 impl From<u64> for Integer {
     #[inline]
     fn from(n: u64) -> Self {
-        Integer { n: IntPriv::PosInt(n as u64) }
+        Integer { n: IntPriv::PosInt(n) }
     }
 }
 
@@ -190,7 +190,7 @@ impl From<i64> for Integer {
     #[inline]
     fn from(n: i64) -> Self {
         if n < 0 {
-            Integer { n: IntPriv::NegInt(n as i64) }
+            Integer { n: IntPriv::NegInt(n) }
         } else {
             Integer { n: IntPriv::PosInt(n as u64) }
         }
@@ -415,9 +415,9 @@ impl<'a> From<&'a str> for Utf8StringRef<'a> {
     }
 }
 
-impl<'a> Into<Utf8String> for Utf8StringRef<'a> {
-    fn into(self) -> Utf8String {
-        match self.s {
+impl<'a> From<Utf8StringRef<'a>> for Utf8String {
+    fn from(val: Utf8StringRef<'a>) -> Self {
+        match val.s {
             Ok(s) => Utf8String { s: Ok(s.into()) },
             Err((buf, err)) => Utf8String { s: Err((buf.into(), err)) }
         }
@@ -509,7 +509,7 @@ impl Value {
                 ValueRef::Array(val.iter().map(|v| v.as_ref()).collect())
             }
             Value::Map(ref val) => {
-                ValueRef::Map(val.iter().map(|&(ref k, ref v)| (k.as_ref(), v.as_ref())).collect())
+                ValueRef::Map(val.iter().map(|(k, v)| (k.as_ref(), v.as_ref())).collect())
             }
             Value::Ext(ty, ref buf) => ValueRef::Ext(ty, buf.as_slice()),
         }
@@ -839,7 +839,7 @@ impl Value {
     #[inline]
     pub fn as_array(&self) -> Option<&Vec<Value>> {
         if let Value::Array(ref array) = *self {
-            Some(&*array)
+            Some(array)
         } else {
             None
         }
@@ -1208,15 +1208,15 @@ impl Display for Value {
                 write!(f, "{{")?;
 
                 match vec.iter().take(1).next() {
-                    Some(&(ref k, ref v)) => {
+                    Some((k, v)) => {
                         write!(f, "{}: {}", k, v)?;
                     }
                     None => {
                         write!(f, "")?;
                     }
                 }
 
-                for &(ref k, ref v) in vec.iter().skip(1) {
+                for (k, v) in vec.iter().skip(1) {
                     write!(f, ", {}: {}", k, v)?;
                 }
 
@@ -1300,7 +1300,7 @@ impl<'a> ValueRef<'a> {
                 Value::Array(val.iter().map(|v| v.to_owned()).collect())
             }
             ValueRef::Map(ref val) => {
-                Value::Map(val.iter().map(|&(ref k, ref v)| (k.to_owned(), v.to_owned())).collect())
+                Value::Map(val.iter().map(|(k, v)| (k.to_owned(), v.to_owned())).collect())
             }
             ValueRef::Ext(ty, buf) => Value::Ext(ty, buf.to_vec()),
         }
@@ -1342,7 +1342,7 @@ impl<'a> ValueRef<'a> {
     /// ```
     pub fn as_array(&self) -> Option<&Vec<ValueRef<'_>>> {
         if let ValueRef::Array(ref array) = *self {
-            Some(&*array)
+            Some(array)
         } else {
             None
         }
@@ -1556,15 +1556,15 @@ impl<'a> Display for ValueRef<'a> {
                 write!(f, "{{")?;
 
                 match vec.iter().take(1).next() {
-                    Some(&(ref k, ref v)) => {
+                    Some((k, v)) => {
                         write!(f, "{}: {}", k, v)?;
                     }
                     None => {
                         write!(f, "")?;
                     }
                 }
 
-                for &(ref k, ref v) in vec.iter().skip(1) {
+                for (k, v) in vec.iter().skip(1) {
                     write!(f, ", {}: {}", k, v)?;
                 }
 

Original file line number	Diff line number	Diff line change
`@@ -327,8 +327,8 @@ impl<'a> Serialize for RawRef<'a> {`
`327`	`327`	`S: serde::Serializer,`
`328`	`328`	`{`
`329`	`329`	`match self.s {`
`330`		`- Ok(ref s) => se.serialize_str(s),`
`331`		`- Err((ref b, ..)) => se.serialize_bytes(b),`
	`330`	`+ Ok(s) => se.serialize_str(s),`
	`331`	`+ Err((b, ..)) => se.serialize_bytes(b),`
`332`	`332`	`}`
`333`	`333`	`}`
`334`	`334`	`}`
Original file line number	Diff line number	Diff line change
`@@ -151,9 +151,9 @@ impl From<u8> for Marker {`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
`154`		`-impl Into<u8> for Marker {`
	`154`	`+impl From<Marker> for u8 {`
`155`	`155`	`#[inline]`
`156`		`- fn into(self) -> u8 {`
`157`		`- self.to_u8()`
	`156`	`+ fn from(val: Marker) -> Self {`
	`157`	`+ val.to_u8()`
`158`	`158`	`}`
`159`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ fn from_bool_false() {`
`7`	`7`	`let buf = [0xc2];`
`8`	`8`	`let mut cur = Cursor::new(&buf[..]);`
`9`	`9`
`10`		`- assert_eq!(false, read_bool(&mut cur).unwrap());`
	`10`	`+ assert!(!read_bool(&mut cur).unwrap());`
`11`	`11`	`assert_eq!(1, cur.position());`
`12`	`12`	`}`
`13`	`13`
Original file line number	Diff line number	Diff line change
`@@ -91,13 +91,13 @@ impl From<ValueReadError> for Error {`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`-impl Into<io::Error> for Error {`
	`94`	`+impl From<Error> for io::Error {`
`95`	`95`	`#[cold]`
`96`		`- fn into(self) -> io::Error {`
`97`		`- match self {`
	`96`	`+ fn from(val: Error) -> Self {`
	`97`	`+ match val {`
`98`	`98`	`Error::InvalidMarkerRead(err) \|`
`99`	`99`	`Error::InvalidDataRead(err) => err,`
`100`		`- Error::DepthLimitExceeded => io::Error::new(self.kind(), self),`
	`100`	`+ Error::DepthLimitExceeded => io::Error::new(val.kind(), val),`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ pub fn write_value<W>(wr: &mut W, val: &Value) -> Result<(), Error>`
`57`	`57`	`}`
`58`	`58`	`Value::Map(ref map) => {`
`59`	`59`	`write_map_len(wr, map.len() as u32)?;`
`60`		`- for &(ref key, ref val) in map {`
	`60`	`+ for (key, val) in map {`
`61`	`61`	`write_value(wr, key)?;`
`62`	`62`	`write_value(wr, val)?;`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ pub fn write_value_ref<W>(wr: &mut W, val: &ValueRef<'_>) -> Result<(), Error>`
`69`	`69`	`}`
`70`	`70`	`ValueRef::Map(ref map) => {`
`71`	`71`	`write_map_len(wr, map.len() as u32)?;`
`72`		`- for &(ref key, ref val) in map {`
	`72`	`+ for (key, val) in map {`
`73`	`73`	`write_value_ref(wr, key)?;`
`74`	`74`	`write_value_ref(wr, val)?;`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ impl Serialize for Value {`
`42`	`42`	`}`
`43`	`43`	`Value::Map(ref map) => {`
`44`	`44`	`let mut state = s.serialize_map(Some(map.len()))?;`
`45`		`- for &(ref key, ref val) in map {`
	`45`	`+ for (key, val) in map {`
`46`	`46`	`state.serialize_entry(key, val)?;`
`47`	`47`	`}`
`48`	`48`	`state.end()`
`@@ -696,7 +696,7 @@ impl SerializeSeq for SerializeVec {`
`696`	`696`	`fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>`
`697`	`697`	`where T: Serialize`
`698`	`698`	`{`
`699`		`- self.vec.push(to_value(&value)?);`
	`699`	`+ self.vec.push(to_value(value)?);`
`700`	`700`	`Ok(())`
`701`	`701`	`}`
`702`	`702`
`@@ -748,7 +748,7 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {`
`748`	`748`	`fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>`
`749`	`749`	`where T: Serialize`
`750`	`750`	`{`
`751`		`- self.vec.push(to_value(&value)?);`
	`751`	`+ self.vec.push(to_value(value)?);`
`752`	`752`	`Ok(())`
`753`	`753`	`}`
`754`	`754`
`@@ -777,7 +777,7 @@ impl ser::SerializeMap for DefaultSerializeMap {`
`777`	`777`	`// expected failure.`
`778`	`778`	`let key = self.next_key.take()`
`779`	`779`	.expect("`serialize_value` called before `serialize_key`");
`780`		`- self.map.push((key, to_value(&value)?));`
	`780`	`+ self.map.push((key, to_value(value)?));`
`781`	`781`	`Ok(())`
`782`	`782`	`}`
`783`	`783`
`@@ -812,7 +812,7 @@ impl ser::SerializeStructVariant for SerializeStructVariant {`
`812`	`812`	`fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<(), Error>`
`813`	`813`	`where T: Serialize`
`814`	`814`	`{`
`815`		`- self.vec.push(to_value(&value)?);`
	`815`	`+ self.vec.push(to_value(value)?);`
`816`	`816`	`Ok(())`
`817`	`817`	`}`
`818`	`818`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ impl From<u32> for Integer {`
`142`	`142`	`impl From<u64> for Integer {`
`143`	`143`	`#[inline]`
`144`	`144`	`fn from(n: u64) -> Self {`
`145`		`- Integer { n: IntPriv::PosInt(n as u64) }`
	`145`	`+ Integer { n: IntPriv::PosInt(n) }`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`@@ -190,7 +190,7 @@ impl From<i64> for Integer {`
`190`	`190`	`#[inline]`
`191`	`191`	`fn from(n: i64) -> Self {`
`192`	`192`	`if n < 0 {`
`193`		`- Integer { n: IntPriv::NegInt(n as i64) }`
	`193`	`+ Integer { n: IntPriv::NegInt(n) }`
`194`	`194`	`} else {`
`195`	`195`	`Integer { n: IntPriv::PosInt(n as u64) }`
`196`	`196`	`}`
`@@ -415,9 +415,9 @@ impl<'a> From<&'a str> for Utf8StringRef<'a> {`
`415`	`415`	`}`
`416`	`416`	`}`
`417`	`417`
`418`		`-impl<'a> Into<Utf8String> for Utf8StringRef<'a> {`
`419`		`- fn into(self) -> Utf8String {`
`420`		`- match self.s {`
	`418`	`+impl<'a> From<Utf8StringRef<'a>> for Utf8String {`
	`419`	`+ fn from(val: Utf8StringRef<'a>) -> Self {`
	`420`	`+ match val.s {`
`421`	`421`	`Ok(s) => Utf8String { s: Ok(s.into()) },`
`422`	`422`	`Err((buf, err)) => Utf8String { s: Err((buf.into(), err)) }`
`423`	`423`	`}`
`@@ -509,7 +509,7 @@ impl Value {`
`509`	`509`	`ValueRef::Array(val.iter().map(\|v\| v.as_ref()).collect())`
`510`	`510`	`}`
`511`	`511`	`Value::Map(ref val) => {`
`512`		`- ValueRef::Map(val.iter().map(\|&(ref k, ref v)\| (k.as_ref(), v.as_ref())).collect())`
	`512`	`+ ValueRef::Map(val.iter().map(\|(k, v)\| (k.as_ref(), v.as_ref())).collect())`
`513`	`513`	`}`
`514`	`514`	`Value::Ext(ty, ref buf) => ValueRef::Ext(ty, buf.as_slice()),`
`515`	`515`	`}`
`@@ -839,7 +839,7 @@ impl Value {`
`839`	`839`	`#[inline]`
`840`	`840`	`pub fn as_array(&self) -> Option<&Vec<Value>> {`
`841`	`841`	`if let Value::Array(ref array) = *self {`
`842`		`- Some(&*array)`
	`842`	`+ Some(array)`
`843`	`843`	`} else {`
`844`	`844`	`None`
`845`	`845`	`}`
`@@ -1208,15 +1208,15 @@ impl Display for Value {`
`1208`	`1208`	`write!(f, "{{")?;`
`1209`	`1209`
`1210`	`1210`	`match vec.iter().take(1).next() {`
`1211`		`- Some(&(ref k, ref v)) => {`
	`1211`	`+ Some((k, v)) => {`
`1212`	`1212`	`write!(f, "{}: {}", k, v)?;`
`1213`	`1213`	`}`
`1214`	`1214`	`None => {`
`1215`	`1215`	`write!(f, "")?;`
`1216`	`1216`	`}`
`1217`	`1217`	`}`
`1218`	`1218`
`1219`		`- for &(ref k, ref v) in vec.iter().skip(1) {`
	`1219`	`+ for (k, v) in vec.iter().skip(1) {`
`1220`	`1220`	`write!(f, ", {}: {}", k, v)?;`
`1221`	`1221`	`}`
`1222`	`1222`
`@@ -1300,7 +1300,7 @@ impl<'a> ValueRef<'a> {`
`1300`	`1300`	`Value::Array(val.iter().map(\|v\| v.to_owned()).collect())`
`1301`	`1301`	`}`
`1302`	`1302`	`ValueRef::Map(ref val) => {`
`1303`		`- Value::Map(val.iter().map(\|&(ref k, ref v)\| (k.to_owned(), v.to_owned())).collect())`
	`1303`	`+ Value::Map(val.iter().map(\|(k, v)\| (k.to_owned(), v.to_owned())).collect())`
`1304`	`1304`	`}`
`1305`	`1305`	`ValueRef::Ext(ty, buf) => Value::Ext(ty, buf.to_vec()),`
`1306`	`1306`	`}`
`@@ -1342,7 +1342,7 @@ impl<'a> ValueRef<'a> {`
`1342`	`1342`	/// ```
`1343`	`1343`	`pub fn as_array(&self) -> Option<&Vec<ValueRef<'_>>> {`
`1344`	`1344`	`if let ValueRef::Array(ref array) = *self {`
`1345`		`- Some(&*array)`
	`1345`	`+ Some(array)`
`1346`	`1346`	`} else {`
`1347`	`1347`	`None`
`1348`	`1348`	`}`
`@@ -1556,15 +1556,15 @@ impl<'a> Display for ValueRef<'a> {`
`1556`	`1556`	`write!(f, "{{")?;`
`1557`	`1557`
`1558`	`1558`	`match vec.iter().take(1).next() {`
`1559`		`- Some(&(ref k, ref v)) => {`
	`1559`	`+ Some((k, v)) => {`
`1560`	`1560`	`write!(f, "{}: {}", k, v)?;`
`1561`	`1561`	`}`
`1562`	`1562`	`None => {`
`1563`	`1563`	`write!(f, "")?;`
`1564`	`1564`	`}`
`1565`	`1565`	`}`
`1566`	`1566`
`1567`		`- for &(ref k, ref v) in vec.iter().skip(1) {`
	`1567`	`+ for (k, v) in vec.iter().skip(1) {`
`1568`	`1568`	`write!(f, ", {}: {}", k, v)?;`
`1569`	`1569`	`}`
`1570`	`1570`