adze-macro 0.8.0

Procedural macros for Rust Sitter
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
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

---
source: macro/src/lib.rs
expression: "rustfmt_code(&expand_grammar(parse_quote!\n{\n    #[adze::grammar(\"test\")] mod grammar\n    {\n        use adze::Spanned; #[adze::language] pub struct NumberList\n        { numbers: Vec<Spanned<Number>>, } pub struct Number\n        {\n            #[adze::leaf(pattern = r\"\\d+\", transform = |v|\n            v.parse().unwrap())] v: i32\n        } #[adze::extra] struct Whitespace\n        { #[adze::leaf(pattern = r\"\\s\")] _whitespace: (), }\n    }\n})? .to_token_stream().to_string())"
---
mod grammar {
    use adze::Spanned;
    pub struct NumberList {
        numbers: Vec<Spanned<Number>>,
    }
    impl ::adze::Extract<NumberList> for NumberList {
        type LeafFn = ();
        #[allow(non_snake_case)]
        fn extract(
            node: Option<::adze::tree_sitter::Node>,
            source: &[u8],
            last_idx: usize,
            _leaf_fn: Option<&Self::LeafFn>,
        ) -> Self {
            let node = node.expect("Extract called with None node for struct");
            ::adze::__private::extract_struct_or_variant(node, move |cursor, last_idx| NumberList {
                numbers: {
                    ::adze::__private::extract_field::<Vec<Spanned<Number>>, _>(
                        cursor, source, last_idx, "numbers", None,
                    )
                },
            })
        }
    }
    pub struct Number {
        v: i32,
    }
    impl ::adze::Extract<Number> for Number {
        type LeafFn = ();
        #[allow(non_snake_case)]
        fn extract(
            node: Option<::adze::tree_sitter::Node>,
            source: &[u8],
            last_idx: usize,
            _leaf_fn: Option<&Self::LeafFn>,
        ) -> Self {
            let node = node.expect("Extract called with None node for struct");
            ::adze::__private::extract_struct_or_variant(node, move |cursor, last_idx| Number {
                v: {
                    ::adze::__private::extract_field::<adze::WithLeaf<i32>, _>(
                        cursor,
                        source,
                        last_idx,
                        "v",
                        Some(&|v| v.parse().unwrap()),
                    )
                },
            })
        }
    }
    struct Whitespace {
        _whitespace: (),
    }
    impl ::adze::Extract<Whitespace> for Whitespace {
        type LeafFn = ();
        #[allow(non_snake_case)]
        fn extract(
            node: Option<::adze::tree_sitter::Node>,
            source: &[u8],
            last_idx: usize,
            _leaf_fn: Option<&Self::LeafFn>,
        ) -> Self {
            let node = node.expect("Extract called with None node for struct");
            ::adze::__private::extract_struct_or_variant(node, move |cursor, last_idx| Whitespace {
                _whitespace: {
                    ::adze::__private::extract_field::<(), _>(
                        cursor,
                        source,
                        last_idx,
                        "_whitespace",
                        None,
                    )
                },
            })
        }
    }
    unsafe extern "C" {
        fn tree_sitter_test() -> ::adze::tree_sitter::Language;
    }
    pub fn language() -> ::adze::tree_sitter::Language {
        unsafe { tree_sitter_test() }
    }
    #[doc = r" Parse an input string according to the grammar. Returns either any parsing errors that happened, or a"]
    #[doc = "[`NumberList`]"]
    #[doc = r" instance containing the parsed structured data."]
    pub fn parse(input: &str) -> core::result::Result<NumberList, Vec<::adze::errors::ParseError>> {
        ::adze::__private::parse::<NumberList>(input, language)
    }
}