Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / src / engine / set_methods.lucb

#==============================================================================================
#
#   set_methods - The ES2025 Set methods: union, intersection, difference and the tests
#
#   DESCRIPTION:
#       Port of quickjs.c lines 52641-53199: GetSetRecord (get_set_record), a side-effect
#       free copy of a Set, and Set.prototype.isDisjointFrom, isSubsetOf, isSupersetOf,
#       intersection, difference, symmetricDifference and union. Each walks the smaller of
#       the two sets: this one through a Set iterator, or the other through its `keys()`
#       iterator. The `goto exception` / `fini` cleanup of the C functions frees values
#       that are assigned along the way; here those are `var`s released by
#       `defer js_free_value_at(ctx, &v)`, which reads the value when it runs.
#
#==============================================================================================

# mark: Set records =============================================================================

## GetSetRecord(obj): the size of the set-like `obj` and its `has` and `keys` methods. A
## Set's own record count is used as its size without reading `size`.
func get_set_record(ctx: Context*, obj: Value, psize: i64*, phas: Value*, pkeys: Value*) -> !:
    var size: i64 = 0
    if let raw = js_get_opaque(obj, (u32)ClassId.set):
        let s = (MapState*)raw
        size = (i64)s.record_count
    else:
        let v = try js_get_property(ctx, obj, atom_size)
        var d: f64 = 0.0
        try js_to_float64_free(ctx, &d, v)
        if d != d:  # isnan(d)
            try js_throw_type_error(ctx, ".size is not a number")
        if d < -9223372036854775808.0:
            size = -9223372036854775808
        elif d >= 9223372036854775808.0:
            # must use INT64_MAX + 1 because INT64_MAX cannot be exactly represented as a
            # double
            size = 9223372036854775807
        else:
            size = (i64)d
        if size < 0:
            try js_throw_range_error(ctx, ".size must be positive")

    let has = try js_get_property(ctx, obj, atom_has)
    errdefer js_free_value(ctx, has)
    if js_is_undefined(has):
        try js_throw_type_error(ctx, ".has is undefined")
    if not js_is_function(ctx, has):
        try js_throw_type_error(ctx, ".has is not a function")

    let keys = try js_get_property(ctx, obj, atom_keys)
    errdefer js_free_value(ctx, keys)
    if js_is_undefined(keys):
        try js_throw_type_error(ctx, ".keys is undefined")
    if not js_is_function(ctx, keys):
        try js_throw_type_error(ctx, ".keys is not a function")
    *psize = size
    *phas = has
    *pkeys = keys

## Call the set record's `has` on `obj` with `item` and convert the result with ToBoolean
## (the `rv = JS_Call(...); ok = JS_ToBoolFree(ctx, rv)` step).
func js_set_call_has(ctx: Context*, has: Value, obj: Value, item: Value) -> bool!:
    var arg = item
    let rv = try js_call(ctx, has, obj, 1, &arg)
    return try js_to_bool_free(ctx, rv)

## The Set of `this_val`; throws if it is not a Set.
func js_set_state_of(ctx: Context*, this_val: Value) -> MapState*!:
    let raw = try js_get_opaque2(ctx, this_val, (u32)ClassId.set)
    return (MapState*)raw

## The MapState of `set`, a Set this port created.
func js_new_set_state(set: Value) -> MapState*:
    let raw = js_get_opaque(set, (u32)ClassId.set) else trap("not a new Set")
    return (MapState*)raw

## A new empty Set (js_map_constructor with no argument).
func js_new_empty_set(ctx: Context*) -> Value!:
    var no_args = js_undefined()
    return try js_map_constructor(ctx, js_undefined(), 0, &no_args, magic_set)

## A copy of the Set `this_val` made without side effects (js_copy_set).
func js_copy_set(ctx: Context*, this_val: Value) -> Value!:
    let s = try js_set_state_of(ctx, this_val)
    let newset = try js_new_empty_set(ctx)
    errdefer js_free_value(ctx, newset)
    let t = js_new_set_state(newset)

    # can't clone this_val using js_map_constructor(), test262 mandates we don't call the
    # .add method
    var el = map_next_link(&s.records)
    while el != &s.records:
        let mr = map_record_of(el)
        if not mr.empty:
            _ = try set_add_record(ctx, t, mr.key)
        el = map_next_link(el)
    return newset

# mark: Tests ===================================================================================

## Set.prototype.isDisjointFrom(other) (js_set_isDisjointFrom).
func js_set_is_disjoint_from(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    var iter = js_undefined()
    var next = js_undefined()
    var has = js_undefined()
    var keys = js_undefined()
    let s = try js_set_state_of(ctx, this_val)
    defer js_free_value_at(ctx, &next)
    defer js_free_value_at(ctx, &iter)
    defer js_free_value_at(ctx, &keys)
    defer js_free_value_at(ctx, &has)
    var size: i64 = 0
    try get_set_record(ctx, argv[0], &size, &has, &keys)
    var no_args = js_undefined()
    var found = false
    if (i64)s.record_count <= size:
        iter = try js_create_map_iterator(ctx, this_val, 0, &no_args, magic_set)
        while not found:
            var done: i32 = 0
            let item = try js_map_iterator_next(ctx, iter, 0, &no_args, &done, magic_set)
            if done != 0:
                break  # item is JS_UNDEFINED
            let ok = js_set_call_has(ctx, has, argv[0], item) catch failure:
                js_free_value(ctx, item)
                error(failure.code, failure.message)
            js_free_value(ctx, item)
            found = ok
    else:
        iter = try js_call(ctx, keys, argv[0], 0, &no_args)
        next = try js_get_property(ctx, iter, atom_next)
        while true:
            var done = false
            var item = try js_iterator_next(ctx, iter, next, 0, &no_args, &done)
            if done:
                break  # item is JS_UNDEFINED
            item = map_normalize_key(ctx, item)
            found = map_find_record(ctx, s, item) != none
            js_free_value(ctx, item)
            if found:
                # as upstream, a failure to close the iterator is not reported
                js_iterator_close(ctx, iter, false) catch: recover ()
                break
    return js_new_bool(not found)

## Set.prototype.isSubsetOf(other) (js_set_isSubsetOf).
func js_set_is_subset_of(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    var iter = js_undefined()
    var next = js_undefined()
    var has = js_undefined()
    var keys = js_undefined()
    let s = try js_set_state_of(ctx, this_val)
    defer js_free_value_at(ctx, &next)
    defer js_free_value_at(ctx, &iter)
    defer js_free_value_at(ctx, &keys)
    defer js_free_value_at(ctx, &has)
    var size: i64 = 0
    try get_set_record(ctx, argv[0], &size, &has, &keys)
    var found = false
    if (i64)s.record_count <= size:
        var no_args = js_undefined()
        iter = try js_create_map_iterator(ctx, this_val, 0, &no_args, magic_set)
        found = true
        while found:
            var done: i32 = 0
            let item = try js_map_iterator_next(ctx, iter, 0, &no_args, &done, magic_set)
            if done != 0:
                break  # item is JS_UNDEFINED
            let ok = js_set_call_has(ctx, has, argv[0], item) catch failure:
                js_free_value(ctx, item)
                error(failure.code, failure.message)
            js_free_value(ctx, item)
            found = ok
    return js_new_bool(found)

## Set.prototype.isSupersetOf(other) (js_set_isSupersetOf).
func js_set_is_superset_of(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    var iter = js_undefined()
    var next = js_undefined()
    var has = js_undefined()
    var keys = js_undefined()
    let s = try js_set_state_of(ctx, this_val)
    defer js_free_value_at(ctx, &next)
    defer js_free_value_at(ctx, &iter)
    defer js_free_value_at(ctx, &keys)
    defer js_free_value_at(ctx, &has)
    var size: i64 = 0
    try get_set_record(ctx, argv[0], &size, &has, &keys)
    var found = false
    if (i64)s.record_count >= size:
        var no_args = js_undefined()
        iter = try js_call(ctx, keys, argv[0], 0, &no_args)
        next = try js_get_property(ctx, iter, atom_next)
        found = true
        while true:
            var done = false
            var item = try js_iterator_next(ctx, iter, next, 0, &no_args, &done)
            if done:
                break  # item is JS_UNDEFINED
            item = map_normalize_key(ctx, item)
            found = map_find_record(ctx, s, item) != none
            js_free_value(ctx, item)
            if not found:
                # as upstream, a failure to close the iterator is not reported
                js_iterator_close(ctx, iter, false) catch: recover ()
                break
    return js_new_bool(found)

# mark: New sets ================================================================================

## Add `item` (owned, normalized) to the new set `t` unless it is there already.
func js_set_add_new(ctx: Context*, t: MapState*, item: Value) -> !:
    defer js_free_value(ctx, item)
    if map_find_record(ctx, t, item) == none:  # no duplicates
        _ = try set_add_record(ctx, t, item)

## Set.prototype.intersection(other) (js_set_intersection).
func js_set_intersection(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    var iter = js_undefined()
    var next = js_undefined()
    var has = js_undefined()
    var keys = js_undefined()
    var newset = js_undefined()
    let s = try js_set_state_of(ctx, this_val)
    defer js_free_value_at(ctx, &next)
    defer js_free_value_at(ctx, &iter)
    defer js_free_value_at(ctx, &keys)
    defer js_free_value_at(ctx, &has)
    errdefer js_free_value_at(ctx, &newset)
    var size: i64 = 0
    try get_set_record(ctx, argv[0], &size, &has, &keys)
    var no_args = js_undefined()
    if (i64)s.record_count > size:
        iter = try js_call(ctx, keys, argv[0], 0, &no_args)
        next = try js_get_property(ctx, iter, atom_next)
        newset = try js_new_empty_set(ctx)
        let t = js_new_set_state(newset)
        while true:
            var done = false
            var item = try js_iterator_next(ctx, iter, next, 0, &no_args, &done)
            if done:
                break  # item is JS_UNDEFINED
            item = map_normalize_key(ctx, item)
            if map_find_record(ctx, s, item) == none:
                js_free_value(ctx, item)
            else:
                try js_set_add_new(ctx, t, item)
    else:
        iter = try js_create_map_iterator(ctx, this_val, 0, &no_args, magic_set)
        newset = try js_new_empty_set(ctx)
        let t = js_new_set_state(newset)
        while true:
            var done: i32 = 0
            let item = try js_map_iterator_next(ctx, iter, 0, &no_args, &done, magic_set)
            if done != 0:
                break  # item is JS_UNDEFINED
            let ok = js_set_call_has(ctx, has, argv[0], item) catch failure:
                js_free_value(ctx, item)
                error(failure.code, failure.message)
            if ok:
                try js_set_add_new(ctx, t, map_normalize_key(ctx, item))
            else:
                js_free_value(ctx, item)
    return newset

## Set.prototype.difference(other) (js_set_difference).
func js_set_difference(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    var iter = js_undefined()
    var next = js_undefined()
    var has = js_undefined()
    var keys = js_undefined()
    let s = try js_set_state_of(ctx, this_val)
    defer js_free_value_at(ctx, &next)
    defer js_free_value_at(ctx, &iter)
    defer js_free_value_at(ctx, &keys)
    defer js_free_value_at(ctx, &has)
    var size: i64 = 0
    try get_set_record(ctx, argv[0], &size, &has, &keys)

    let newset = try js_copy_set(ctx, this_val)
    errdefer js_free_value(ctx, newset)
    let t = js_new_set_state(newset)

    var no_args = js_undefined()
    if (i64)s.record_count <= size:
        iter = try js_create_map_iterator(ctx, newset, 0, &no_args, magic_set)
        while true:
            var done: i32 = 0
            let item = try js_map_iterator_next(ctx, iter, 0, &no_args, &done, magic_set)
            if done != 0:
                break  # item is JS_UNDEFINED
            let ok = js_set_call_has(ctx, has, argv[0], item) catch failure:
                js_free_value(ctx, item)
                error(failure.code, failure.message)
            if ok:
                _ = map_delete_record(ctx, t, item)
            js_free_value(ctx, item)
    else:
        iter = try js_call(ctx, keys, argv[0], 0, &no_args)
        next = try js_get_property(ctx, iter, atom_next)
        while true:
            var done = false
            let item = try js_iterator_next(ctx, iter, next, 0, &no_args, &done)
            if done:
                break  # item is JS_UNDEFINED
            _ = map_delete_record(ctx, t, item)
            js_free_value(ctx, item)
    return newset

## Set.prototype.symmetricDifference(other) (js_set_symmetricDifference).
func js_set_symmetric_difference(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let s = try js_set_state_of(ctx, this_val)
    var has = js_undefined()
    var keys = js_undefined()
    var size: i64 = 0
    try get_set_record(ctx, argv[0], &size, &has, &keys)
    js_free_value(ctx, has)
    defer js_free_value(ctx, keys)

    var no_args = js_undefined()
    let iter = try js_call(ctx, keys, argv[0], 0, &no_args)
    defer js_free_value(ctx, iter)
    let next = try js_get_property(ctx, iter, atom_next)
    defer js_free_value(ctx, next)
    let newset = try js_copy_set(ctx, this_val)
    errdefer js_free_value(ctx, newset)
    let t = js_new_set_state(newset)
    while true:
        var done = false
        var item = try js_iterator_next(ctx, iter, next, 0, &no_args, &done)
        if done:
            break  # item is JS_UNDEFINED
        # note the subtlety here: due to mutating iterators, it's possible for keys to
        # disappear during iteration; test262 still expects us to maintain insertion order
        # though, so we first check |this|, then |new|; |new| is a copy of |this|
        # - if item exists in |this|, delete (if it exists) from |new|
        # - if item misses in |this| and |new|, add to |new|
        # - if item exists in |new| but misses in |this|, *don't* add it, mutating iterator
        #   erased it
        item = map_normalize_key(ctx, item)
        let present = map_find_record(ctx, s, item) != none
        let mr = map_find_record(ctx, t, item)
        if present:
            _ = map_delete_record(ctx, t, item)
            js_free_value(ctx, item)
        elif mr != none:
            js_free_value(ctx, item)
        else:
            let added = set_add_record(ctx, t, item) catch failure:
                js_free_value(ctx, item)
                error(failure.code, failure.message)
            _ = added
            js_free_value(ctx, item)
    return newset

## Set.prototype.union(other) (js_set_union).
func js_set_union(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    _ = try js_set_state_of(ctx, this_val)
    var has = js_undefined()
    var keys = js_undefined()
    var size: i64 = 0
    try get_set_record(ctx, argv[0], &size, &has, &keys)
    js_free_value(ctx, has)
    defer js_free_value(ctx, keys)

    var no_args = js_undefined()
    let iter = try js_call(ctx, keys, argv[0], 0, &no_args)
    defer js_free_value(ctx, iter)
    let next = try js_get_property(ctx, iter, atom_next)
    defer js_free_value(ctx, next)

    let newset = try js_copy_set(ctx, this_val)
    errdefer js_free_value(ctx, newset)

    while true:
        var done = false
        var item = try js_iterator_next(ctx, iter, next, 0, &no_args, &done)
        if done:
            break  # item is JS_UNDEFINED
        let rv = js_map_set(ctx, newset, 1, &item, magic_set) catch failure:
            js_free_value(ctx, item)
            error(failure.code, failure.message)
        js_free_value(ctx, item)
        js_free_value(ctx, rv)
    return newset