Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.0

0.6.0 / src / engine / promise_statics.lucb

#==============================================================================================
#
#   promise_statics - The static methods of Promise: resolve, reject, withResolvers,
#                     try, all, allSettled, any and race
#
#   DESCRIPTION:
#       Port of quickjs.c lines 53786-54189. Promise.all and its kin keep their shared
#       state in function data: the values array, and a one-element array holding the
#       remaining elements count. C's `done:` cleanup of the iteration locals becomes a
#       PromiseIterLocals record freed by a `defer`, and the `fail_reject:` path (reject
#       the result promise with the pending exception) wraps the iteration in a helper.
#
#==============================================================================================

# mark: resolve, reject, withResolvers, try =====================================================

## Promise.resolve (magic 0) and Promise.reject (magic 1).
func js_promise_resolve(ctx: Context*, this_val: Value, argc: i32, argv: Value*, magic: i32) -> Value!:
    let is_reject = magic != 0

    if not js_is_object(this_val):
        try js_throw_type_error_not_an_object(ctx)
    if not is_reject and js_get_opaque(argv[0], (u32)ClassId.promise) != none:
        let ctor = try js_get_property(ctx, argv[0], atom_constructor)
        let is_same = js_same_value(ctx, ctor, this_val)
        js_free_value(ctx, ctor)
        if is_same:
            return js_dup_value(ctx, argv[0])
    var resolving_funcs: Value[2] = ---
    let result_promise = try js_new_promise_capability_internal(ctx, &resolving_funcs[0], this_val)
    defer js_free_value(ctx, resolving_funcs[0])
    defer js_free_value(ctx, resolving_funcs[1])
    errdefer js_free_value(ctx, result_promise)
    let ret = try js_call(ctx, resolving_funcs[(usize)magic], js_undefined(), 1, argv)
    js_free_value(ctx, ret)
    return result_promise

## Promise.withResolvers.
func js_promise_with_resolvers(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    if not js_is_object(this_val):
        try js_throw_type_error_not_an_object(ctx)
    var resolving_funcs: Value[2] = ---
    let result_promise = try js_new_promise_capability_internal(ctx, &resolving_funcs[0], this_val)
    # The three values are moved into the result object one at a time; on a failure the
    # ones not moved yet are freed (C's `exception:` label).
    let owned: Value[3] = [result_promise, resolving_funcs[0], resolving_funcs[1]]
    let names: Atom[3] = [atom_promise, atom_resolve, atom_reject]
    let obj = js_new_object(ctx) catch failure:
        for v in owned:
            js_free_value(ctx, v)
        error(failure.code, failure.message)
    for i: usize in 0..<3:
        let defined = js_define_property_value(ctx, obj, names[i], owned[i], prop_c_w_e) catch failure:
            for j in i + 1..<3:
                js_free_value(ctx, owned[j])
            js_free_value(ctx, obj)
            error(failure.code, failure.message)
        _ = defined
    return obj

## Promise.try(callbackfn, ...args).
func js_promise_try(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    if not js_is_object(this_val):
        try js_throw_type_error_not_an_object(ctx)
    var resolving_funcs: Value[2] = ---
    let result_promise = try js_new_promise_capability_internal(ctx, &resolving_funcs[0], this_val)
    defer js_free_value(ctx, resolving_funcs[0])
    defer js_free_value(ctx, resolving_funcs[1])
    errdefer js_free_value(ctx, result_promise)
    var is_reject: usize = 0
    var ret = js_call(ctx, argv[0], js_undefined(), argc - 1, argv + 1) catch:
        is_reject = 1
        recover js_get_exception(ctx)
    let ret2 = js_call(ctx, resolving_funcs[is_reject], js_undefined(), 1, &ret) catch failure:
        js_free_value(ctx, ret)
        error(failure.code, failure.message)
    js_free_value(ctx, ret)
    js_free_value(ctx, ret2)
    return result_promise

# mark: all, allSettled, any ====================================================================

## Add `addend` to the remaining elements count kept in element 0 of
## `resolve_element_env`; answer whether it reached zero.
func remaining_elements_count_add(ctx: Context*, resolve_element_env: Value, addend: i32) -> bool!:
    let val = try js_get_property_uint32(ctx, resolve_element_env, 0)
    var remaining_elements_count: i32 = 0
    try js_to_int32_free(ctx, &remaining_elements_count, val)
    remaining_elements_count += addend
    _ = try js_set_property_uint32(ctx, resolve_element_env, 0,
                                   js_new_int32(remaining_elements_count))
    return remaining_elements_count == 0

let promise_magic_all: i32 = 0
let promise_magic_all_settled: i32 = 1
let promise_magic_any: i32 = 2

## The function settling one element of Promise.all, allSettled or any. Its data is
## alreadyCalled, index, values, resolve and resolve_element_env; `magic` is the
## resolve type, plus 4 for the reject function of allSettled.
func js_promise_all_resolve_element(ctx: Context*, this_val: Value, argc: i32, argv: Value*, magic: i32, func_data: Value*) -> Value!:
    let resolve_type = magic & 3
    let is_reject = (magic & 4) != 0
    let already_called = try js_to_bool(ctx, func_data[0])
    var values = func_data[2]
    let resolve = func_data[3]
    let resolve_element_env = func_data[4]
    var index: i32 = 0

    try js_to_int32(ctx, &index, func_data[1])
    if already_called:
        return js_undefined()
    func_data[0] = js_new_bool(true)

    var obj = js_undefined()
    if resolve_type == promise_magic_all_settled:
        let o = try js_new_object(ctx)
        # fail1:
        errdefer js_free_value(ctx, o)
        let status = try js_new_string8(ctx, ("rejected" if is_reject else "fulfilled").bytes.data)
        _ = try js_define_property_value(ctx, o, atom_status, status, prop_c_w_e)
        _ = try js_define_property_value(ctx, o, atom_reason if is_reject else atom_value,
                                         js_dup_value(ctx, argv[0]), prop_c_w_e)
        obj = o
    else:
        obj = js_dup_value(ctx, argv[0])
    _ = try js_define_property_value_uint32(ctx, values, (u32)index, obj, prop_c_w_e)

    let is_zero = try remaining_elements_count_add(ctx, resolve_element_env, -1)
    if is_zero:
        var ret = js_undefined()
        if resolve_type == promise_magic_any:
            var err = try js_aggregate_error_constructor(ctx, values)
            ret = js_call(ctx, resolve, js_undefined(), 1, &err) catch failure:
                js_free_value(ctx, err)
                error(failure.code, failure.message)
            js_free_value(ctx, err)
        else:
            ret = try js_call(ctx, resolve, js_undefined(), 1, &values)
        js_free_value(ctx, ret)
    return js_undefined()

## The locals of Promise.all and Promise.race that C frees at its `done:` label.
struct PromiseIterLocals:
    var promise_resolve: Value
    var iter: Value
    var next_method: Value
    var values: Value
    var resolve_element_env: Value

func promise_iter_locals_free(ctx: Context*, l: PromiseIterLocals*):
    js_free_value(ctx, l.promise_resolve)
    js_free_value(ctx, l.resolve_element_env)
    js_free_value(ctx, l.values)
    js_free_value(ctx, l.next_method)
    js_free_value(ctx, l.iter)

# Reject the result promise of a combinator with the pending exception (C's
# `fail_reject:`); fails if the reject function throws.
func promise_reject_with_exception(ctx: Context*, reject_func: Value) -> !:
    var err = js_get_exception(ctx)
    let ret = js_call(ctx, reject_func, js_undefined(), 1, &err) catch failure:
        js_free_value(ctx, err)
        error(failure.code, failure.message)
    js_free_value(ctx, err)
    js_free_value(ctx, ret)

# Settle one element `item` (freed) of Promise.all, allSettled or any: resolve it with
# the constructor's resolve and call its then with the element functions.
func js_promise_all_element(ctx: Context*, this_val: Value, magic: i32, resolving_funcs: Value*, l: PromiseIterLocals*, item: Value*, index: i32) -> !:
    let is_promise_any = (usize)(i32)(magic == promise_magic_any)
    let next_promise = js_call(ctx, l.promise_resolve, this_val, 1, item) catch failure:
        js_free_value(ctx, *item)
        error(failure.code, failure.message)
    js_free_value(ctx, *item)
    var resolve_element_data: Value[5] = [
        js_new_bool(false),
        js_new_int32(index),
        l.values,
        resolving_funcs[is_promise_any],
        l.resolve_element_env,
    ]
    var resolve_element = js_new_c_function_data(ctx, js_promise_all_resolve_element, 1,
                                                 magic, 5, &resolve_element_data[0]) catch failure:
        js_free_value(ctx, next_promise)
        error(failure.code, failure.message)

    var reject_element = js_undefined()
    if magic == promise_magic_all_settled:
        # as upstream, resolve_element is not freed if this fails
        reject_element = js_new_c_function_data(ctx, js_promise_all_resolve_element, 1,
                                                magic | 4, 5, &resolve_element_data[0]) catch failure:
            js_free_value(ctx, next_promise)
            error(failure.code, failure.message)
    elif magic == promise_magic_any:
        # as upstream, next_promise and resolve_element are not freed if this fails
        _ = try js_define_property_value_uint32(ctx, l.values, (u32)index, js_undefined(),
                                                prop_c_w_e)
        reject_element = resolve_element
        resolve_element = js_dup_value(ctx, resolving_funcs[0])
    else:
        reject_element = js_dup_value(ctx, resolving_funcs[1])

    let counted = remaining_elements_count_add(ctx, l.resolve_element_env, 1) catch failure:
        js_free_value(ctx, next_promise)
        js_free_value(ctx, resolve_element)
        js_free_value(ctx, reject_element)
        error(failure.code, failure.message)
    _ = counted

    var then_args: Value[2] = [resolve_element, reject_element]
    let ret = js_invoke_free(ctx, next_promise, atom_then, 2, &then_args[0]) catch failure:
        js_free_value(ctx, resolve_element)
        js_free_value(ctx, reject_element)
        error(failure.code, failure.message)
    js_free_value(ctx, resolve_element)
    js_free_value(ctx, reject_element)
    js_free_value(ctx, ret)

# The body of Promise.all and its kin, up to its `fail_reject:` label: every failure
# rejects the result promise.
func js_promise_all_iterate(ctx: Context*, this_val: Value, iterable: Value, magic: i32, resolving_funcs: Value*, l: PromiseIterLocals*) -> !:
    let is_promise_any = (usize)(i32)(magic == promise_magic_any)
    l.promise_resolve = try js_get_property(ctx, this_val, atom_resolve)
    try check_function(ctx, l.promise_resolve)
    l.iter = try js_get_iterator(ctx, iterable, false)
    l.next_method = try js_get_property(ctx, l.iter, atom_next)
    l.values = try js_new_array(ctx)
    l.resolve_element_env = try js_new_array(ctx)
    # remainingElementsCount field
    _ = try js_define_property_value_uint32(ctx, l.resolve_element_env, 0, js_new_int32(1),
                                            prop_configurable | prop_enumerable | prop_writable)

    var index: i32 = 0
    while true:
        # XXX: conformance: should close the iterator if error on 'done'
        # access, but not on 'value' access
        var done = false
        var no_args = js_undefined()
        var item = try js_iterator_next(ctx, l.iter, l.next_method, 0, &no_args, &done)
        if done:
            break
        js_promise_all_element(ctx, this_val, magic, resolving_funcs, l, &item, index) catch failure:
            # fail_reject1:
            js_iterator_close(ctx, l.iter, true) catch: recover ()
            error(failure.code, failure.message)
        index += 1

    let is_zero = try remaining_elements_count_add(ctx, l.resolve_element_env, -1)
    if is_zero:
        if magic == promise_magic_any:
            let err = try js_aggregate_error_constructor(ctx, l.values)
            js_free_value(ctx, l.values)
            l.values = err
        let ret = try js_call(ctx, resolving_funcs[is_promise_any], js_undefined(), 1, &l.values)
        js_free_value(ctx, ret)

## Promise.all (magic 0), Promise.allSettled (1) and Promise.any (2).
func js_promise_all(ctx: Context*, this_val: Value, argc: i32, argv: Value*, magic: i32) -> Value!:
    if not js_is_object(this_val):
        try js_throw_type_error_not_an_object(ctx)
    var resolving_funcs: Value[2] = ---
    let result_promise = try js_new_promise_capability_internal(ctx, &resolving_funcs[0], this_val)
    # done:
    defer js_free_value(ctx, resolving_funcs[1])
    defer js_free_value(ctx, resolving_funcs[0])
    var l = PromiseIterLocals(promise_resolve = js_undefined(), iter = js_undefined(),
                              next_method = js_undefined(), values = js_undefined(),
                              resolve_element_env = js_undefined())
    defer promise_iter_locals_free(ctx, &l)
    # fail:
    errdefer js_free_value(ctx, result_promise)
    js_promise_all_iterate(ctx, this_val, argv[0], magic, &resolving_funcs[0], &l) catch:
        # fail_reject:
        try promise_reject_with_exception(ctx, resolving_funcs[1])
        recover ()
    return result_promise

# mark: race ====================================================================================

# The body of Promise.race, up to its `fail_reject:` label.
func js_promise_race_iterate(ctx: Context*, this_val: Value, iterable: Value, resolving_funcs: Value*, l: PromiseIterLocals*) -> !:
    l.promise_resolve = try js_get_property(ctx, this_val, atom_resolve)
    try check_function(ctx, l.promise_resolve)
    l.iter = try js_get_iterator(ctx, iterable, false)
    l.next_method = try js_get_property(ctx, l.iter, atom_next)
    while true:
        # XXX: conformance: should close the iterator if error on 'done'
        # access, but not on 'value' access
        var done = false
        var no_args = js_undefined()
        var item = try js_iterator_next(ctx, l.iter, l.next_method, 0, &no_args, &done)
        if done:
            break
        js_promise_race_element(ctx, this_val, resolving_funcs, l, &item) catch failure:
            # fail_reject1:
            js_iterator_close(ctx, l.iter, true) catch: recover ()
            error(failure.code, failure.message)

# Resolve one element `item` (freed) of Promise.race and call its then with the result
# promise's resolving functions.
func js_promise_race_element(ctx: Context*, this_val: Value, resolving_funcs: Value*, l: PromiseIterLocals*, item: Value*) -> !:
    let next_promise = js_call(ctx, l.promise_resolve, this_val, 1, item) catch failure:
        js_free_value(ctx, *item)
        error(failure.code, failure.message)
    js_free_value(ctx, *item)
    let ret = try js_invoke_free(ctx, next_promise, atom_then, 2, resolving_funcs)
    js_free_value(ctx, ret)

## Promise.race.
func js_promise_race(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    if not js_is_object(this_val):
        try js_throw_type_error_not_an_object(ctx)
    var resolving_funcs: Value[2] = ---
    let result_promise = try js_new_promise_capability_internal(ctx, &resolving_funcs[0], this_val)
    # done:
    defer js_free_value(ctx, resolving_funcs[1])
    defer js_free_value(ctx, resolving_funcs[0])
    var l = PromiseIterLocals(promise_resolve = js_undefined(), iter = js_undefined(),
                              next_method = js_undefined(), values = js_undefined(),
                              resolve_element_env = js_undefined())
    defer promise_iter_locals_free(ctx, &l)
    # fail:
    errdefer js_free_value(ctx, result_promise)
    js_promise_race_iterate(ctx, this_val, argv[0], &resolving_funcs[0], &l) catch:
        # fail_reject:
        try promise_reject_with_exception(ctx, resolving_funcs[1])
        recover ()
    return result_promise