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

use crate::records::lint_local_hygiene::LintLocalHygiene;
use crate::records::local_linter::Local;
use luaur_ast::records::ast_local::AstLocal;
use luaur_config::enums::code::Code;

impl LintLocalHygiene {
    pub fn report_used_local(&mut self, local: *mut AstLocal, info: &Local) {
        let shadow = unsafe { (*local).shadow };
        if !shadow.is_null() {
            let shadow_local = self.locals.find(&shadow);
            let duplicate_function_enabled = unsafe {
                (*self.context)
                    .options
                    .is_enabled(Code::Code_DuplicateFunction)
            };
            let duplicate_local_enabled = unsafe {
                (*self.context)
                    .options
                    .is_enabled(Code::Code_DuplicateLocal)
            };

            if duplicate_function_enabled
                && info.function
                && shadow_local.is_some_and(|shadow_info| shadow_info.function)
            {
                return;
            }

            if duplicate_local_enabled
                && shadow_local.is_some_and(|shadow_info| shadow_info.defined == info.defined)
            {
                return;
            }

            if unsafe { (*shadow).function_depth == (*local).function_depth } {
                crate::functions::emit_warning::emit_warning(
                    unsafe { &mut *self.context },
                    Code::Code_LocalShadow,
                    unsafe { (*local).location },
                    format_args!(
                        "Variable '{}' shadows previous declaration at line {}",
                        name_str(unsafe { (*local).name.value }),
                        unsafe { (*shadow).location.begin.line + 1 }
                    ),
                );
            }

            return;
        }

        if let Some(global) = self.globals.find(unsafe { &(*local).name }) {
            if global.builtin {
                return;
            }

            if !global.firstRef.is_null() {
                crate::functions::emit_warning::emit_warning(
                    unsafe { &mut *self.context },
                    Code::Code_LocalShadow,
                    unsafe { (*local).location },
                    format_args!(
                        "Variable '{}' shadows a global variable used at line {}",
                        name_str(unsafe { (*local).name.value }),
                        unsafe { (*global.firstRef).base.base.location.begin.line + 1 }
                    ),
                );
            } else {
                crate::functions::emit_warning::emit_warning(
                    unsafe { &mut *self.context },
                    Code::Code_LocalShadow,
                    unsafe { (*local).location },
                    format_args!(
                        "Variable '{}' shadows a global variable",
                        name_str(unsafe { (*local).name.value })
                    ),
                );
            }
        }
    }
}

fn name_str(value: *const core::ffi::c_char) -> alloc::borrow::Cow<'static, str> {
    if value.is_null() {
        alloc::borrow::Cow::Borrowed("")
    } else {
        unsafe { core::ffi::CStr::from_ptr(value).to_string_lossy() }
    }
}