Add constructor functions for FieldAttrs

serde_macros/src/de.rs

@@ -395,7 +395,7 @@ fn deserialize_item_enum(
         builder,
         enum_def.variants.iter()
             .map(|variant|
-                 attr::FieldAttrs::Global(builder.expr().str(variant.node.name)))
+                 attr::FieldAttrs::new(builder.expr().str(variant.node.name)))
             .collect()
     );
 
@@ -702,7 +702,7 @@ fn deserialize_struct_visitor(
     let field_visitor = deserialize_field_visitor(
         cx,
         builder,
-        field::struct_field_strs(cx, builder, struct_def),
+        field::struct_field_attrs(cx, builder, struct_def),
     );
 
     let visit_map_expr = deserialize_map(
@@ -744,7 +744,7 @@ fn deserialize_map(
 
     let extract_values: Vec<P<ast::Stmt>> = field_names.iter()
         .zip(struct_def.fields.iter())
-        .zip(field::struct_field_strs(cx, builder, struct_def).iter())
+        .zip(field::struct_field_attrs(cx, builder, struct_def).iter())
         .map(|((field_name, field), field_attr)| {
             let missing_expr = if field::default_value(field) {
                 quote_expr!(cx, ::std::default::Default::default())

serde_macros/src/field.rs

@@ -9,13 +9,48 @@ use aster;
 
 use attr::FieldAttrs;
 
-pub enum Rename<'a> {
+enum Rename<'a> {
     None,
     Global(&'a ast::Lit),
     Format(HashMap<P<ast::Expr>, &'a ast::Lit>)
 }
 
-pub fn field_rename<'a>(
+fn rename<'a>(
+    builder: &aster::AstBuilder,
+    mi: &'a ast::MetaItem,
+    ) -> Option<Rename<'a>>
+{
+    match mi.node {
+        ast::MetaNameValue(ref n, ref lit) => {
+            if n == &"rename" {
+                Some(Rename::Global(lit))
+            } else {
+                None
+            }
+        },
+        ast::MetaList(ref n, ref items) => {
+            if n == &"rename" {
+                let mut m = HashMap::new();
+                m.extend(
+                    items.iter()
+                        .filter_map(
+                            |item|
+                            match item.node {
+                                ast::MetaNameValue(ref n, ref lit) =>
+                                    Some((builder.expr().str(n),
+                                          lit)),
+                                _ => None
+                            }));
+                Some(Rename::Format(m))
+            } else {
+                None
+            }
+        },
+        _ => None
+    }
+}
+
+fn field_rename_attrs<'a>(
     builder: &aster::AstBuilder,
     field: &'a ast::StructField,
 ) -> Rename<'a> {
@@ -31,34 +66,7 @@ pub fn field_rename<'a>(
             if let ast::MetaList(_, ref vals) = sa.node.value.node {
                 attr::mark_used(&sa);
                 vals.iter().fold(None, |v, mi| {
-                    match mi.node {
+                    v.or(rename(builder, mi))
-                        ast::MetaNameValue(ref n, ref lit) => {
-                            if n == &"rename" {
-                                Some(Rename::Global(lit))
-                            } else {
-                                v
-                            }
-                        },
-                        ast::MetaList(ref n, ref items) => {
-                            if n == &"rename" {
-                                let mut m = HashMap::new();
-                                m.extend(
-                                    items.iter()
-                                        .filter_map(
-                                            |item|
-                                            match item.node {
-                                                ast::MetaNameValue(ref n, ref lit) =>
-                                                    Some((builder.expr().str(n),
-                                                          lit)),
-                                                _ => None
-                                            }));
-                                Some(Rename::Format(m))
-                            } else {
-                                v
-                            }
-                        },
-                        _ => {v}
-                    }
                 })
             } else {
                 None
@@ -67,16 +75,16 @@ pub fn field_rename<'a>(
         .unwrap_or(Rename::None)
 }
 
-pub fn struct_field_strs(
+pub fn struct_field_attrs(
     cx: &ExtCtxt,
     builder: &aster::AstBuilder,
     struct_def: &ast::StructDef,
 ) -> Vec<FieldAttrs> {
     struct_def.fields.iter()
         .map(|field| {
-            match field_rename(builder, field) {
+            match field_rename_attrs(builder, field) {
                 Rename::Global(rename) =>
-                    FieldAttrs::Global(
+                    FieldAttrs::new(
                         builder.expr().build_lit(P(rename.clone()))),
                 Rename::Format(renames) => {
                     let mut res = HashMap::new();
@@ -84,13 +92,12 @@ pub fn struct_field_strs(
                         renames.into_iter()
                             .map(|(k,v)|
                                  (k, builder.expr().build_lit(P(v.clone())))));
-                    FieldAttrs::Format{
+                    FieldAttrs::new_with_formats(
-                        formats: res,
+                        default_field(cx, builder, field.node.kind),
-                        default: default_field(cx, builder, field.node.kind),
+                        res)
-                    }
                 },
                 Rename::None => {
-                    FieldAttrs::Global(
+                    FieldAttrs::new(
                         default_field(cx, builder, field.node.kind))
                 }
             }

serde_macros/src/ser.rs

@@ -13,7 +13,7 @@ use syntax::ptr::P;
 
 use aster;
 
-use field::struct_field_strs;
+use field::struct_field_attrs;
 
 pub fn expand_derive_serialize(
     cx: &mut ExtCtxt,
@@ -517,9 +517,9 @@ fn serialize_struct_visitor<I>(
 {
     let len = struct_def.fields.len();
 
-    let key_exprs = struct_field_strs(cx, builder, struct_def);
+    let field_attrs = struct_field_attrs(cx, builder, struct_def);
 
-    let arms: Vec<ast::Arm> = key_exprs.into_iter()
+    let arms: Vec<ast::Arm> = field_attrs.into_iter()
         .zip(value_exprs)
         .enumerate()
         .map(|(i, (field, value_expr))| {