Merge branch 'main' into caleb/fix/variadic

philippedistributive · web-flow · commit 4cfd707bfe58 · 2024-06-14T11:38:51.000-04:00
diff --git a/README.md b/README.md
@@ -164,11 +164,11 @@ They are largely based on SpiderMonkey's `CompileOptions`. The supported option
 - `filename`: set the filename of this code for the purposes of generating stack traces etc.
 - `lineno`: set the line number offset of this code for the purposes of generating stack traces etc.
 - `column`: set the column number offset of this code for the purposes of generating stack traces etc.
-- `mutedErrors`: experimental
-- `noScriptRval`: experimental
-- `selfHosting`: experimental
-- `strict`: experimental
-- `module`: experimental
+- `mutedErrors`: if set to `True`, eval errors or unhandled rejections are ignored ("muted"). Default `False`.
+- `noScriptRval`: if `False`, return the last expression value of the script as the result value to the caller. Default `False`.
+- `selfHosting`: *experimental*
+- `strict`: forcibly evaluate in strict mode (`"use strict"`). Default `False`.
+- `module`: indicate the file is an ECMAScript module (always strict mode code and disallow HTML comments). Default `False`.
 - `fromPythonFrame`: generate the equivalent of filename, lineno, and column based on the location of
   the Python call to eval. This makes it possible to evaluate Python multiline string literals and
   generate stack traces in JS pointing to the error in the Python source file.
diff --git a/python/pminit/pminit/cli.py b/python/pminit/pminit/cli.py
@@ -11,8 +11,8 @@ def execute(cmd: str, cwd: str):
 
     popen.stdout.close()
     return_code = popen.wait()
-    if return_code:
-        raise subprocess.CalledProcessError(return_code, cmd)
+    if return_code != 0:
+        sys.exit(return_code)
 
 def commandType(value: str):
     if value != "npm":
@@ -34,7 +34,3 @@ def main():
     )
 
     execute(' '.join( args.executable + args.args ), pythonmonkey_path)
-
-    
-    
-    
diff --git a/python/pythonmonkey/helpers.py b/python/pythonmonkey/helpers.py
@@ -43,8 +43,19 @@ def new(ctor):
   return (lambda *args: newCtor(list(args)))
 
 
+def simpleUncaughtExceptionHandler(loop, context):
+  """
+  A simple exception handler for uncaught JS Promise rejections sent to the Python event-loop
+
+  See https://docs.python.org/3.11/library/asyncio-eventloop.html#error-handling-api
+  """
+  error = context["exception"]
+  pm.eval("(err) => console.error('Uncaught', err)")(error)
+  pm.stop()  # unblock `await pm.wait()` to gracefully exit the program
+
+
 # List which symbols are exposed to the pythonmonkey module.
-__all__ = ["new", "typeof"]
+__all__ = ["new", "typeof", "simpleUncaughtExceptionHandler"]
 
 # Add the non-enumerable properties of globalThis which don't collide with pythonmonkey.so as exports:
 globalThis = pm.eval('globalThis')
diff --git a/python/pythonmonkey/pythonmonkey.pyi b/python/pythonmonkey/pythonmonkey.pyi
@@ -1,4 +1,5 @@
 """
+stub file for type hints & documentations for the native module
 @see https://typing.readthedocs.io/en/latest/source/stubs.html
 """
 
@@ -25,6 +26,25 @@ def eval(code: str, evalOpts: EvalOptions = {}, /) -> _typing.Any:
   """
 
 
+def require(moduleIdentifier: str, /) -> JSObjectProxy:
+  """
+  Return the exports of a CommonJS module identified by `moduleIdentifier`, using standard CommonJS semantics
+  """
+
+
+def new(ctor: JSFunctionProxy) -> _typing.Callable[..., _typing.Any]:
+  """
+  Wrap the JS new operator, emitting a lambda which constructs a new
+  JS object upon invocation
+  """
+
+
+def typeof(jsval: _typing.Any, /):
+  """
+  This is the JS `typeof` operator, wrapped in a function so that it can be used easily from Python.
+  """
+
+
 def wait() -> _typing.Awaitable[None]:
   """
   Block until all asynchronous jobs (Promise/setTimeout/etc.) finish.
@@ -43,6 +63,12 @@ def stop() -> None:
   """
 
 
+def runProgramModule(filename: str, argv: _typing.List[str], extraPaths: _typing.List[str] = []) -> None:
+  """
+  Load and evaluate a program (main) module. Program modules must be written in JavaScript.
+  """
+
+
 def isCompilableUnit(code: str) -> bool:
   """
   Hint if a string might be compilable Javascript without actual evaluation
@@ -55,6 +81,14 @@ def collect() -> None:
   """
 
 
+def internalBinding(namespace: str) -> JSObjectProxy:
+  """
+  INTERNAL USE ONLY
+
+  See function declarations in ./builtin_modules/internal-binding.d.ts
+  """
+
+
 class JSFunctionProxy():
   """
   JavaScript Function proxy
@@ -81,13 +115,60 @@ class JSMethodProxy(JSFunctionProxy, object):
   print(myObject.value) # 42.0
   """
 
-  def __init__(self) -> None:
-    """
-    PythonMonkey init function
-    """
+  def __init__(self) -> None: "deleted"
+
+
+class JSObjectProxy(dict):
+  """
+  JavaScript Object proxy dict
+  """
+
+  def __init__(self) -> None: "deleted"
+
+
+class JSArrayProxy(list):
+  """
+  JavaScript Array proxy
+  """
+
+  def __init__(self) -> None: "deleted"
+
+
+class JSArrayIterProxy(_typing.Iterator):
+  """
+  JavaScript Array Iterator proxy
+  """
+
+  def __init__(self) -> None: "deleted"
+
+
+class JSStringProxy(str):
+  """
+  JavaScript String proxy
+  """
+
+  def __init__(self) -> None: "deleted"
+
+
+class bigint(int):
+  """
+  Representing JavaScript BigInt in Python
+  """
+
+
+class SpiderMonkeyError(Exception):
+  """
+  Representing a corresponding JS Error in Python
+  """
 
 
 null = _typing.Annotated[
-    _typing.NewType("pythonmonkey.null", object),
-    "Representing the JS null type in Python using a singleton object",
+  _typing.NewType("pythonmonkey.null", object),
+  "Representing the JS null type in Python using a singleton object",
+]
+
+
+globalThis = _typing.Annotated[
+  JSObjectProxy,
+  "A Python Dict which is equivalent to the globalThis object in JavaScript",
 ]
diff --git a/python/pythonmonkey/require.py b/python/pythonmonkey/require.py
@@ -409,7 +409,8 @@ def runProgramModule(filename, argv, extraPaths=[]):
   globalThis.__filename = fullFilename
   globalThis.__dirname = os.path.dirname(fullFilename)
   with open(fullFilename, encoding="utf-8", mode="r") as mainModuleSource:
-    pm.eval(mainModuleSource.read(), {'filename': fullFilename})
+    pm.eval(mainModuleSource.read(), {'filename': fullFilename, 'noScriptRval': True})
+    # forcibly run in file mode. We shouldn't be getting the last expression of the script as the result value.
 
 # The pythonmonkey require export. Every time it is used, the stack is inspected so that the filename
 # passed to createRequire is correct. This is necessary so that relative requires work. If the filename
diff --git a/src/JobQueue.cc b/src/JobQueue.cc
@@ -9,6 +9,7 @@
  */
 
 #include "include/JobQueue.hh"
+#include "include/modules/pythonmonkey/pythonmonkey.hh"
 
 #include "include/PyEventLoop.hh"
 #include "include/pyTypeFactory.hh"
@@ -134,6 +135,21 @@ void JobQueue::promiseRejectionTracker(JSContext *cx,
     return;
   }
 
+  // Test if there's no user-defined (or pmjs defined) exception handler on the Python event-loop
+  PyEventLoop loop = PyEventLoop::getRunningLoop();
+  if (!loop.initialized()) return;
+  PyObject *customHandler = PyObject_GetAttrString(loop._loop, "_exception_handler"); // see https://github.com/python/cpython/blob/v3.9.16/Lib/asyncio/base_events.py#L1782
+  if (customHandler == Py_None) { // we only have the default exception handler
+    // Set an exception handler to the event-loop
+    PyObject *pmModule = PyImport_ImportModule("pythonmonkey");
+    PyObject *exceptionHandler = PyObject_GetAttrString(pmModule, "simpleUncaughtExceptionHandler");
+    PyObject_CallMethod(loop._loop, "set_exception_handler", "O", exceptionHandler);
+    Py_DECREF(pmModule);
+    Py_DECREF(exceptionHandler);
+  }
+  Py_DECREF(customHandler);
+
+  // Go ahead and send this unhandled Promise rejection to the exception handler on the Python event-loop
   PyObject *pyFuture = PromiseType::getPyObject(cx, promise); // ref count == 2
   // Unhandled Future object calls the event-loop exception handler in its destructor (the `__del__` magic method)
   // See https://github.com/python/cpython/blob/v3.9.16/Lib/asyncio/futures.py#L108
diff --git a/src/pyTypeFactory.cc b/src/pyTypeFactory.cc
@@ -37,6 +37,8 @@
 #include <js/ValueArray.h>
 
 PyObject *pyTypeFactory(JSContext *cx, JS::HandleValue rval) {
+  std::string errorString;
+
   if (rval.isUndefined()) {
     return NoneType::getPyObject();
   }
@@ -53,7 +55,7 @@ PyObject *pyTypeFactory(JSContext *cx, JS::HandleValue rval) {
     return StrType::getPyObject(cx, rval);
   }
   else if (rval.isSymbol()) {
-    printf("symbol type is not handled by PythonMonkey yet");
+    errorString = "symbol type is not handled by PythonMonkey yet.\n";
   }
   else if (rval.isBigInt()) {
     return IntType::getPyObject(cx, rval.toBigInt());
@@ -117,12 +119,17 @@ PyObject *pyTypeFactory(JSContext *cx, JS::HandleValue rval) {
     return DictType::getPyObject(cx, rval);
   }
   else if (rval.isMagic()) {
-    printf("magic type is not handled by PythonMonkey yet\n");
+    errorString = "magic type is not handled by PythonMonkey yet.\n";
   }
 
-  std::string errorString("pythonmonkey cannot yet convert Javascript value of: ");
-  JS::RootedString str(cx, JS::ToString(cx, rval));
-  errorString += JS_EncodeStringToUTF8(cx, str).get();
+  errorString += "pythonmonkey cannot yet convert Javascript value of: ";
+  JSString *valToStr = JS::ToString(cx, rval);
+  if (!valToStr) { // `JS::ToString` returns `nullptr` for JS symbols, see https://hg.mozilla.org/releases/mozilla-esr102/file/3b574e1/js/src/vm/StringType.cpp#l2208
+    // TODO (Tom Tang): Revisit this once we have Symbol coercion support
+    valToStr = JS_ValueToSource(cx, rval);
+  }
+  JS::RootedString valToStrRooted(cx, valToStr);
+  errorString += JS_EncodeStringToUTF8(cx, valToStrRooted).get();
   PyErr_SetString(PyExc_TypeError, errorString.c_str());
   return NULL;
 }
diff --git a/tests/js/uncaught-rejection-handler.bash b/tests/js/uncaught-rejection-handler.bash
@@ -0,0 +1,53 @@
+#! /bin/bash
+#
+# @file        uncaught-rejection-handler.bash
+#              For testing if the actual JS error gets printed out for uncaught Promise rejections, 
+#              instead of printing out a Python `Future exception was never retrieved` error message when not in pmjs
+#
+# @author      Tom Tang (xmader@distributive.network)
+# @date        June 2024
+
+set -u
+set -o pipefail
+
+panic()
+{
+  echo "FAIL: $*" >&2
+  exit 2
+}
+
+cd `dirname "$0"` || panic "could not change to test directory"
+
+code='
+import asyncio
+import pythonmonkey as pm
+
+async def pythonmonkey_main():
+  pm.eval("""void Promise.reject(new TypeError("abc"));""")
+  await pm.wait()
+
+asyncio.run(pythonmonkey_main())
+'
+
+OUTPUT=$(python -c "$code" \
+         < /dev/null 2>&1
+)
+
+echo "$OUTPUT" \
+| tr -d '\r' \
+| (grep -c 'Future exception was never retrieved' || true) \
+| while read qty
+  do
+    echo "$OUTPUT"
+    [ "$qty" != "0" ] && panic "There shouldn't be a 'Future exception was never retrieved' error massage"
+    break
+  done || exit $?
+
+echo "$OUTPUT" \
+| tr -d '\r' \
+| grep -c 'Uncaught TypeError: abc' \
+| while read qty
+  do
+    [ "$qty" != "1" ] && panic "It should print out 'Uncaught TypeError' directly"
+    break
+  done || exit $?
