Boa 0.9.0

Boa is a Javascript lexer, parser and Just-in-Time compiler written in Rust. Currently, it has support for some of the language.
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

use super::*;
use crate::{builtins::value::same_value, exec::Interpreter, forward, forward_val, realm::Realm};

#[test]
fn check_boolean_constructor_is_function() {
    let global = Value::new_object(None);
    let boolean_constructor = Boolean::create(&global);
    assert_eq!(boolean_constructor.is_function(), true);
}

/// Test the correct type is returned from call and construct
#[allow(clippy::result_unwrap_used)]
#[test]
fn construct_and_call() {
    let realm = Realm::create();
    let mut engine = Interpreter::new(realm);
    let init = r#"
        var one = new Boolean(1);
        var zero = Boolean(0);
        "#;
    eprintln!("{}", forward(&mut engine, init));
    let one = forward_val(&mut engine, "one").unwrap();
    let zero = forward_val(&mut engine, "zero").unwrap();

    assert_eq!(one.is_object(), true);
    assert_eq!(zero.is_boolean(), true);
}

#[test]
fn constructor_gives_true_instance() {
    let realm = Realm::create();
    let mut engine = Interpreter::new(realm);
    let init = r#"
        var trueVal = new Boolean(true);
        var trueNum = new Boolean(1);
        var trueString = new Boolean("true");
        var trueBool = new Boolean(trueVal);
        "#;

    eprintln!("{}", forward(&mut engine, init));
    let true_val = forward_val(&mut engine, "trueVal").expect("value expected");
    let true_num = forward_val(&mut engine, "trueNum").expect("value expected");
    let true_string = forward_val(&mut engine, "trueString").expect("value expected");
    let true_bool = forward_val(&mut engine, "trueBool").expect("value expected");

    // Values should all be objects
    assert_eq!(true_val.is_object(), true);
    assert_eq!(true_num.is_object(), true);
    assert_eq!(true_string.is_object(), true);
    assert_eq!(true_bool.is_object(), true);

    // Values should all be truthy
    assert_eq!(true_val.is_true(), true);
    assert_eq!(true_num.is_true(), true);
    assert_eq!(true_string.is_true(), true);
    assert_eq!(true_bool.is_true(), true);
}

#[test]
fn instances_have_correct_proto_set() {
    let realm = Realm::create();
    let mut engine = Interpreter::new(realm);
    let init = r#"
        var boolInstance = new Boolean(true);
        var boolProto = Boolean.prototype;
        "#;

    eprintln!("{}", forward(&mut engine, init));
    let bool_instance = forward_val(&mut engine, "boolInstance").expect("value expected");
    let bool_prototype = forward_val(&mut engine, "boolProto").expect("value expected");

    assert!(same_value(
        &bool_instance.get_internal_slot("__proto__"),
        &bool_prototype
    ));
}