mist-parser 0.1.7-alpha.0

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
126

pub mod attribute;
pub mod class;
pub mod enums;
pub mod function;
pub mod impl_decl;

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

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

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

        let attributes = collect_recovered(inner.next().unwrap().into_inner());

        ast_expr!(TopLevel(
            inner.next().map(Spanned::try_from).unwrap(),
            attributes,
        ))
    }
}

impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TopLevelKind {
    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::import => ast_expr!(TopLevelKind::Import(
                Visibility::try_from(&mut inner),
                Path::try_from(inner.next().unwrap()),
            )),

            Rule::function_decl => ast_expr!(TopLevelKind::FunctionDecl(pair.try_into())),

            Rule::struct_decl => ast_expr!(TopLevelKind::StructDecl {
                visibility: Visibility::try_from(&mut inner),

                name: inner.next().unwrap().try_into(),

                generics: consume_rule(&mut inner, Rule::generics_decl)
                    .map(GenericsDecl::try_from)
                    .transpose()
                    .map(|v| v.unwrap_or_default()),

                fields: inner
                    .next()
                    .map(|pair| collect_recovered(pair.into_inner()))
                    .transpose()
                    .map(|v| v.unwrap_or_default()),
            }),

            Rule::class_decl => ast_expr!(TopLevelKind::ClassDecl {
                visibility: Visibility::try_from(&mut inner),

                name: inner.next().unwrap().try_into(),

                generics: consume_rule(&mut inner, Rule::generics_decl)
                    .map(GenericsDecl::try_from)
                    .transpose()
                    .map(|v| v.unwrap_or_default()),

                inherits: consume_rule(&mut inner, Rule::type_expr)
                    .map(TypeExpr::try_from)
                    .transpose(),

                fields: collect_recovered(inner.next().unwrap().into_inner()),

                constructor: inner.next().unwrap().try_into(),

                items: collect_recovered(inner),
            }),

            Rule::enum_decl => ast_expr!(TopLevelKind::EnumDecl {
                visibility: Visibility::try_from(&mut inner),

                name: inner.next().unwrap().try_into(),

                generics: consume_rule(&mut inner, Rule::generics_decl)
                    .map(GenericsDecl::try_from)
                    .transpose()
                    .map(|v| v.unwrap_or_default()),

                fields: collect_recovered(inner),
            }),

            Rule::mod_package => ast_expr!(TopLevelKind::Mod(
                Visibility::try_from(&mut inner),
                inner.next().unwrap().try_into(),
            )),

            Rule::impl_for_decl | Rule::impl_decl => {
                ast_expr!(TopLevelKind::ImplDecl(pair.try_into()))
            }

            Rule::trait_decl => ast_expr!(TopLevelKind::TraitDecl {
                visibility: Visibility::try_from(&mut inner),

                name: inner.next().unwrap().try_into(),

                generics: consume_rule(&mut inner, Rule::generics_decl)
                    .map(GenericsDecl::try_from)
                    .transpose()
                    .map(|v| v.unwrap_or_default()),

                requirements: consume_rule(&mut inner, Rule::trait_requirements)
                    .map(|pair| collect_recovered(pair.into_inner()))
                    .transpose()
                    .map(|v| v.unwrap_or_default()),

                items: collect_recovered(&mut inner),
            }),

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