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

use crate::functions::get_type_pack::get_type_pack_id;
use crate::records::substitution::Substitution;
use crate::records::type_function_instance_type_pack::TypeFunctionInstanceTypePack;
use crate::records::type_pack::TypePack;
use crate::records::type_pack_var::TypePackVar;
use crate::records::variadic_type_pack::VariadicTypePack;
use crate::type_aliases::type_pack_id::TypePackId;

impl Substitution {
    pub fn clone_type_pack_id(&mut self, tp: TypePackId) -> TypePackId {
        let mut tp = unsafe { (*self.base.log).follow_type_pack_id(tp) };

        let ptp = unsafe { (*self.base.log).pending_type_pack_id(tp) };
        if !ptp.is_null() {
            tp = unsafe { &(*ptp).pending as *const TypePackVar };
        }

        let tpp = unsafe { get_type_pack_id::<TypePack>(tp) };
        if !tpp.is_null() {
            let tpp = unsafe { &*tpp };
            let clone = TypePack {
                head: tpp.head.clone(),
                tail: tpp.tail,
            };
            return self.add_type_pack(clone);
        }

        let vtp = unsafe { get_type_pack_id::<VariadicTypePack>(tp) };
        if !vtp.is_null() {
            let vtp = unsafe { &*vtp };
            let clone = VariadicTypePack {
                ty: vtp.ty,
                hidden: vtp.hidden,
            };
            return self.add_type_pack(clone);
        }

        let tfitp = unsafe { get_type_pack_id::<TypeFunctionInstanceTypePack>(tp) };
        if !tfitp.is_null() {
            let tfitp = unsafe { &*tfitp };
            let clone = TypeFunctionInstanceTypePack {
                function: tfitp.function,
                typeArguments: tfitp.typeArguments.clone(),
                packArguments: tfitp.packArguments.clone(),
            };
            return self.add_type_pack(clone);
        }

        self.add_type_pack(unsafe { (*tp).clone() })
    }
}