Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.0

0.6.0 / 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)