Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.0

0.6.0 / src / engine / module_eval.lucb

#==============================================================================================
#
#   module_eval - Module evaluation with top-level await
#
#   DESCRIPTION:
#       Port of quickjs.c lines 31173-31592: InnerModuleEvaluation
#       (js_inner_module_evaluation), the asynchronous execution of modules that await
#       (js_execute_async_module and its fulfilled and rejected callbacks, which run the
#       ancestors that became ready, GatherAvailableAncestors, in [[AsyncEvaluationOrder]]),
#       the synchronous execution of the others, and js_evaluate_module. The DUMP_MODULE_EXEC
#       tracing (js_dump_module) is not ported.
#
#==============================================================================================

# mark: Ready ancestors =========================================================================

func js_set_module_evaluated(ctx: Context*, m: ModuleDef*):
    m.status = ModuleStatus.evaluated
    if not js_is_undefined(m.promise):
        assert(m.cycle_root == m)
        var value = js_undefined()
        call_free_result(ctx, m.resolving_funcs[0], js_undefined(), 1, &value)

## The modules whose asynchronous dependencies have all completed (ExecModuleList).
struct ExecModuleList:
    var tab: ModuleDef**?
    var count: i32
    var size: i32

# The module `i` of the list (exec_list->tab[i]).
func exec_module_list_get(exec_list: ExecModuleList*, i: i32) -> ModuleDef*:
    let tab = exec_list.tab else trap("empty module list")
    return tab[(usize)i]

# XXX: slow. Could use a linked list instead of ExecModuleList
func find_in_exec_module_list(exec_list: ExecModuleList*, m: ModuleDef*) -> bool:
    for i in 0..<exec_list.count:
        if exec_module_list_get(exec_list, i) == m:
            return true
    return false

# The async parent `i` of `m` (m->async_parent_modules[i]).
func async_parent_module(m: ModuleDef*, i: i32) -> ModuleDef*:
    let tab = m.async_parent_modules else trap("module without async parents")
    return tab[(usize)i]

func gather_available_ancestors(ctx: Context*, module: ModuleDef*, exec_list: ExecModuleList*) -> !:
    if js_check_stack_overflow(ctx.rt, 0):
        try js_throw_stack_overflow(ctx)
    for i in 0..<module.async_parent_modules_count:
        let m = async_parent_module(module, i)
        let cycle_root = m.cycle_root else trap("gather_available_ancestors: no cycle root")
        if not find_in_exec_module_list(exec_list, m) and not cycle_root.eval_has_exception:
            assert(m.status == ModuleStatus.evaluating_async)
            assert(not m.eval_has_exception)
            assert(m.async_evaluation)
            assert(m.pending_async_dependencies > 0)
            m.pending_async_dependencies -= 1
            if m.pending_async_dependencies == 0:
                try js_resize_array(ctx, (void*?*)&exec_list.tab, (i32)memory.size_of(ModuleDef*),
                                    &exec_list.size, exec_list.count + 1)
                let tab = exec_list.tab else trap("gather_available_ancestors: no module list")
                tab[(usize)exec_list.count] = m
                exec_list.count += 1
                if not m.has_tla:
                    try gather_available_ancestors(ctx, m, exec_list)

# Order modules by increasing async_evaluation_timestamp.
func exec_module_list_cmp(p1: const void*, p2: const void*, opaque: void*?) -> i32:
    let m1 = *(ModuleDef**)p1
    let m2 = *(ModuleDef**)p2
    let t1 = m1.async_evaluation_timestamp
    let t2 = m2.async_evaluation_timestamp
    return (i32)(t1 > t2) - (i32)(t1 < t2)

# mark: Asynchronous execution ==================================================================

# `func_data[0]` is the module; `argv[0]` its exception.
func js_async_module_execution_rejected(ctx: Context*, this_val: Value, argc: i32, argv: Value*,
                                        magic: i32, func_data: Value*) -> Value!:
    let module = func_data[0].u.module
    var error_val = argv[0]

    if js_check_stack_overflow(ctx.rt, 0):
        try js_throw_stack_overflow(ctx)

    if module.status == ModuleStatus.evaluated:
        assert(module.eval_has_exception)
        return js_undefined()

    assert(module.status == ModuleStatus.evaluating_async)
    assert(not module.eval_has_exception)
    assert(module.async_evaluation)

    module.eval_has_exception = true
    module.eval_exception = js_dup_value(ctx, error_val)
    module.status = ModuleStatus.evaluated
    module.async_evaluation = false

    if not js_is_undefined(module.promise):
        assert(module.cycle_root == module)
        call_free_result(ctx, module.resolving_funcs[1], js_undefined(), 1, &error_val)

    for i in 0..<module.async_parent_modules_count:
        let m = async_parent_module(module, i)
        var m_obj = js_new_module_value(ctx, m)
        _ = js_async_module_execution_rejected(ctx, js_undefined(), 1, &error_val, 0, &m_obj) catch failure: recover js_exception()
        js_free_value(ctx, m_obj)
    return js_undefined()

# Release the array of an ExecModuleList.
func free_exec_module_list(ctx: Context*, exec_list: ExecModuleList*):
    if let tab = exec_list.tab:
        js_free(ctx, tab)

# `func_data[0]` is the module.
func js_async_module_execution_fulfilled(ctx: Context*, this_val: Value, argc: i32, argv: Value*,
                                         magic: i32, func_data: Value*) -> Value!:
    let module = func_data[0].u.module

    if module.status == ModuleStatus.evaluated:
        assert(module.eval_has_exception)
        return js_undefined()
    assert(module.status == ModuleStatus.evaluating_async)
    assert(not module.eval_has_exception)
    assert(module.async_evaluation)
    module.async_evaluation = false
    js_set_module_evaluated(ctx, module)

    var exec_list: ExecModuleList
    defer free_exec_module_list(ctx, &exec_list)

    try gather_available_ancestors(ctx, module, &exec_list)

    # sort by increasing async_evaluation timestamp
    if let tab = exec_list.tab:
        cutils.rqsort(tab, (usize)exec_list.count, memory.size_of(ModuleDef*), exec_module_list_cmp, none)

    for i in 0..<exec_list.count:
        let m = exec_module_list_get(&exec_list, i)
        if m.status == ModuleStatus.evaluated:
            assert(m.eval_has_exception)
        elif m.has_tla:
            js_execute_async_module(ctx, m) catch failure: recover ()
        else:
            var error_val = js_undefined()
            if js_execute_sync_module(ctx, m, &error_val) < 0:
                var m_obj = js_new_module_value(ctx, m)
                _ = js_async_module_execution_rejected(ctx, js_undefined(), 1, &error_val, 0, &m_obj) catch failure: recover js_exception()
                js_free_value(ctx, m_obj)
                js_free_value(ctx, error_val)
            else:
                m.async_evaluation = false
                js_set_module_evaluated(ctx, m)
    return js_undefined()

# Start the module function of `m`, which awaits, and settle the module when its promise
# does.
func js_execute_async_module(ctx: Context*, m: ModuleDef*) -> !:
    var no_args = js_undefined()
    let promise = try js_async_function_call(ctx, m.func_obj, js_undefined(), 0, &no_args, 0)
    var m_obj = js_new_module_value(ctx, m)
    var resolve_funcs: Value[2] = ---
    resolve_funcs[0] = js_new_c_function_data(ctx, js_async_module_execution_fulfilled, 0, 0, 1, &m_obj) catch failure: recover js_exception()
    resolve_funcs[1] = js_new_c_function_data(ctx, js_async_module_execution_rejected, 0, 0, 1, &m_obj) catch failure: recover js_exception()
    let ret_val = js_promise_then(ctx, promise, 2, &resolve_funcs[0]) catch failure: recover js_exception()
    js_free_value(ctx, ret_val)
    js_free_value(ctx, m_obj)
    js_free_value(ctx, resolve_funcs[0])
    js_free_value(ctx, resolve_funcs[1])
    js_free_value(ctx, promise)

# The `fail` exit of the evaluation functions: move the pending exception to *pvalue and
# answer -1.
func take_module_exception(ctx: Context*, pvalue: Value*) -> i32:
    *pvalue = js_get_exception(ctx)
    return -1

# return < 0 in case of exception. *pvalue contains the exception (no exception is pending
# then).
func js_execute_sync_module(ctx: Context*, m: ModuleDef*, pvalue: Value*) -> i32:
    if let init_func = m.init_func:
        # C module init : no asynchronous execution
        init_func(ctx, m) catch failure: return take_module_exception(ctx, pvalue)
    else:
        var no_args = js_undefined()
        let promise = js_async_function_call(ctx, m.func_obj, js_undefined(), 0, &no_args, 0) catch failure:
            return take_module_exception(ctx, pvalue)
        let state = js_promise_state(ctx, promise)
        if state == PromiseState.fulfilled:
            js_free_value(ctx, promise)
        elif state == PromiseState.rejected:
            *pvalue = js_promise_result(ctx, promise)
            js_free_value(ctx, promise)
            return -1
        else:
            js_free_value(ctx, promise)
            js_throw_type_error(ctx, "promise is pending") catch failure:
                return take_module_exception(ctx, pvalue)
    *pvalue = js_undefined()
    return 0

# mark: Evaluation ==============================================================================

# spec: InnerModuleEvaluation. Return (index, undefined) or (-1, exception): the exception
# is in *pvalue, not pending.
func js_inner_module_evaluation(ctx: Context*, m: ModuleDef*, index: i32, pstack_top: ModuleDef*?*,
                                pvalue: Value*) -> i32:
    if js_check_stack_overflow(ctx.rt, 0):
        js_throw_stack_overflow(ctx) catch failure: return take_module_exception(ctx, pvalue)

    if m.status == ModuleStatus.evaluating_async or m.status == ModuleStatus.evaluated:
        if m.eval_has_exception:
            *pvalue = js_dup_value(ctx, m.eval_exception)
            return -1
        else:
            *pvalue = js_undefined()
            return index
    if m.status == ModuleStatus.evaluating:
        *pvalue = js_undefined()
        return index
    assert(m.status == ModuleStatus.linked)

    m.status = ModuleStatus.evaluating
    m.dfs_index = index
    m.dfs_ancestor_index = index
    m.pending_async_dependencies = 0
    var next_index = index + 1
    # push 'm' on stack
    m.stack_prev = *pstack_top
    *pstack_top = m

    for i in 0..<m.req_module_entries_count:
        let rme = module_req_entry(m, i)
        var m1 = req_entry_module(rme)
        next_index = js_inner_module_evaluation(ctx, m1, next_index, pstack_top, pvalue)
        if next_index < 0:
            return -1
        assert(m1.status == ModuleStatus.evaluating or m1.status == ModuleStatus.evaluating_async or m1.status == ModuleStatus.evaluated)
        if m1.status == ModuleStatus.evaluating:
            m.dfs_ancestor_index = cutils.min_int(m.dfs_ancestor_index, m1.dfs_ancestor_index)
        else:
            m1 = m1.cycle_root else trap("js_inner_module_evaluation: no cycle root")
            assert(m1.status == ModuleStatus.evaluating_async or m1.status == ModuleStatus.evaluated)
            if m1.eval_has_exception:
                *pvalue = js_dup_value(ctx, m1.eval_exception)
                return -1
        if m1.async_evaluation:
            m.pending_async_dependencies += 1
            js_resize_array(ctx, (void*?*)&m1.async_parent_modules, (i32)memory.size_of(ModuleDef*),
                            &m1.async_parent_modules_size, m1.async_parent_modules_count + 1) catch failure:
                return take_module_exception(ctx, pvalue)
            let parents = m1.async_parent_modules else trap("js_inner_module_evaluation: no parents")
            parents[(usize)m1.async_parent_modules_count] = m
            m1.async_parent_modules_count += 1

    let rt = ctx.rt
    if m.pending_async_dependencies > 0:
        assert(not m.async_evaluation)
        m.async_evaluation = true
        m.async_evaluation_timestamp = rt.module_async_evaluation_next_timestamp
        rt.module_async_evaluation_next_timestamp += 1
    elif m.has_tla:
        assert(not m.async_evaluation)
        m.async_evaluation = true
        m.async_evaluation_timestamp = rt.module_async_evaluation_next_timestamp
        rt.module_async_evaluation_next_timestamp += 1
        js_execute_async_module(ctx, m) catch failure: recover ()
    else:
        if js_execute_sync_module(ctx, m, pvalue) < 0:
            return -1

    assert(m.dfs_ancestor_index <= m.dfs_index)
    if m.dfs_index == m.dfs_ancestor_index:
        while true:
            # pop m1 from stack
            let m1 = *pstack_top else trap("js_inner_module_evaluation: empty module stack")
            *pstack_top = m1.stack_prev
            if not m1.async_evaluation:
                m1.status = ModuleStatus.evaluated
            else:
                m1.status = ModuleStatus.evaluating_async
            # spec bug: cycle_root must be assigned before the test
            m1.cycle_root = m
            if m1 == m:
                break
    *pvalue = js_undefined()
    return next_index

# Run the <eval> function of the module and of all its requested modules. Return a promise
# or fail with an exception.
func js_evaluate_module(ctx: Context*, m0: ModuleDef*) -> Value!:
    var m = m0
    assert(m.status == ModuleStatus.linked or m.status == ModuleStatus.evaluating_async or m.status == ModuleStatus.evaluated)
    if m.status == ModuleStatus.evaluating_async or m.status == ModuleStatus.evaluated:
        m = m.cycle_root else trap("js_evaluate_module: no cycle root")
    # a promise may be created only on the cycle_root of a cycle
    if not js_is_undefined(m.promise):
        return js_dup_value(ctx, m.promise)
    # QuickJS stores JS_EXCEPTION in m->promise when this fails; the port leaves it
    # undefined, since a stored exception marker would be answered as a promise later.
    m.promise = try js_new_promise_capability(ctx, &m.resolving_funcs[0])

    var stack_top: ModuleDef*? = none
    var result = js_undefined()
    if js_inner_module_evaluation(ctx, m, 0, &stack_top, &result) < 0:
        while let m1 = stack_top:
            assert(m1.status == ModuleStatus.evaluating)
            m1.status = ModuleStatus.evaluated
            m1.eval_has_exception = true
            m1.eval_exception = js_dup_value(ctx, result)
            # spec bug: should be present
            m1.cycle_root = m
            stack_top = m1.stack_prev
        js_free_value(ctx, result)
        assert(m.status == ModuleStatus.evaluated)
        assert(m.eval_has_exception)
        call_free_result(ctx, m.resolving_funcs[1], js_undefined(), 1, &m.eval_exception)
    else:
        assert(m.status == ModuleStatus.evaluating_async or m.status == ModuleStatus.evaluated)
        assert(not m.eval_has_exception)
        if not m.async_evaluation:
            assert(m.status == ModuleStatus.evaluated)
            var value = js_undefined()
            call_free_result(ctx, m.resolving_funcs[0], js_undefined(), 1, &value)
        assert(stack_top == none)
    return js_dup_value(ctx, m.promise)