ecp 0.1.0

easily build a compiler plugin.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98


use prelude::*;
use utils;


/// Struct builder.
#[derive(Clone)]
pub struct StructBuilder<'a, 'b: 'a> {
    cx: &'a ExtCtxt<'b>,
    ident: Option<Ident>,
    id: NodeId,
    span: Span,
    vis: Visibility,
    attrs: Vec<Attribute>,
    node: Option<ItemKind>,
}

impl<'a, 'b> StructBuilder<'a, 'b> {
    /// Create a struct builder.
    pub fn new(cx: &'a ExtCtxt<'b>) -> StructBuilder<'a, 'b> {
        StructBuilder {
            cx: cx,
            ident: None,
            id: DUMMY_NODE_ID,
            span: DUMMY_SP,
            vis: Visibility::Inherited,
            attrs: Vec::new(),
            node: None,
        }
    }

    /// Create from an `Item` and `ExtCtxt`.
    pub fn from(cx: &'a ExtCtxt<'b>, item: &Item) -> StructBuilder<'a, 'b> {
        StructBuilder {
            cx: cx,
            ident: Some(item.ident.clone()),
            id: item.id.clone(),
            span: item.span.clone(),
            vis: item.vis.clone(),
            attrs: item.attrs.clone(),
            node: Some(item.node.clone()),
        }
    }

    /// Add a `Derive` attribute.
    pub fn derive<T: AsRef<str>>(&mut self, attr: T) {
        let attr_ident = utils::to_ident(attr.as_ref());
        let attr = quote_attr!(self.cx, #[derive($attr_ident)]);
        self.attrs.push(attr);
    }

    /// Add an attribute.
    pub fn attr<T: AsRef<str>>(&mut self, attr: T) {
        let attr_ident = utils::to_ident(attr.as_ref());
        let attr = quote_attr!(self.cx, #[$attr_ident]);
        self.attrs.push(attr);
    }

    /// Get all attributes.
    pub fn get_attrs(&self) -> Vec<Attribute> {
        self.attrs.clone()
    }

    /// Get struct name.
    pub fn get_name(&self) -> Ident {
        self.ident.clone().unwrap()
    }

    /// Set struct name.
    pub fn set_name<T: AsRef<str>>(&mut self, name: T) {
        self.ident = Some(utils::to_ident(name));
    }

    /// Get all struct fields.
    pub fn get_fields(&self) -> Vec<StructField> {
        if let Some(ItemKind::Struct(ref variant_data, _)) = self.node {
            if let VariantData::Struct(ref fields, _) = *variant_data {
                fields.clone()
            } else {
                panic!("not struct variant data");
            }
        } else {
            panic!("not struct item");
        }
    }

    /// Build an `Item`.
    pub fn build(self) -> Item {
        Item {
            ident: self.ident.unwrap(),
            id: self.id,
            span: self.span,
            vis: self.vis,
            attrs: self.attrs,
            node: self.node.unwrap(),
        }
    }
}