ecma-runtime-cat 0.3.3

ECMAScript runtime: native built-ins (console, Math, JSON, parseInt, isNaN, Promise, Object, Array, ...) that the boa-cat engine exposes to scripts. v0.3.3 adds `Object.{keys, values, entries, assign}` and `Array.isArray` static methods. All four `Object` methods walk own data properties and skip the synthetic `length` slot when the source looks like an array; `Object.assign` also copies accessor pairs onto the target so getter/setter semantics survive the merge. `Array.isArray(value)` returns `true` when `value` is an object whose own data-property keys are numeric or `length`.
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

//! `Array` global static methods (v0.3.3): `isArray`.
//!
//! Detects the array shape this runtime represents (a
//! `Value::Object` whose own data-property keys are all numeric or
//! `length`, with `length` a non-negative number).  This mirrors
//! `JSON.stringify`'s `is_array_object` discriminator and the
//! existing array-literal evaluator's output shape.

use std::collections::BTreeMap;

use boa_cat::Value;
use boa_cat::fuel::Fuel;
use boa_cat::heap::Heap;
use boa_cat::outcome::{EvalResult, Outcome};
use boa_cat::value::Object;

use crate::coercion::first_arg;

/// Build the `Array` global and allocate it on the heap.
#[must_use]
pub fn build(heap: Heap) -> (Value, Heap) {
    let mut props = BTreeMap::new();
    let _ = props.insert("isArray".to_owned(), Value::Native(is_array_impl));
    let (id, heap) = heap.alloc_object(Object::from_properties(props));
    (Value::Object(id), heap)
}

/// `Array.isArray(value)` -- returns `true` when `value` is an
/// `Object` whose properties match the runtime's array shape
/// (numeric keys plus `length`), `false` otherwise.
#[allow(clippy::needless_pass_by_value, clippy::unnecessary_wraps)]
fn is_array_impl(args: Vec<Value>, _this: Value, heap: Heap, fuel: Fuel) -> EvalResult {
    let arg = first_arg(&args);
    let is_array = match arg {
        Value::Object(id) => heap.object(id).is_some_and(looks_like_array),
        Value::Undefined
        | Value::Null
        | Value::Boolean(_)
        | Value::Number(_)
        | Value::String(_)
        | Value::Function(_)
        | Value::Native(_)
        | Value::Promise(_) => false,
    };
    Ok((Outcome::Normal(Value::Boolean(is_array)), heap, fuel))
}

fn looks_like_array(obj: &Object) -> bool {
    obj.get("length")
        .is_some_and(|v| matches!(v, Value::Number(_)))
        && obj
            .properties()
            .keys()
            .all(|k| k == "length" || k.parse::<u32>().is_ok())
}