luau-syntax 0.732.0

Luau lexer, parser, AST, CST, and source utilities
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::cell::UnsafeCell;
use std::marker::PhantomData;
use std::ops::Index;
use std::slice;

pub(super) struct ScratchVec<T> {
    storage: Box<UnsafeCell<Vec<T>>>,
}

impl<T> Default for ScratchVec<T> {
    fn default() -> Self {
        Self {
            storage: Box::new(UnsafeCell::new(Vec::new())),
        }
    }
}

impl<T> ScratchVec<T> {
    pub(super) fn reserve(&mut self, additional: usize) {
        unsafe {
            (*self.storage.get()).reserve(additional);
        }
    }

    fn as_ptr(&self) -> *mut Vec<T> {
        self.storage.get()
    }
}

pub(super) struct TempVector<T> {
    storage: *mut Vec<T>,
    offset: usize,
    size: usize,
    _marker: PhantomData<*mut Vec<T>>,
}

impl<T> TempVector<T> {
    pub(super) fn new(storage: &ScratchVec<T>) -> Self {
        let storage = storage.as_ptr();
        Self {
            storage,
            offset: unsafe { (*storage).len() },
            size: 0,
            _marker: PhantomData,
        }
    }

    pub(super) fn nested(&mut self) -> Self {
        // TempVector mirrors Luau's parser scratch arrays: nested users may append
        // only at the current end, and drops must unwind in stack order.  UnsafeCell
        // keeps that source-shaped storage model without creating overlapping Rust
        // `&mut Vec<T>` borrows while a parent TempVector is still alive.
        let storage = self.storage;
        let offset = self.storage().len();
        Self {
            storage,
            offset,
            size: 0,
            _marker: PhantomData,
        }
    }

    pub(super) fn push_back(&mut self, item: T) {
        debug_assert!(self.storage().len() == self.offset + self.size);
        self.storage_mut().push(item);
        self.size += 1;
    }

    pub(super) fn len(&self) -> usize {
        self.size
    }

    pub(super) fn as_slice(&self) -> &[T] {
        let storage = self.storage();
        &storage[self.offset..self.offset + self.size]
    }

    pub(super) fn as_mut_slice(&mut self) -> &mut [T] {
        let offset = self.offset;
        let size = self.size;
        &mut self.storage_mut()[offset..offset + size]
    }

    pub(super) fn iter(&self) -> slice::Iter<'_, T> {
        self.as_slice().iter()
    }

    fn storage(&self) -> &Vec<T> {
        unsafe { &*self.storage }
    }

    fn storage_mut(&mut self) -> &mut Vec<T> {
        unsafe { &mut *self.storage }
    }
}

impl<T> Drop for TempVector<T> {
    fn drop(&mut self) {
        let offset = self.offset;
        let size = self.size;
        let storage = self.storage_mut();
        debug_assert!(storage.len() == offset + size);
        storage.truncate(offset);
    }
}

impl<T> Index<usize> for TempVector<T> {
    type Output = T;

    fn index(&self, index: usize) -> &Self::Output {
        &self.as_slice()[index]
    }
}