luaur-analysis 0.1.1

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

//! Source: `Analysis/include/Luau/TypePath.h:139` + `Analysis/src/TypePath.cpp:72-122` (hand-ported)
use crate::type_aliases::component::Component;
use alloc::vec::Vec;

#[derive(Debug, Clone, Default, PartialEq)]
pub struct Path {
    pub components: Vec<Component>,
}

impl Path {
    /// C++ `explicit Path(Component component)` — single-component path
    pub fn from_component(component: Component) -> Path {
        Path {
            components: alloc::vec![component],
        }
    }

    /// C++ `explicit Path(std::vector<Component> components)`
    pub fn from_components(components: Vec<Component>) -> Path {
        Path { components }
    }

    pub fn append(&self, suffix: &Path) -> Path {
        let mut joined = self.components.clone();
        joined.reserve(suffix.components.len());
        joined.extend(suffix.components.iter().cloned());
        Path { components: joined }
    }

    pub fn push(&self, component: Component) -> Path {
        let mut joined = self.components.clone();
        joined.push(component);
        Path { components: joined }
    }

    pub fn push_front(&self, component: Component) -> Path {
        let mut joined = Vec::with_capacity(self.components.len() + 1);
        joined.push(component);
        joined.extend(self.components.iter().cloned());
        Path { components: joined }
    }

    pub fn pop(&self) -> Path {
        if self.path_empty() {
            return Path::default(); // kEmpty
        }
        let mut popped = self.components.clone();
        popped.pop();
        Path { components: popped }
    }

    pub fn last(&self) -> Option<Component> {
        self.components.last().cloned()
    }

    // C++ Path::empty; `empty` collides with nothing but keep the pinned name
    pub fn path_empty(&self) -> bool {
        self.components.is_empty()
    }

    pub fn operator_eq(&self, other: &Path) -> bool {
        self.components == other.components
    }
}