use aster::AstBuilder;
use error::Error;
use syntax::ast;
use syntax::ext::base::ExtCtxt;
use syntax::ptr::P;
use attr::ContainerAttrs;
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);
}
};
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,
}
}
}