Boa 0.10.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

use crate::{forward, forward_val, value::same_value, Context};

/// Test the correct type is returned from call and construct
#[allow(clippy::unwrap_used)]
#[test]
fn construct_and_call() {
    let mut engine = Context::new();
    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 mut engine = Context::new();
    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.to_boolean(), true);
    assert_eq!(true_num.to_boolean(), true);
    assert_eq!(true_string.to_boolean(), true);
    assert_eq!(true_bool.to_boolean(), true);
}

#[test]
fn instances_have_correct_proto_set() {
    let mut engine = Context::new();
    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
            .as_object()
            .unwrap()
            .prototype_instance()
            .clone(),
        &bool_prototype
    ));
}