luna-core 1.1.0

Pure-Rust Lua runtime (interpreter only, zero third-party dependencies). The JIT-equipped variant lives in the `luna` crate.
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
114
115
116

//! B11 smoke tests: Rust-side debug hook.

use luna_core::runtime::Value;
use luna_core::version::LuaVersion;
use luna_core::vm::Vm;
use luna_core::vm::exec::{
    HOOK_MASK_CALL, HOOK_MASK_COUNT, HOOK_MASK_LINE, HOOK_MASK_RETURN, RustHookEvent,
};
use std::cell::RefCell;

thread_local! {
    static EVENTS: RefCell<Vec<RustHookEvent>> = const { RefCell::new(Vec::new()) };
}

fn record_hook(_vm: &mut Vm, event: RustHookEvent) {
    EVENTS.with(|e| e.borrow_mut().push(event));
}

fn fresh() -> Vm {
    EVENTS.with(|e| e.borrow_mut().clear());
    Vm::sandbox(LuaVersion::Lua55).open_base().build()
}

#[test]
fn call_hook_fires_on_function_entry() {
    let mut vm = fresh();
    vm.set_rust_debug_hook(Some(record_hook), HOOK_MASK_CALL, 0);
    let _ = vm
        .eval("local function f() return 1 end; f(); f(); f()")
        .unwrap();
    let calls = EVENTS.with(|e| {
        e.borrow()
            .iter()
            .filter(|ev| matches!(ev, RustHookEvent::Call))
            .count()
    });
    // Each f() call fires Call; we called 3 times.
    assert!(calls >= 3, "expected ≥3 Call events, got {calls}");
}

#[test]
fn return_hook_fires_on_function_return() {
    let mut vm = fresh();
    vm.set_rust_debug_hook(Some(record_hook), HOOK_MASK_RETURN, 0);
    let _ = vm
        .eval("local function f() return 1 end; f(); f()")
        .unwrap();
    let rets = EVENTS.with(|e| {
        e.borrow()
            .iter()
            .filter(|ev| matches!(ev, RustHookEvent::Return | RustHookEvent::TailCall))
            .count()
    });
    assert!(rets >= 2, "expected ≥2 Return events, got {rets}");
}

#[test]
fn count_hook_fires_at_instruction_interval() {
    let mut vm = fresh();
    // Fire every 100 instructions.
    vm.set_rust_debug_hook(Some(record_hook), HOOK_MASK_COUNT, 100);
    let _ = vm.eval("local s = 0; for i = 1, 500 do s = s + i end").unwrap();
    let counts = EVENTS.with(|e| {
        e.borrow()
            .iter()
            .filter(|ev| matches!(ev, RustHookEvent::Count))
            .count()
    });
    // 500-iter loop dispatches many opcodes; at granularity 100 we
    // expect multiple count events.
    assert!(counts >= 2, "expected ≥2 Count events, got {counts}");
}

#[test]
fn line_hook_fires_on_source_line_change() {
    let mut vm = fresh();
    vm.set_rust_debug_hook(Some(record_hook), HOOK_MASK_LINE, 0);
    let _ = vm.eval("local a = 1\nlocal b = 2\nlocal c = a + b").unwrap();
    let lines: Vec<u32> = EVENTS.with(|e| {
        e.borrow()
            .iter()
            .filter_map(|ev| match ev {
                RustHookEvent::Line(n) => Some(*n),
                _ => None,
            })
            .collect()
    });
    // 3-line source dispatches a Line event per line change.
    assert!(
        lines.len() >= 2,
        "expected ≥2 Line events, got {lines:?}"
    );
}

#[test]
fn clear_rust_debug_hook_stops_events() {
    let mut vm = fresh();
    vm.set_rust_debug_hook(Some(record_hook), HOOK_MASK_CALL, 0);
    let _ = vm.eval("local function f() return 1 end; f()").unwrap();
    let before = EVENTS.with(|e| e.borrow().len());
    EVENTS.with(|e| e.borrow_mut().clear());
    vm.clear_rust_debug_hook();
    let _ = vm.eval("local function g() return 2 end; g()").unwrap();
    let after = EVENTS.with(|e| e.borrow().len());
    assert!(before > 0);
    assert_eq!(after, 0, "events should not fire after clear_rust_debug_hook");
}

#[test]
fn rust_hook_does_not_interfere_with_eval_result() {
    let mut vm = fresh();
    vm.set_rust_debug_hook(Some(record_hook), HOOK_MASK_CALL | HOOK_MASK_RETURN, 0);
    let r = vm.eval("return 1 + 2").unwrap();
    assert_eq!(r.len(), 1);
    assert!(matches!(r[0], Value::Int(3)));
}