safe-resolve-thenables.js

Enable keyboard shortcuts

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

//

// JS::SafeResolve: promise-like and non-native-promise resolution values must

// be handled via a deferred microtask, so that Get(resolution, "then") never

// runs on the caller's stack.

// ---------------------------------------------------------------------------

// Plain thenable with a callable data "then" property on the object itself.

  const {promise} = Promise.withResolvers();

  const observations = [];

  const thenable = {

     then(onFulfilled, onRejected) {

        observations.push("then-called");

        onFulfilled(42);

},

};

  safeResolvePromise(promise, thenable);

  // Neither the getter nor the returned function should be called.

  assertEq(observations.length, 0);

  let settled;

  promise.then(v => { settled = v; });

  drainJobQueue();

  assertEq(observations[0], "then-called");

  assertEq(settled, 42);

// ---------------------------------------------------------------------------

// Thenable where "then" is an accessor (getter). Pure lookup can't read it;

// SafeResolve must defer and the getter runs in the job, not synchronously.

  const {promise} = Promise.withResolvers();

  const log = [];

  const thenable = {

    get then() {

      log.push("get-then");

      return function(onFulfilled) {

        log.push("call-then");

        onFulfilled("from-getter");

};

},

};

  safeResolvePromise(promise, thenable);

  // The getter must not have run yet.

  assertEq(log.length, 0);

  let settled;

  promise.then(v => { settled = v; });

  drainJobQueue();

  assertEq(log.join(","), "get-then,call-then");

  assertEq(settled, "from-getter");

// ---------------------------------------------------------------------------

// Thenable where "then" lives on the prototype (inherited). Must be treated

// as callable and deferred.

  const {promise} = Promise.withResolvers();

  const log = [];

  class Thenable {

    then(onFulfilled) {

      log.push("proto-then");

      onFulfilled("proto-value");

  const thenable = new Thenable();

  safeResolvePromise(promise, thenable);

  assertEq(log.length, 0);

  let settled;

  promise.then(v => { settled = v; });

  drainJobQueue();

  assertEq(log[0], "proto-then");

  assertEq(settled, "proto-value");

// ---------------------------------------------------------------------------

// Proxy with a "then" trap. Proxies MUST force deferral regardless of trap

// behavior, because any MOP access could run user code.

  const {promise} = Promise.withResolvers();

  const log = [];

  const target = {};

  const handler = {

    get(t, name) {

      log.push("proxy-get:" + String(name));

      if (name === "then") {

        return function(onFulfilled) {

          log.push("proxy-then");

          onFulfilled("proxy-value");

};

      return t[name];

},

};

  const thenable = new Proxy(target, handler);

  safeResolvePromise(promise, thenable);

  // No MOP access should have happened yet.

  assertEq(log.length, 0);

  let settled;

  promise.then(v => { settled = v; });

  drainJobQueue();

  // In the microtask, Get(resolution, "then") happens exactly once, then the

  // assimilation job calls the returned function (a separate MOP access —

  // "get" trap is not invoked for calling a function already retrieved).

  assertEq(log[0], "proxy-get:then");

  assertEq(log[1], "proxy-then");

  assertEq(settled, "proxy-value");

// ---------------------------------------------------------------------------

// Revoked proxy: Get("then") throws. The rejection must happen in the job,

// not synchronously.

  const {promise} = Promise.withResolvers();

  const {proxy, revoke} = Proxy.revocable({}, {});

  revoke();

  safeResolvePromise(promise, proxy);

  let result = null;

  promise.then(v => { result = {fulfilled: v}; },

               e => { result = {rejected: e}; });

  drainJobQueue();

  assertEq(result !== null, true);

  assertEq("rejected" in result, true);

// ---------------------------------------------------------------------------

// Proxy whose "then" is NOT callable. Must still defer, then fulfill with the

// object itself (because IsCallable(then) is false in PerformPromiseResolution).

  const {promise} = Promise.withResolvers();

  const target = {};

  const proxy = new Proxy(target, {

    get(t, name) { return name === "then" ? 42 : t[name]; },

});

  safeResolvePromise(promise, proxy);

  let settled;

  promise.then(v => { settled = v; });

  drainJobQueue();

  assertEq(settled, proxy);

// ---------------------------------------------------------------------------

// A real Promise as the resolution value, with an observable own "then" so we

// can verify the call happens in the deferred job, not on the caller's stack.

  const {promise} = Promise.withResolvers();

  const inner = Promise.resolve("inner-value");

  const observations = [];

  const originalThen = Promise.prototype.then;

  Object.defineProperty(inner, "then", {

    value: function(...args) {

      observations.push("then-called");

      return originalThen.apply(this, args);

},

    writable: true, configurable: true,

});

  safeResolvePromise(promise, inner);

  assertEq(observations.length, 0);

  let settled;

  promise.then(v => { settled = v; });

  drainJobQueue();

  assertEq(observations[0], "then-called");

  assertEq(settled, "inner-value");

// ---------------------------------------------------------------------------

// Cross-compartment promise as the resolution value.

  const g = newGlobal({newCompartment: true});

  const {promise} = Promise.withResolvers();

  const inner = g.eval("Promise.resolve('cross-realm')");

  safeResolvePromise(promise, inner);

  let settled;

  promise.then(v => { settled = v; });

  drainJobQueue();

  assertEq(settled, "cross-realm");