Function callPyObjectKwargsPromising

src/core/pyproxy.ts:576–651

* A version of callPyObjectKwargs that supports the JSPI. * * It returns a promise. Inside Python, JS promises can be syncified, which * switches the stack to synchronously wait for them to be resolved. * * Pretty much everything is the same as callPyObjectKwargs except we use the * special JS

(
  ptrobj: number,
  jsargs: any,
  kwargs: any,
)

 * _pyproxy_apply with the same arguments we gave to `promisingApply`.
 */
async function callPyObjectKwargsPromising(
  ptrobj: number,
  jsargs: any,
  kwargs: any,
) {
  if (!Module.jspiSupported) {
    throw new Error(
      "WebAssembly stack switching not supported in this JavaScript runtime",
    );
  }
  // We don't do any checking for kwargs, checks are in PyProxy.callKwargs
  // which only is used when the keyword arguments come from the user.
  const num_pos_args = jsargs.length;
  const kwargs_names = Object.keys(kwargs);
  const kwargs_values = Object.values(kwargs);
  const num_kwargs = kwargs_names.length;
  jsargs.push(...kwargs_values);
  // We have to take ownership of the pointer before we sleep or else it could
  // get freed out from under us. This also fixes a bug that was around before
  // we added the sleep.
  _Py_IncRef(ptrobj);
  // Yield to the event loop before starting the task. We may have been called by
  // WebAssembly stack frames which own data on the stack. We can't overwrite that
  // data until those stack frames are finished with it. Returning to the event
  // loop first unwinds all the caller frames. That way enterTask() is free to
  // place the task wherever it likes.
  await new Promise<void>((res) => API.scheduleCallback(res, 0));
  let result;
  const exc = _malloc(4);
  try {
    // enterTask() decides where the stackStop of the new task should be.
    enterTask();
    Py_ENTER();
    // promisingApply clears the error flag and saves any error into excStatus.
    // This ensures that tasks that are run between when promisingApply resolves
    // and when this task resumes here won't incorrectly observe the error flag.
    // See test_stack_switching.test_throw_from_switcher for a detailed
    // explanation.
    //
    // The result of promisingApply() is wrapped in a one element list
    // (regardless of whether there was an error or not) to ensure that we only
    // await the stack switches and not a thenable result.
    result = await Module.promisingApply(
      ptrobj,
      jsargs,
      num_pos_args,
      kwargs_names,
      num_kwargs,
      exc,
    );
    Py_EXIT();
  } catch (e) {
    API.fatal_error(e);
  }
  try {
    // Unwrap result
    result = result[0];
    if (result === Module.error) {