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
117
118
119
120
121
122
123
124
125
126

//! P2-B B3+B4 smoke tests: IntoValue + TableBuilder + table_of + generic set_global.

use luna_core::runtime::Value;
use luna_core::version::LuaVersion;
use luna_core::vm::Vm;

fn sandbox(version: LuaVersion) -> Vm {
    Vm::sandbox(version).open_base().open_math().build()
}

#[test]
fn set_global_i64() {
    let mut vm = sandbox(LuaVersion::Lua55);
    vm.set_global("answer", 42_i64).unwrap();
    let r = vm.eval("return answer").unwrap();
    assert_eq!(r.len(), 1);
    assert!(matches!(r[0], Value::Int(42)));
}

#[test]
fn set_global_f64_str_bool_nil() {
    let mut vm = sandbox(LuaVersion::Lua55);
    vm.set_global("pi", 3.14_f64).unwrap();
    vm.set_global("name", "luna").unwrap();
    vm.set_global("flag", true).unwrap();
    vm.set_global("nothing", ()).unwrap();
    let r = vm
        .eval("return type(pi), type(name), type(flag), type(nothing)")
        .unwrap();
    assert_eq!(r.len(), 4);
    assert_eq!(r[0].try_as_str(), Some("number"));
    assert_eq!(r[1].try_as_str(), Some("string"));
    assert_eq!(r[2].try_as_str(), Some("boolean"));
    assert_eq!(r[3].try_as_str(), Some("nil"));
}

#[test]
fn set_global_value_identity_still_works() {
    let mut vm = sandbox(LuaVersion::Lua55);
    // Pre-B4 callers passing `Value::*` directly still compile.
    vm.set_global("seven", Value::Int(7)).unwrap();
    let r = vm.eval("return seven").unwrap();
    assert!(matches!(r[0], Value::Int(7)));
}

#[test]
fn set_global_option_none_is_nil() {
    let mut vm = sandbox(LuaVersion::Lua55);
    let none: Option<i64> = None;
    let some: Option<i64> = Some(5);
    vm.set_global("nothing", none).unwrap();
    vm.set_global("something", some).unwrap();
    let r = vm
        .eval("return type(nothing), type(something), something")
        .unwrap();
    assert_eq!(r.len(), 3);
    assert_eq!(r[0].try_as_str(), Some("nil"));
    assert_eq!(r[1].try_as_str(), Some("number"));
    assert!(matches!(r[2], Value::Int(5)));
}

#[test]
fn table_of_basic() {
    let mut vm = sandbox(LuaVersion::Lua55);
    let t = vm.table_of([("answer", 42_i64), ("year", 2026)]);
    vm.set_global("c", Value::Table(t)).unwrap();
    let r = vm.eval("return c.answer + c.year").unwrap();
    assert!(matches!(r[0], Value::Int(2068)));
}

#[test]
fn new_table_builder_chain() {
    let mut vm = sandbox(LuaVersion::Lua55);
    let t = vm
        .new_table()
        .with("name", "luna")
        .with("major", 1_i64)
        .with("minor", 1_i64)
        .build();
    vm.set_global("info", Value::Table(t)).unwrap();
    let r = vm
        .eval("return info.name, info.major + info.minor")
        .unwrap();
    assert_eq!(r.len(), 2);
    assert_eq!(r[0].try_as_str(), Some("luna"));
    assert!(matches!(r[1], Value::Int(2)));
}

#[test]
fn new_table_mixed_value_kinds() {
    let mut vm = sandbox(LuaVersion::Lua55);
    let t = vm
        .new_table()
        .with("int_key", 100_i64)
        .with("float_key", 3.5_f64)
        .with("bool_key", false)
        .with(1_i64, "first")
        .with(2_i64, "second")
        .build();
    vm.set_global("t", Value::Table(t)).unwrap();
    let r = vm
        .eval("return t.int_key, t.float_key, t.bool_key, t[1], t[2]")
        .unwrap();
    assert_eq!(r.len(), 5);
    assert!(matches!(r[0], Value::Int(100)));
    if let Value::Float(f) = r[1] {
        assert!((f - 3.5).abs() < 1e-9);
    } else {
        panic!("expected float, got {:?}", r[1]);
    }
    assert!(matches!(r[2], Value::Bool(false)));
    assert_eq!(r[3].try_as_str(), Some("first"));
    assert_eq!(r[4].try_as_str(), Some("second"));
}

#[test]
fn try_with_propagates_overflow() {
    // We can't actually trigger Overflow (MAX_ASIZE = 1<<27); this
    // test just verifies the signature compiles and a normal
    // try_with succeeds.
    let mut vm = sandbox(LuaVersion::Lua55);
    let t = vm.new_table().try_with("k", "v").unwrap().build();
    vm.set_global("t", Value::Table(t)).unwrap();
    let r = vm.eval("return t.k").unwrap();
    assert_eq!(r[0].try_as_str(), Some("v"));
}