serde_codegen 0.6.12

Macros to auto-generate implementations for the serde framework
Documentation
use aster::AstBuilder;
use error::Error;
use syntax::ast;
use syntax::ext::base::ExtCtxt;
use syntax::ptr::P;
use attr::ContainerAttrs;

/*
pub struct Name {
    ident: ast::Ident,
    serialized_name: Option<ast::Ident>,
    deserialized_name: Option<ast::Ident>,
}

impl Name {
    fn new(ident: ast::Ident) -> Self {
        Name {
            ident: ident,
            serialized_name: None,
            deserialized_name: None,
        }
    }

    pub fn to_serialize_expr(&self) -> P<ast::Expr> {
        let ident = match self.serialized_name {
            Some(name) => name,
            None => self.ident,
        };

        AstBuilder::new().expr().id(ident)
    }

    pub fn to_deserialize_expr(&self) -> P<ast::Expr> {
        let ident = match self.deserialized_name {
            Some(name) => name,
            None => self.ident,
        };

        AstBuilder::new().expr().id(ident)
    }
}
*/

pub struct Container {
    pub attrs: ContainerAttrs,
    pub kind: ContainerKind,
}

impl Container {
    pub fn new(cx: &ExtCtxt,
               item: &ast::Item,
               trait_bounds: &[&str]) -> Result<Self, Error> {
        let generics = match item.node {
            ast::ItemStruct(_, ref generics) => generics,
            ast::ItemEnum(_, ref generics) => generics,
            _ => {
                cx.span_err(item.span, "Item is not a struct or enum");
                return Err(Error);
            }
        };

        // Add the bounds to the generic type.
        let builder = AstBuilder::new().span(item.span);
        let generics = builder.from_generics(generics.clone())
            .add_ty_param_bound(
                builder.path()
                    .global()
                    .ids(trait_bounds)
                    .build()
            )
            .build();

        let ty = AstBuilder::new().ty().path()
            .segment(item.ident).with_generics(generics.clone()).build()
            .build();

        let kind = match item.node {
            ast::ItemStruct(ref variant_data, _) => {
                let variant = Variant::new(cx,
                                           item.ident,
                                           ty.clone(),
                                           ty,
                                           generics,
                                           variant_data);
                let kind = ContainerKind::Variant(variant);
                kind
            }
            ast::ItemEnum(ref enum_, _) => {
                let enum_ = Enum::new(cx, item.ident, ty, generics, enum_);
                let kind = ContainerKind::Enum(enum_);
                kind
            }
            _ => {
                unreachable!()
            }
        };

        let attrs = try!(ContainerAttrs::new(cx, item.attrs()));


        Ok(Container {
            attrs: attrs,
            kind: kind,
        })
    }

    pub fn ident(&self) -> ast::Ident {
        match self.kind {
            ContainerKind::Variant(ref variant) => variant.ident,
            ContainerKind::Enum(ref enum_) => enum_.ident,
        }
    }

    pub fn ty(&self) -> &P<ast::Ty> {
        match self.kind {
            ContainerKind::Variant(ref variant) => &variant.container_ty,
            ContainerKind::Enum(ref enum_) => &enum_.ty,
        }
    }

    pub fn generics(&self) -> &ast::Generics {
        match self.kind {
            ContainerKind::Variant(ref variant) => &variant.generics,
            ContainerKind::Enum(ref enum_) => &enum_.generics,
        }
    }
}

pub enum ContainerKind {
    Variant(Variant),
    Enum(Enum),
}

pub struct Variant {
    pub ident: ast::Ident,
    pub container_ty: P<ast::Ty>,
    pub ty: P<ast::Ty>,
    pub generics: ast::Generics,
    pub data: VariantData,
}

impl Variant {
    fn new(cx: &ExtCtxt,
           ident: ast::Ident,
           container_ty: P<ast::Ty>,
           ty: P<ast::Ty>,
           generics: ast::Generics,
           variant_data: &ast::VariantData) -> Self {
        Variant {
            ident: ident,
            container_ty: ty.clone(),
            ty: ty,
            generics: generics,
            data: VariantData::new(cx, variant_data),
        }
    }

    pub fn serialized_name(&self) -> P<ast::Expr> {
        AstBuilder::new().expr().str(self.ident)
    }
}

pub enum VariantData {
    Struct {
        fields: Vec<NamedField>,
    },
    Tuple {
        fields: Vec<UnnamedField>,
    },
    Unit,
}

impl VariantData {
    fn new(cx: &ExtCtxt, variant: &ast::VariantData) -> Self {
        match *variant {
            ast::VariantData::Struct(ref fields, _) => {
                VariantData::Struct {
                    fields: fields.iter()
                        .map(|field| NamedField::new(cx, field))
                        .collect()
                }
            }
            ast::VariantData::Tuple(ref fields, _) => {
                VariantData::Tuple {
                    fields: fields.iter()
                        .map(|field| UnnamedField::new(cx, field))
                        .collect()
                }
            }
            ast::VariantData::Unit(_) => {
                VariantData::Unit
            }
        }
    }
}

pub struct NamedField {
    pub ident: ast::Ident,
}

impl NamedField {
    fn new(cx: &ExtCtxt, field: &ast::StructField) -> Self {
        match field.node.kind {
            ast::NamedField(ident, _) => {
                NamedField {
                    ident: ident,
                }
            }
            ast::UnnamedField(_) => {
                cx.span_bug(field.span, "struct field has unnamed field")
            }
        }
    }

    pub fn serialized_name(&self) -> P<ast::Expr> {
        AstBuilder::new().expr().str(self.ident)
    }
}

pub struct UnnamedField;

impl UnnamedField {
    fn new(cx: &ExtCtxt, field: &ast::StructField) -> Self {
        match field.node.kind {
            ast::UnnamedField(_) => {
                UnnamedField
            }
            ast::NamedField(_, _) => {
                cx.span_bug(field.span, "tuple field has named field")
            }
        }
    }
}

pub struct Enum {
    pub ident: ast::Ident,
    pub ty: P<ast::Ty>,
    pub generics: ast::Generics,
    pub variants: Vec<Variant>,
}

impl Enum {
    fn new(cx: &ExtCtxt,
           ident: ast::Ident,
           ty: P<ast::Ty>,
           generics: ast::Generics,
           enum_def: &ast::EnumDef) -> Self {
        let variants = enum_def.variants.iter()
            .map(|variant| {
                Variant::new(cx,
                             variant.node.name,
                             ty.clone(),
                             ty.clone(),
                             generics.clone(),
                             &variant.node.data)
            })
            .collect();

        Enum {
            ident: ident,
            ty: ty,
            generics: generics,
            variants: variants,
        }
    }
}