Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.0

0.6.0 / src / engine / promise_reactions.lucb

#==============================================================================================
#
#   promise_reactions - Promise records, their state, and settling a promise
#
#   DESCRIPTION:
#       Port of quickjs.c "Promise" (lines 53333-53480): the promise records (JSPromiseData
#       and the data of the resolving functions and of the reactions), JS_PromiseState,
#       JS_PromiseResult, the reaction job, JS_SetHostPromiseRejectionTracker, and
#       fulfilling or rejecting a promise, which queues a reaction job per registered
#       reaction.
#
#==============================================================================================

# mark: Promise records =========================================================================

## A promise's state and reactions (JSPromiseData).
struct PromiseData:
    var promise_state: PromiseState
    ## 0=fulfill, 1=reject, list of PromiseReactionData.link.
    var promise_reactions: cutils.ListHead[2]
    ## Note: only useful to debug.
    var is_handled: bool
    var promise_result: Value

## The "already resolved" flag the two resolving functions of a promise share
## (JSPromiseFunctionDataResolved).
struct PromiseFunctionDataResolved:
    var ref_count: i32
    var already_resolved: bool

## The data of a resolving function (JSPromiseFunctionData).
struct PromiseFunctionData:
    var promise: Value
    var presolved: PromiseFunctionDataResolved*

## A reaction registered by `then` (JSPromiseReactionData).
struct PromiseReactionData:
    ## Not used in promise_reaction_job.
    var link: cutils.ListHead
    var resolving_funcs: Value[2]
    var handler: Value

## The state of `promise`, or none if it is not a promise (JS_PromiseState; QuickJS
## answers -1 then).
pub func js_promise_state(ctx: Context*, promise: Value) -> PromiseState?:
    let raw = js_get_opaque(promise, (u32)ClassId.promise) else return none
    let s = (PromiseData*)raw
    return s.promise_state

## A new reference to the result of `promise`, undefined if it is not a promise
## (JS_PromiseResult).
pub func js_promise_result(ctx: Context*, promise: Value) -> Value:
    let raw = js_get_opaque(promise, (u32)ClassId.promise) else return js_undefined()
    let s = (PromiseData*)raw
    return js_dup_value(ctx, s.promise_result)

## Free a reaction record (promise_reaction_data_free).
func promise_reaction_data_free(rt: Runtime*, rd: PromiseReactionData*):
    js_free_value_rt(rt, rd.resolving_funcs[0])
    js_free_value_rt(rt, rd.resolving_funcs[1])
    js_free_value_rt(rt, rd.handler)
    js_free_rt(rt, rd)

# mark: Reaction jobs ===========================================================================

## The handler step of a reaction: call `handler` on `arg`, or with no handler pass `arg`
## through (fulfilled) or throw it (rejected).
func promise_reaction_handler_result(ctx: Context*, handler: Value, is_reject: bool, arg: Value) -> Value!:
    if js_is_undefined(handler):
        if is_reject:
            try js_throw(ctx, js_dup_value(ctx, arg))
        return js_dup_value(ctx, arg)
    var a = arg
    return try js_call(ctx, handler, js_undefined(), 1, &a)

## The job of a reaction: `argv` is the two resolving functions, the handler, whether
## the promise was rejected, and its result (promise_reaction_job).
func promise_reaction_job(ctx: Context*, argc: i32, argv: Value*) -> Value!:
    assert(argc == 5)
    let handler = argv[2]
    var is_reject = try js_to_bool(ctx, argv[3])
    let arg = argv[4]

    var failed = false
    var res = promise_reaction_handler_result(ctx, handler, is_reject, arg) catch failure:
        failed = true
        recover js_undefined()
    is_reject = failed
    if is_reject:
        res = js_get_exception(ctx)
    defer js_free_value(ctx, res)
    let func_ = argv[(usize)is_reject]
    # as an extension, we support undefined as value to avoid creating a dummy promise in
    # the 'await' implementation of async functions
    if not js_is_undefined(func_):
        return try js_call(ctx, func_, js_undefined(), 1, &res)
    return js_undefined()

## Set the callback called when a promise is rejected with or without a handler
## (JS_SetHostPromiseRejectionTracker).
pub func js_set_host_promise_rejection_tracker(rt: Runtime*, cb: HostPromiseRejectionTracker?, opaque: void*?):
    rt.host_promise_rejection_tracker = cb
    rt.host_promise_rejection_tracker_opaque = opaque

# mark: Settling ================================================================================

## The reaction record of the list link `el`.
func promise_reaction_of(el: cutils.ListHead*) -> PromiseReactionData*:
    return (PromiseReactionData*)((u8*)el - memory.offset_of(PromiseReactionData, link))

## Settle the pending `promise` with `value`: queue a job for each reaction of the outcome
## and drop the others (fulfill_or_reject_promise).
func fulfill_or_reject_promise(ctx: Context*, promise: Value, value: Value, is_reject: bool):
    let raw = js_get_opaque(promise, (u32)ClassId.promise) else return  # should never happen
    let s = (PromiseData*)raw
    if s.promise_state != PromiseState.pending:
        return  # should never happen
    set_value(ctx, &s.promise_result, js_dup_value(ctx, value))
    s.promise_state = (PromiseState)((i32)PromiseState.fulfilled + (i32)is_reject)
    if s.promise_state == PromiseState.rejected and not s.is_handled:
        let rt = ctx.rt
        if let tracker = rt.host_promise_rejection_tracker:
            tracker(ctx, promise, value, false, rt.host_promise_rejection_tracker_opaque)

    let reactions = &s.promise_reactions[(usize)is_reject]
    var el = reactions.next else trap("fulfill_or_reject_promise: unlinked list")
    while el != reactions:
        let el1 = el.next else trap("fulfill_or_reject_promise: unlinked list")
        let rd = promise_reaction_of(el)
        var args: Value[5] = [rd.resolving_funcs[0], rd.resolving_funcs[1], rd.handler,
                              js_new_bool(is_reject), value]
        # as upstream, a failure to queue the job is not reported
        js_enqueue_job(ctx, promise_reaction_job, 5, &args[0]) catch: recover ()
        cutils.list_del(&rd.link)
        promise_reaction_data_free(ctx.rt, rd)
        el = el1

    let others = &s.promise_reactions[(usize)(1 - (i32)is_reject)]
    el = others.next else trap("fulfill_or_reject_promise: unlinked list")
    while el != others:
        let el1 = el.next else trap("fulfill_or_reject_promise: unlinked list")
        let rd = promise_reaction_of(el)
        cutils.list_del(&rd.link)
        promise_reaction_data_free(ctx.rt, rd)
        el = el1

## Reject the pending `promise` with `value` (reject_promise).
func reject_promise(ctx: Context*, promise: Value, value: Value):
    fulfill_or_reject_promise(ctx, promise, value, true)