sapphire-lang 0.8.0

Gradually typed scripting language where every value is an object and types are optional, checked at runtime
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

//! Direct bytecode / chunk tests (no lexer/parser/compiler).

use sapphire::chunk::{Chunk, Constant, Function, OpCode};
use sapphire::vm::{Vm, VmError, VmValue};
use std::path::PathBuf;
use std::rc::Rc;

fn run(chunk: Chunk) -> Result<Option<VmValue>, VmError> {
    let f = Rc::new(Function {
        name: String::new(),
        arity: 0,
        super_method_name: None,
        chunk,
        upvalue_defs: vec![],
        return_type: None,
    });
    Vm::new(f, PathBuf::new()).run()
}

fn chunk_with(ops: impl Fn(&mut Chunk)) -> Chunk {
    let mut c = Chunk::new();
    ops(&mut c);
    c
}

#[test]
fn bytecode_returns_constant() {
    let chunk = chunk_with(|c| {
        let i = c.add_constant(Constant::Int(42));
        c.write(OpCode::Constant(i), 1);
        c.write(OpCode::Return, 1);
    });
    assert_eq!(run(chunk).unwrap(), Some(VmValue::Int(42)));
}

#[test]
fn bytecode_addition_int() {
    let chunk = chunk_with(|c| {
        let a = c.add_constant(Constant::Int(10));
        let b = c.add_constant(Constant::Int(32));
        c.write(OpCode::Constant(a), 1);
        c.write(OpCode::Constant(b), 1);
        c.write(OpCode::Add, 1);
        c.write(OpCode::Return, 1);
    });
    assert_eq!(run(chunk).unwrap(), Some(VmValue::Int(42)));
}

#[test]
fn bytecode_addition_mixed() {
    let chunk = chunk_with(|c| {
        let a = c.add_constant(Constant::Int(1));
        let b = c.add_constant(Constant::Float(1.5));
        c.write(OpCode::Constant(a), 1);
        c.write(OpCode::Constant(b), 1);
        c.write(OpCode::Add, 1);
        c.write(OpCode::Return, 1);
    });
    assert_eq!(run(chunk).unwrap(), Some(VmValue::Float(2.5)));
}

#[test]
fn bytecode_negation() {
    let chunk = chunk_with(|c| {
        let i = c.add_constant(Constant::Int(7));
        c.write(OpCode::Constant(i), 1);
        c.write(OpCode::Negate, 1);
        c.write(OpCode::Return, 1);
    });
    assert_eq!(run(chunk).unwrap(), Some(VmValue::Int(-7)));
}

#[test]
fn bytecode_not_false_is_true() {
    let chunk = chunk_with(|c| {
        c.write(OpCode::False, 1);
        c.write(OpCode::Not, 1);
        c.write(OpCode::Return, 1);
    });
    assert_eq!(run(chunk).unwrap(), Some(VmValue::Bool(true)));
}

#[test]
fn bytecode_comparison_less() {
    let chunk = chunk_with(|c| {
        let a = c.add_constant(Constant::Int(3));
        let b = c.add_constant(Constant::Int(5));
        c.write(OpCode::Constant(a), 1);
        c.write(OpCode::Constant(b), 1);
        c.write(OpCode::Less, 1);
        c.write(OpCode::Return, 1);
    });
    assert_eq!(run(chunk).unwrap(), Some(VmValue::Bool(true)));
}

#[test]
fn bytecode_string_concat() {
    let chunk = chunk_with(|c| {
        let a = c.add_constant(Constant::Str("hello".into()));
        let b = c.add_constant(Constant::Str(" world".into()));
        c.write(OpCode::Constant(a), 1);
        c.write(OpCode::Constant(b), 1);
        c.write(OpCode::Add, 1);
        c.write(OpCode::Return, 1);
    });
    assert_eq!(
        run(chunk).unwrap(),
        Some(VmValue::Str("hello world".into()))
    );
}

#[test]
fn bytecode_type_error_on_bad_add() {
    let chunk = chunk_with(|c| {
        let a = c.add_constant(Constant::Int(1));
        c.write(OpCode::Constant(a), 1);
        c.write(OpCode::True, 1);
        c.write(OpCode::Add, 1);
        c.write(OpCode::Return, 1);
    });
    assert!(matches!(run(chunk), Err(VmError::TypeError { .. })));
}