From 88f5b9511d34d63a461179aba57d0356d01a478d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 6 Nov 2017 22:24:23 -0800 Subject: [PATCH] Use `..` in patterns As recommended by Clippy's unneeded_field_pattern lint. --- serde_test/src/de.rs | 66 ++++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs index 623d11b8..89716430 100644 --- a/serde_test/src/de.rs +++ b/serde_test/src/de.rs @@ -166,14 +166,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { Token::None => visitor.visit_none(), Token::Some => visitor.visit_some(self), Token::Unit => visitor.visit_unit(), - Token::UnitStruct { name: _ } => visitor.visit_unit(), - Token::NewtypeStruct { name: _ } => visitor.visit_newtype_struct(self), + Token::UnitStruct { .. } => visitor.visit_unit(), + Token::NewtypeStruct { .. } => visitor.visit_newtype_struct(self), Token::Seq { len } => self.visit_seq(len, Token::SeqEnd, visitor), Token::Tuple { len } => self.visit_seq(Some(len), Token::TupleEnd, visitor), - Token::TupleStruct { name: _, len } => self.visit_seq(Some(len), Token::TupleStructEnd, visitor), + Token::TupleStruct { len, .. } => self.visit_seq(Some(len), Token::TupleStructEnd, visitor), Token::Map { len } => self.visit_map(len, Token::MapEnd, visitor), - Token::Struct { name: _, len } => self.visit_map(Some(len), Token::StructEnd, visitor), - Token::Enum { name: _ } => { + Token::Struct { len, .. } => self.visit_map(Some(len), Token::StructEnd, visitor), + Token::Enum { .. } => { let variant = self.next_token(); let next = self.peek_token(); match (variant, next) { @@ -195,14 +195,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { } } } - Token::UnitVariant { name: _, variant } => visitor.visit_str(variant), - Token::NewtypeVariant { name: _, variant } => { + Token::UnitVariant { variant, .. } => visitor.visit_str(variant), + Token::NewtypeVariant { variant, .. } => { visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any),) } - Token::TupleVariant { name: _, variant, len: _ } => { + Token::TupleVariant { variant, .. } => { visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq),) } - Token::StructVariant { name: _, variant, len: _ } => { + Token::StructVariant { variant, .. } => { visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map),) } Token::SeqEnd | Token::TupleEnd | Token::TupleStructEnd | Token::MapEnd | @@ -245,10 +245,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { visitor.visit_enum(DeserializerEnumVisitor { de: self }) } - Token::UnitVariant { name: n, variant: _ } | - Token::NewtypeVariant { name: n, variant: _ } | - Token::TupleVariant { name: n, variant: _, len: _ } | - Token::StructVariant { name: n, variant: _, len: _ } if name == n => { + Token::UnitVariant { name: n, .. } | + Token::NewtypeVariant { name: n, .. } | + Token::TupleVariant { name: n, .. } | + Token::StructVariant { name: n, .. } if name == n => { visitor.visit_enum(DeserializerEnumVisitor { de: self }) } _ => { @@ -262,7 +262,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { V: Visitor<'de>, { match self.peek_token() { - Token::UnitStruct { name: _ } => { + Token::UnitStruct { .. } => { assert_next_token!(self, Token::UnitStruct { name: name }); visitor.visit_unit() } @@ -275,7 +275,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { V: Visitor<'de>, { match self.peek_token() { - Token::NewtypeStruct { name: _ } => { + Token::NewtypeStruct { .. } => { assert_next_token!(self, Token::NewtypeStruct { name: name }); visitor.visit_newtype_struct(self) } @@ -289,19 +289,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { { match self.peek_token() { Token::Unit | - Token::UnitStruct { name: _ } => { + Token::UnitStruct { .. } => { self.next_token(); visitor.visit_unit() } - Token::Seq { len: _ } => { + Token::Seq { .. } => { self.next_token(); self.visit_seq(Some(len), Token::SeqEnd, visitor) } - Token::Tuple { len: _ } => { + Token::Tuple { .. } => { self.next_token(); self.visit_seq(Some(len), Token::TupleEnd, visitor) } - Token::TupleStruct { name: _, len: _ } => { + Token::TupleStruct { .. } => { self.next_token(); self.visit_seq(Some(len), Token::TupleStructEnd, visitor) } @@ -323,19 +323,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { self.next_token(); visitor.visit_unit() } - Token::UnitStruct { name: _ } => { + Token::UnitStruct { .. } => { assert_next_token!(self, Token::UnitStruct { name: name }); visitor.visit_unit() } - Token::Seq { len: _ } => { + Token::Seq { .. } => { self.next_token(); self.visit_seq(Some(len), Token::SeqEnd, visitor) } - Token::Tuple { len: _ } => { + Token::Tuple { .. } => { self.next_token(); self.visit_seq(Some(len), Token::TupleEnd, visitor) } - Token::TupleStruct { name: _, len: n } => { + Token::TupleStruct { len: n, .. } => { assert_next_token!(self, Token::TupleStruct { name: name, len: n }); self.visit_seq(Some(len), Token::TupleStructEnd, visitor) } @@ -353,11 +353,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> { V: Visitor<'de>, { match self.peek_token() { - Token::Struct { name: _, len: n } => { + Token::Struct { len: n, .. } => { assert_next_token!(self, Token::Struct { name: name, len: n }); self.visit_map(Some(fields.len()), Token::StructEnd, visitor) } - Token::Map { len: _ } => { + Token::Map { .. } => { self.next_token(); self.visit_map(Some(fields.len()), Token::MapEnd, visitor) } @@ -449,10 +449,10 @@ impl<'de, 'a> EnumAccess<'de> for DeserializerEnumVisitor<'a, 'de> { V: DeserializeSeed<'de>, { match self.de.peek_token() { - Token::UnitVariant { name: _, variant: v } | - Token::NewtypeVariant { name: _, variant: v } | - Token::TupleVariant { name: _, variant: v, len: _ } | - Token::StructVariant { name: _, variant: v, len: _ } => { + Token::UnitVariant { variant: v, .. } | + Token::NewtypeVariant { variant: v, .. } | + Token::TupleVariant { variant: v, .. } | + Token::StructVariant { variant: v, .. } => { let de = v.into_deserializer(); let value = try!(seed.deserialize(de)); Ok((value, self)) @@ -470,7 +470,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { fn unit_variant(self) -> Result<(), Error> { match self.de.peek_token() { - Token::UnitVariant { name: _, variant: _ } => { + Token::UnitVariant { .. } => { self.de.next_token(); Ok(()) } @@ -483,7 +483,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { T: DeserializeSeed<'de>, { match self.de.peek_token() { - Token::NewtypeVariant { name: _, variant: _ } => { + Token::NewtypeVariant { .. } => { self.de.next_token(); seed.deserialize(self.de) } @@ -496,7 +496,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { V: Visitor<'de>, { match self.de.peek_token() { - Token::TupleVariant { name: _, variant: _, len: enum_len } => { + Token::TupleVariant { len: enum_len, .. } => { let token = self.de.next_token(); if len == enum_len { @@ -524,7 +524,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { V: Visitor<'de>, { match self.de.peek_token() { - Token::StructVariant { name: _, variant: _, len: enum_len } => { + Token::StructVariant { len: enum_len, .. } => { let token = self.de.next_token(); if fields.len() == enum_len {