Merge branch origin/master into origin/enum

Conflicts:
    serde/src/de/mod.rs
    serde_codegen/src/de.rs
    testing/tests/test_bytes.rs

serde_codegen/src/bound.rs

@@ -1,9 +1,6 @@
 use std::collections::HashSet;
 
-use aster::AstBuilder;
-
-use syntax::ast;
-use syntax::visit;
+use syn::{self, aster, visit};
 
 use internals::ast::Item;
 use internals::attr;
@@ -11,10 +8,10 @@ use internals::attr;
 // Remove the default from every type parameter because in the generated impls
 // they look like associated types: "error: associated type bindings are not
 // allowed here".
-pub fn without_defaults(generics: &ast::Generics) -> ast::Generics {
-    ast::Generics {
+pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
+    syn::Generics {
         ty_params: generics.ty_params.iter().map(|ty_param| {
-            ast::TyParam {
+            syn::TyParam {
                 default: None,
                 .. ty_param.clone()
             }}).collect(),
@@ -23,24 +20,22 @@ pub fn without_defaults(generics: &ast::Generics) -> ast::Generics {
 }
 
 pub fn with_where_predicates(
-    builder: &AstBuilder,
-    generics: &ast::Generics,
-    predicates: &[ast::WherePredicate],
-) -> ast::Generics {
-    builder.from_generics(generics.clone())
+    generics: &syn::Generics,
+    predicates: &[syn::WherePredicate],
+) -> syn::Generics {
+    aster::from_generics(generics.clone())
         .with_predicates(predicates.to_vec())
         .build()
 }
 
 pub fn with_where_predicates_from_fields<F>(
-    builder: &AstBuilder,
     item: &Item,
-    generics: &ast::Generics,
+    generics: &syn::Generics,
     from_field: F,
-) -> ast::Generics
-    where F: Fn(&attr::Field) -> Option<&[ast::WherePredicate]>,
+) -> syn::Generics
+    where F: Fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
 {
-    builder.from_generics(generics.clone())
+    aster::from_generics(generics.clone())
         .with_predicates(
             item.body.all_fields()
                 .flat_map(|field| from_field(&field.attrs))
@@ -60,34 +55,33 @@ pub fn with_where_predicates_from_fields<F>(
 //         c: C,
 //     }
 pub fn with_bound<F>(
-    builder: &AstBuilder,
     item: &Item,
-    generics: &ast::Generics,
+    generics: &syn::Generics,
     filter: F,
-    bound: &ast::Path,
-) -> ast::Generics
+    bound: &syn::Path,
+) -> syn::Generics
     where F: Fn(&attr::Field) -> bool,
 {
     struct FindTyParams {
         // Set of all generic type parameters on the current struct (A, B, C in
         // the example). Initialized up front.
-        all_ty_params: HashSet<ast::Name>,
+        all_ty_params: HashSet<syn::Ident>,
         // Set of generic type parameters used in fields for which filter
         // returns true (A and B in the example). Filled in as the visitor sees
         // them.
-        relevant_ty_params: HashSet<ast::Name>,
+        relevant_ty_params: HashSet<syn::Ident>,
     }
     impl visit::Visitor for FindTyParams {
-        fn visit_path(&mut self, path: &ast::Path, _id: ast::NodeId) {
+        fn visit_path(&mut self, path: &syn::Path) {
             if let Some(seg) = path.segments.last() {
-                if seg.identifier.name.as_str() == "PhantomData" {
+                if seg.ident == "PhantomData" {
                     // Hardcoded exception, because PhantomData<T> implements
                     // Serialize and Deserialize whether or not T implements it.
                     return;
                 }
             }
             if !path.global && path.segments.len() == 1 {
-                let id = path.segments[0].identifier.name;
+                let id = path.segments[0].ident.clone();
                 if self.all_ty_params.contains(&id) {
                     self.relevant_ty_params.insert(id);
                 }
@@ -97,7 +91,7 @@ pub fn with_bound<F>(
     }
 
     let all_ty_params: HashSet<_> = generics.ty_params.iter()
-        .map(|ty_param| ty_param.ident.name)
+        .map(|ty_param| ty_param.ident.clone())
         .collect();
 
     let relevant_tys = item.body.all_fields()
@@ -112,14 +106,14 @@ pub fn with_bound<F>(
         visit::walk_ty(&mut visitor, ty);
     }
 
-    builder.from_generics(generics.clone())
+    aster::from_generics(generics.clone())
         .with_predicates(
             generics.ty_params.iter()
-                .map(|ty_param| ty_param.ident.name)
+                .map(|ty_param| ty_param.ident.clone())
                 .filter(|id| visitor.relevant_ty_params.contains(id))
-                .map(|id| builder.where_predicate()
+                .map(|id| aster::where_predicate()
                     // the type parameter that is being bounded e.g. T
-                    .bound().build(builder.ty().id(id))
+                    .bound().build(aster::ty().id(id))
                     // the bound e.g. Serialize
                     .bound().trait_(bound.clone()).build()
                     .build()))

serde_codegen/src/lib.rs

@@ -2,11 +2,10 @@
 #![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))]
-#![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]
 
-extern crate aster;
-extern crate quasi;
+// The `quote!` macro requires deep recursion.
+#![recursion_limit = "192"]
+
 extern crate serde_codegen_internals as internals;
 
 #[cfg(feature = "with-syntex")]
@@ -16,24 +15,68 @@ extern crate syntex;
 #[macro_use]
 extern crate syntex_syntax as syntax;
 
-#[cfg(not(feature = "with-syntex"))]
+extern crate syn;
 #[macro_use]
-extern crate syntax;
-
-#[cfg(not(feature = "with-syntex"))]
-extern crate rustc_plugin;
+extern crate quote;
 
 #[cfg(feature = "with-syntex")]
 use std::path::Path;
 
-#[cfg(not(feature = "with-syntex"))]
-use syntax::feature_gate::AttributeType;
+mod bound;
+mod de;
+mod ser;
 
 #[cfg(feature = "with-syntex")]
-include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+fn syntex_registry() -> syntex::Registry {
+    use syntax::{ast, fold};
 
-#[cfg(not(feature = "with-syntex"))]
-include!("lib.rs.in");
+    /// Strip the serde attributes from the crate.
+    #[cfg(feature = "with-syntex")]
+    fn strip_attributes(krate: ast::Crate) -> ast::Crate {
+        /// Helper folder that strips the serde attributes after the extensions have been expanded.
+        struct StripAttributeFolder;
+
+        impl fold::Folder for StripAttributeFolder {
+            fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
+                if attr.value.name == "serde" {
+                    if let ast::MetaItemKind::List(..) = attr.value.node {
+                        return None;
+                    }
+                }
+                Some(attr)
+            }
+
+            fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
+                fold::noop_fold_mac(mac, self)
+            }
+        }
+
+        fold::Folder::fold_crate(&mut StripAttributeFolder, krate)
+    }
+
+    let mut reg = syntex::Registry::new();
+
+    reg.add_attr("feature(custom_derive)");
+    reg.add_attr("feature(custom_attribute)");
+
+    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);
+
+    reg
+}
+
+#[cfg(feature = "with-syntex")]
+pub fn expand_str(src: &str) -> Result<String, syntex::Error> {
+    let src = src.to_owned();
+
+    let expand_thread = move || {
+        syntex_registry().expand_str("", "", &src)
+    };
+
+    syntex::with_extra_stack(expand_thread)
+}
 
 #[cfg(feature = "with-syntex")]
 pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
@@ -44,59 +87,86 @@ pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
     let dst = dst.as_ref().to_owned();
 
     let expand_thread = move || {
-        use syntax::{ast, fold};
-
-        /// Strip the serde attributes from the crate.
-        #[cfg(feature = "with-syntex")]
-        fn strip_attributes(krate: ast::Crate) -> ast::Crate {
-            /// Helper folder that strips the serde attributes after the extensions have been expanded.
-            struct StripAttributeFolder;
-
-            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; }
-                        _ => {}
-                    }
-
-                    Some(attr)
-                }
-
-                fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
-                    fold::noop_fold_mac(mac, self)
-                }
-            }
-
-            fold::Folder::fold_crate(&mut StripAttributeFolder, krate)
-        }
-
-        let mut reg = syntex::Registry::new();
-
-        reg.add_attr("feature(custom_derive)");
-        reg.add_attr("feature(custom_attribute)");
-
-        reg.add_decorator("derive_Serialize", ser::expand_derive_serialize);
-        reg.add_decorator("derive_Deserialize", de::expand_derive_deserialize);
-
-        reg.add_post_expansion_pass(strip_attributes);
-
-        reg.expand("", src, dst)
+        syntex_registry().expand("", src, dst)
     };
 
     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(ser::expand_derive_serialize)));
+macro_rules! shim {
+    ($name:ident $pkg:ident :: $func:ident) => {
+        pub fn $func(
+            cx: &mut ::syntax::ext::base::ExtCtxt,
+            span: ::syntax::codemap::Span,
+            meta_item: &::syntax::ast::MetaItem,
+            annotatable: &::syntax::ext::base::Annotatable,
+            push: &mut FnMut(::syntax::ext::base::Annotatable)
+        ) {
+            let item = match *annotatable {
+                ::syntax::ext::base::Annotatable::Item(ref item) => item,
+                _ => {
+                    cx.span_err(
+                        meta_item.span,
+                        concat!("`#[derive(",
+                                stringify!($name),
+                                ")]` may only be applied to structs and enums"));
+                    return;
+                }
+            };
 
-    reg.register_syntax_extension(
-        syntax::parse::token::intern("derive_Deserialize"),
-        syntax::ext::base::MultiDecorator(
-            Box::new(de::expand_derive_deserialize)));
+            use syntax::{attr, ast, visit};
+            struct MarkSerdeAttributesUsed;
+            impl<'a> visit::Visitor<'a> for MarkSerdeAttributesUsed {
+                fn visit_attribute(&mut self, attr: &ast::Attribute) {
+                    if attr.value.name == "serde" {
+                        if let ast::MetaItemKind::List(..) = attr.value.node {
+                            attr::mark_used(attr);
+                        }
+                    }
+                }
+            }
+            visit::walk_item(&mut MarkSerdeAttributesUsed, item);
 
-    reg.register_attribute("serde".to_owned(), AttributeType::Normal);
+            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(),
+                Err(msg) => {
+                    cx.span_err(span, &msg);
+                    return;
+                }
+            };
+
+            use syntax::parse;
+            let name = stringify!($name).to_string();
+            let sess = cx.parse_sess;
+            let impl_item = parse::parse_item_from_source_str(name, expanded, sess);
+            push(::syntax::ext::base::Annotatable::Item(impl_item.unwrap().unwrap()));
+        }
+    };
+}
+
+#[cfg(feature = "with-syntex")]
+mod shim {
+    shim!(Serialize ser::expand_derive_serialize);
+    shim!(Deserialize de::expand_derive_deserialize);
+}
+
+#[cfg(feature = "with-syn")]
+#[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();
+    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/lib.rs.in

@@ -1,4 +0,0 @@
-mod bound;
-mod de;
-mod ser;
-mod span;

serde_codegen/src/ser.rs

@@ -1,102 +1,62 @@
-use aster;
-
-use syntax::ast::{self, Ident, MetaItem};
-use syntax::codemap::Span;
-use syntax::ext::base::{Annotatable, ExtCtxt};
-use syntax::ptr::P;
+use syn::{self, aster};
+use quote::Tokens;
 
 use bound;
-use span;
 use internals::ast::{Body, Field, Item, Style, Variant};
-use internals::{attr, Error};
+use internals::{self, attr};
 
-pub fn expand_derive_serialize(
-    cx: &mut ExtCtxt,
-    span: Span,
-    meta_item: &MetaItem,
-    annotatable: &Annotatable,
-    push: &mut FnMut(Annotatable)
-) {
-    let item = match *annotatable {
-        Annotatable::Item(ref item) => item,
-        _ => {
-            cx.span_err(
-                meta_item.span,
-                "`#[derive(Serialize)]` may only be applied to structs and enums");
-            return;
-        }
-    };
+pub fn expand_derive_serialize(item: &syn::MacroInput) -> Result<Tokens, String> {
+    let ctxt = internals::Ctxt::new();
+    let item = Item::from_ast(&ctxt, item);
+    try!(ctxt.check());
 
-    let item = match Item::from_ast(cx, item) {
-        Ok(item) => item,
-        Err(Error::UnexpectedItemKind) => {
-            cx.span_err(item.span,
-                "`#[derive(Serialize)]` may only be applied to structs and enums");
-            return;
-        }
-    };
+    let impl_generics = build_impl_generics(&item);
 
-    let builder = aster::AstBuilder::new().span(span);
-
-    let impl_item = serialize_item(cx, &builder, &item);
-    push(span::record_expansion(cx, impl_item, "Serialize"))
-}
-
-fn serialize_item(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    item: &Item,
-) -> P<ast::Item> {
-    let impl_generics = build_impl_generics(builder, &item);
-
-    let ty = builder.ty().path()
-        .segment(item.ident).with_generics(impl_generics.clone()).build()
+    let ty = aster::ty().path()
+        .segment(item.ident.clone()).with_generics(impl_generics.clone()).build()
         .build();
 
-    let body = serialize_body(cx,
-                              builder,
-                              &item,
+    let body = serialize_body(&item,
                               &impl_generics,
                               ty.clone());
 
     let where_clause = &impl_generics.where_clause;
 
-    let dummy_const = builder.id(format!("_IMPL_SERIALIZE_FOR_{}", item.ident));
+    let dummy_const = aster::id(format!("_IMPL_SERIALIZE_FOR_{}", item.ident));
 
-    quote_item!(cx,
+    Ok(quote! {
         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-        const $dummy_const: () = {
+        const #dummy_const: () = {
             extern crate serde as _serde;
             #[automatically_derived]
-            impl $impl_generics _serde::ser::Serialize for $ty $where_clause {
+            impl #impl_generics _serde::ser::Serialize for #ty #where_clause {
                 fn serialize<__S>(&self, _serializer: &mut __S) -> ::std::result::Result<(), __S::Error>
                     where __S: _serde::ser::Serializer
-                $body
+                {
+                    #body
+                }
             }
         };
-    ).unwrap()
+    })
 }
 
 // All the generics in the input, plus a bound `T: Serialize` for each generic
 // field type that will be serialized by us.
-fn build_impl_generics(
-    builder: &aster::AstBuilder,
-    item: &Item,
-) -> ast::Generics {
+fn build_impl_generics(item: &Item) -> syn::Generics {
     let generics = bound::without_defaults(item.generics);
 
     let generics = bound::with_where_predicates_from_fields(
-        builder, item, &generics,
+        item, &generics,
         |attrs| attrs.ser_bound());
 
     match item.attrs.ser_bound() {
         Some(predicates) => {
-            bound::with_where_predicates(builder, &generics, predicates)
+            bound::with_where_predicates(&generics, predicates)
         }
         None => {
-            bound::with_bound(builder, item, &generics,
+            bound::with_bound(item, &generics,
                 needs_serialize_bound,
-                &builder.path().ids(&["_serde", "ser", "Serialize"]).build())
+                &aster::path().ids(&["_serde", "ser", "Serialize"]).build())
         }
     }
 }
@@ -112,18 +72,14 @@ fn needs_serialize_bound(attrs: &attr::Field) -> bool {
 }
 
 fn serialize_body(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
     item: &Item,
-    impl_generics: &ast::Generics,
-    ty: P<ast::Ty>,
-) -> P<ast::Block> {
+    impl_generics: &syn::Generics,
+    ty: syn::Ty,
+) -> Tokens {
     match item.body {
         Body::Enum(ref variants) => {
             serialize_item_enum(
-                cx,
-                builder,
-                item.ident,
+                &item.ident,
                 impl_generics,
                 ty,
                 variants,
@@ -131,12 +87,10 @@ fn serialize_body(
         }
         Body::Struct(Style::Struct, ref fields) => {
             if fields.iter().any(|field| field.ident.is_none()) {
-                cx.span_bug(item.span, "struct has unnamed fields")
+                panic!("struct has unnamed fields");
             }
 
             serialize_struct(
-                cx,
-                builder,
                 impl_generics,
                 ty,
                 fields,
@@ -144,12 +98,10 @@ fn serialize_body(
         }
         Body::Struct(Style::Tuple, ref fields) => {
             if fields.iter().any(|field| field.ident.is_some()) {
-                cx.span_bug(item.span, "tuple struct has named fields")
+                panic!("tuple struct has named fields");
             }
 
             serialize_tuple_struct(
-                cx,
-                builder,
                 impl_generics,
                 ty,
                 fields,
@@ -157,8 +109,6 @@ fn serialize_body(
         }
         Body::Struct(Style::Newtype, ref fields) => {
             serialize_newtype_struct(
-                cx,
-                builder,
                 impl_generics,
                 ty,
                 &fields[0],
@@ -166,129 +116,116 @@ fn serialize_body(
         }
         Body::Struct(Style::Unit, _) => {
             serialize_unit_struct(
-                cx,
-                builder,
                 &item.attrs)
         }
     }
 }
 
-fn serialize_unit_struct(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    item_attrs: &attr::Item,
-) -> P<ast::Block> {
-    let type_name = name_expr(builder, item_attrs.name());
+fn serialize_unit_struct(item_attrs: &attr::Item) -> Tokens {
+    let type_name = item_attrs.name().serialize_name();
 
-    quote_block!(cx, {
-        _serializer.serialize_unit_struct($type_name)
-    }).unwrap()
+    quote! {
+        _serializer.serialize_unit_struct(#type_name)
+    }
 }
 
 fn serialize_newtype_struct(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    impl_generics: &ast::Generics,
-    item_ty: P<ast::Ty>,
+    impl_generics: &syn::Generics,
+    item_ty: syn::Ty,
     field: &Field,
     item_attrs: &attr::Item,
-) -> P<ast::Block> {
-    let type_name = name_expr(builder, item_attrs.name());
+) -> Tokens {
+    let type_name = item_attrs.name().serialize_name();
 
-    let mut field_expr = quote_expr!(cx, &self.0);
+    let mut field_expr = quote!(&self.0);
     if let Some(path) = field.attrs.serialize_with() {
-        field_expr = wrap_serialize_with(cx, builder,
-            &item_ty, impl_generics, &field.ty, path, field_expr);
+        field_expr = wrap_serialize_with(
+            &item_ty, impl_generics, field.ty, path, field_expr);
     }
 
-    quote_block!(cx, {
-        _serializer.serialize_newtype_struct($type_name, $field_expr)
-    }).unwrap()
+    quote! {
+        _serializer.serialize_newtype_struct(#type_name, #field_expr)
+    }
 }
 
 fn serialize_tuple_struct(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    impl_generics: &ast::Generics,
-    ty: P<ast::Ty>,
+    impl_generics: &syn::Generics,
+    ty: syn::Ty,
     fields: &[Field],
     item_attrs: &attr::Item,
-) -> P<ast::Block> {
+) -> Tokens {
     let serialize_stmts = serialize_tuple_struct_visitor(
-        cx,
-        builder,
         ty.clone(),
         fields,
         impl_generics,
         false,
-        cx.ident_of("serialize_tuple_struct_elt"),
+        aster::id("serialize_tuple_struct_elt"),
     );
 
-    let type_name = name_expr(builder, item_attrs.name());
+    let type_name = item_attrs.name().serialize_name();
     let len = serialize_stmts.len();
+    let let_mut = mut_if(len > 0);
 
-    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_tuple_struct($type_name, $len));
-        $serialize_stmts
-        _serializer.serialize_tuple_struct_end(state)
-    }).unwrap()
+    quote! {
+        let #let_mut __serde_state = try!(_serializer.serialize_tuple_struct(#type_name, #len));
+        #(#serialize_stmts)*
+        _serializer.serialize_tuple_struct_end(__serde_state)
+    }
 }
 
 fn serialize_struct(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    impl_generics: &ast::Generics,
-    ty: P<ast::Ty>,
+    impl_generics: &syn::Generics,
+    ty: syn::Ty,
     fields: &[Field],
     item_attrs: &attr::Item,
-) -> P<ast::Block> {
+) -> Tokens {
     let serialize_fields = serialize_struct_visitor(
-        cx,
-        builder,
         ty.clone(),
         fields,
         impl_generics,
         false,
-        cx.ident_of("serialize_struct_elt"),
+        aster::id("serialize_struct_elt"),
     );
 
-    let type_name = name_expr(builder, item_attrs.name());
-    let len = fields.iter()
+    let type_name = item_attrs.name().serialize_name();
+
+    let mut serialized_fields = fields.iter()
         .filter(|&field| !field.attrs.skip_serializing())
+        .peekable();
+
+    let let_mut = mut_if(serialized_fields.peek().is_some());
+
+    let len = serialized_fields
         .map(|field| {
-            let ident = field.ident.expect("struct has unnamed fields");
-            let field_expr = quote_expr!(cx, &self.$ident);
+            let ident = field.ident.clone().expect("struct has unnamed fields");
+            let field_expr = quote!(&self.#ident);
 
             match field.attrs.skip_serializing_if() {
-                Some(path) => quote_expr!(cx, if $path($field_expr) { 0 } else { 1 }),
-                None => quote_expr!(cx, 1),
+                Some(path) => quote!(if #path(#field_expr) { 0 } else { 1 }),
+                None => quote!(1),
             }
          })
-        .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
+        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
 
-    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_struct($type_name, $len));
-        $serialize_fields
-        _serializer.serialize_struct_end(state)
-    }).unwrap()
+    quote! {
+        let #let_mut __serde_state = try!(_serializer.serialize_struct(#type_name, #len));
+        #(#serialize_fields)*
+        _serializer.serialize_struct_end(__serde_state)
+    }
 }
 
 fn serialize_item_enum(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    type_ident: Ident,
-    impl_generics: &ast::Generics,
-    ty: P<ast::Ty>,
+    type_ident: &syn::Ident,
+    impl_generics: &syn::Generics,
+    ty: syn::Ty,
     variants: &[Variant],
     item_attrs: &attr::Item,
-) -> P<ast::Block> {
+) -> Tokens {
     let arms: Vec<_> =
         variants.iter()
             .enumerate()
             .map(|(variant_index, variant)| {
                 serialize_variant(
-                    cx,
-                    builder,
                     type_ident,
                     impl_generics,
                     ty.clone(),
@@ -299,341 +236,335 @@ fn serialize_item_enum(
             })
             .collect();
 
-    quote_block!(cx, {
+    quote! {
         match *self {
-            $arms
+            #(#arms)*
         }
-    }).unwrap()
+    }
 }
 
 fn serialize_variant(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    type_ident: Ident,
-    generics: &ast::Generics,
-    ty: P<ast::Ty>,
+    type_ident: &syn::Ident,
+    generics: &syn::Generics,
+    ty: syn::Ty,
     variant: &Variant,
     variant_index: usize,
     item_attrs: &attr::Item,
-) -> ast::Arm {
-    let type_name = name_expr(builder, item_attrs.name());
+) -> Tokens {
+    let type_name = item_attrs.name().serialize_name();
 
-    let variant_ident = variant.ident;
-    let variant_name = name_expr(builder, variant.attrs.name());
+    let variant_ident = variant.ident.clone();
+    let variant_name = variant.attrs.name().serialize_name();
 
-    match variant.style {
-        Style::Unit => {
-            quote_arm!(cx,
-                $type_ident::$variant_ident =>
-                    _serde::ser::Serializer::serialize_unit_variant(
-                        _serializer,
-                        $type_name,
-                        $variant_index,
-                        $variant_name,
-                    ),
-            )
-        },
-        Style::Newtype => {
-            let block = serialize_newtype_variant(
-                cx,
-                builder,
-                type_name,
-                variant_index,
-                variant_name,
-                ty,
-                generics,
-                &variant.fields[0],
-            );
-
-            quote_arm!(cx,
-                $type_ident::$variant_ident(ref __simple_value) => $block
-            )
-        },
-        Style::Tuple => {
-            let field_names: Vec<ast::Ident> = (0 .. variant.fields.len())
-                .map(|i| builder.id(format!("__field{}", i)))
-                .collect();
-
-            let pat = builder.pat().enum_()
-                .id(type_ident).id(variant_ident).build()
-                .with_pats(
-                    field_names.iter()
-                        .map(|field| builder.pat().ref_id(field))
-                )
-                .build();
-
-            let block = serialize_tuple_variant(
-                cx,
-                builder,
-                type_name,
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-            );
-
-            quote_arm!(cx,
-                $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 mut pat = builder.pat().struct_().id(type_ident).id(variant_ident).build();
-            for field in &variant.fields {
-                let name = match field.ident {
-                    Some(name) => name,
-                    None => cx.span_bug(field.span, "struct variant has unnamed fields"),
-                };
-                pat = pat.with_field_pat(ast::FieldPat {
-                    ident: name,
-                    pat: builder.pat().ref_id(name),
-                    is_shorthand: true,
-                });
+    } 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],
+                );
+
+                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)));
+
+                let block = serialize_tuple_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident(#(ref #field_names),*) => { #block }
+                }
             }
-            let pat = pat.build();
+            Style::Struct => {
+                let fields = variant.fields.iter()
+                    .map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
 
-            let block = serialize_struct_variant(
-                cx,
-                builder,
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-                item_attrs,
-            );
+                let block = serialize_struct_variant(
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                    item_attrs,
+                );
 
-            quote_arm!(cx,
-                $pat => $block
-            )
+                quote! {
+                    #type_ident::#variant_ident { #(ref #fields),* } => { #block }
+                }
+            }
         }
     }
 }
 
 fn serialize_newtype_variant(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    type_name: P<ast::Expr>,
+    type_name: String,
     variant_index: usize,
-    variant_name: P<ast::Expr>,
-    item_ty: P<ast::Ty>,
-    generics: &ast::Generics,
+    variant_name: String,
+    item_ty: syn::Ty,
+    generics: &syn::Generics,
     field: &Field,
-) -> P<ast::Block> {
-    let mut field_expr = quote_expr!(cx, __simple_value);
+) -> Tokens {
+    let mut field_expr = quote!(__simple_value);
     if let Some(path) = field.attrs.serialize_with() {
-        field_expr = wrap_serialize_with(cx, builder,
-            &item_ty, generics, &field.ty, path, field_expr);
+        field_expr = wrap_serialize_with(
+            &item_ty, generics, field.ty, path, field_expr);
     }
 
-    quote_block!(cx, {
+    quote! {
         _serde::ser::Serializer::serialize_newtype_variant(
             _serializer,
-            $type_name,
-            $variant_index,
-            $variant_name,
-            $field_expr,
+            #type_name,
+            #variant_index,
+            #variant_name,
+            #field_expr,
         )
-    }).unwrap()
+    }
 }
 
 fn serialize_tuple_variant(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    type_name: P<ast::Expr>,
+    type_name: String,
     variant_index: usize,
-    variant_name: P<ast::Expr>,
-    generics: &ast::Generics,
-    structure_ty: P<ast::Ty>,
+    variant_name: String,
+    generics: &syn::Generics,
+    structure_ty: syn::Ty,
     fields: &[Field],
-) -> P<ast::Block> {
+) -> Tokens {
     let serialize_stmts = serialize_tuple_struct_visitor(
-        cx,
-        builder,
         structure_ty,
         fields,
         generics,
         true,
-        cx.ident_of("serialize_tuple_variant_elt"),
+        aster::id("serialize_tuple_variant_elt"),
     );
 
     let len = serialize_stmts.len();
+    let let_mut = mut_if(len > 0);
 
-    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len));
-        $serialize_stmts
-        _serializer.serialize_tuple_variant_end(state)
-    }).unwrap()
+    quote! {
+        let #let_mut __serde_state = try!(_serializer.serialize_tuple_variant(
+            #type_name,
+            #variant_index,
+            #variant_name,
+            #len));
+        #(#serialize_stmts)*
+        _serializer.serialize_tuple_variant_end(__serde_state)
+    }
 }
 
 fn serialize_struct_variant(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
     variant_index: usize,
-    variant_name: P<ast::Expr>,
-    generics: &ast::Generics,
-    ty: P<ast::Ty>,
+    variant_name: String,
+    generics: &syn::Generics,
+    ty: syn::Ty,
     fields: &[Field],
     item_attrs: &attr::Item,
-) -> P<ast::Block> {
-
+) -> Tokens {
     let serialize_fields = serialize_struct_visitor(
-        cx,
-        builder,
         ty.clone(),
         fields,
-        &generics,
+        generics,
         true,
-        cx.ident_of("serialize_struct_variant_elt"),
+        aster::id("serialize_struct_variant_elt"),
     );
 
-    let item_name = name_expr(builder, item_attrs.name());
-    let len = fields.iter()
+    let item_name = item_attrs.name().serialize_name();
+
+    let mut serialized_fields = fields.iter()
         .filter(|&field| !field.attrs.skip_serializing())
+        .peekable();
+
+    let let_mut = mut_if(serialized_fields.peek().is_some());
+
+    let len = serialized_fields
         .map(|field| {
-            let ident = field.ident.expect("struct has unnamed fields");
-            let field_expr = quote_expr!(cx, $ident);
+            let ident = field.ident.clone().expect("struct has unnamed fields");
 
             match field.attrs.skip_serializing_if() {
-                Some(path) => quote_expr!(cx, if $path($field_expr) { 0 } else { 1 }),
-                None => quote_expr!(cx, 1),
+                Some(path) => quote!(if #path(#ident) { 0 } else { 1 }),
+                None => quote!(1),
             }
          })
-        .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
+        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
 
-    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_struct_variant(
-            $item_name,
-            $variant_index,
-            $variant_name,
-            $len,
+    quote! {
+        let #let_mut __serde_state = try!(_serializer.serialize_struct_variant(
+            #item_name,
+            #variant_index,
+            #variant_name,
+            #len,
         ));
-        $serialize_fields
-        _serializer.serialize_struct_variant_end(state)
-    }).unwrap()
+        #(#serialize_fields)*
+        _serializer.serialize_struct_variant_end(__serde_state)
+    }
 }
 
 fn serialize_tuple_struct_visitor(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    structure_ty: P<ast::Ty>,
+    structure_ty: syn::Ty,
     fields: &[Field],
-    generics: &ast::Generics,
+    generics: &syn::Generics,
     is_enum: bool,
-    func: ast::Ident,
-) -> Vec<ast::Stmt> {
+    func: syn::Ident,
+) -> Vec<Tokens> {
     fields.iter()
         .enumerate()
         .map(|(i, field)| {
             let mut field_expr = if is_enum {
-                builder.expr().path().id(format!("__field{}", i)).build()
+                let id = aster::id(format!("__field{}", i));
+                quote!(#id)
             } else {
-                builder.expr().ref_().tup_field(i).self_()
+                let i = aster::id(i);
+                quote!(&self.#i)
             };
 
             let skip = field.attrs.skip_serializing_if()
-                .map(|path| quote_expr!(cx, $path($field_expr)))
-                .unwrap_or(quote_expr!(cx, false));
+                .map(|path| quote!(#path(#field_expr)));
 
             if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_with(cx, builder,
-                    &structure_ty, generics, &field.ty, path, field_expr);
+                field_expr = wrap_serialize_with(
+                    &structure_ty, generics, field.ty, path, field_expr);
             }
 
-            quote_stmt!(cx,
-                if !$skip {
-                    try!(_serializer.$func(&mut state, $field_expr));
-                }
-            ).unwrap()
+            let ser = quote! {
+                try!(_serializer.#func(&mut __serde_state, #field_expr));
+            };
+
+            match skip {
+                None => ser,
+                Some(skip) => quote!(if !#skip { #ser }),
+            }
         })
         .collect()
 }
 
 fn serialize_struct_visitor(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    structure_ty: P<ast::Ty>,
+    structure_ty: syn::Ty,
     fields: &[Field],
-    generics: &ast::Generics,
+    generics: &syn::Generics,
     is_enum: bool,
-    func: ast::Ident,
-) -> Vec<ast::Stmt> {
+    func: syn::Ident,
+) -> Vec<Tokens> {
     fields.iter()
         .filter(|&field| !field.attrs.skip_serializing())
         .map(|field| {
-            let ident = field.ident.expect("struct has unnamed field");
+            let ident = field.ident.clone().expect("struct has unnamed field");
             let mut field_expr = if is_enum {
-                quote_expr!(cx, $ident)
+                quote!(#ident)
             } else {
-                quote_expr!(cx, &self.$ident)
+                quote!(&self.#ident)
             };
 
-            let key_expr = name_expr(builder, field.attrs.name());
+            let key_expr = field.attrs.name().serialize_name();
 
             let skip = field.attrs.skip_serializing_if()
-                .map(|path| quote_expr!(cx, $path($field_expr)))
-                .unwrap_or(quote_expr!(cx, false));
+                .map(|path| quote!(#path(#field_expr)));
 
             if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_with(cx, builder,
-                    &structure_ty, generics, &field.ty, path, field_expr)
+                field_expr = wrap_serialize_with(
+                    &structure_ty, generics, field.ty, path, field_expr)
             }
 
-            quote_stmt!(cx,
-                if !$skip {
-                    try!(_serializer.$func(&mut state, $key_expr, $field_expr));
-                }
-            ).unwrap()
+            let ser = quote! {
+                try!(_serializer.#func(&mut __serde_state, #key_expr, #field_expr));
+            };
+
+            match skip {
+                None => ser,
+                Some(skip) => quote!(if !#skip { #ser }),
+            }
         })
         .collect()
 }
 
 fn wrap_serialize_with(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    item_ty: &P<ast::Ty>,
-    generics: &ast::Generics,
-    field_ty: &P<ast::Ty>,
-    path: &ast::Path,
-    value: P<ast::Expr>,
-) -> P<ast::Expr> {
+    item_ty: &syn::Ty,
+    generics: &syn::Generics,
+    field_ty: &syn::Ty,
+    path: &syn::Path,
+    value: Tokens,
+) -> Tokens {
     let where_clause = &generics.where_clause;
 
-    let wrapper_generics = builder.from_generics(generics.clone())
+    let wrapper_generics = aster::from_generics(generics.clone())
         .add_lifetime_bound("'__a")
         .lifetime_name("'__a")
         .build();
 
-    let wrapper_ty = builder.path()
+    let wrapper_ty = aster::path()
         .segment("__SerializeWith")
             .with_generics(wrapper_generics.clone())
             .build()
         .build();
 
-    quote_expr!(cx, {
-        struct __SerializeWith $wrapper_generics $where_clause {
-            value: &'__a $field_ty,
-            phantom: ::std::marker::PhantomData<$item_ty>,
+    quote!({
+        struct __SerializeWith #wrapper_generics #where_clause {
+            value: &'__a #field_ty,
+            phantom: ::std::marker::PhantomData<#item_ty>,
         }
 
-        impl $wrapper_generics _serde::ser::Serialize for $wrapper_ty $where_clause {
-            fn serialize<__S>(&self, __s: &mut __S) -> Result<(), __S::Error>
+        impl #wrapper_generics _serde::ser::Serialize for #wrapper_ty #where_clause {
+            fn serialize<__S>(&self, __s: &mut __S) -> ::std::result::Result<(), __S::Error>
                 where __S: _serde::ser::Serializer
             {
-                $path(self.value, __s)
+                #path(self.value, __s)
             }
         }
 
         __SerializeWith {
-            value: $value,
-            phantom: ::std::marker::PhantomData::<$item_ty>,
+            value: #value,
+            phantom: ::std::marker::PhantomData::<#item_ty>,
         }
     })
 }
 
-fn name_expr(
-    builder: &aster::AstBuilder,
-    name: &attr::Name,
-) -> P<ast::Expr> {
-    builder.expr().str(name.serialize_name())
+// Serialization of an empty struct results in code like:
+//
+//     let mut __serde_state = try!(serializer.serialize_struct("S", 0));
+//     serializer.serialize_struct_end(__serde_state)
+//
+// where we want to omit the `mut` to avoid a warning.
+fn mut_if(is_mut: bool) -> Option<Tokens> {
+    if is_mut {
+        Some(quote!(mut))
+    } else {
+        None
+    }
 }

serde_codegen/src/span.rs

@@ -1,43 +0,0 @@
-use syntax::ast;
-use syntax::codemap::{self, ExpnId, Span};
-use syntax::ext::base::{Annotatable, ExtCtxt};
-use syntax::fold::{self, Folder};
-use syntax::parse::token::intern;
-use syntax::ptr::P;
-
-pub fn record_expansion(
-    cx: &ExtCtxt,
-    item: P<ast::Item>,
-    derive: &str,
-) -> Annotatable {
-    let info = codemap::ExpnInfo {
-        call_site: codemap::DUMMY_SP,
-        callee: codemap::NameAndSpan {
-            format: codemap::MacroAttribute(intern(&format!("derive({})", derive))),
-            span: None,
-            allow_internal_unstable: false,
-        },
-    };
-    let expn_id = cx.codemap().record_expansion(info);
-
-    let mut respanner = Respanner { expn_id: expn_id };
-    let item = item.map(|item| respanner.fold_item_simple(item));
-    Annotatable::Item(item)
-}
-
-struct Respanner {
-    expn_id: ExpnId,
-}
-
-impl Folder for Respanner {
-    fn new_span(&mut self, span: Span) -> Span {
-        Span {
-            expn_id: self.expn_id,
-            .. span
-        }
-    }
-
-    fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
-        fold::noop_fold_mac(mac, self)
-    }
-}