luaur-analysis 0.1.3

Luau type checker and type inference (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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::functions::emit_warning::emit_warning;
use crate::records::lint_table_literal::LintTableLiteral;
use alloc::collections::BTreeMap;
use luaur_ast::enums::ast_table_access::AstTableAccess;
use luaur_ast::records::ast_name::AstName;
use luaur_ast::records::ast_type_table::AstTypeTable;
use luaur_ast::records::location::Location;
use luaur_config::enums::code::Code;

impl LintTableLiteral {
    pub fn visit_ast_type_table(&mut self, node: *mut AstTypeTable) -> bool {
        let node = unsafe { &*node };
        let checked_in_new_solver = unsafe {
            !(*self.context).module.is_null() && (*(*self.context).module).checked_in_new_solver
        };

        if checked_in_new_solver {
            #[derive(Clone, Copy)]
            struct Rec {
                access: AstTableAccess,
                location: Location,
            }

            let mut names: BTreeMap<AstName, Rec> = BTreeMap::new();

            for item in node.props.iter() {
                let name = unsafe { core::ffi::CStr::from_ptr(item.name.value).to_string_lossy() };

                if let Some(rec) = names.get_mut(&item.name) {
                    if (rec.access as u8 & item.access as u8) != 0 {
                        if rec.access == item.access {
                            emit_warning(
                                unsafe { &mut *self.context },
                                Code::Code_TableLiteral,
                                item.location,
                                format_args!(
                                    "Table type field '{}' is a duplicate; previously defined at line {}",
                                    name,
                                    rec.location.begin.line + 1
                                ),
                            );
                        } else if rec.access == AstTableAccess::ReadWrite {
                            emit_warning(
                                unsafe { &mut *self.context },
                                Code::Code_TableLiteral,
                                item.location,
                                format_args!(
                                    "Table type field '{}' is already read-write; previously defined at line {}",
                                    name,
                                    rec.location.begin.line + 1
                                ),
                            );
                        } else if rec.access == AstTableAccess::Read {
                            emit_warning(
                                unsafe { &mut *self.context },
                                Code::Code_TableLiteral,
                                rec.location,
                                format_args!(
                                    "Table type field '{}' already has a read type defined at line {}",
                                    name,
                                    rec.location.begin.line + 1
                                ),
                            );
                        } else if rec.access == AstTableAccess::Write {
                            emit_warning(
                                unsafe { &mut *self.context },
                                Code::Code_TableLiteral,
                                rec.location,
                                format_args!(
                                    "Table type field '{}' already has a write type defined at line {}",
                                    name,
                                    rec.location.begin.line + 1
                                ),
                            );
                        }
                    } else {
                        rec.access = match rec.access as u8 | item.access as u8 {
                            1 => AstTableAccess::Read,
                            2 => AstTableAccess::Write,
                            _ => AstTableAccess::ReadWrite,
                        };
                    }
                } else {
                    names.insert(
                        item.name,
                        Rec {
                            access: item.access,
                            location: item.location,
                        },
                    );
                }
            }

            return true;
        }

        let mut names: BTreeMap<AstName, u32> = BTreeMap::new();

        for item in node.props.iter() {
            let name = unsafe { core::ffi::CStr::from_ptr(item.name.value).to_string_lossy() };

            if let Some(line) = names.get(&item.name).copied() {
                emit_warning(
                    unsafe { &mut *self.context },
                    Code::Code_TableLiteral,
                    item.location,
                    format_args!(
                        "Table type field '{}' is a duplicate; previously defined at line {}",
                        name, line
                    ),
                );
            } else {
                names.insert(item.name, item.location.begin.line + 1);
            }
        }

        true
    }
}