tla reworking

builtins/web/fetch/fetch_event.cpp

@@ -589,16 +589,14 @@ void exports_wasi_http_incoming_handler(exports_wasi_http_incoming_request reque
 
   dispatch_fetch_event(fetch_event, &total_compute);
 
-  RootedValue result(ENGINE->cx());
-  if (!ENGINE->run_event_loop(&result)) {
-    fflush(stdout);
-    fprintf(stderr, "Error running event loop: ");
-    ENGINE->dump_value(result, stderr);
-    return;
-  }
+  bool success = ENGINE->run_event_loop();
 
   if (JS_IsExceptionPending(ENGINE->cx())) {
-    ENGINE->dump_pending_exception("Error evaluating code: ");
+    ENGINE->dump_pending_exception("evaluating incoming request");
+  }
+
+  if (!success) {
+    fprintf(stderr, "Internal error.");
   }
 
   if (ENGINE->debug_logging_enabled() && ENGINE->has_pending_async_tasks()) {

include/extension-api.h

@@ -48,7 +48,7 @@ class Engine {
   void enable_module_mode(bool enable);
   bool eval_toplevel(const char *path, MutableHandleValue result);
 
-  bool run_event_loop(MutableHandleValue result);
+  bool run_event_loop();
 
   /**
    * Get the JS value associated with the top-level script execution -

runtime/engine.cpp

@@ -358,14 +358,25 @@ bool api::Engine::eval_toplevel(const char *path, MutableHandleValue result) {
     return false;
   }
 
-  // Drive TLA as far as possible. Rejections during pre-initialization are
-  // treated as top-level exceptions. TLA may remain unresolved, in which case
-  // it will continue tasks at runtime. Rejections after pre-intialization remain
-  // unhandled rejections for now.
+  SCRIPT_VALUE.init(cx, ns);
+
+  // Ensure that any pending promise reactions are run before taking the
+  // snapshot.
+  while (js::HasJobsPending(cx)) {
+    js::RunJobs(cx);
+
+    if (JS_IsExceptionPending(cx))
+      abort("running Promise reactions");
+  }
+
+  if (!core::EventLoop::run_event_loop(this, 0)) {
+    return false;
+  }
+
+  // TLA rejections during pre-initialization are treated as top-level exceptions.
+  // TLA may remain unresolved, in which case it will continue tasks at runtime.
+  // Rejections after pre-intialization remain unhandled rejections for now.
   if (tla_promise.isObject()) {
-    if (!core::EventLoop::run_event_loop(this, 0, &tla_promise)) {
-      return false;
-    }
     RootedObject promise_obj(cx, &tla_promise.toObject());
     JS::PromiseState state = JS::GetPromiseState(promise_obj);
     if (state == JS::PromiseState::Rejected) {
@@ -377,17 +388,6 @@ bool api::Engine::eval_toplevel(const char *path, MutableHandleValue result) {
     }
   }
 
-  SCRIPT_VALUE.init(cx, ns);
-
-  // Ensure that any pending promise reactions are run before taking the
-  // snapshot.
-  while (js::HasJobsPending(cx)) {
-    js::RunJobs(cx);
-
-    if (JS_IsExceptionPending(cx))
-      abort("running Promise reactions");
-  }
-
   // Report any promise rejections that weren't handled before snapshotting.
   // TODO: decide whether we should abort in this case, instead of just
   // reporting.
@@ -424,8 +424,8 @@ bool api::Engine::eval_toplevel(const char *path, MutableHandleValue result) {
   return true;
 }
 
-bool api::Engine::run_event_loop(MutableHandleValue result) {
-  return core::EventLoop::run_event_loop(this, 0, result);
+bool api::Engine::run_event_loop() {
+  return core::EventLoop::run_event_loop(this, 0);
 }
 
 bool api::Engine::dump_value(JS::Value val, FILE *fp) { return ::dump_value(CONTEXT, val, fp); }

runtime/event_loop.cpp

@@ -38,8 +38,7 @@ bool EventLoop::cancel_async_task(api::Engine *engine, const int32_t id) {
 
 bool EventLoop::has_pending_async_tasks() { return !queue.get().tasks.empty(); }
 
-bool EventLoop::run_event_loop(api::Engine *engine, double total_compute,
-                               MutableHandleValue result) {
+bool EventLoop::run_event_loop(api::Engine *engine, double total_compute) {
   // Loop until no more resolved promises or backend requests are pending.
   // LOG("Start processing async jobs ...\n");
 
@@ -51,7 +50,7 @@ bool EventLoop::run_event_loop(api::Engine *engine, double total_compute,
       js::RunJobs(cx);
 
       if (JS_IsExceptionPending(cx))
-        engine->abort("running Promise reactions");
+        return false;
     }
 
     // TODO: add general mechanism for extending the event loop duration.

runtime/event_loop.h

@@ -33,7 +33,7 @@ class EventLoop {
    *
    * The loop terminates once both of these steps are null-ops.
    */
-  static bool run_event_loop(api::Engine *engine, double total_compute, MutableHandleValue result);
+  static bool run_event_loop(api::Engine *engine, double total_compute);
 
   /**
    * Queue a new async task.

runtime/js.cpp

@@ -42,7 +42,7 @@ bool initialize(const char *filename) {
 
   RootedValue result(engine.cx());
   bool success = engine.eval_toplevel(filename, &result);
-  success = success && engine.run_event_loop(&result);
+  success = success && engine.run_event_loop();
 
   if (JS_IsExceptionPending(engine.cx())) {
     engine.dump_pending_exception("pre-initializing");
@@ -51,8 +51,7 @@ bool initialize(const char *filename) {
 
   if (!success) {
     fflush(stdout);
-    fprintf(stderr, "Error running event loop: ");
-    engine.dump_value(result, stderr);
+    fprintf(stderr, "Internal error");
     return false;
   }
 

tests/cases/syntax-err/expect_wizer_stderr.txt

@@ -1 +1 @@
-Exception while pre-initializing: (new SyntaxError("expected expression, got end of script", "syntax-err.js", 1))
+Exception while pre-initializing: (new SyntaxError("expected expression, got end of script", "syntax-err.js", 2))