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
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

use crate::enums::kind::Kind;
use crate::functions::sref_compiler::sref_ast_name;
use crate::records::compiler::Compiler;
use crate::records::l_value::LValue;
use crate::records::reg_scope::RegScope;
use luaur_ast::records::ast_expr::AstExpr;
use luaur_ast::records::ast_expr_global::AstExprGlobal;
use luaur_ast::records::ast_expr_index_expr::AstExprIndexExpr;
use luaur_ast::records::ast_expr_index_name::AstExprIndexName;
use luaur_ast::records::ast_expr_local::AstExprLocal;
use luaur_ast::rtti;
use luaur_common::macros::luau_assert::LUAU_ASSERT;

impl Compiler {
    pub fn compile_l_value(&mut self, node: *mut AstExpr, rs: &mut RegScope) -> LValue {
        self.set_debug_line_ast_node(node as *mut _);
        unsafe {
            let expr = rtti::ast_node_as::<AstExprLocal>(node as *mut _);
            if !expr.is_null() {
                if luaur_common::FFlag::LuauExportValueSyntax.get() && (*(*expr).local).is_exported
                {
                    return LValue {
                        kind: Kind::Kind_IndexName,
                        reg: self.get_export_table_reg(node as *mut _),
                        upval: 0,
                        index: 0,
                        number: 0,
                        name: sref_ast_name((*(*expr).local).name),
                        location: (*node).base.location,
                    };
                }
                let reg = self.get_expr_local_reg(node);
                if reg >= 0 {
                    LValue {
                        kind: Kind::Kind_Local,
                        reg: reg as u8,
                        upval: 0,
                        index: 0,
                        number: 0,
                        name: Default::default(),
                        location: (*node).base.location,
                    }
                } else {
                    LUAU_ASSERT!((*expr).upvalue);
                    LValue {
                        kind: Kind::Kind_Upvalue,
                        reg: 0,
                        upval: self.get_upval((*expr).local),
                        index: 0,
                        number: 0,
                        name: Default::default(),
                        location: (*node).base.location,
                    }
                }
            } else {
                let expr = rtti::ast_node_as::<AstExprGlobal>(node as *mut _);
                if !expr.is_null() {
                    LValue {
                        kind: Kind::Kind_Global,
                        reg: 0,
                        upval: 0,
                        index: 0,
                        number: 0,
                        name: sref_ast_name((*expr).name),
                        location: (*node).base.location,
                    }
                } else {
                    let expr = rtti::ast_node_as::<AstExprIndexName>(node as *mut _);
                    if !expr.is_null() {
                        LValue {
                            kind: Kind::Kind_IndexName,
                            reg: self.compile_expr_auto((*expr).expr, rs),
                            upval: 0,
                            index: 0,
                            number: 0,
                            name: sref_ast_name((*expr).index),
                            location: (*node).base.location,
                        }
                    } else {
                        let expr = rtti::ast_node_as::<AstExprIndexExpr>(node as *mut _);
                        if !expr.is_null() {
                            let reg = self.compile_expr_auto((*expr).expr, rs);
                            self.compile_l_value_index(reg, (*expr).index, rs)
                        } else {
                            LUAU_ASSERT!(false);
                            LValue {
                                kind: Kind::Kind_Local,
                                reg: 0,
                                upval: 0,
                                index: 0,
                                number: 0,
                                name: Default::default(),
                                location: (*node).base.location,
                            }
                        }
                    }
                }
            }
        }
    }
}