tree-builder-macro 0.0.1

Macros for the tree-builder crate.
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
94
95
96
97
98
99
100
101
102
103

use proc_macro2::TokenStream as TokenStream2;
pub mod parser_builder;
mod tuple_type_builder;
pub use tuple_type_builder::{ast_from_rule, ast_from_rule_no_alts};

use crate::parser::parser_ast::{
    ConcatKind, Concatenation, Factor, Grouping, Include, Term,
};
use quote::quote;

#[derive(Debug)]
struct IncludeAnalysis<'a> {
    children: Vec<IncludeAnalysis<'a>>,
    node: &'a Factor,
}

impl<'a> IncludeAnalysis<'a> {
    /// Construct an IncludeAnalysis object out of a factor consisting of a reference to
    /// the factor itself, and a vector of other IncludeAnalysis objects, which will be
    /// other factors which have been included inside the input if it is a grouping,
    /// or an empty vec if it is another kind of include
    pub fn new(factor: &'a Factor) -> Self {
        let children: Vec<Self> = match factor {
            Factor::Term(Term::Grouping(Grouping(conc, _)))
            | Factor::Optional(Term::Grouping(Grouping(conc, _)))
            | Factor::OneOrMore(Term::Grouping(Grouping(conc, _)))
            | Factor::ZeroOrMore(Term::Grouping(Grouping(conc, _))) => {
                Self::analyze_concatenation(conc)
            }
            _ => vec![],
        };
        IncludeAnalysis {
            children,
            node: factor,
        }
    }

    pub fn analyze_concatenation(conc: &'a Concatenation) -> Vec<Self> {
        let mut result = vec![];
        for next in &(conc.0) {
            match next {
                ConcatKind::Factor(_) => (),
                ConcatKind::Include(Include(next)) => result.push(Self::new(next)),
            }
        }
        result
    }

    pub fn generate_type(&self) -> TokenStream2 {
        let Self { node, .. } = self;
        let (wrapper, term): (fn(TokenStream2) -> TokenStream2, &Term) = match node {
            Factor::Optional(term) => (|x: TokenStream2| quote! {std::option::Option<#x>}, term),
            Factor::OneOrMore(term) if matches!(term, Term::Metacharacter(_))
                => (|x: TokenStream2| x, term),
            Factor::OneOrMore(term) => (|x: TokenStream2| quote! {std::vec::Vec<#x>}, term),
            Factor::ZeroOrMore(term) if matches!(term, Term::Metacharacter(_))
                => (|x: TokenStream2| x, term),
            Factor::ZeroOrMore(term) => (|x: TokenStream2| quote! {std::vec::Vec<#x>}, term),
            Factor::Term(term) => (|x: TokenStream2| x, term),
        };
        if !node.is_grouping() {
            wrapper(Self::term_to_type(term))
        } else {
            wrapper(Self::type_from_grouping(self))
        }
    }

    fn term_to_type(term: &Term) -> TokenStream2 {
        match term {
            Term::Metacharacter(_) | Term::Terminal(_) => quote!(String),
            Term::Ident(ident) => {
                let ident = proc_macro2::Ident::new(ident, proc_macro2::Span::call_site());
                quote!(std::boxed::Box<#ident>)
            }
            _ => panic!("Do not call with grouping"),
        }
    }

    fn type_from_grouping(analysis: &Self) -> TokenStream2 {
        let wrapper = if analysis.children.len() > 1 || analysis.children.is_empty() {
            |x: Vec<TokenStream2>| quote!((#(#x),*))
        } else {
            |x: Vec<TokenStream2>| {
                let x = &x[0];
                quote!(#x)
            }
        };
        wrapper(analysis.children.iter().map(Self::generate_type).collect())
    }

    pub fn concat_to_type(concatenation: &Concatenation) -> TokenStream2 {
        let analysis = IncludeAnalysis::analyze_concatenation(concatenation);
        let analysis: Vec<TokenStream2> = analysis
            .iter()
            .map(IncludeAnalysis::generate_type)
            .collect();
        quote!((#(#analysis),*))
    }


}