safe-resolve-ticks.js

Enable keyboard shortcuts

// |jit-test| skip-if: getBuildConfiguration("release_or_beta")

//

// JS::SafeResolve of a thenable settles the outer promise at the SAME

// microtask depth as an ordinary resolve(thenable). Under the updated

// thenable-curtailment spec, PerformPromiseResolution runs in ~deferred~

// mode: when it finds a callable "then" it invokes PerformPromiseResolveThenable

// synchronously rather than enqueuing a further job, so the deferred resolution

// does not add an extra tick relative to normal assimilation.

// Measure at which microtask "tick" the outer reaction fires, by racing it

// against a chain of native-promise reactions that bump `tick`.

function measure(installResolution) {

  const {promise} = Promise.withResolvers();

  let ticksAtFulfill = -1;

  let tick = 0;

  promise.then(() => { ticksAtFulfill = tick; });

  installResolution(promise);

  let pending = Promise.resolve();

  for (let i = 0; i < 6; i++) {

    pending = pending.then(() => { tick++; });

  drainJobQueue();

  assertEq(ticksAtFulfill >= 0, true, "reaction fired at some tick");

  return ticksAtFulfill;

// Baseline: a normal resolve(thenable). The resolve function lives on the

// capability, so we need the resolvers; reproduce measure() inline to get it.

function measureNormal() {

  const {promise, resolve} = Promise.withResolvers();

  let ticksAtFulfill = -1;

  let tick = 0;

  promise.then(() => { ticksAtFulfill = tick; });

  resolve({ then(onFulfilled) { onFulfilled("normal"); } });

  let pending = Promise.resolve();

  for (let i = 0; i < 6; i++) {

    pending = pending.then(() => { tick++; });

  drainJobQueue();

  assertEq(ticksAtFulfill >= 0, true, "reaction fired at some tick");

  return ticksAtFulfill;

// Plain callable-"then" thenable.

  const baseline = measureNormal();

  const safe = measure(p => {

    safeResolvePromise(p, { then(onFulfilled) { onFulfilled("safe"); } });

});

  assertEq(safe, baseline,

           "SafeResolve(thenable) settles at the same tick as resolve(thenable)");

// A real Promise as the resolution value: same invariant.

  let baseTick;

    const {promise, resolve} = Promise.withResolvers();

    let ticksAtFulfill = -1, tick = 0;

    promise.then(() => { ticksAtFulfill = tick; });

    resolve(Promise.resolve("inner"));

    let pending = Promise.resolve();

    for (let i = 0; i < 7; i++) pending = pending.then(() => { tick++; });

    drainJobQueue();

    baseTick = ticksAtFulfill;

  let safeTick;

    const {promise} = Promise.withResolvers();

    let ticksAtFulfill = -1, tick = 0;

    promise.then(() => { ticksAtFulfill = tick; });

    safeResolvePromise(promise, Promise.resolve("inner"));

    let pending = Promise.resolve();

    for (let i = 0; i < 7; i++) pending = pending.then(() => { tick++; });

    drainJobQueue();

    safeTick = ticksAtFulfill;

  assertEq(safeTick, baseTick,

           "promise-with-promise via SafeResolve settles at the same tick");