parsegen 0.1.1

A parser generator implemented as a proc macro
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::ast;
use crate::grammar::{Grammar, NonTerminalIdx, Symbol, SymbolKind, TerminalIdx};

use std::iter::FromIterator;

use fxhash::FxHashMap;
use proc_macro2::Span;

pub fn lower(
    non_terminals: Vec<ast::NonTerminal>,
    terminals: &[ast::Conversion],
) -> Grammar<syn::Expr> {
    let mut grammar = Grammar::new();

    let mut nt_indices: FxHashMap<String, NonTerminalIdx> = Default::default();

    let t_indices = {
        let mut t_indices: FxHashMap<String, TerminalIdx> = Default::default();
        for conv in terminals {
            let idx = grammar.new_terminal(conv.from.clone());
            let old = t_indices.insert(conv.from.clone(), idx);
            if old.is_some() {
                panic!("Terminal {:?} defined multiple times", conv.from);
            }
        }
        t_indices
    };

    for nt in &non_terminals {
        if nt.visibility.is_pub() {
            // For a `pub` non-terminal:
            //
            // - Add a "1" suffix to the original non-terminal
            //
            // - Create a new non-terminal with the original name:
            //
            //       NonTerminal0: ... = { <x:NonTerminal1> => x }
            //
            //   This new terminal will be used as an entry point to the parser.
            let nt1_name = nt.name.to_string() + "1";
            let nt1_idx = grammar.add_non_terminal(nt1_name, nt.type_decl.clone(), false);
            // Original name mapped to the new name with "1" suffix
            nt_indices.insert(nt.name.to_string(), nt1_idx);

            // Create the entry point
            let nt_idx = grammar.add_non_terminal(nt.name.to_string(), nt.type_decl.clone(), true);
            // Add the production here as we already defined non-terminal on the RHS
            let binder_ident = syn::Ident::new("x", Span::call_site());
            grammar.add_production(
                nt_idx,
                vec![Symbol {
                    binder: Some(ast::Name {
                        mutable: false,
                        name: binder_ident.clone(),
                    }),
                    kind: SymbolKind::NonTerminal(nt1_idx),
                }],
                syn::Expr::Path(syn::ExprPath {
                    attrs: vec![],
                    qself: None,
                    path: syn::Path {
                        leading_colon: None,
                        segments: syn::punctuated::Punctuated::from_iter(vec![syn::PathSegment {
                            ident: binder_ident,
                            arguments: syn::PathArguments::None,
                        }]),
                    },
                }),
            );
        } else {
            let nt_name = nt.name.to_string();
            let nt_idx = grammar.add_non_terminal(nt_name.clone(), nt.type_decl.clone(), false);
            nt_indices.insert(nt_name, nt_idx);
        }
    }

    for ast::NonTerminal {
        name, productions, ..
    } in non_terminals
    {
        for prod in productions {
            let mut symbols: Vec<Symbol> = vec![];
            for sym in prod.symbols {
                add_symbol(
                    &mut grammar,
                    &nt_indices,
                    &t_indices,
                    &mut symbols,
                    None,
                    sym,
                );
            }
            let nt_idx = nt_indices.get(&name.to_string()).unwrap();

            let action = match prod.action {
                ast::Action::User(expr) => expr,
                ast::Action::Fallible(_) => todo!("Fallible actions not supported yet"),
            };

            grammar.add_production(*nt_idx, symbols, action);
        }
    }

    grammar
}

fn add_symbol<A>(
    grammar: &mut Grammar<A>,
    nt_indices: &FxHashMap<String, NonTerminalIdx>,
    t_indices: &FxHashMap<String, TerminalIdx>,
    symbols: &mut Vec<Symbol>,
    binder: Option<ast::Name>,
    symbol: ast::Symbol,
) {
    match symbol {
        ast::Symbol::NonTerminal(nt) => {
            let nt_name = nt.to_string();
            let nt_idx = match nt_indices.get(&nt_name) {
                None => panic!("Non-terminal not defined: {}", nt_name),
                Some(nt_idx) => nt_idx,
            };
            symbols.push(Symbol {
                binder,
                kind: SymbolKind::NonTerminal(*nt_idx),
            });
        }
        ast::Symbol::Terminal(str) => {
            let str = str.value();
            let idx = t_indices
                .get(&str)
                .unwrap_or_else(|| panic!("Unknown non-terminal: {:?}", str));
            symbols.push(Symbol {
                binder,
                kind: SymbolKind::Terminal(*idx),
            });
        }
        ast::Symbol::Repeat(_) => {
            todo!("Repeat symbol not supported yet");
        }
        ast::Symbol::Name(binder, sym) => {
            add_symbol(grammar, nt_indices, t_indices, symbols, Some(binder), *sym)
        }
    }
}