dymokomi/luce-js
Source of release 0.6.1
0.6.1 / src / engine / module_resolve.lucb
#==============================================================================================
#
# module_resolve - Export resolution, exported names and the module namespace object
#
# DESCRIPTION:
# Port of quickjs.c lines 30086-30522: ResolveExport (js_resolve_export and its
# JSResolveState of visited (module, name) pairs), GetExportedNames, and the module
# namespace object with its exotic has_property and its lazily resolved bindings
# (js_build_module_ns, JS_GetModuleNamespace). JS_RESOLVE_RES_EXCEPTION is a
# failure here, as every pending exception is in the port.
#
#==============================================================================================
# mark: Resolving exports =======================================================================
## A (module, export name) pair visited by js_resolve_export (JSResolveEntry).
struct ResolveEntry:
var module: ModuleDef*
var name: Atom
## The pairs js_resolve_export has visited, to detect circular imports (JSResolveState).
struct ResolveState:
var array: ResolveEntry*?
var size: i32
var count: i32
## The outcome of js_resolve_export (JSResolveResultEnum). QuickJS's
## JS_RESOLVE_RES_EXCEPTION (a memory error) is a failure of the resolving function.
enum ResolveResult as i32:
found = 0
not_found = 1
circular = 2
ambiguous = 3
# The entry `i` of the resolve state (&s->array[i]).
func resolve_entry(s: ResolveState*, i: i32) -> ResolveEntry*:
let array = s.array else trap("empty resolve state")
return array + (usize)i
func find_resolve_entry(s: ResolveState*, m: ModuleDef*, name: Atom) -> i32:
for i in 0..<s.count:
let re = resolve_entry(s, i)
if re.module == m and re.name == name:
return i
return -1
func add_resolve_entry(ctx: Context*, s: ResolveState*, m: ModuleDef*, name: Atom) -> !:
try js_resize_array(ctx, (void*?*)&s.array, (i32)memory.size_of(ResolveEntry), &s.size, s.count + 1)
let re = resolve_entry(s, s.count)
s.count += 1
re.module = m
re.name = js_dup_atom(ctx, name)
# Release the names and the array of a resolve state (the end of js_resolve_export).
func free_resolve_state(ctx: Context*, s: ResolveState*):
for i in 0..<s.count:
js_free_atom(ctx, resolve_entry(s, i).name)
if let array = s.array:
js_free(ctx, array)
func js_resolve_export1(ctx: Context*, pmodule: ModuleDef*?*, pme: ExportEntry*?*, m: ModuleDef*,
export_name: Atom, s: ResolveState*) -> ResolveResult!:
*pmodule = none
*pme = none
if find_resolve_entry(s, m, export_name) >= 0:
return ResolveResult.circular
try add_resolve_entry(ctx, s, m, export_name)
if let me = find_export_entry(ctx, m, export_name):
if me.export_type == ExportType.local_:
# local export
*pmodule = m
*pme = me
return ResolveResult.found
else:
# indirect export
if me.local_name == atom__star_:
# export ns from
*pmodule = m
*pme = me
return ResolveResult.found
else:
let m1 = req_entry_module(module_req_entry(m, me.u.req_module_idx))
return try js_resolve_export1(ctx, pmodule, pme, m1, me.local_name, s)
else:
if export_name != atom_default:
# not found in direct or indirect exports: try star exports
for i in 0..<m.star_export_entries_count:
let se = module_star_export_entry(m, i)
let m1 = req_entry_module(module_req_entry(m, se.req_module_idx))
var res_m: ModuleDef*? = none
var res_me: ExportEntry*? = none
let ret = try js_resolve_export1(ctx, &res_m, &res_me, m1, export_name, s)
if ret == ResolveResult.ambiguous:
return ret
elif ret == ResolveResult.found:
let found_me = res_me else trap("js_resolve_export1: found without an entry")
if let pme0 = *pme:
if *pmodule != res_m or found_me.local_name != pme0.local_name:
*pmodule = none
*pme = none
return ResolveResult.ambiguous
else:
*pmodule = res_m
*pme = res_me
if *pme != none:
return ResolveResult.found
return ResolveResult.not_found
# If the return value is ResolveResult.found, return the module (*pmodule) and the
# corresponding local export entry (*pme). Otherwise return (none, none).
func js_resolve_export(ctx: Context*, pmodule: ModuleDef*?*, pme: ExportEntry*?*, m: ModuleDef*,
export_name: Atom) -> ResolveResult!:
var s: ResolveState
defer free_resolve_state(ctx, &s)
return try js_resolve_export1(ctx, pmodule, pme, m, export_name, &s)
# Throw the SyntaxError of an unresolved export.
func js_resolve_export_throw_error(ctx: Context*, res: ResolveResult, m: ModuleDef*,
export_name: Atom) -> never!:
var buf1: u8[atom_get_str_buf_size] = ---
var buf2: u8[atom_get_str_buf_size] = ---
let name1 = js_atom_get_str(ctx, buf1, export_name)
let name2 = js_atom_get_str(ctx, buf2, m.module_name)
match res:
.circular:
try js_throw_syntax_error(ctx, f"circular reference when looking for export '{name1}' in module '{name2}'")
.ambiguous:
try js_throw_syntax_error(ctx, f"export '{name1}' in module '{name2}' is ambiguous")
_:
try js_throw_syntax_error(ctx, f"Could not find export '{name1}' in module '{name2}'")
# mark: Exported names ==========================================================================
## What an exported name resolves to (ExportedNameEntryEnum).
enum ExportedNameKind as i32:
ambiguous = 0
normal = 1
delayed = 2
## The payload of an exported name.
union ExportedNameEntryUnion:
## Used when the list is built.
me: ExportEntry*?
## ExportedNameKind.normal.
var_ref: VarRef*?
## One name a module exports (ExportedNameEntry).
struct ExportedNameEntry:
var export_name: Atom
var export_type: ExportedNameKind
var u: ExportedNameEntryUnion
## The modules visited and the names found by get_exported_names (GetExportNamesState).
struct GetExportNamesState:
var modules: ModuleDef**?
var modules_size: i32
var modules_count: i32
var exported_names: ExportedNameEntry*?
var exported_names_size: i32
var exported_names_count: i32
# The exported name `i` of the state (&s->exported_names[i]).
func exported_name_entry(s: GetExportNamesState*, i: i32) -> ExportedNameEntry*:
let names = s.exported_names else trap("no exported names")
return names + (usize)i
func find_exported_name(s: GetExportNamesState*, name: Atom) -> i32:
for i in 0..<s.exported_names_count:
if exported_name_entry(s, i).export_name == name:
return i
return -1
func get_exported_names(ctx: Context*, s: GetExportNamesState*, m: ModuleDef*, from_star: bool) -> !:
# check circular reference
for i in 0..<s.modules_count:
let modules = s.modules else trap("get_exported_names: no module list")
if modules[(usize)i] == m:
return
try js_resize_array(ctx, (void*?*)&s.modules, (i32)memory.size_of(ModuleDef*), &s.modules_size,
s.modules_count + 1)
let modules = s.modules else trap("get_exported_names: no module list")
modules[(usize)s.modules_count] = m
s.modules_count += 1
for i in 0..<m.export_entries_count:
let me = module_export_entry(m, i)
if from_star and me.export_name == atom_default:
continue
let j = find_exported_name(s, me.export_name)
if j < 0:
try js_resize_array(ctx, (void*?*)&s.exported_names, (i32)memory.size_of(ExportedNameEntry),
&s.exported_names_size, s.exported_names_count + 1)
let en = exported_name_entry(s, s.exported_names_count)
s.exported_names_count += 1
en.export_name = me.export_name
# avoid a second lookup for simple module exports
if from_star or me.export_type != ExportType.local_:
en.u.me = none
else:
en.u.me = me
else:
let en = exported_name_entry(s, j)
en.u.me = none
for i in 0..<m.star_export_entries_count:
let se = module_star_export_entry(m, i)
let m1 = req_entry_module(module_req_entry(m, se.req_module_idx))
try get_exported_names(ctx, s, m1, true)
# mark: The namespace object ====================================================================
# Unfortunately, the spec gives a different behavior from GetOwnProperty !
func js_module_ns_has(ctx: Context*, obj: Value, atom: Atom) -> bool!:
return find_own_property1(js_value_get_obj(obj), atom) != none
## The exotic behaviour of module namespace objects.
let js_module_ns_exotic_methods: ClassExoticMethods = ClassExoticMethods(
has_property = js_module_ns_has,
)
# Order exported names by their text; `opaque` is the context.
func exported_names_cmp(p1: const void*, p2: const void*, opaque: void*?) -> i32:
let ctx = (Context*)(opaque else trap("exported_names_cmp: no context"))
let me1 = (const ExportedNameEntry*)p1
let me2 = (const ExportedNameEntry*)p2
# XXX: should avoid allocation memory in atom comparison
let str1 = js_atom_to_string(ctx, me1.export_name) catch failure: recover js_exception()
let str2 = js_atom_to_string(ctx, me2.export_name) catch failure: recover js_exception()
var ret: i32 = 0
if js_is_exception(str1) or js_is_exception(str2):
# XXX: raise an error ?
ret = 0
else:
ret = js_string_compare(ctx, js_value_get_string(str1), js_value_get_string(str2))
js_free_value(ctx, str1)
js_free_value(ctx, str2)
return ret
# The closure variable `var_idx` of the module function of `m`
# (JS_VALUE_GET_OBJ(m->func_obj)->u.func.var_refs[var_idx]).
func module_func_var_ref(m: ModuleDef*, var_idx: i32) -> VarRef*?:
let p1 = js_value_get_obj(m.func_obj)
let var_refs = p1.u.func_.var_refs else trap("module function without variables")
return var_refs[(usize)var_idx]
# The AutoInitId.module_ns initializer of a delayed namespace binding: `opaque` is the
# module.
func js_module_ns_autoinit(ctx: Context*, p: Object*, atom: Atom, opaque: void*) -> Value!:
let m = (ModuleDef*)opaque
var res_me: ExportEntry*? = none
var res_m: ModuleDef*? = none
let res = try js_resolve_export(ctx, &res_m, &res_me, m, atom)
if res != ResolveResult.found:
# fail safe: normally no error should happen here except for memory
try js_resolve_export_throw_error(ctx, res, m, atom)
let me = res_me else trap("js_module_ns_autoinit: found without an entry")
let rm = res_m else trap("js_module_ns_autoinit: found without a module")
if me.local_name == atom__star_:
return try js_get_module_namespace(ctx, req_entry_module(module_req_entry(rm, me.u.req_module_idx)))
else:
var var_ref = me.u.local_.var_ref
if var_ref == none:
var_ref = module_func_var_ref(rm, me.u.local_.var_idx)
let vr = var_ref else trap("js_module_ns_autoinit: uninitialized binding")
# WARNING: a varref is returned as a string !
return js_mkptr(Tag.string, vr)
# Release the arrays of a GetExportNamesState's modules.
func free_export_names_modules(ctx: Context*, s: GetExportNamesState*):
if let modules = s.modules:
js_free(ctx, modules)
func js_build_module_ns(ctx: Context*, m: ModuleDef*) -> Value!:
let obj = try js_new_object_class(ctx, (i32)ClassId.module_ns)
errdefer js_free_value(ctx, obj)
let p = js_value_get_obj(obj)
var s: GetExportNamesState
defer free_exported_names(ctx, &s)
get_exported_names(ctx, &s, m, false) catch failure:
free_export_names_modules(ctx, &s)
error(failure.code, failure.message)
free_export_names_modules(ctx, &s)
# Resolve the exported names. The ambiguous exports are removed
for i in 0..<s.exported_names_count:
let en = exported_name_entry(&s, i)
var res = ResolveResult.found
var res_me: ExportEntry*? = none
var res_m: ModuleDef*? = none
if let me = en.u.me:
# fast case: no resolution needed
res_me = me
res_m = m
else:
res = try js_resolve_export(ctx, &res_m, &res_me, m, en.export_name)
if res != ResolveResult.found:
if res != ResolveResult.ambiguous:
try js_resolve_export_throw_error(ctx, res, m, en.export_name)
en.export_type = ExportedNameKind.ambiguous
else:
let me = res_me else trap("js_build_module_ns: found without an entry")
let rm = res_m else trap("js_build_module_ns: found without a module")
if me.local_name == atom__star_:
en.export_type = ExportedNameKind.delayed
else:
if let var_ref = me.u.local_.var_ref:
en.u.var_ref = var_ref
else:
en.u.var_ref = module_func_var_ref(rm, me.u.local_.var_idx)
if en.u.var_ref == none:
en.export_type = ExportedNameKind.delayed
else:
en.export_type = ExportedNameKind.normal
# sort the exported names
if let names = s.exported_names:
cutils.rqsort(names, (usize)s.exported_names_count, memory.size_of(ExportedNameEntry),
exported_names_cmp, ctx)
for i in 0..<s.exported_names_count:
let en = exported_name_entry(&s, i)
match en.export_type:
.normal:
let var_ref = en.u.var_ref else trap("js_build_module_ns: no binding")
let pr = try add_property(ctx, p, en.export_name,
prop_enumerable | prop_writable | prop_varref)
js_rc(var_ref).ref_count += 1
pr.u.var_ref = var_ref
.delayed:
# the exported namespace or reference may depend on circular references, so
# we resolve it lazily
_ = try js_define_auto_init_property(ctx, obj, en.export_name, AutoInitId.module_ns,
m, prop_enumerable | prop_writable)
_: continue
let tag = js_atom_to_string(ctx, atom_Module) catch failure: recover js_exception()
_ = js_define_property_value(ctx, obj, atom_Symbol_toStringTag, tag, 0) catch failure: recover false
p.extensible = false
return obj
# Release the exported names of a GetExportNamesState.
func free_exported_names(ctx: Context*, s: GetExportNamesState*):
if let names = s.exported_names:
js_free(ctx, names)
## The namespace object of the module `m`, built on first use (JS_GetModuleNamespace).
pub func js_get_module_namespace(ctx: Context*, m: ModuleDef*) -> Value!:
if js_is_undefined(m.module_ns):
let val = try js_build_module_ns(ctx, m)
m.module_ns = val
return js_dup_value(ctx, m.module_ns)