mist-parser 0.1.7-alpha.2

The Mist programming language parser
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

use crate::{
    Rule,
    ast::*,
    ast_ensure, ast_expr,
    error::{AstError, IntoErr, collect_recovered},
};

impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Block {
    type Error = AstError<'a, Self>;

    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
        let mut inner = pair.clone().into_inner();

        ast_ensure!(pair, Rule::block => {
            ast_expr!(Block(collect_recovered(inner.next().unwrap().into_inner()), inner.next().map(Spanned::try_from).transpose()))
        })
    }
}

impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for StatementBody {
    type Error = AstError<'a, Self>;

    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
        let mut inner = pair.clone().into_inner();

        ast_ensure!(pair, Rule::statement_body => {
            let i = inner.next().unwrap();

            match i.as_rule() {
                Rule::expr => ast_expr!(StatementBody::Expression(i.try_into())),
                Rule::statement_wrapper => ast_expr!(StatementBody::Statement(i.try_into())),
                _ => AstError::bug_unimplemented(i),
            }
        })
    }
}

impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for StatementBranch {
    type Error = AstError<'a, Self>;

    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
        let mut inner = pair.clone().into_inner();

        ast_ensure!(pair, Rule::statement_branch => {
            ast_expr!(StatementBranch {
                condition: inner.next().unwrap().try_into(),
                body: inner.next().unwrap().try_into().map(Box::new),
            })
        })
    }
}

impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
    type Error = AstError<'a, Self>;

    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
        let rule = pair.as_rule();
        let mut inner = pair.clone().into_inner();

        match rule {
            Rule::statement | Rule::basic_stmt | Rule::control_flow => {
                Statement::try_from(inner.next().unwrap())
            }

            Rule::block => ast_expr!(Statement::Block(pair.try_into())),

            Rule::var_decl_statement => ast_expr!(Statement::VarDecl(pair.try_into())),

            Rule::return_stmt => {
                ast_expr!(Statement::Return(
                    inner.next().map(Expression::try_from).transpose()
                ))
            }

            Rule::break_stmt => Ok(Statement::Break),

            Rule::continue_stmt => Ok(Statement::Continue),

            Rule::if_stmt => {
                ast_expr!(Statement::If {
                    initial: inner.next().unwrap().try_into(),
                    else_if: collect_recovered(inner.next().unwrap().into_inner()),
                    else_branch: inner.next().map(StatementBody::try_from).transpose(),
                })
            }

            Rule::while_stmt => ast_expr!(Statement::While(inner.next().unwrap().try_into())),

            Rule::loop_stmt => ast_expr!(Statement::Loop(inner.next().unwrap().try_into())),

            Rule::c_for_stmt => ast_expr!(Statement::CStyleFor {
                init: inner.next().unwrap().try_into(),
                condition: inner.next().unwrap().try_into(),
                update: inner.next().unwrap().try_into(),
                body: inner.next().unwrap().try_into(),
            }),

            Rule::for_stmt => ast_expr!(Statement::For {
                pattern: inner.next().unwrap().try_into(),
                iterator: inner.next().unwrap().try_into(),
                body: inner.next().unwrap().try_into(),
            }),

            Rule::match_stmt => ast_expr!(Statement::Match(
                inner.next().unwrap().try_into(),
                collect_recovered(inner),
            )),

            _ => AstError::bug_unimplemented(pair),
        }
    }
}

impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for MatchItem {
    type Error = AstError<'a, Self>;

    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
        let mut match_inner = pair.into_inner();

        Ok(MatchItem(
            collect_recovered(match_inner.next().unwrap().into_inner()).get()?,
            Expression::try_from(match_inner.next().unwrap()).get()?,
        ))
    }
}