type-sitter-gen 0.1.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

use indexmap::IndexMap;
use proc_macro2::TokenStream;
use crate::types::{AnonUnionId, NodeModule};

/// Generated AST tokens from calling [NodeType::print] on a single instance or each element of a
/// collection.
///
/// We can't just collect the output of [NodeType::print] into a [TokenStream] because some
/// declarations go in specific submodules (`unnamed`, `symbols`, `anon_unions`), and also we don't want
/// duplicate definitions of the anonymous unions.
#[derive(Default)]
pub struct GeneratedNodeTokens {
    /// Toplevel declaration tokens
    pub toplevel: TokenStream,
    /// Tokens for the `unnamed` submodule
    pub unnamed: TokenStream,
    /// Tokens for the `symbols` submodule
    pub symbols: TokenStream,
    /// Anonymous unions and tokens for the `anon_union` submodule
    pub anon_unions: AnonUnions,
}

pub type AnonUnions = IndexMap<AnonUnionId, TokenStream>;

impl GeneratedNodeTokens {
    /// Empty instance
    pub fn new() -> Self {
        Self::default()
    }

    /// Append the tokens to the given module
    pub fn extend(&mut self, module: NodeModule, tokens: TokenStream) {
        match module {
            NodeModule::Toplevel => self.toplevel.extend(tokens),
            NodeModule::Unnamed => self.unnamed.extend(tokens),
            NodeModule::Symbols => self.symbols.extend(tokens),
        }
    }
}

impl Extend<GeneratedNodeTokens> for GeneratedNodeTokens {
    fn extend<T: IntoIterator<Item = GeneratedNodeTokens>>(&mut self, iter: T) {
        for x in iter {
            self.toplevel.extend(x.toplevel);
            self.unnamed.extend(x.unnamed);
            self.symbols.extend(x.symbols);
            self.anon_unions.extend(x.anon_unions);
        }
    }
}

impl FromIterator<GeneratedNodeTokens> for GeneratedNodeTokens {
    fn from_iter<T: IntoIterator<Item = GeneratedNodeTokens>>(iter: T) -> Self {
        let mut this = Self::new();
        Extend::<GeneratedNodeTokens>::extend(&mut this, iter);
        this
    }
}