rustpython-jit 0.5.0

Experimental JIT(just in time) compiler for python code.
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

use rustpython_jit::{AbiValue, JitArgumentError};

// TODO currently broken
// #[test]
// fn test_no_return_value() {
//     let func = jit_function! { func() => r##"
//         def func():
//             pass
//     "## };
//
//     assert_eq!(func(), Ok(()));
// }

#[test]
fn test_invoke() {
    let func = jit_function! { func => r##"
        def func(a: int, b: float):
            return 1
    "## };

    assert_eq!(
        func.invoke(&[AbiValue::Int(1)]),
        Err(JitArgumentError::WrongNumberOfArguments)
    );
    assert_eq!(
        func.invoke(&[AbiValue::Int(1), AbiValue::Float(2.0), AbiValue::Int(0)]),
        Err(JitArgumentError::WrongNumberOfArguments)
    );
    assert_eq!(
        func.invoke(&[AbiValue::Int(1), AbiValue::Int(1)]),
        Err(JitArgumentError::ArgumentTypeMismatch)
    );
    assert_eq!(
        func.invoke(&[AbiValue::Int(1), AbiValue::Float(2.0)]),
        Ok(Some(AbiValue::Int(1)))
    );
}

#[test]
fn test_args_builder() {
    let func = jit_function! { func=> r##"
        def func(a: int, b: float):
            return 1
    "## };

    let mut args_builder = func.args_builder();
    assert_eq!(args_builder.set(0, AbiValue::Int(1)), Ok(()));
    assert!(args_builder.is_set(0));
    assert!(!args_builder.is_set(1));
    assert_eq!(
        args_builder.set(1, AbiValue::Int(1)),
        Err(JitArgumentError::ArgumentTypeMismatch)
    );
    assert!(args_builder.is_set(0));
    assert!(!args_builder.is_set(1));
    assert!(args_builder.into_args().is_none());

    let mut args_builder = func.args_builder();
    assert_eq!(args_builder.set(0, AbiValue::Int(1)), Ok(()));
    assert_eq!(args_builder.set(1, AbiValue::Float(1.0)), Ok(()));
    assert!(args_builder.is_set(0));
    assert!(args_builder.is_set(1));

    let args = args_builder.into_args();
    assert!(args.is_some());
    assert_eq!(args.unwrap().invoke(), Some(AbiValue::Int(1)));
}

#[test]
fn test_if_else() {
    let if_else = jit_function! { if_else(a:i64) -> i64 => r##"
        def if_else(a: int):
            if a:
                return 42
            else:
                return 0

            # Prevent type failure from implicit `return None`
            return 0
    "## };

    assert_eq!(if_else(0), Ok(0));
    assert_eq!(if_else(1), Ok(42));
    assert_eq!(if_else(-1), Ok(42));
    assert_eq!(if_else(100), Ok(42));
}

#[test]
fn test_while_loop() {
    let while_loop = jit_function! { while_loop(a:i64) -> i64 => r##"
        def while_loop(a: int):
            b = 0
            while a > 0:
                b += 1
                a -= 1
            return b
    "## };
    assert_eq!(while_loop(0), Ok(0));
    assert_eq!(while_loop(-1), Ok(0));
    assert_eq!(while_loop(1), Ok(1));
    assert_eq!(while_loop(10), Ok(10));
}

#[test]
fn test_unpack_tuple() {
    let unpack_tuple = jit_function! { unpack_tuple(a:i64, b:i64) -> i64 => r##"
        def unpack_tuple(a: int, b: int):
            a, b = b, a
            return a
    "## };

    assert_eq!(unpack_tuple(0, 1), Ok(1));
    assert_eq!(unpack_tuple(1, 2), Ok(2));
}

#[test]
fn test_recursive_fib() {
    let fib = jit_function! { fib(n: i64) -> i64 => r##"
        def fib(n: int) -> int:
          if n == 0 or n == 1:
            return 1
          return fib(n-1) + fib(n-2)
    "## };

    assert_eq!(fib(10), Ok(89));
}