Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / src / engine / weakref.lucb

#==============================================================================================
#
#   weakref - WeakRef and FinalizationRegistry
#
#   DESCRIPTION:
#       Port of quickjs.c "WeakRef" (lines 61134-61424): the WeakRef objects, the
#       FinalizationRegistry objects with their entries and cleanup jobs, and
#       JS_AddIntrinsicWeakRef. Both kinds of holder are in the runtime's weakref_list;
#       the collector calls weakref_delete_weakref / finrec_delete_weakref on them once
#       it has found the dead targets (gc_remove_weak_objects). The weak reference
#       primitives (js_weakref_new, js_weakref_is_live, js_weakref_free) are with WeakMap.
#
#==============================================================================================

# mark: WeakRef =================================================================================

## The data of a WeakRef object (JSWeakRefData).
struct WeakRefData:
    var weakref_header: WeakRefHeader
    var target: Value

## Finalizer of ClassId.weak_ref.
func js_weakref_finalizer(rt: Runtime*, val: Value):
    let raw = js_get_opaque(val, (u32)ClassId.weak_ref) else return
    let wrd = (WeakRefData*)raw
    js_weakref_free(rt, wrd.target)
    cutils.list_del(&wrd.weakref_header.link)
    js_free_rt(rt, wrd)

## Called by the collector: forget the target once it is dead.
func weakref_delete_weakref(rt: Runtime*, wh: WeakRefHeader*):
    let wrd = (WeakRefData*)((u8*)wh - memory.offset_of(WeakRefData, weakref_header))

    if not js_weakref_is_live(wrd.target):
        js_weakref_free(rt, wrd.target)
        wrd.target = js_undefined()

## new WeakRef(target).
func js_weakref_constructor(ctx: Context*, new_target: Value, argc: i32, argv: Value*) -> Value!:
    if js_is_undefined(new_target):
        try js_throw_type_error(ctx, "constructor requires 'new'")
    let arg = argv[0]
    if not js_weakref_is_target(arg):
        try js_throw_type_error(ctx, "invalid target")
    let obj = try js_create_from_ctor(ctx, new_target, (u32)ClassId.weak_ref)
    errdefer js_free_value(ctx, obj)
    let wrd = (WeakRefData*)(try js_mallocz(ctx, memory.size_of(WeakRefData)))
    wrd.target = js_weakref_new(ctx, arg)
    wrd.weakref_header.weakref_type = WeakRefHeaderType.weakref
    cutils.list_add_tail(&wrd.weakref_header.link, &ctx.rt.weakref_list)
    js_set_opaque(obj, wrd)
    return obj

## WeakRef.prototype.deref(): the target, or undefined once it was collected.
func js_weakref_deref(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let wrd = (WeakRefData*)(try js_get_opaque2(ctx, this_val, (u32)ClassId.weak_ref))
    if js_weakref_is_live(wrd.target):
        return js_dup_value(ctx, wrd.target)
    else:
        return js_undefined()

let js_weakref_proto_funcs = [
    CFunctionListEntry(name = "deref", def_type = def_cfunc, length = 0, generic = js_weakref_deref),
    CFunctionListEntry(name = "[Symbol.toStringTag]", prop_flags = 1, def_type = def_prop_string, string_value = "WeakRef"),
]

let js_weakref_class_def: ClassShortDef[1] = [
    ClassShortDef(atom_WeakRef, js_weakref_finalizer, none),   # ClassId.weak_ref
]

# mark: FinalizationRegistry ====================================================================

## A registration of a FinalizationRegistry (JSFinRecEntry).
struct FinRecEntry:
    var link: cutils.ListHead
    ## Weak.
    var target: Value
    var held_val: Value
    ## Weak; undefined when there is no unregister token.
    var token: Value

## The data of a FinalizationRegistry object (JSFinalizationRegistryData).
struct FinalizationRegistryData:
    var weakref_header: WeakRefHeader
    ## List of FinRecEntry.link.
    var entries: cutils.ListHead
    var realm: Context*
    var cb: Value

# The FinRecEntry of the link `el`.
func finrec_entry(el: cutils.ListHead*) -> FinRecEntry*:
    return (FinRecEntry*)((u8*)el - memory.offset_of(FinRecEntry, link))

## Finalizer of ClassId.finalization_registry.
func js_finrec_finalizer(rt: Runtime*, val: Value):
    let raw = js_get_opaque(val, (u32)ClassId.finalization_registry) else return
    let frd = (FinalizationRegistryData*)raw
    var el = frd.entries.next else trap("js_finrec_finalizer: unlinked list")
    while el != &frd.entries:
        let el1 = el.next else trap("js_finrec_finalizer: unlinked list")
        let fre = finrec_entry(el)
        js_weakref_free(rt, fre.target)
        js_weakref_free(rt, fre.token)
        js_free_value_rt(rt, fre.held_val)
        js_free_rt(rt, fre)
        el = el1
    js_free_value_rt(rt, frd.cb)
    js_free_context(frd.realm)
    cutils.list_del(&frd.weakref_header.link)
    js_free_rt(rt, frd)

## Marking function of ClassId.finalization_registry: the held values, the callback and
## the realm are strong references.
func js_finrec_mark(rt: Runtime*, val: Value, mark_func: MarkFunc):
    let raw = js_get_opaque(val, (u32)ClassId.finalization_registry) else return
    let frd = (FinalizationRegistryData*)raw
    var el = frd.entries.next else trap("js_finrec_mark: unlinked list")
    while el != &frd.entries:
        let fre = finrec_entry(el)
        js_mark_value(rt, fre.held_val, mark_func)
        el = el.next else trap("js_finrec_mark: unlinked list")
    js_mark_value(rt, frd.cb, mark_func)
    mark_func(rt, &frd.realm.header)

## The cleanup job of a dead target: `argv[0](argv[1])`.
func js_finrec_job(ctx: Context*, argc: i32, argv: Value*) -> Value!:
    return try js_call(ctx, argv[0], js_undefined(), 1, &argv[1])

## Called by the collector: forget the dead unregister tokens, and queue the cleanup job
## of every entry whose target is dead.
func finrec_delete_weakref(rt: Runtime*, wh: WeakRefHeader*):
    let frd = (FinalizationRegistryData*)((u8*)wh - memory.offset_of(FinalizationRegistryData, weakref_header))

    var el = frd.entries.next else trap("finrec_delete_weakref: unlinked list")
    while el != &frd.entries:
        let el1 = el.next else trap("finrec_delete_weakref: unlinked list")
        let fre = finrec_entry(el)

        if not js_weakref_is_live(fre.token):
            js_weakref_free(rt, fre.token)
            fre.token = js_undefined()

        if not js_weakref_is_live(fre.target):
            var args: Value[2] = ---
            args[0] = frd.cb
            args[1] = fre.held_val
            # no exception is raised to avoid recursing into the GC
            js_enqueue_job2(frd.realm, js_finrec_job, 2, &args[0], true) catch: recover ()

            js_weakref_free(rt, fre.target)
            js_weakref_free(rt, fre.token)
            js_free_value_rt(rt, fre.held_val)
            cutils.list_del(&fre.link)
            js_free_rt(rt, fre)
        el = el1

## new FinalizationRegistry(callback).
func js_finrec_constructor(ctx: Context*, new_target: Value, argc: i32, argv: Value*) -> Value!:
    if js_is_undefined(new_target):
        try js_throw_type_error(ctx, "constructor requires 'new'")
    let cb = argv[0]
    if not js_is_function(ctx, cb):
        try js_throw_type_error(ctx, "argument must be a function")

    let obj = try js_create_from_ctor(ctx, new_target, (u32)ClassId.finalization_registry)
    errdefer js_free_value(ctx, obj)
    let frd = (FinalizationRegistryData*)(try js_mallocz(ctx, memory.size_of(FinalizationRegistryData)))
    frd.weakref_header.weakref_type = WeakRefHeaderType.finrec
    cutils.list_add_tail(&frd.weakref_header.link, &ctx.rt.weakref_list)
    cutils.init_list_head(&frd.entries)
    frd.realm = js_dup_context(ctx)
    frd.cb = js_dup_value(ctx, cb)
    js_set_opaque(obj, frd)
    return obj

## FinalizationRegistry.prototype.register(target, heldValue[, unregisterToken]).
func js_finrec_register(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let frd = (FinalizationRegistryData*)(try js_get_opaque2(ctx, this_val, (u32)ClassId.finalization_registry))
    let target = argv[0]
    let held_val = argv[1]
    let token = argv[2] if argc > 2 else js_undefined()

    if not js_weakref_is_target(target):
        try js_throw_type_error(ctx, "invalid target")
    if js_same_value(ctx, target, held_val):
        try js_throw_type_error(ctx, "held value cannot be the target")
    if not js_is_undefined(token) and not js_weakref_is_target(token):
        try js_throw_type_error(ctx, "invalid unregister token")
    let fre = (FinRecEntry*)(try js_malloc(ctx, memory.size_of(FinRecEntry)))
    fre.target = js_weakref_new(ctx, target)
    fre.held_val = js_dup_value(ctx, held_val)
    fre.token = js_weakref_new(ctx, token)
    cutils.list_add_tail(&fre.link, &frd.entries)
    return js_undefined()

## FinalizationRegistry.prototype.unregister(token): remove the registrations made with
## `token`; whether there was one.
func js_finrec_unregister(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
    let frd = (FinalizationRegistryData*)(try js_get_opaque2(ctx, this_val, (u32)ClassId.finalization_registry))
    let token = argv[0]
    if not js_weakref_is_target(token):
        try js_throw_type_error(ctx, "invalid unregister token")

    var removed = false
    var el = frd.entries.next else trap("js_finrec_unregister: unlinked list")
    while el != &frd.entries:
        let el1 = el.next else trap("js_finrec_unregister: unlinked list")
        let fre = finrec_entry(el)
        if js_weakref_is_live(fre.token) and js_same_value(ctx, fre.token, token):
            js_weakref_free(ctx.rt, fre.target)
            js_weakref_free(ctx.rt, fre.token)
            js_free_value(ctx, fre.held_val)
            cutils.list_del(&fre.link)
            js_free(ctx, fre)
            removed = true
        el = el1
    return js_new_bool(removed)

let js_finrec_proto_funcs = [
    CFunctionListEntry(name = "register", def_type = def_cfunc, length = 2, generic = js_finrec_register),
    CFunctionListEntry(name = "unregister", def_type = def_cfunc, length = 1, generic = js_finrec_unregister),
    CFunctionListEntry(name = "[Symbol.toStringTag]", prop_flags = 1, def_type = def_prop_string, string_value = "FinalizationRegistry"),
]

let js_finrec_class_def: ClassShortDef[1] = [
    ClassShortDef(atom_FinalizationRegistry, js_finrec_finalizer, js_finrec_mark),   # ClassId.finalization_registry
]

# mark: The intrinsics ==========================================================================

## Add WeakRef and FinalizationRegistry to the global object, declaring their classes on
## first use (JS_AddIntrinsicWeakRef).
pub func js_add_intrinsic_weak_ref(ctx: Context*) -> !:
    let rt = ctx.rt

    # WeakRef
    if not js_is_registered_class(rt, (u32)ClassId.weak_ref):
        if init_class_range(rt, js_weakref_class_def, (i32)ClassId.weak_ref) != 0:
            error(exception, "")  # C returns -1 with no exception pending
    var obj = try js_new_c_constructor_tables(ctx, (i32)ClassId.weak_ref, "WeakRef",
                                              js_weakref_constructor, 1, CFunctionEnum.constructor_or_func, 0,
                                              js_undefined(),
                                              none,
                                              js_weakref_proto_funcs,
                                              0)
    js_free_value(ctx, obj)

    # FinalizationRegistry
    if not js_is_registered_class(rt, (u32)ClassId.finalization_registry):
        if init_class_range(rt, js_finrec_class_def, (i32)ClassId.finalization_registry) != 0:
            error(exception, "")  # C returns -1 with no exception pending

    obj = try js_new_c_constructor_tables(ctx, (i32)ClassId.finalization_registry, "FinalizationRegistry",
                                          js_finrec_constructor, 1, CFunctionEnum.constructor_or_func, 0,
                                          js_undefined(),
                                          none,
                                          js_finrec_proto_funcs,
                                          0)
    js_free_value(ctx, obj)