luaur-compiler 0.1.3

Luau source-to-bytecode compiler (Rust).
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

use crate::records::table_mutation_tracker::TableMutationTracker;
use luaur_ast::records::ast_expr::AstExpr;
use luaur_ast::records::ast_expr_binary::{AstExprBinary, AstExprBinary_Op};
use luaur_ast::records::ast_expr_group::AstExprGroup;
use luaur_ast::records::ast_expr_if_else::AstExprIfElse;
use luaur_ast::records::ast_expr_instantiate::AstExprInstantiate;
use luaur_ast::records::ast_expr_local::AstExprLocal;
use luaur_ast::records::ast_expr_type_assertion::AstExprTypeAssertion;
use luaur_ast::records::ast_node::AstNode;
use luaur_ast::rtti::{ast_node_as, ast_node_is};

impl<'a> TableMutationTracker<'a> {
    #[allow(non_snake_case)]
    pub fn mark_escaped_impl(&mut self, mut expr: *mut AstExpr) {
        loop {
            if expr.is_null() {
                return;
            }

            let expr_ptr = expr as *mut AstNode;

            let expr_local = unsafe { ast_node_as::<AstExprLocal>(expr_ptr) };
            if !expr_local.is_null() {
                unsafe {
                    self.escaped.insert((*expr_local).local);
                }
                return;
            }

            let expr_group = unsafe { ast_node_as::<AstExprGroup>(expr_ptr) };
            if !expr_group.is_null() {
                expr = unsafe { (*expr_group).expr };
                continue;
            }

            let expr_assertion = unsafe { ast_node_as::<AstExprTypeAssertion>(expr_ptr) };
            if !expr_assertion.is_null() {
                expr = unsafe { (*expr_assertion).expr };
                continue;
            }

            let expr_instantiate = unsafe { ast_node_as::<AstExprInstantiate>(expr_ptr) };
            if !expr_instantiate.is_null() {
                expr = unsafe { (*expr_instantiate).expr };
                continue;
            }

            let expr_if_else = unsafe { ast_node_as::<AstExprIfElse>(expr_ptr) };
            if !expr_if_else.is_null() {
                self.mark_escaped_impl(unsafe { (*expr_if_else).true_expr });
                expr = unsafe { (*expr_if_else).false_expr };
                continue;
            }

            let bin_expr = unsafe { ast_node_as::<AstExprBinary>(expr_ptr) };
            if !bin_expr.is_null() {
                let op = unsafe { (*bin_expr).op };
                if op == AstExprBinary_Op::And || op == AstExprBinary_Op::Or {
                    self.mark_escaped_impl(unsafe { (*bin_expr).left });
                    expr = unsafe { (*bin_expr).right };
                    continue;
                } else {
                    return;
                }
            }

            return;
        }
    }
}

#[allow(non_snake_case)]
pub fn table_mutation_tracker_mark_escaped(tracker: &mut TableMutationTracker, expr: *mut AstExpr) {
    tracker.mark_escaped_impl(expr);
}