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

use crate::functions::follow_type::follow_type_id;
use crate::records::constraint::Constraint;
use crate::records::constraint_solver::ConstraintSolver;
use crate::records::infinite_type_finder::InfiniteTypeFinder;
use crate::records::intersection_type::IntersectionType;
use crate::records::iterative_type_visitor::IterativeTypeVisitorTrait;
use crate::records::metatable_type::MetatableType;
use crate::records::name_constraint::NameConstraint;
use crate::records::table_type::TableType;
use crate::records::union_type::UnionType;
use crate::type_aliases::type_id::TypeId;

impl ConstraintSolver {
    pub fn try_dispatch_name_constraint_not_null_constraint(
        &mut self,
        c: &NameConstraint,
        constraint: *const Constraint,
    ) -> bool {
        if self.is_blocked_type_id(c.named_type) {
            return self.block_type_id_not_null_constraint(c.named_type, constraint);
        }

        let target = unsafe { follow_type_id(c.named_type) };

        unsafe {
            if (*target).persistent || (*target).owning_arena != self.arena {
                return true;
            }
        }

        if let Some(tf) = unsafe {
            (*(*constraint).scope)
                .lookup_type(&crate::type_aliases::name_type::Name::from(c.name.as_str()))
        } {
            let signature = crate::records::instantiation_signature::InstantiationSignature {
                fn_sig: tf,
                arguments: c.type_parameters.clone(),
                pack_arguments: c.type_pack_parameters.clone(),
            };

            let mut itf = InfiniteTypeFinder::infinite_type_finder_infinite_type_finder(
                self,
                &signature,
                unsafe { core::ptr::NonNull::new_unchecked((*constraint).scope) },
            );
            itf.run_type_id(target);

            if itf.found_infinite_type {
                unsafe {
                    (*(*constraint).scope)
                        .invalid_type_aliases
                        .try_insert(c.name.clone(), (*constraint).location)
                };
                self.bind_not_null_constraint_type_id_type_id(constraint, target, unsafe {
                    (*self.builtin_types).errorType
                });
                return true;
            }
        }

        let ttv =
            unsafe { crate::functions::get_mutable_type::get_mutable_type_id::<TableType>(target) };
        if !ttv.is_null() {
            unsafe {
                if c.synthetic && (*ttv).name.is_none() {
                    (*ttv).synthetic_name = Some(c.name.clone());
                } else {
                    (*ttv).name = Some(c.name.clone());
                    (*ttv).instantiated_type_params = c.type_parameters.clone();
                    (*ttv).instantiated_type_pack_params = c.type_pack_parameters.clone();
                }
            }
        } else {
            let mtv = unsafe {
                crate::functions::get_mutable_type::get_mutable_type_id::<MetatableType>(target)
            };
            if !mtv.is_null() {
                unsafe { (*mtv).syntheticName = Some(c.name.clone()) };
            }
        }

        true
    }
}