mun_syntax 0.4.0

Parsing functionality for the Mun programming language
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

use super::*;

pub(super) const PATH_FIRST: TokenSet =
    TokenSet::new(&[IDENT, T![super], T![self], T![package], T![::]]);

pub(super) fn is_path_start(p: &Parser) -> bool {
    matches!(p.current(), IDENT | T![self] | T![super] | T![package])
}

pub(super) fn is_use_path_start(p: &Parser, top_level: bool) -> bool {
    if top_level {
        matches!(p.current(), IDENT | T![self] | T![super] | T![package])
    } else {
        matches!(p.current(), IDENT | T![self])
    }
}

pub(super) fn type_path(p: &mut Parser) {
    path(p, Mode::Type, true)
}
pub(super) fn expr_path(p: &mut Parser) {
    path(p, Mode::Expr, true)
}
pub(super) fn use_path(p: &mut Parser, top_level: bool) {
    path(p, Mode::Use, top_level)
}

#[derive(Clone, Copy, Eq, PartialEq)]
enum Mode {
    Type,
    Expr,
    Use,
}

fn path(p: &mut Parser, mode: Mode, top_level: bool) {
    let path = p.start();
    path_segment(p, mode, top_level);
    let mut qualifier = path.complete(p, PATH);
    loop {
        let use_tree = matches!(p.nth(2), T![*] | T!['{']);
        if p.at(T![::]) && !use_tree {
            let path = qualifier.precede(p);
            p.bump(T![::]);
            path_segment(p, mode, false);
            let path = path.complete(p, PATH);
            qualifier = path;
        } else {
            break;
        }
    }
}

fn path_segment(p: &mut Parser, _mode: Mode, top_level: bool) {
    let m = p.start();
    match p.current() {
        IDENT => {
            name_ref(p);
        }
        T![super] | T![package] if top_level => p.bump_any(),
        T![self] => p.bump(T![self]),
        _ => p.error_recover(
            "expected identifier",
            declarations::DECLARATION_RECOVERY_SET,
        ),
    }
    m.complete(p, PATH_SEGMENT);
}