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

use crate::enums::normalization_result::NormalizationResult;
use crate::records::normalized_extern_type::NormalizedExternType;
use crate::records::normalized_function_type::NormalizedFunctionType;
use crate::records::normalized_string_type::NormalizedStringType;
use crate::records::normalized_type::NormalizedType;
use crate::records::normalizer::Normalizer;
use crate::records::type_ids::TypeIds;
use crate::type_aliases::seen_table_prop_pairs::SeenTablePropPairs;
use crate::type_aliases::type_id::TypeId;
use alloc::collections::BTreeMap;
use luaur_common::records::dense_hash_set::DenseHashSet;

impl Normalizer {
    pub fn normalize_intersections(
        &mut self,
        intersections: &alloc::vec::Vec<TypeId>,
        out_type: &mut NormalizedType,
        seen_table_prop_pairs: &mut SeenTablePropPairs,
        seen_set: &mut DenseHashSet<TypeId>,
    ) -> NormalizationResult {
        if self.arena.is_null() {
            panic!("Normalizing types outside a module");
        }

        self.consume_fuel();

        let never_type = unsafe { (*self.builtin_types).neverType };
        let mut norm = NormalizedType {
            builtin_types: self.builtin_types,
            tops: unsafe { (*self.builtin_types).unknownType },
            booleans: never_type,
            extern_types: NormalizedExternType {
                extern_types: BTreeMap::new(),
                shape_extensions: TypeIds::type_ids(),
                ordering: Vec::new(),
            },
            errors: never_type,
            nils: never_type,
            numbers: never_type,
            integers: never_type,
            strings: NormalizedStringType::never,
            threads: never_type,
            buffers: never_type,
            tables: TypeIds::type_ids(),
            functions: NormalizedFunctionType {
                is_top: false,
                parts: TypeIds::type_ids(),
            },
            tyvars: BTreeMap::new(),
            is_cacheable: true,
        };

        for &ty in intersections {
            let res = self.intersect_normal_with_ty(&mut norm, ty, seen_table_prop_pairs, seen_set);
            if res != NormalizationResult::True {
                return res;
            }
        }

        let res = self.union_normals(out_type, &norm, -1);
        if res != NormalizationResult::True {
            return res;
        }

        NormalizationResult::True
    }
}