dymokomi/luce-js
Source of release 0.6.1
0.6.1 / 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)