Merge branch 'main' into Xmader/chore/spidermonkey-115

Xmader · Xmader · commit 044bdf2a2deb · 2023-08-10T21:25:33.000Z
diff --git a/.eslintrc.js b/.eslintrc.js
@@ -25,26 +25,23 @@ module.exports = {
   },
   rules: {
     'indent':                                   [ 'warn', 2, {
-        SwitchCase: 1,
-        ignoredNodes: ['CallExpression', 'ForStatement'],
-      }
-    ],
+      SwitchCase: 1,
+      ignoredNodes: ['CallExpression', 'ForStatement'],
+    }],
     'linebreak-style':                          [ 'error', 'unix' ],
-    'quotes':                                   [ 'warn', 'single' ],
     'func-call-spacing':                        [ 'off', 'never' ],
     'no-prototype-builtins':                    'off',
-    'quotes':                                   ['warn', 'single', 'avoid-escape'],
+    'quotes':                                   [ 'warn', 'single', 'avoid-escape' ],
     'no-empty': [ 'warn' ],
     'no-multi-spaces':                          [ 'off' ],
     'prettier/prettier':                        [ 'off' ],
     'vars-on-top':                              [ 'error' ],
     'no-var':                                   [ 'off' ],
     'spaced-comment':                           [ 'warn' ],
-    'brace-style':                              [ 'off' ],
+    'brace-style':                              [ 'warn', 'allman' ],
     'no-eval':                                  [ 'error' ],
     'object-curly-spacing':                     [ 'warn',       'always' ],
     'eqeqeq':                                   [ 'warn',       'always' ],
-    'no-dupe-keys':                             [ 'warn' ],
     'no-constant-condition':                    [ 'warn' ],
     'no-extra-boolean-cast':                    [ 'warn' ],
     'no-sparse-arrays':                         [ 'off' ],
@@ -60,16 +57,15 @@ module.exports = {
     'no-unused-expressions':                    [ 'warn',       { allowShortCircuit: true, allowTernary: true } ],
     'prefer-promise-reject-errors':             [ 'error' ],
     'no-throw-literal':                         [ 'error' ],
-    'semi':                                     [ 'off',        { omitLastInOneLineBlock: true }], /* does not work right with exports.X = function allmanStyle */
+    'semi':                                     [ 'warn'  ],
     'semi-style':                               [ 'warn',       'last' ],
-    'semi-spacing':                             [ 'error',      {'before': false, 'after': true}],
+    'semi-spacing':                             [ 'error',      { 'before': false, 'after': true }],
     'no-extra-semi':                            [ 'warn' ],
     'no-tabs':                                  [ 'error' ],
     'symbol-description':                       [ 'error' ],
     'operator-linebreak':                       [ 'warn',       'before' ],
     'new-cap':                                  [ 'warn' ],
     'consistent-this':                          [ 'error',      'that' ],
-    'no-use-before-define':                     [ 'error',      { functions: false, classes: false } ],
     'no-shadow':                                [ 'error' ],
     'no-label-var':                             [ 'error' ],
     'radix':                                    [ 'error' ],
@@ -89,10 +85,9 @@ module.exports = {
       allow: ['!!'] /* really only want to allow if(x) and if(!x) but not if(!!x) */
     }],
     'no-trailing-spaces': [ 'off', {
-        skipBlankLines: true,
-        ignoreComments: true
-      }
-                          ],
+      skipBlankLines: true,
+      ignoreComments: true
+    }],
     'no-unused-vars':                           ['warn',        {
       vars: 'all',
       args: 'none',
diff --git a/include/PyEventLoop.hh b/include/PyEventLoop.hh
@@ -15,6 +15,7 @@
 #include <Python.h>
 #include <vector>
 #include <utility>
+#include <atomic>
 
 struct PyEventLoop {
 public:
@@ -179,9 +180,54 @@ public:
    */
   static PyEventLoop getMainLoop();
 
-protected:
-  PyObject *_loop;
+  struct Lock {
+  public:
+    explicit Lock() {
+      PyObject *asyncio = PyImport_ImportModule("asyncio");
+      _queueIsEmpty = PyObject_CallMethod(asyncio, "Event", NULL); // _queueIsEmpty = asyncio.Event()
+      Py_DECREF(asyncio);
+
+      // The flag should initially be set as the queue is initially empty
+      Py_XDECREF(PyObject_CallMethod(_queueIsEmpty, "set", NULL)); // _queueIsEmpty.set()
+    };
+    ~Lock() {
+      Py_DECREF(_queueIsEmpty);
+    }
 
+    /**
+     * @brief Increment the counter for the number of our job functions in the Python event-loop
+     */
+    inline void incCounter() {
+      _counter++;
+      Py_XDECREF(PyObject_CallMethod(_queueIsEmpty, "clear", NULL)); // _queueIsEmpty.clear()
+    }
+
+    /**
+     * @brief Decrement the counter for the number of our job functions in the Python event-loop
+     */
+    inline void decCounter() {
+      _counter--;
+      if (_counter == 0) { // no job queueing
+        // Notify that the queue is empty and awake (unblock) the event-loop shield
+        Py_XDECREF(PyObject_CallMethod(_queueIsEmpty, "set", NULL)); // _queueIsEmpty.set()
+      } else if (_counter < 0) { // something went wrong
+        PyErr_SetString(PyExc_RuntimeError, "Event-loop job counter went below zero.");
+      }
+    }
+
+    /**
+     * @brief An `asyncio.Event` instance to notify that there are no queueing asynchronous jobs
+     * @see https://docs.python.org/3/library/asyncio-sync.html#asyncio.Event
+     */
+    PyObject *_queueIsEmpty = nullptr;
+  protected:
+    std::atomic_int _counter = 0;
+  };
+
+  static inline PyEventLoop::Lock *_locker;
+
+  PyObject *_loop;
+protected:
   PyEventLoop() = delete;
   PyEventLoop(PyObject *loop) : _loop(loop) {};
 private:
diff --git a/include/internalBinding.hh b/include/internalBinding.hh
@@ -14,6 +14,7 @@
 
 namespace InternalBinding {
   extern JSFunctionSpec utils[];
+  extern JSFunctionSpec timers[];
 }
 
 JSObject *createInternalBindingsForNamespace(JSContext *cx, JSFunctionSpec *methodSpecs);
diff --git a/peter-jr b/peter-jr
@@ -21,6 +21,7 @@ cd "$runDir"
 set -u
 set -o pipefail
 peter_exit_code=2
+defaultTimeout="${defaultTimeout:-15}"
 
 if [ "${1:-}" = "-h" ] || [ "${1:-}" = "--help" ]; then
 cat <<EOF
@@ -160,13 +161,14 @@ findTests \
       FAIL="$(red FAIL)"
     fi
     (
+      timeout=$(egrep '^( *[*#] *timeout: )' "$file" | head -1 | sed -e 's/^\( *[*#] *timeout: \)//')
       case "$testType" in
         "simple")
-          "${PMJS}" "$file"
+          eval timeout -s9 "${timeout:-${defaultTimeout}}" "${PMJS}" \"$file\"
           exitCode="$?"
           ;;
         "bash")
-          bash "$file"
+          eval timeout -s9 "${timeout:-${defaultTimeout}}" bash \"$file\"
           exitCode="$?"
           ;;
         *)
diff --git a/python/pythonmonkey/__init__.py b/python/pythonmonkey/__init__.py
@@ -8,9 +8,10 @@
 __version__= importlib.metadata.version(__name__)
 del importlib
 
-# Load the module by default to make `console`/`atob`/`btoa` globally available
+# Load the module by default to expose global APIs
 require("console")
 require("base64")
+require("timers")
 
 # Add the `.keys()` method on `Object.prototype` to get JSObjectProxy dict() conversion working
 # Conversion from a dict-subclass to a strict dict by `dict(subclass)` internally calls the .keys() method to read the dictionary keys, 
diff --git a/python/pythonmonkey/builtin_modules/internal-binding.d.ts b/python/pythonmonkey/builtin_modules/internal-binding.d.ts
@@ -30,4 +30,19 @@ declare function internalBinding(namespace: "utils"): {
   getProxyDetails<T extends object>(proxy: T): undefined | [target: T, handler: ProxyHandler<T>];
 };
 
+declare function internalBinding(namespace: "timers"): {
+  /**
+   * internal binding helper for the `setTimeout` global function
+   * 
+   * **UNSAFE**, does not perform argument type checks
+   * @return timeoutId
+   */
+  enqueueWithDelay(handler: Function, delaySeconds: number): number;
+
+  /**
+   * internal binding helper for the `clearTimeout` global function
+   */
+  cancelByTimeoutId(timeoutId: number): void;
+};
+
 export = internalBinding;
diff --git a/python/pythonmonkey/builtin_modules/timers.js b/python/pythonmonkey/builtin_modules/timers.js
@@ -0,0 +1,65 @@
+/**
+ * @file     timers.js
+ * @author   Tom Tang <xmader@distributive.network>
+ * @date     May 2023
+ */
+const internalBinding = require('internal-binding');
+
+const { 
+  enqueueWithDelay,
+  cancelByTimeoutId
+} = internalBinding('timers');
+
+/**
+ * Implement the `setTimeout` global function
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/setTimeout and
+ * @see https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
+ * @param {Function | string} handler
+ * @param {number} delayMs timeout milliseconds, use value of 0 if this is omitted
+ * @param {any[]} args additional arguments to be passed to the `handler`
+ * @return {number} timeoutId
+ */
+function setTimeout(handler, delayMs = 0, ...args) 
+{
+  // Ensure the first parameter is a function
+  // We support passing a `code` string to `setTimeout` as the callback function
+  if (typeof handler !== 'function')
+    handler = new Function(handler);
+
+  // `setTimeout` allows passing additional arguments to the callback, as spec-ed
+  // FIXME (Tom Tang): the spec doesn't allow additional arguments to be passed if the original `handler` is not a function
+  const thisArg = globalThis; // HTML spec requires `thisArg` to be the global object
+  // Wrap the job function into a bound function with the given additional arguments
+  //    https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind
+  /** @type {Function} */
+  const boundHandler = handler.bind(thisArg, ...args);
+
+  // Get the delay time in seconds
+  //  JS `setTimeout` takes milliseconds, but Python takes seconds
+  delayMs = Number(delayMs) || 0; // ensure the `delayMs` is a `number`, explicitly do type coercion
+  if (delayMs < 0)
+    delayMs = 0; // as spec-ed
+  const delaySeconds = delayMs / 1000; // convert ms to s
+
+  return enqueueWithDelay(boundHandler, delaySeconds);
+}
+
+/**
+ * Implement the `clearTimeout` global function
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/clearTimeout and
+ * @see https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-cleartimeout
+ * @param {number} timeoutId
+ * @return {void}
+ */
+function clearTimeout(timeoutId) 
+{
+  return cancelByTimeoutId(timeoutId);
+}
+
+if (!globalThis.setTimeout)
+  globalThis.setTimeout = setTimeout;
+if (!globalThis.clearTimeout)
+  globalThis.clearTimeout = clearTimeout;
+
+exports.setTimeout = setTimeout;
+exports.clearTimeout = clearTimeout;
diff --git a/python/pythonmonkey/cli/pmjs.py b/python/pythonmonkey/cli/pmjs.py
@@ -5,6 +5,7 @@
 
 import sys, os, signal, getopt
 import readline
+import asyncio
 import pythonmonkey as pm
 from pythonmonkey.lib import pmdb
 
@@ -356,8 +357,11 @@ def main():
             assert False, "unhandled option"
 
     if (len(args) > 0):
-        globalInitModule.patchGlobalRequire()
-        pm.runProgramModule(args[0], args, requirePath)
+        async def runJS():
+            globalInitModule.patchGlobalRequire()
+            pm.runProgramModule(args[0], args, requirePath)
+            await pm.wait() # blocks until all asynchronous calls finish
+        asyncio.run(runJS())
     elif (enterRepl or forceRepl):
         globalInitModule.initReplLibs()
         repl()
diff --git a/python/pythonmonkey/global.d.ts b/python/pythonmonkey/global.d.ts
@@ -51,6 +51,10 @@ declare var console: import("console").Console;
 declare var atob: typeof import("base64").atob;
 declare var btoa: typeof import("base64").btoa;
 
+// Expose `setTimeout`/`clearTimeout` APIs
+declare var setTimeout: typeof import("timers").setTimeout;
+declare var clearTimeout: typeof import("timers").clearTimeout;
+
 // Keep this in sync with both https://hg.mozilla.org/releases/mozilla-esr102/file/a03fde6/js/public/Promise.h#l331
 //                        and  https://github.com/nodejs/node/blob/v20.2.0/deps/v8/include/v8-promise.h#L30
 declare enum PromiseState { Pending = 0, Fulfilled = 1, Rejected = 2 }
diff --git a/python/pythonmonkey/pythonmonkey.pyi b/python/pythonmonkey/pythonmonkey.pyi
@@ -22,6 +22,17 @@ def eval(code: str, evalOpts: EvalOptions = {}, /) -> _typing.Any:
     JavaScript evaluator in Python
     """
 
+def wait() -> _typing.Awaitable[None]:
+    """
+    Block until all asynchronous jobs (Promise/setTimeout/etc.) finish.
+    
+    ```py
+    await pm.wait()
+    ```
+
+    This is the event-loop shield that protects the loop from being prematurely terminated.
+    """
+
 def isCompilableUnit(code: str) -> bool:
     """
     Hint if a string might be compilable Javascript without actual evaluation
diff --git a/src/PyEventLoop.cc b/src/PyEventLoop.cc
@@ -2,17 +2,36 @@
 
 #include <Python.h>
 
+/**
+ * @brief Wrapper to decrement the counter of queueing event-loop jobs after the job finishes
+ */
+static PyObject *eventLoopJobWrapper(PyObject *jobFn, PyObject *Py_UNUSED(_)) {
+  PyObject *ret = PyObject_CallObject(jobFn, NULL); // jobFn()
+  Py_XDECREF(ret); // don't care about its return value
+  PyEventLoop::_locker->decCounter();
+  if (PyErr_Occurred()) {
+    return NULL;
+  } else {
+    Py_RETURN_NONE;
+  }
+}
+static PyMethodDef jobWrapperDef = {"eventLoopJobWrapper", eventLoopJobWrapper, METH_NOARGS, NULL};
+
 PyEventLoop::AsyncHandle PyEventLoop::enqueue(PyObject *jobFn) {
+  PyEventLoop::_locker->incCounter();
+  PyObject *wrapper = PyCFunction_New(&jobWrapperDef, jobFn);
   // Enqueue job to the Python event-loop
   //    https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.call_soon
-  PyObject *asyncHandle = PyObject_CallMethod(_loop, "call_soon_threadsafe", "O", jobFn); // https://docs.python.org/3/c-api/arg.html#c.Py_BuildValue
+  PyObject *asyncHandle = PyObject_CallMethod(_loop, "call_soon_threadsafe", "O", wrapper); // https://docs.python.org/3/c-api/arg.html#c.Py_BuildValue
   return PyEventLoop::AsyncHandle(asyncHandle);
 }
 
 PyEventLoop::AsyncHandle PyEventLoop::enqueueWithDelay(PyObject *jobFn, double delaySeconds) {
+  PyEventLoop::_locker->incCounter();
+  PyObject *wrapper = PyCFunction_New(&jobWrapperDef, jobFn);
   // Schedule job to the Python event-loop
   //    https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.call_later
-  PyObject *asyncHandle = PyObject_CallMethod(_loop, "call_later", "dO", delaySeconds, jobFn); // https://docs.python.org/3/c-api/arg.html#c.Py_BuildValue
+  PyObject *asyncHandle = PyObject_CallMethod(_loop, "call_later", "dO", delaySeconds, wrapper); // https://docs.python.org/3/c-api/arg.html#c.Py_BuildValue
   if (asyncHandle == nullptr) {
     PyErr_Print(); // RuntimeError: Non-thread-safe operation invoked on an event loop other than the current one
   }
@@ -122,6 +141,14 @@ PyEventLoop PyEventLoop::getRunningLoop() {
 }
 
 void PyEventLoop::AsyncHandle::cancel() {
+  PyObject *scheduled = PyObject_GetAttrString(_handle, "_scheduled"); // this attribute only exists on asyncio.TimerHandle returned by loop.call_later
+                                                                       // NULL if no such attribute (on a strict asyncio.Handle returned by loop.call_soon)
+  bool finishedOrCanceled = scheduled && scheduled == Py_False; // the job function has already been executed or canceled
+  if (!finishedOrCanceled) {
+    PyEventLoop::_locker->decCounter();
+  }
+  Py_XDECREF(scheduled);
+
   // https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.Handle.cancel
   PyObject *ret = PyObject_CallMethod(_handle, "cancel", NULL); // returns None
   Py_XDECREF(ret);
diff --git a/src/internalBinding.cc b/src/internalBinding.cc
@@ -23,6 +23,8 @@ JSObject *createInternalBindingsForNamespace(JSContext *cx, JSFunctionSpec *meth
 JSObject *getInternalBindingsByNamespace(JSContext *cx, JSLinearString *namespaceStr) {
   if (JS_LinearStringEqualsLiteral(namespaceStr, "utils")) {
     return createInternalBindingsForNamespace(cx, InternalBinding::utils);
+  } else if (JS_LinearStringEqualsLiteral(namespaceStr, "timers")) {
+    return createInternalBindingsForNamespace(cx, InternalBinding::timers);
   } else { // not found
     return nullptr;
   }
diff --git a/src/internalBinding/timers.cc b/src/internalBinding/timers.cc
diff --git a/src/modules/pythonmonkey/pythonmonkey.cc b/src/modules/pythonmonkey/pythonmonkey.cc
diff --git a/tests/js/js2py/promise-await-in-python.simple b/tests/js/js2py/promise-await-in-python.simple
diff --git a/tests/js/js2py/promise.simple b/tests/js/js2py/promise.simple
diff --git a/tests/python/test_event_loop.py b/tests/python/test_event_loop.py

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`
`15`	`15`	`namespace InternalBinding {`
`16`	`16`	`extern JSFunctionSpec utils[];`
	`17`	`+ extern JSFunctionSpec timers[];`
`17`	`18`	`}`
`18`	`19`
`19`	`20`	`JSObject createInternalBindingsForNamespace(JSContext cx, JSFunctionSpec *methodSpecs);`