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

use crate::functions::get_def::get_def_id;
use crate::records::blocked_type::BlockedType;
use crate::records::cell::Cell;
use crate::records::constraint_generator::ConstraintGenerator;
use crate::records::phi::Phi;
use crate::records::scope::Scope;
use crate::records::type_ids::TypeIds;
use crate::type_aliases::def_id_def::DefId;
use crate::type_aliases::scope_ptr_constraint_generator::ScopePtr;
use crate::type_aliases::type_id::TypeId;
use luaur_ast::records::location::Location;

impl ConstraintGenerator {
    pub fn lookup(
        &mut self,
        scope: &ScopePtr,
        location: Location,
        def: DefId,
        prototype: bool,
    ) -> Option<TypeId> {
        if unsafe { !get_def_id::<Cell>(def).is_null() } {
            return scope.lookup_def_id(def);
        }

        if let Some(phi) = unsafe { get_def_id::<Phi>(def).as_ref() } {
            if let Some(found) = scope.lookup_def_id(def) {
                return Some(found);
            } else if !prototype && phi.operands.len() == 1 {
                return self.lookup(scope, location, phi.operands[0], prototype);
            } else if !prototype {
                return None;
            }

            let mut res = unsafe { (*self.builtin_types).neverType };

            for operand in &phi.operands {
                let mut ty = self.lookup(scope, location, *operand, /*prototype*/ false);
                if ty.is_none() {
                    let blocked_ty = unsafe {
                        (*self.arena).add_type(BlockedType {
                            index: 0,
                            owner: core::ptr::null(),
                        })
                    };
                    self.local_types.try_insert(blocked_ty, TypeIds::type_ids());
                    unsafe {
                        *(*self.root_scope).lvalue_types.get_or_insert(*operand) = blocked_ty;
                    }
                    ty = Some(blocked_ty);
                }

                res = self.make_union_scope_ptr_location_type_id_type_id(
                    self.root_scope,
                    location,
                    res,
                    ty.unwrap(),
                );
            }

            unsafe {
                let scope_ptr = scope.as_ref() as *const Scope as *mut Scope;
                *(*scope_ptr).lvalue_types.get_or_insert(def) = res;
            }
            return Some(res);
        }

        unsafe { (*self.ice).ice_string("ConstraintGenerator::lookup is inexhaustive?") };
        None
    }
}