nolana 1.0.0

An extremely fast parser Molang 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

use crate::{
    ast::*,
    diagnostic::{errors, Diagnostic},
    visit::{walk::*, Visit},
};

/// Traverses an AST and checks the Molang program for any semantic errors.
#[derive(Default)]
pub struct SemanticChecker {
    /// `loop` and `for_each` level.
    loop_depth: u32,
    errors: Vec<Diagnostic>,
}

impl SemanticChecker {
    /// Main entry point.
    pub fn check(mut self, program: &Program) -> Vec<Diagnostic> {
        self.visit_program(program);
        self.errors
    }

    const fn in_loop(kind: AstKind) -> bool {
        matches!(kind, AstKind::LoopExpression | AstKind::ForEachExpression)
    }
}

impl<'a> Visit<'a> for SemanticChecker {
    fn enter_node(&mut self, kind: AstKind) {
        if Self::in_loop(kind) {
            self.loop_depth += 1;
        }
    }

    fn leave_node(&mut self, kind: AstKind) {
        if Self::in_loop(kind) {
            self.loop_depth -= 1;
        }
    }

    fn visit_block_expression(&mut self, it: &BlockExpression<'a>) {
        if it.expressions.is_empty() {
            self.errors.push(errors::empty_block_expression(it.span));
        }
        walk_block_expression(self, it);
    }

    fn visit_binary_expression(&mut self, it: &BinaryExpression<'a>) {
        use BinaryOperator::*;
        use Expression::*;
        match (&it.left, it.operator, &it.right) {
            (StringLiteral(_), op, StringLiteral(_)) if !matches!(op, Equality | Inequality) => (),
            (left, _, StringLiteral(_)) if !matches!(left, StringLiteral(_)) => (),
            (StringLiteral(_), _, right) if !matches!(right, StringLiteral(_)) => (),
            _ => {
                walk_binary_expression(self, it);
                return;
            }
        }
        self.errors.push(errors::illegal_string_operators(it.span));
        walk_binary_expression(self, it);
    }

    fn visit_assignment_expression(&mut self, it: &AssignmentExpression<'a>) {
        if it.left.lifetime == VariableLifetime::Context {
            self.errors.push(errors::assigning_context(it.span))
        }
        walk_assignment_expression(self, it);
    }

    fn visit_break(&mut self, it: &Break) {
        if self.loop_depth == 0 {
            self.errors.push(errors::break_outside_loop(it.span));
        }
    }

    fn visit_continue(&mut self, it: &Continue) {
        if self.loop_depth == 0 {
            self.errors.push(errors::continue_outside_loop(it.span));
        }
    }
}