luaur-analysis 0.1.0

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

use crate::enums::inhabited::Inhabited;
use crate::enums::relation::Relation;
use crate::functions::follow_type::follow_type_id;
use crate::functions::get_type_alt_j::get_type_id;
use crate::functions::relate_simplify_alt_b::relate_type_id_type_id;
use crate::records::intersection_type::IntersectionType;
use crate::records::type_ids::TypeIds;
use crate::records::type_simplifier::TypeSimplifier;
use crate::type_aliases::type_id::TypeId;

pub fn intersect_one_with_intersection(
    simplifier: &mut TypeSimplifier,
    source: &mut TypeIds,
    dest: &mut TypeIds,
    candidate: TypeId,
) -> Inhabited {
    // `get<T>` requires a followed type (it asserts the argument is not a BoundType).
    // The C++ pipeline guarantees the candidate is followed at this point (TypeIds
    // entries are followed on insert); a recursed sub-part of an IntersectionType is
    // not necessarily followed, so we follow here to preserve that invariant.
    let candidate = unsafe { follow_type_id(candidate) };

    if dest.count(candidate) > 0 {
        return Inhabited::Yes;
    }

    if let Some(itv) = unsafe { get_type_id::<IntersectionType>(candidate).as_ref() } {
        for &sub_part in &itv.parts {
            if intersect_one_with_intersection(simplifier, source, dest, sub_part) == Inhabited::No
            {
                return Inhabited::No;
            }
        }

        return Inhabited::Yes;
    }

    if source.empty() {
        dest.insert_type_id(candidate);
        return Inhabited::Yes;
    }
    for i in 0..source.size() {
        let ty = unsafe { *source.order.as_ptr().add(i) };
        match relate_type_id_type_id(candidate, ty) {
            Relation::Disjoint => return Inhabited::No,
            Relation::Subset => dest.insert_type_id(candidate),
            Relation::Coincident | Relation::Superset => dest.insert_type_id(ty),
            Relation::Intersects => {
                if let Some(simplified) = simplifier.basic_intersect(candidate, ty) {
                    dest.insert_type_id(simplified);
                } else {
                    dest.insert_type_id(candidate);
                    dest.insert_type_id(ty);
                }
            }
        }
    }
    Inhabited::Yes
}