rune 0.14.2

The Rune Language, an embeddable dynamic programming language for 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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

prelude!();

#[derive(Any)]
struct MyAny;

fn get_vm() -> crate::support::Result<crate::Vm> {
    use std::sync::Arc;

    let mut sources = crate::sources! {
        entry => {
            enum Enum {
                Variant(internal)
            }

            struct Tuple(internal);

            pub fn function(argument) {}
        }
    };

    let unit = crate::prepare(&mut sources).build()?;
    Ok(crate::Vm::without_runtime(Arc::new(unit)))
}

#[test]
fn references_allowed_for_function_calls() {
    let vm = get_vm().unwrap();
    let function = vm.lookup_function(["function"]).unwrap();

    let value_result = function.call::<crate::Value>((crate::Value::unit(),));
    assert!(value_result.is_ok());

    let mut mine = MyAny;

    let ref_result = function.call::<crate::Value>((&mine,));
    assert!(ref_result.is_ok());

    let mut_result = function.call::<crate::Value>((&mut mine,));
    assert!(mut_result.is_ok());

    let any_result = function.call::<crate::Value>((mine,));
    assert!(any_result.is_ok());
}

#[test]
fn references_disallowed_for_tuple_variant() {
    let vm = get_vm().unwrap();
    let constructor = vm.lookup_function(["Enum", "Variant"]).unwrap();

    let value_result = constructor.call::<crate::Value>((crate::Value::unit(),));
    assert!(value_result.is_ok());

    let mut mine = MyAny;

    let tuple = constructor.call::<DynamicTuple>((&mine,)).unwrap();
    assert!(tuple.first().unwrap().borrow_ref::<MyAny>().is_err());

    let tuple = constructor.call::<DynamicTuple>((&mut mine,)).unwrap();
    assert!(tuple.first().unwrap().borrow_ref::<MyAny>().is_err());

    let tuple = constructor.call::<DynamicTuple>((mine,)).unwrap();
    assert!(tuple.first().unwrap().borrow_ref::<MyAny>().is_ok());
}

#[test]
fn references_disallowed_for_tuple_struct() {
    let vm = get_vm().unwrap();
    let constructor = vm.lookup_function(["Tuple"]).unwrap();

    let value_result = constructor.call::<crate::Value>((crate::Value::unit(),));
    assert!(value_result.is_ok());

    let mut mine = MyAny;

    let st = constructor.call::<DynamicTuple>((&mine,)).unwrap();
    assert!(st.first().unwrap().borrow_ref::<MyAny>().is_err());

    let st = constructor.call::<DynamicTuple>((&mut mine,)).unwrap();
    assert!(st.first().unwrap().borrow_ref::<MyAny>().is_err());

    let st = constructor.call::<DynamicTuple>((mine,)).unwrap();
    assert!(st.first().unwrap().borrow_ref::<MyAny>().is_ok());
}