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
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

prelude!();

use VmErrorKind::*;

macro_rules! op_tests {
    ($ty:ty, ! $lhs:literal = $out:expr) => {
        op_tests!(@unary $ty, !, $lhs, $out);
    };

    ($ty:ty, $lhs:literal $op:tt $rhs:literal = $out:expr) => {
        op_tests!(@binary $ty, $lhs, $op, $rhs, $out);
    };

    (@binary $ty:ty, $lhs:literal, $op:tt, $rhs:literal, $out:expr) => {
        let out: $ty = rune!(let a = $lhs; let b = $rhs; a $op b);
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = {lhs}; let b = {rhs}; a {op}= b; a"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"struct Foo {{ padding, field }}; let a = Foo{{ padding: 0, field: {lhs} }}; let b = {rhs}; a.field {op}= b; a.field"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"enum Enum {{ Foo {{ padding, field }} }}; let a = Enum::Foo {{ padding: 0, field: {lhs} }}; let b = {rhs}; a.field {op}= b; a.field"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = #{{ padding: 0, field: {lhs} }}; let b = {rhs}; a.field {op}= b; a.field"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = (0, {lhs}); let b = {rhs}; a.1 {op}= b; a.1"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"struct Foo(padding, a); let a = Foo(0, {lhs}); let b = {rhs}; a.1 {op}= b; a.1"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"enum Enum {{ Foo(padding, a) }}; let a = Enum::Foo(0, {lhs}); let b = {rhs}; a.1 {op}= b; a.1"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = Ok({lhs}); let b = {rhs}; a.0 {op}= b; a.0"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = Some({lhs}); let b = {rhs}; a.0 {op}= b; a.0"#,
            lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);
    };

    (@unary $ty:ty, $op:tt, $lhs:literal, $out:expr) => {
        let out: $ty = rune!(let a = $lhs; $op a);
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = {lhs}; {op} a"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"struct Foo {{ padding, field }}; let a = Foo{{ padding: 0, field: {lhs} }}; {op} a.field"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"enum Enum {{ Foo {{ padding, field }} }}; let a = Enum::Foo {{ padding: 0, field: {lhs} }}; {op} a.field"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = #{{ padding: 0, field: {lhs} }}; {op} a.field"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = (0, {lhs}); {op} a.1"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"struct Foo(padding, a); let a = Foo(0, {lhs}); {op} a.1"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"enum Enum {{ Foo(padding, a) }}; let a = Enum::Foo(0, {lhs}); {op} a.1"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = Ok({lhs}); {op} a.0"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);

        let out: $ty = eval(&format!(
            r#"let a = Some({lhs}); {op} a.0"#,
            lhs = stringify!($lhs), op = stringify!($op),
        ));
        assert_eq!(out, $out);
    };
}

macro_rules! error_test {
    ($lhs:literal $op:tt $rhs:literal = $error:ident) => {
        assert_vm_error!(
            &format!(
                r#"let a = {lhs}; let b = {rhs}; a {op} b;"#,
                lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
            ),
            $error => {}
        );

        assert_vm_error!(
            &format!(
                r#"let a = {lhs}; let b = {rhs}; a {op}= b;"#,
                lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
            ),
            $error => {}
        );

        assert_vm_error!(
            &format!(
                r#"let a = #{{ padding: 0, field: {lhs} }}; let b = {rhs}; a.field {op}= b;"#,
                lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
            ),
            $error => {}
        );

        assert_vm_error!(
            &format!(
                r#"let a = (0, {lhs}); let b = {rhs}; a.1 {op}= b;"#,
                lhs = stringify!($lhs), rhs = stringify!($rhs), op = stringify!($op),
            ),
            $error => {}
        );
    }
}

#[test]
fn i64() {
    op_tests!(i64, 10 + 2 = 12);
    op_tests!(i64, 10 - 2 = 8);
    op_tests!(i64, 10 * 2 = 20);
    op_tests!(i64, 10 / 2 = 5);
    op_tests!(i64, 10 % 3 = 1);
    op_tests!(i64, 0b1100 & 0b0110 = 0b1100 & 0b0110);
    op_tests!(i64, 0b1100 ^ 0b0110 = 0b1100 ^ 0b0110);
    op_tests!(i64, 0b1100 | 0b0110 = 0b1100 | 0b0110);
    op_tests!(i64, 0b1100 << 2 = 0b1100 << 2);
    op_tests!(i64, 0b1100 >> 2 = 0b1100 >> 2);
    op_tests!(i64, !0b10100i64 = !0b10100i64);

    error_test!(9223372036854775807i64 + 2 = Overflow);
    error_test!(-9223372036854775808i64 - 2 = Underflow);
    error_test!(9223372036854775807i64 * 2 = Overflow);
    error_test!(10 / 0 = DivideByZero);
    error_test!(10 % 0 = DivideByZero);
    error_test!(0b1 << 64 = Overflow);
    error_test!(0b1 >> 64 = Underflow);
}

#[test]
fn u64() {
    op_tests!(u64, 0b1100 & 0b0110 = 0b1100 & 0b0110);
    op_tests!(u64, 0b1100 ^ 0b0110 = 0b1100 ^ 0b0110);
    op_tests!(u64, 0b1100 | 0b0110 = 0b1100 | 0b0110);
    op_tests!(u64, 0b1100 << 2 = 0b1100 << 2);
    op_tests!(u64, 0b1100 >> 2 = 0b1100 >> 2);
    op_tests!(u64, !0b10100u64 = !0b10100u64);

    error_test!(0b1 << 64 = Overflow);
    error_test!(0b1 >> 64 = Underflow);
}

#[test]
fn u8() {
    op_tests!(u8, 0b1100u8 & 0b0110u8 = 0b1100u8 & 0b0110u8);
    op_tests!(u8, 0b1100u8 ^ 0b0110u8 = 0b1100u8 ^ 0b0110u8);
    op_tests!(u8, 0b1100u8 | 0b0110u8 = 0b1100u8 | 0b0110u8);
    op_tests!(u8, 0b1100u8 << 2 = 0b1100u8 << 2);
    op_tests!(u8, 0b1100u8 >> 2 = 0b1100u8 >> 2);
    op_tests!(u64, !0b10100u8 = !0b10100u64);
}

#[test]
fn i8() {
    op_tests!(i8, 0b1100i8 & 0b0110i8 = 0b1100i8 & 0b0110i8);
    op_tests!(i8, 0b1100i8 ^ 0b0110i8 = 0b1100i8 ^ 0b0110i8);
    op_tests!(i8, 0b1100i8 | 0b0110i8 = 0b1100i8 | 0b0110i8);
    op_tests!(i8, 0b1100i8 << 2 = 0b1100i8 << 2);
    op_tests!(i8, 0b1100i8 >> 2 = 0b1100i8 >> 2);
    op_tests!(i64, !0b10100i8 = !0b10100i64);
}