luaur-common 0.1.3

Foundational data structures and flags for the luaur Luau-in-Rust toolchain.
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

//! Node: `cxx:Record:Luau.Common:Common/src/TimeTrace.cpp:92:global_context`
//! Source: `Common/src/TimeTrace.cpp:92-110` (hand-ported)
//!
//! C++ `struct GlobalContext` holds a `std::mutex` guarding the mutable trace
//! state (`threads`, `nextThreadId`, `tokens`, `traceFile`). The Rust port keeps
//! that state behind a `std::sync::Mutex` so the singleton is safely shareable
//! through `Arc`, exactly as the C++ `std::scoped_lock(context.mutex)` does.

extern crate alloc;

use crate::records::thread_context::ThreadContext;
use crate::records::token::Token;
use alloc::vec::Vec;
use std::sync::Mutex;

/// `std::vector<ThreadContext*>`. The raw pointers reference thread-owned
/// `ThreadContext`s exactly as the C++ vector does; wrapped so `Send` holds
/// for the `Mutex`-guarded state.
#[derive(Debug, Default)]
pub(crate) struct ThreadPtr(pub(crate) *mut ThreadContext);

// Safety: mirrors the C++ `GlobalContext`, where the same `ThreadContext*`
// pointers are shared across threads under the protection of `context.mutex`.
unsafe impl Send for ThreadPtr {}

#[derive(Debug, Default)]
pub(crate) struct GlobalContextState {
    pub(crate) threads: Vec<ThreadPtr>,
    pub(crate) next_thread_id: u32,
    pub(crate) tokens: Vec<Token>,
    pub(crate) trace_file: Option<std::fs::File>,
}

#[derive(Debug)]
pub struct GlobalContext {
    pub(crate) state: Mutex<GlobalContextState>,
}