Release 0.8.22

Support deserializing ByteBuf from string

.travis.yml

@@ -1,8 +1,8 @@
 sudo: false
 language: rust
 rust:
-- 1.10.0
-- 1.11.0
+- 1.12.0
+- 1.13.0
 - stable
 - beta
 - nightly

README.md

@@ -11,12 +11,11 @@ You may be looking for:
 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
 - [Examples](https://serde.rs/examples.html)
 - [API documentation](https://docs.serde.rs/serde/)
+- [Release notes](https://github.com/serde-rs/serde/releases)
 
 ## Serde in action
 
 ```rust
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

examples/serde-syntex-example/Cargo.toml

@@ -3,6 +3,7 @@ name = "serde-syntex-example"
 version = "0.1.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 build = "build.rs"
+publish = false
 
 [features]
 default = ["serde_codegen"]

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.8.15"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"

serde/src/bytes.rs

@@ -84,7 +84,7 @@ mod bytebuf {
     use de;
 
     #[cfg(feature = "collections")]
-    use collections::Vec;
+    use collections::{String, Vec};
 
     /// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
     #[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
@@ -208,7 +208,7 @@ mod bytebuf {
         fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
             where E: de::Error,
         {
-            self.visit_byte_buf(v.to_vec())
+            Ok(ByteBuf::from(v))
         }
 
         #[inline]
@@ -217,6 +217,18 @@ mod bytebuf {
         {
             Ok(ByteBuf::from(v))
         }
+
+        fn visit_str<E>(&mut self, v: &str) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
+
+        fn visit_string<E>(&mut self, v: String) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
     }
 
     impl de::Deserialize for ByteBuf {

serde/src/de/impls.rs

@@ -283,6 +283,12 @@ impl Visitor for StringVisitor {
         Ok(v)
     }
 
+    fn visit_unit<E>(&mut self) -> Result<String, E>
+        where E: Error,
+    {
+        Ok(String::new())
+    }
+
     fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<String, E>
         where E: Error,
     {

serde_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.8.15"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -22,9 +22,8 @@ with-syn = []
 
 [dependencies]
 clippy = { version = "^0.*", optional = true }
-post-expansion = "0.1.0"
-quote = "0.3"
-serde_codegen_internals = { version = "=0.10.0", default-features = false, path = "../serde_codegen_internals" }
-syn = { version = "0.9", features = ["aster", "visit"] }
-syntex = { version = "^0.45.0", optional = true }
-syntex_syntax = { version = "^0.45.0", optional = true }
+quote = "0.3.8"
+serde_codegen_internals = { version = "=0.11.3", default-features = false, path = "../serde_codegen_internals" }
+syn = { version = "0.10", features = ["aster", "visit"] }
+syntex = { version = "^0.54.0", optional = true }
+syntex_syntax = { version = "^0.54.0", optional = true }

serde_codegen/src/de.rs

@@ -496,6 +496,7 @@ fn deserialize_item_enum(
 
     let variant_visitor = deserialize_field_visitor(
         variants.iter()
+            .filter(|variant| !variant.attrs.skip_deserializing())
             .map(|variant| variant.attrs.name().deserialize_name())
             .collect(),
         item_attrs,
@@ -518,7 +519,7 @@ fn deserialize_item_enum(
 
     // Match arms to extract a variant from a string
     let mut variant_arms = vec![];
-    for (i, variant) in variants.iter().enumerate() {
+    for (i, variant) in variants.iter().filter(|variant| !variant.attrs.skip_deserializing()).enumerate() {
         let variant_name = aster::id(format!("__field{}", i));
         let variant_name = quote!(__Field::#variant_name);
 
@@ -881,7 +882,7 @@ fn deserialize_map(
         .map(|&(_, ref name)| {
             quote! {
                 __Field::#name => {
-                    try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>());
+                    let _ = try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>());
                 }
             }
         })
@@ -892,7 +893,7 @@ fn deserialize_map(
         None
     } else {
         Some(quote! {
-            _ => { try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>()); }
+            _ => { let _ = try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>()); }
         })
     };
 

serde_codegen/src/lib.rs

@@ -2,7 +2,6 @@
 #![cfg_attr(feature = "clippy", feature(plugin))]
 #![cfg_attr(feature = "clippy", allow(too_many_arguments))]
 #![cfg_attr(feature = "clippy", allow(used_underscore_binding))]
-#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
 
 // The `quote!` macro requires deep recursion.
 #![recursion_limit = "192"]
@@ -16,26 +15,13 @@ extern crate syntex;
 #[macro_use]
 extern crate syntex_syntax as syntax;
 
-#[cfg(not(feature = "with-syntex"))]
-#[macro_use]
-extern crate syntax;
-
-#[cfg(not(feature = "with-syntex"))]
-extern crate rustc_plugin;
-
 extern crate syn;
 #[macro_use]
 extern crate quote;
 
-#[cfg(feature = "with-syn")]
-extern crate post_expansion;
-
 #[cfg(feature = "with-syntex")]
 use std::path::Path;
 
-#[cfg(not(feature = "with-syntex"))]
-use syntax::feature_gate::AttributeType;
-
 mod bound;
 mod de;
 mod ser;
@@ -52,11 +38,11 @@ fn syntex_registry() -> syntex::Registry {
 
         impl fold::Folder for StripAttributeFolder {
             fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
-                match attr.node.value.node {
-                    ast::MetaItemKind::List(ref n, _) if n == &"serde" => { return None; }
-                    _ => {}
+                if attr.value.name == "serde" {
+                    if let ast::MetaItemKind::List(..) = attr.value.node {
+                        return None;
+                    }
                 }
-
                 Some(attr)
             }
 
@@ -73,8 +59,8 @@ fn syntex_registry() -> syntex::Registry {
     reg.add_attr("feature(custom_derive)");
     reg.add_attr("feature(custom_attribute)");
 
-    reg.add_decorator("derive_Serialize", expand_derive_serialize);
-    reg.add_decorator("derive_Deserialize", expand_derive_deserialize);
+    reg.add_decorator("derive_Serialize", shim::expand_derive_serialize);
+    reg.add_decorator("derive_Deserialize", shim::expand_derive_deserialize);
 
     reg.add_post_expansion_pass(strip_attributes);
 
@@ -107,24 +93,9 @@ pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
     syntex::with_extra_stack(expand_thread)
 }
 
-#[cfg(not(feature = "with-syntex"))]
-pub fn register(reg: &mut rustc_plugin::Registry) {
-    reg.register_syntax_extension(
-        syntax::parse::token::intern("derive_Serialize"),
-        syntax::ext::base::MultiDecorator(
-            Box::new(expand_derive_serialize)));
-
-    reg.register_syntax_extension(
-        syntax::parse::token::intern("derive_Deserialize"),
-        syntax::ext::base::MultiDecorator(
-            Box::new(expand_derive_deserialize)));
-
-    reg.register_attribute("serde".to_owned(), AttributeType::Normal);
-}
-
 macro_rules! shim {
     ($name:ident $pkg:ident :: $func:ident) => {
-        fn $func(
+        pub fn $func(
             cx: &mut ::syntax::ext::base::ExtCtxt,
             span: ::syntax::codemap::Span,
             meta_item: &::syntax::ast::MetaItem,
@@ -145,13 +116,12 @@ macro_rules! shim {
 
             use syntax::{attr, ast, visit};
             struct MarkSerdeAttributesUsed;
-            impl visit::Visitor for MarkSerdeAttributesUsed {
+            impl<'a> visit::Visitor<'a> for MarkSerdeAttributesUsed {
                 fn visit_attribute(&mut self, attr: &ast::Attribute) {
-                    match attr.node.value.node {
-                        ast::MetaItemKind::List(ref name, _) if name == "serde" => {
+                    if attr.value.name == "serde" {
+                        if let ast::MetaItemKind::List(..) = attr.value.node {
                             attr::mark_used(attr);
                         }
-                        _ => {}
                     }
                 }
             }
@@ -160,6 +130,7 @@ macro_rules! shim {
             use syntax::print::pprust;
             let s = pprust::item_to_string(item);
 
+            use {syn, $pkg};
             let syn_item = syn::parse_macro_input(&s).unwrap();
             let expanded = match $pkg::$func(&syn_item) {
                 Ok(expanded) => expanded.to_string(),
@@ -171,78 +142,31 @@ macro_rules! shim {
 
             use syntax::parse;
             let name = stringify!($name).to_string();
-            let cfg = Vec::new();
             let sess = cx.parse_sess;
-            let impl_item = parse::parse_item_from_source_str(name, expanded, cfg, sess);
+            let impl_item = parse::parse_item_from_source_str(name, expanded, sess);
             push(::syntax::ext::base::Annotatable::Item(impl_item.unwrap().unwrap()));
         }
     };
 }
 
-shim!(Serialize ser::expand_derive_serialize);
-shim!(Deserialize de::expand_derive_deserialize);
+#[cfg(feature = "with-syntex")]
+mod shim {
+    shim!(Serialize ser::expand_derive_serialize);
+    shim!(Deserialize de::expand_derive_deserialize);
+}
 
 #[cfg(feature = "with-syn")]
-pub fn expand_single_item(item: &str) -> Result<String, String> {
+#[doc(hidden)]
+/// Not public API. Use the serde_derive crate.
+pub fn expand_derive_serialize(item: &str) -> Result<quote::Tokens, String> {
     let syn_item = syn::parse_macro_input(item).unwrap();
-    let (ser, de, syn_item) = strip_serde_derives(syn_item);
-    let expanded_ser = if ser {
-        Some(try!(ser::expand_derive_serialize(&syn_item)))
-    } else {
-        None
-    };
-    let expanded_de = if de {
-        Some(try!(de::expand_derive_deserialize(&syn_item)))
-    } else {
-        None::<quote::Tokens>
-    };
-    let syn_item = post_expansion::strip_attrs_later(syn_item, &["serde"], "serde");
-    return Ok(quote!(#expanded_ser #expanded_de #syn_item).to_string());
-
-    fn strip_serde_derives(item: syn::MacroInput) -> (bool, bool, syn::MacroInput) {
-        let mut ser = false;
-        let mut de = false;
-        let item = syn::MacroInput {
-            attrs: item.attrs.into_iter().flat_map(|attr| {
-                if attr.is_sugared_doc || attr.style != syn::AttrStyle::Outer {
-                    return Some(attr);
-                }
-                let (name, nested) = match attr.value {
-                    syn::MetaItem::List(name, nested) => (name, nested),
-                    _ => return Some(attr)
-                };
-                if name != "derive" {
-                    return Some(syn::Attribute {
-                        style: syn::AttrStyle::Outer,
-                        value: syn::MetaItem::List(name, nested),
-                        is_sugared_doc: false,
-                    });
-                }
-                let rest: Vec<_> = nested.into_iter().filter(|nested| {
-                    match *nested {
-                        syn::MetaItem::Word(ref word) if word == "Serialize" => {
-                            ser = true;
-                            false
-                        }
-                        syn::MetaItem::Word(ref word) if word == "Deserialize" => {
-                            de = true;
-                            false
-                        }
-                        _ => true,
-                    }
-                }).collect();
-                if rest.is_empty() {
-                    None
-                } else {
-                    Some(syn::Attribute {
-                        style: syn::AttrStyle::Outer,
-                        value: syn::MetaItem::List(name, rest),
-                        is_sugared_doc: false,
-                    })
-                }
-            }).collect(),
-            ..item
-        };
-        (ser, de, item)
-    }
+    ser::expand_derive_serialize(&syn_item)
+}
+
+#[cfg(feature = "with-syn")]
+#[doc(hidden)]
+/// Not public API. Use the serde_derive crate.
+pub fn expand_derive_deserialize(item: &str) -> Result<quote::Tokens, String> {
+    let syn_item = syn::parse_macro_input(item).unwrap();
+    de::expand_derive_deserialize(&syn_item)
 }

serde_codegen/src/ser.rs

@@ -256,76 +256,80 @@ fn serialize_variant(
     let variant_ident = variant.ident.clone();
     let variant_name = variant.attrs.name().serialize_name();
 
-    match variant.style {
-        Style::Unit => {
-            quote! {
-                #type_ident::#variant_ident =>
-                    _serde::ser::Serializer::serialize_unit_variant(
-                        _serializer,
-                        #type_name,
-                        #variant_index,
-                        #variant_name,
-                    ),
-            }
-        },
-        Style::Newtype => {
-            let block = serialize_newtype_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                ty,
-                generics,
-                &variant.fields[0],
-            );
-
-            quote! {
-                #type_ident::#variant_ident(ref __simple_value) => #block,
-            }
-        },
-        Style::Tuple => {
-            let field_names: Vec<Tokens> = (0 .. variant.fields.len())
-                .map(|i| {
-                    let id = aster::id(format!("__field{}", i));
-                    quote!(ref #id)
-                })
-                .collect();
-
-            let pat = quote!(#type_ident::#variant_ident(#(#field_names),*));
-
-            let block = serialize_tuple_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-            );
-
-            quote! {
-                #pat => { #block }
-            }
+    if variant.attrs.skip_serializing() {
+        let skipped_msg = format!("The enum variant {}::{} cannot be serialized",
+                                type_ident, variant_ident);
+        let skipped_err = quote! {
+            Err(_serde::ser::Error::invalid_value(#skipped_msg))
+        };
+        let fields_pat = match variant.style {
+            Style::Unit => quote!(),
+            Style::Newtype | Style::Tuple => quote!( (..) ),
+            Style::Struct => quote!( {..} ),
+        };
+        quote! {
+            #type_ident::#variant_ident #fields_pat => #skipped_err,
         }
-        Style::Struct => {
-            let fields = variant.fields.iter().map(|field| {
-                let id = match field.ident {
-                    Some(ref name) => name.clone(),
-                    None => panic!("struct variant has unnamed fields"),
-                };
-                quote!(ref #id)
-            });
-            let pat = quote!(#type_ident::#variant_ident { #(#fields),* });
+    } else { // variant wasn't skipped
+        match variant.style {
+            Style::Unit => {
+                quote! {
+                    #type_ident::#variant_ident =>
+                        _serde::ser::Serializer::serialize_unit_variant(
+                            _serializer,
+                            #type_name,
+                            #variant_index,
+                            #variant_name,
+                        ),
+                }
+            },
+            Style::Newtype => {
+                let block = serialize_newtype_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    ty,
+                    generics,
+                    &variant.fields[0],
+                );
 
-            let block = serialize_struct_variant(
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-                item_attrs,
-            );
+                quote! {
+                    #type_ident::#variant_ident(ref __simple_value) => #block,
+                }
+            },
+            Style::Tuple => {
+                let field_names = (0 .. variant.fields.len())
+                    .map(|i| aster::id(format!("__field{}", i)));
 
-            quote! {
-                #pat => { #block }
+                let block = serialize_tuple_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident(#(ref #field_names),*) => { #block }
+                }
+            }
+            Style::Struct => {
+                let fields = variant.fields.iter()
+                    .map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
+
+                let block = serialize_struct_variant(
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                    item_attrs,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident { #(ref #fields),* } => { #block }
+                }
             }
         }
     }

serde_codegen_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen_internals"
-version = "0.10.0"
+version = "0.11.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde codegen. Unstable."
@@ -15,4 +15,4 @@ unstable-testing = ["clippy"]
 
 [dependencies]
 clippy = { version = "^0.*", optional = true }
-syn = "0.9"
+syn = "0.10"

serde_codegen_internals/src/attr.rs

@@ -1,5 +1,7 @@
 use Ctxt;
 use syn;
+use syn::MetaItem::{List, NameValue, Word};
+use syn::NestedMetaItem::{Literal, MetaItem};
 
 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
 // are `attr::Item::from_ast`, `attr::Variant::from_ast`, and
@@ -105,7 +107,7 @@ impl Item {
             for meta_item in meta_items {
                 match meta_item {
                     // Parse `#[serde(rename="foo")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "rename" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "rename" => {
                         if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
                             ser_name.set(s.clone());
                             de_name.set(s);
@@ -113,7 +115,7 @@ impl Item {
                     }
 
                     // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "rename" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "rename" => {
                         if let Ok((ser, de)) = get_renames(cx, meta_items) {
                             ser_name.set_opt(ser);
                             de_name.set_opt(de);
@@ -121,12 +123,12 @@ impl Item {
                     }
 
                     // Parse `#[serde(deny_unknown_fields)]`
-                    syn::MetaItem::Word(ref name) if name == "deny_unknown_fields" => {
+                    MetaItem(Word(ref name)) if name == "deny_unknown_fields" => {
                         deny_unknown_fields.set_true();
                     }
 
                     // Parse `#[serde(bound="D: Serialize")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "bound" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "bound" => {
                         if let Ok(where_predicates) = parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit) {
                             ser_bound.set(where_predicates.clone());
                             de_bound.set(where_predicates);
@@ -134,17 +136,21 @@ impl Item {
                     }
 
                     // Parse `#[serde(bound(serialize="D: Serialize", deserialize="D: Deserialize"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "bound" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "bound" => {
                         if let Ok((ser, de)) = get_where_predicates(cx, meta_items) {
                             ser_bound.set_opt(ser);
                             de_bound.set_opt(de);
                         }
                     }
 
-                    _ => {
+                    MetaItem(ref meta_item) => {
                         cx.error(format!("unknown serde container attribute `{}`",
                                          meta_item.name()));
                     }
+
+                    Literal(_) => {
+                        cx.error(format!("unexpected literal in serde container attribute"));
+                    }
                 }
             }
         }
@@ -181,18 +187,22 @@ impl Item {
 #[derive(Debug)]
 pub struct Variant {
     name: Name,
+    skip_deserializing: bool,
+    skip_serializing: bool,
 }
 
 impl Variant {
     pub fn from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self {
         let mut ser_name = Attr::none(cx, "rename");
         let mut de_name = Attr::none(cx, "rename");
+        let mut skip_deserializing = BoolAttr::none(cx, "skip_deserializing");
+        let mut skip_serializing = BoolAttr::none(cx, "skip_serializing");
 
         for meta_items in variant.attrs.iter().filter_map(get_serde_meta_items) {
             for meta_item in meta_items {
                 match meta_item {
                     // Parse `#[serde(rename="foo")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "rename" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "rename" => {
                         if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
                             ser_name.set(s.clone());
                             de_name.set(s);
@@ -200,17 +210,29 @@ impl Variant {
                     }
 
                     // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "rename" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "rename" => {
                         if let Ok((ser, de)) = get_renames(cx, meta_items) {
                             ser_name.set_opt(ser);
                             de_name.set_opt(de);
                         }
                     }
+                    // Parse `#[serde(skip_deserializing)]`
+                    MetaItem(Word(ref name)) if name == "skip_deserializing" => {
+                        skip_deserializing.set_true();
+                    }
+                    // Parse `#[serde(skip_serializing)]`
+                    MetaItem(Word(ref name)) if name == "skip_serializing" => {
+                        skip_serializing.set_true();
+                    }
 
-                    _ => {
+                    MetaItem(ref meta_item) => {
                         cx.error(format!("unknown serde variant attribute `{}`",
                                          meta_item.name()));
                     }
+
+                    Literal(_) => {
+                        cx.error(format!("unexpected literal in serde variant attribute"));
+                    }
                 }
             }
         }
@@ -220,12 +242,22 @@ impl Variant {
                 serialize: ser_name.get().unwrap_or_else(|| variant.ident.to_string()),
                 deserialize: de_name.get().unwrap_or_else(|| variant.ident.to_string()),
             },
+            skip_deserializing: skip_deserializing.get(),
+            skip_serializing: skip_serializing.get(),
         }
     }
 
     pub fn name(&self) -> &Name {
         &self.name
     }
+
+    pub fn skip_deserializing(&self) -> bool {
+        self.skip_deserializing
+    }
+
+    pub fn skip_serializing(&self) -> bool {
+        self.skip_serializing
+    }
 }
 
 /// Represents field attribute information
@@ -278,7 +310,7 @@ impl Field {
             for meta_item in meta_items {
                 match meta_item {
                     // Parse `#[serde(rename="foo")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "rename" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "rename" => {
                         if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
                             ser_name.set(s.clone());
                             de_name.set(s);
@@ -286,7 +318,7 @@ impl Field {
                     }
 
                     // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "rename" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "rename" => {
                         if let Ok((ser, de)) = get_renames(cx, meta_items) {
                             ser_name.set_opt(ser);
                             de_name.set_opt(de);
@@ -294,50 +326,50 @@ impl Field {
                     }
 
                     // Parse `#[serde(default)]`
-                    syn::MetaItem::Word(ref name) if name == "default" => {
+                    MetaItem(Word(ref name)) if name == "default" => {
                         default.set(FieldDefault::Default);
                     }
 
                     // Parse `#[serde(default="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "default" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "default" => {
                         if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                             default.set(FieldDefault::Path(path));
                         }
                     }
 
                     // Parse `#[serde(skip_serializing)]`
-                    syn::MetaItem::Word(ref name) if name == "skip_serializing" => {
+                    MetaItem(Word(ref name)) if name == "skip_serializing" => {
                         skip_serializing.set_true();
                     }
 
                     // Parse `#[serde(skip_deserializing)]`
-                    syn::MetaItem::Word(ref name) if name == "skip_deserializing" => {
+                    MetaItem(Word(ref name)) if name == "skip_deserializing" => {
                         skip_deserializing.set_true();
                     }
 
                     // Parse `#[serde(skip_serializing_if="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "skip_serializing_if" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "skip_serializing_if" => {
                         if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                             skip_serializing_if.set(path);
                         }
                     }
 
                     // Parse `#[serde(serialize_with="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "serialize_with" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "serialize_with" => {
                         if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                             serialize_with.set(path);
                         }
                     }
 
                     // Parse `#[serde(deserialize_with="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "deserialize_with" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "deserialize_with" => {
                         if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                             deserialize_with.set(path);
                         }
                     }
 
                     // Parse `#[serde(bound="D: Serialize")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "bound" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "bound" => {
                         if let Ok(where_predicates) = parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit) {
                             ser_bound.set(where_predicates.clone());
                             de_bound.set(where_predicates);
@@ -345,17 +377,21 @@ impl Field {
                     }
 
                     // Parse `#[serde(bound(serialize="D: Serialize", deserialize="D: Deserialize"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "bound" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "bound" => {
                         if let Ok((ser, de)) = get_where_predicates(cx, meta_items) {
                             ser_bound.set_opt(ser);
                             de_bound.set_opt(de);
                         }
                     }
 
-                    _ => {
+                    MetaItem(ref meta_item) => {
                         cx.error(format!("unknown serde field attribute `{}`",
                                          meta_item.name()));
                     }
+
+                    Literal(_) => {
+                        cx.error(format!("unexpected literal in serde field attribute"));
+                    }
                 }
             }
         }
@@ -424,7 +460,7 @@ type SerAndDe<T> = (Option<T>, Option<T>);
 fn get_ser_and_de<T, F>(
     cx: &Ctxt,
     attr_name: &'static str,
-    items: &[syn::MetaItem],
+    items: &[syn::NestedMetaItem],
     f: F
 ) -> Result<SerAndDe<T>, ()>
     where F: Fn(&Ctxt, &str, &str, &syn::Lit) -> Result<T, ()>,
@@ -434,13 +470,13 @@ fn get_ser_and_de<T, F>(
 
     for item in items {
         match *item {
-            syn::MetaItem::NameValue(ref name, ref lit) if name == "serialize" => {
+            MetaItem(NameValue(ref name, ref lit)) if name == "serialize" => {
                 if let Ok(v) = f(cx, attr_name, name.as_ref(), lit) {
                     ser_item.set(v);
                 }
             }
 
-            syn::MetaItem::NameValue(ref name, ref lit) if name == "deserialize" => {
+            MetaItem(NameValue(ref name, ref lit)) if name == "deserialize" => {
                 if let Ok(v) = f(cx, attr_name, name.as_ref(), lit) {
                     de_item.set(v);
                 }
@@ -459,21 +495,21 @@ fn get_ser_and_de<T, F>(
 
 fn get_renames(
     cx: &Ctxt,
-    items: &[syn::MetaItem],
+    items: &[syn::NestedMetaItem],
 ) -> Result<SerAndDe<String>, ()> {
     get_ser_and_de(cx, "rename", items, get_string_from_lit)
 }
 
 fn get_where_predicates(
     cx: &Ctxt,
-    items: &[syn::MetaItem],
+    items: &[syn::NestedMetaItem],
 ) -> Result<SerAndDe<Vec<syn::WherePredicate>>, ()> {
     get_ser_and_de(cx, "bound", items, parse_lit_into_where)
 }
 
-pub fn get_serde_meta_items(attr: &syn::Attribute) -> Option<Vec<syn::MetaItem>> {
+pub fn get_serde_meta_items(attr: &syn::Attribute) -> Option<Vec<syn::NestedMetaItem>> {
     match attr.value {
-        syn::MetaItem::List(ref name, ref items) if name == "serde" => {
+        List(ref name, ref items) if name == "serde" => {
             Some(items.iter().cloned().collect())
         }
         _ => None

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "0.8.15"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -14,11 +14,8 @@ include = ["Cargo.toml", "src/**/*.rs"]
 name = "serde_derive"
 proc-macro = true
 
-[dependencies]
-post-expansion = "0.1.0"
-
 [dependencies.serde_codegen]
-version = "=0.8.15"
+version = "=0.8.22"
 path = "../serde_codegen"
 default-features = false
 features = ["with-syn"]
@@ -26,5 +23,5 @@ features = ["with-syn"]
 [dev-dependencies]
 compiletest_rs = "^0.2.0"
 fnv = "1.0"
-serde = { version = "0.8.15", path = "../serde" }
-serde_test = { version = "0.8.15", path = "../serde_test" }
+serde = { version = "0.8.22", path = "../serde" }
+serde_test = { version = "0.8.22", path = "../serde_test" }

serde_derive/src/lib.rs

@@ -1,30 +1,20 @@
-#![feature(proc_macro, proc_macro_lib)]
-#![cfg(not(test))]
-
 extern crate proc_macro;
 extern crate serde_codegen;
 
-#[macro_use]
-extern crate post_expansion;
-
 use proc_macro::TokenStream;
 
-#[proc_macro_derive(Serialize)]
+#[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let item = format!("#[derive(Serialize)]\n{}", input);
-    match serde_codegen::expand_single_item(&item) {
+    match serde_codegen::expand_derive_serialize(&input.to_string()) {
         Ok(expanded) => expanded.parse().unwrap(),
         Err(msg) => panic!(msg),
     }
 }
 
-#[proc_macro_derive(Deserialize)]
+#[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let item = format!("#[derive(Deserialize)]\n{}", input);
-    match serde_codegen::expand_single_item(&item) {
+    match serde_codegen::expand_derive_deserialize(&input.to_string()) {
         Ok(expanded) => expanded.parse().unwrap(),
         Err(msg) => panic!(msg),
     }
 }
-
-register_post_expansion!(PostExpansion_serde);

serde_derive/tests/compile-fail/duplicate-attribute/rename-and-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-rename-de.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/two-rename-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/str_ref_deser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/container.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/field.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/variant.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/run-pass/identity-op.rs

@@ -1,4 +1,3 @@
-#![feature(proc_macro)]
 #![deny(identity_op)]
 
 #[macro_use]

serde_derive/tests/test.rs

@@ -1,4 +1,4 @@
-#![feature(test, proc_macro)]
+#![feature(test)]
 
 #[macro_use]
 extern crate serde_derive;

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "0.8.15"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
@@ -12,4 +12,4 @@ keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]
 
 [dependencies]
-serde = { version = "0.8.15", path = "../serde" }
+serde = { version = "0.8.22", path = "../serde" }

testing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_testing"
-version = "0.8.15"
+version = "0.8.22"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -10,6 +10,7 @@ documentation = "https://docs.serde.rs/serde/"
 readme = "README.md"
 keywords = ["serialization"]
 build = "build.rs"
+publish = false
 
 [features]
 unstable-testing = ["clippy", "serde/unstable-testing", "serde_codegen/unstable-testing"]

testing/tests/test.rs.in

@@ -1,4 +1,5 @@
 extern crate serde;
+extern crate serde_test;
 
 #[macro_use]
 mod macros;

testing/tests/test_bytes.rs

@@ -1,11 +1,13 @@
 use std::fmt;
 use std::error;
 
-use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
 use serde::bytes::{ByteBuf, Bytes};
 use serde::ser;
 use serde::de;
 
+use serde_test::{assert_de_tokens, Token};
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #[derive(Debug, PartialEq)]
@@ -286,153 +288,6 @@ impl Serializer for BytesSerializer {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct BytesDeserializer {
-    bytes: Option<Vec<u8>>,
-}
-
-impl BytesDeserializer {
-    fn new(bytes: Vec<u8>) -> Self {
-        BytesDeserializer {
-            bytes: Some(bytes),
-        }
-    }
-}
-
-impl Deserializer for BytesDeserializer {
-    type Error = Error;
-
-    fn deserialize<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        Err(Error)
-    }
-
-    fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        visitor.visit_byte_buf(self.bytes.take().unwrap())
-    }
-
-    fn deserialize_seq<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_struct_field<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_map<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_unit<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_ignored_any<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_string<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_str<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_char<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_f32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_f64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_bool<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_usize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_option<__V>(&mut self, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_seq_fixed_size<__V>(&mut self, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_unit_struct<__V>(&mut self, _: &str, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_newtype_struct<__V>(&mut self, _: &str, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_tuple<__V>(&mut self, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::EnumVisitor {
-        Err(Error)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 #[test]
 fn test_bytes_ser_bytes() {
     let buf = vec![];
@@ -449,12 +304,42 @@ fn test_bytes_ser_bytes() {
 ///////////////////////////////////////////////////////////////////////////////
 
 #[test]
-fn test_byte_buf_de_bytes() {
-    let mut de = BytesDeserializer::new(vec![]);
-    let bytes = Deserialize::deserialize(&mut de);
-    assert_eq!(bytes, Ok(ByteBuf::new()));
+fn test_byte_buf_de() {
+    let empty = ByteBuf::new();
+    assert_de_tokens(&empty, &[Token::Bytes(b""),]);
+    assert_de_tokens(&empty, &[Token::Str("")]);
+    assert_de_tokens(&empty, &[Token::String(String::new())]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(None),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(Some(0)),
+        Token::SeqEnd,
+    ]);
 
-    let mut de = BytesDeserializer::new(vec![1, 2, 3]);
-    let bytes = Deserialize::deserialize(&mut de);
-    assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
+    let buf = ByteBuf::from(vec![65, 66, 67]);
+    assert_de_tokens(&buf, &[Token::Bytes(b"ABC")]);
+    assert_de_tokens(&buf, &[Token::Str("ABC")]);
+    assert_de_tokens(&buf, &[Token::String("ABC".to_owned())]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(None),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(Some(3)),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
 }

testing/tests/test_de.rs

@@ -37,7 +37,10 @@ enum Enum {
     Unit,
     Simple(i32),
     Seq(i32, i32, i32),
-    Map { a: i32, b: i32, c: i32 }
+    Map { a: i32, b: i32, c: i32 },
+    #[allow(dead_code)]
+    #[serde(skip_deserializing)]
+    Skipped,
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -215,6 +218,9 @@ declare_tests! {
             Token::SeqEnd,
         ],
     }
+    test_unit_string {
+        String::new() => &[Token::Unit],
+    }
     test_tuple_struct {
         TupleStruct(1, 2, 3) => &[
             Token::SeqStart(Some(3)),
@@ -802,6 +808,12 @@ declare_error_tests! {
         ],
         Error::UnknownVariant("Foo".to_owned()),
     }
+    test_enum_skipped_variant<Enum> {
+        &[
+            Token::EnumUnit("Enum", "Skipped"),
+        ],
+        Error::UnknownVariant("Skipped".to_owned()),
+    }
     test_struct_seq_too_long<Struct> {
         &[
             Token::SeqStart(Some(4)),

testing/tests/test_ser.rs

@@ -30,12 +30,20 @@ struct Struct {
     c: i32,
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, PartialEq, Debug)]
 enum Enum {
     Unit,
     One(i32),
     Seq(i32, i32),
     Map { a: i32, b: i32 },
+    #[serde(skip_serializing)]
+    SkippedUnit,
+    #[serde(skip_serializing)]
+    SkippedOne(i32),
+    #[serde(skip_serializing)]
+    SkippedSeq(i32, i32),
+    #[serde(skip_serializing)]
+    SkippedMap { _a: i32, _b: i32 },
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -388,3 +396,23 @@ fn test_cannot_serialize_paths() {
         &[],
         Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
 }
+
+#[test]
+fn test_enum_skipped() {
+    assert_ser_tokens_error(
+        &Enum::SkippedUnit,
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedUnit cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedOne(42),
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedOne cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedSeq(1, 2),
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedSeq cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedMap { _a: 1, _b: 2 },
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedMap cannot be serialized".to_owned()));
+}