type-sitter-gen 0.4.0

generate typed wrappers for tree-sitter grammars from node-types.json and queries
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

use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use syn::{Ident, LitStr, parse_str};
use crate::Error;

macro_rules! modularize {
    ($module:ident) => {
        crate::mk_syntax::modularize!($module (use super::*))
    };
    ($module:ident (use $($imports:tt)+)) => {
        if $module.is_empty() {
            quote!()
        } else {
            quote! {
                pub mod $module {
                    #[allow(unused_imports)]
                    use $($imports)+;
                    #$module
                }
            }
        }
    }
}
pub(crate) use modularize;

/// Concatenate strings for documentation
macro_rules! concat_doc {
    ($($term:expr),*) => {{
        let mut result = String::new();
        $(
            result.push_str(&$term);
        )*
        quote::quote! { #result }
    }}
}
pub(crate) use concat_doc;

/// Create an identifier
macro_rules! ident {
    ($name:expr, $fmt:literal $(, $arg:expr)*) => {
        $crate::mk_syntax::_ident(&$name, || format!($fmt $(, $arg)*))
    };
}
pub(crate) use ident;

pub fn _ident(name: &str, type_desc: impl FnOnce() -> String) -> Result<Ident, Error> {
    match parse_str::<Ident>(name).or_else(|_| parse_str::<Ident>(&format!("r#{}", name))) {
        Ok(ident) => Ok(ident),
        Err(_) => Err(Error::IllegalIdentifier {
            type_desc: type_desc(),
            name: name.to_string()
        })
    }
}

/// Create a literal string
pub fn lit_str(contents: &str) -> LitStr {
    LitStr::new(contents, Span::call_site())
}

/// Create a literal array
pub fn lit_array<T: ToTokens>(contents: impl Iterator<Item=T>) -> TokenStream {
    quote! { [#(#contents),*] }
}