Bump syntex/aster/quasi version

serde/src/bytes.rs

@@ -61,7 +61,7 @@ impl<'a> ser::Serialize for Bytes<'a> {
 ///////////////////////////////////////////////////////////////////////////////
 
 /// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
-#[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct ByteBuf {
     bytes: Vec<u8>,
 }

serde_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.7.1"
+version = "0.7.2"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -16,13 +16,13 @@ nightly-testing = ["clippy"]
 with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
 
 [build-dependencies]
-quasi_codegen = { version = "^0.8.0", optional = true }
+quasi_codegen = { version = "^0.9.0", optional = true }
-syntex = { version = "^0.30.0", optional = true }
+syntex = { version = "^0.31.0", optional = true }
 
 [dependencies]
-aster = { version = "^0.14.0", default-features = false }
+aster = { version = "^0.15.0", default-features = false }
 clippy = { version = "^0.*", optional = true }
-quasi = { version = "^0.8.0", default-features = false }
+quasi = { version = "^0.9.0", default-features = false }
-quasi_macros = { version = "^0.8.0", optional = true }
+quasi_macros = { version = "^0.9.0", optional = true }
-syntex = { version = "^0.30.0", optional = true }
+syntex = { version = "^0.31.0", optional = true }
-syntex_syntax = { version = "^0.30.0", optional = true }
+syntex_syntax = { version = "^0.31.0", optional = true }

serde_codegen/src/attr.rs

@@ -196,7 +196,7 @@ impl FieldAttrs {
                       is_enum: bool) -> Result<Self, Error> {
         let builder = AstBuilder::new();
 
-        let field_ident = match field.node.ident() {
+        let field_ident = match field.ident {
             Some(ident) => ident,
             None => { cx.span_bug(field.span, "struct field has no name?") }
         };
@@ -210,7 +210,7 @@ impl FieldAttrs {
             deserialize_with: None,
         };
 
-        for meta_items in field.node.attrs.iter().filter_map(get_serde_meta_items) {
+        for meta_items in field.attrs.iter().filter_map(get_serde_meta_items) {
             for meta_item in meta_items {
                 match meta_item.node {
                     // Parse `#[serde(rename="foo")]`
@@ -278,7 +278,7 @@ impl FieldAttrs {
                     ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize_with" => {
                         let expr = wrap_deserialize_with(
                             cx,
-                            &field.node.ty,
+                            &field.ty,
                             generics,
                             try!(parse_lit_into_path(cx, name, lit)),
                         );

serde_codegen/src/de.rs

@@ -148,7 +148,7 @@ fn deserialize_item_struct(
             )
         }
         ast::VariantData::Tuple(ref fields, _) => {
-            if fields.iter().any(|field| !field.node.kind.is_unnamed()) {
+            if fields.iter().any(|field| field.ident.is_some()) {
                 cx.span_bug(span, "tuple struct has named fields")
             }
 
@@ -163,7 +163,7 @@ fn deserialize_item_struct(
             )
         }
         ast::VariantData::Struct(ref fields, _) => {
-            if fields.iter().any(|field| field.node.kind.is_unnamed()) {
+            if fields.iter().any(|field| field.ident.is_none()) {
                 cx.span_bug(span, "struct has unnamed fields")
             }
 
@@ -452,9 +452,9 @@ fn deserialize_struct_as_seq(
                 .enumerate()
                 .map(|(i, field)| {
                     (
-                        match field.node.kind {
+                        match field.ident {
-                            ast::NamedField(name, _) => name.clone(),
+                            Some(name) => name.clone(),
-                            ast::UnnamedField(_) => {
+                            None => {
                                 cx.span_bug(field.span, "struct contains unnamed fields")
                             }
                         },
@@ -583,10 +583,10 @@ fn deserialize_item_enum(
         const VARIANTS: &'static [&'static str] = $variants_expr;
     ).unwrap();
 
-    let ignored_arm = if !container_attrs.deny_unknown_fields() {
+    let ignored_arm = if container_attrs.deny_unknown_fields() {
-        Some(quote_arm!(cx, __Field::__ignore => { Err(::serde::de::Error::end_of_stream()) }))
-    } else {
         None
+    } else {
+        Some(quote_arm!(cx, __Field::__ignore => { Err(::serde::de::Error::end_of_stream()) }))
     };
 
     // Match arms to extract a variant from a string
@@ -816,11 +816,11 @@ fn deserialize_field_visitor(
         .map(|i| builder.id(format!("__field{}", i)))
         .collect();
 
-    let ignore_variant = if !container_attrs.deny_unknown_fields() {
+    let ignore_variant = if container_attrs.deny_unknown_fields() {
+        None
+    } else {
         let skip_ident = builder.id("__ignore");
         Some(builder.variant(skip_ident).unit())
-    } else {
-        None
     };
 
     let field_enum = builder.item()
@@ -1008,9 +1008,9 @@ fn deserialize_struct_visitor(
         .with_exprs(
             fields.iter()
                 .map(|field| {
-                    match field.node.kind {
+                    match field.ident {
-                        ast::NamedField(name, _) => builder.expr().str(name),
+                        Some(name) => builder.expr().str(name),
-                        ast::UnnamedField(_) => {
+                        None => {
                             cx.span_bug(field.span, "struct contains unnamed fields")
                         }
                     }
@@ -1053,12 +1053,12 @@ fn deserialize_map(
 
 
     // Visit ignored values to consume them
-    let ignored_arm = if !container_attrs.deny_unknown_fields() {
+    let ignored_arm = if container_attrs.deny_unknown_fields() {
+        None
+    } else {
         Some(quote_arm!(cx,
             _ => { try!(visitor.visit_value::<::serde::de::impls::IgnoredAny>()); }
         ))
-    } else {
-        None
     };
 
     // Match arms to extract a value for a field.
@@ -1099,9 +1099,9 @@ fn deserialize_map(
                 .zip(field_names.iter())
                 .map(|(field, field_name)| {
                     (
-                        match field.node.kind {
+                        match field.ident {
-                            ast::NamedField(name, _) => name.clone(),
+                            Some(name) => name.clone(),
-                            ast::UnnamedField(_) => {
+                            None => {
                                 cx.span_bug(field.span, "struct contains unnamed fields")
                             }
                         },

serde_codegen/src/lib.rs

@@ -1,5 +1,6 @@
 #![cfg_attr(feature = "nightly-testing", plugin(clippy))]
 #![cfg_attr(feature = "nightly-testing", feature(plugin))]
+#![cfg_attr(feature = "nightly-testing", allow(too_many_arguments))]
 #![cfg_attr(feature = "nightly-testing", allow(used_underscore_binding))]
 #![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
 #![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]

serde_codegen/src/ser.rs

@@ -151,7 +151,7 @@ fn serialize_item_struct(
             )
         }
         ast::VariantData::Tuple(ref fields, _) => {
-            if fields.iter().any(|field| !field.node.kind.is_unnamed()) {
+            if fields.iter().any(|field| field.ident.is_some()) {
                 cx.span_bug(span, "tuple struct has named fields")
             }
 
@@ -165,7 +165,7 @@ fn serialize_item_struct(
             )
         }
         ast::VariantData::Struct(ref fields, _) => {
-            if fields.iter().any(|field| field.node.kind.is_unnamed()) {
+            if fields.iter().any(|field| field.ident.is_none()) {
                 cx.span_bug(span, "struct has unnamed fields")
             }
 
@@ -399,9 +399,9 @@ fn serialize_variant(
                     field_names.iter()
                         .zip(fields.iter())
                         .map(|(id, field)| {
-                            let name = match field.node.kind {
+                            let name = match field.ident {
-                                ast::NamedField(name, _) => name,
+                                Some(name) => name,
-                                ast::UnnamedField(_) => {
+                                None => {
                                     cx.span_bug(field.span, "struct variant has unnamed fields")
                                 }
                             };
@@ -447,7 +447,7 @@ fn serialize_tuple_variant(
                 builder.ty()
                     .ref_()
                     .lifetime("'__a")
-                    .build_ty(field.node.ty.clone())
+                    .build_ty(field.ty.clone())
             })
         )
         .build();
@@ -502,12 +502,12 @@ fn serialize_struct_variant(
         .with_generics(variant_generics.clone())
         .with_fields(
             fields.iter().map(|field| {
-                builder.struct_field(field.node.ident().expect("struct has unnamed fields"))
+                builder.struct_field(field.ident.expect("struct has unnamed fields"))
-                    .with_attrs(field.node.attrs.iter().cloned())
+                    .with_attrs(field.attrs.iter().cloned())
                     .ty()
                     .ref_()
                     .lifetime("'__serde_variant")
-                    .build_ty(field.node.ty.clone())
+                    .build_ty(field.ty.clone())
             })
         )
         .field("__serde_container_ty")
@@ -520,7 +520,7 @@ fn serialize_struct_variant(
                 .zip(field_names.iter())
                 .map(|(field, field_name)| {
                     (
-                        field.node.ident().expect("struct has unnamed fields"),
+                        field.ident.expect("struct has unnamed fields"),
                         builder.expr().id(field_name),
                     )
                 })
@@ -656,7 +656,7 @@ fn serialize_struct_visitor(
         .filter(|&(_, ref field_attr)| !field_attr.skip_serializing_field())
         .enumerate()
         .map(|(i, (ref field, ref field_attr))| {
-            let name = field.node.ident().expect("struct has unnamed field");
+            let name = field.ident.expect("struct has unnamed field");
 
             let key_expr = field_attr.name().serialize_name_expr();
 

serde_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_macros"
-version = "0.7.0"
+version = "0.7.2"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -17,7 +17,7 @@ nightly-testing = ["clippy", "serde/nightly-testing", "serde_codegen/nightly-tes
 
 [dependencies]
 clippy = { version = "^0.*", optional = true }
-serde_codegen = { version = "^0.7.0", path = "../serde_codegen", default-features = false, features = ["nightly"] }
+serde_codegen = { version = "^0.7.2", path = "../serde_codegen", default-features = false, features = ["nightly"] }
 
 [dev-dependencies]
 compiletest_rs = "^0.1.1"

serde_tests/Cargo.toml

@@ -14,14 +14,14 @@ build = "build.rs"
 nightly-testing = ["clippy", "serde/nightly-testing", "serde_codegen/nightly-testing"]
 
 [build-dependencies]
-syntex = { version = "^0.30.0" }
+syntex = { version = "^0.31.0" }
-syntex_syntax = { version = "^0.30.0" }
+syntex_syntax = { version = "^0.31.0" }
 serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-syntex"] }
 
 [dev-dependencies]
 rustc-serialize = "^0.3.16"
 serde = { version = "*", path = "../serde" }
-syntex = "^0.30.0"
+syntex = "^0.31.0"
 
 [dependencies]
 clippy = { version = "^0.*", optional = true }