syn 0.11.8

Nom parser for Rust source code
Documentation 
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

use super::*;

#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct Crate {
    pub shebang: Option<String>,
    pub attrs: Vec<Attribute>,
    pub items: Vec<Item>,
}

#[cfg(feature = "parsing")]
pub mod parsing {
    use super::*;
    use attr::parsing::inner_attr;
    use item::parsing::items;

    named!(pub krate -> Crate, do_parse!(
        option!(byte_order_mark) >>
        shebang: option!(shebang) >>
        attrs: many0!(inner_attr) >>
        items: items >>
        (Crate {
            shebang: shebang,
            attrs: attrs,
            items: items,
        })
    ));

    named!(byte_order_mark -> &str, tag!("\u{feff}"));

    named!(shebang -> String, do_parse!(
        tag!("#!") >>
        not!(tag!("[")) >>
        content: take_until!("\n") >>
        (format!("#!{}", content))
    ));
}

#[cfg(feature = "printing")]
mod printing {
    use super::*;
    use attr::FilterAttrs;
    use quote::{Tokens, ToTokens};

    impl ToTokens for Crate {
        fn to_tokens(&self, tokens: &mut Tokens) {
            if let Some(ref shebang) = self.shebang {
                tokens.append(&format!("{}\n", shebang));
            }
            for attr in self.attrs.inner() {
                attr.to_tokens(tokens);
            }
            for item in &self.items {
                item.to_tokens(tokens);
            }
        }
    }
}