fix(core): module execution with top level await (denoland#7672)

This commit fixes implementation of top level await in "deno_core".

Previously promise returned from module execution was ignored causing to execute
modules out-of-order.

With this commit promise returned from module execution is stored on "JsRuntime"
and event loop is polled until the promise resolves.

cli/ops/worker_host.rs

@@ -155,6 +155,13 @@ fn run_worker_thread(
 
     if let Err(e) = result {
       let mut sender = worker.internal_channels.sender.clone();
+
+      // If sender is closed it means that worker has already been closed from
+      // within using "globalThis.close()"
+      if sender.is_closed() {
+        return;
+      }
+
       sender
         .try_send(WorkerEvent::TerminalError(e))
         .expect("Failed to post message to host");

cli/tests/integration_tests.rs

@@ -2662,6 +2662,16 @@ itest!(ignore_require {
   exit_code: 0,
 });
 
+itest!(top_level_await_bug {
+  args: "run --allow-read top_level_await_bug.js",
+  output: "top_level_await_bug.out",
+});
+
+itest!(top_level_await_bug2 {
+  args: "run --allow-read top_level_await_bug2.js",
+  output: "top_level_await_bug2.out",
+});
+
 #[test]
 fn cafile_env_fetch() {
   use deno_core::url::Url;

cli/tests/top_level_await_bug.js

@@ -0,0 +1,2 @@
+const mod = await import("./top_level_await_bug_nested.js");
+console.log(mod);

cli/tests/top_level_await_bug.out

@@ -0,0 +1 @@
+Module { default: 1, [Symbol(Symbol.toStringTag)]: "Module" }

cli/tests/top_level_await_bug2.js

@@ -0,0 +1,15 @@
+const mod = await import("./top_level_await_bug_nested.js");
+console.log(mod);
+
+const sleep = (n) => new Promise((r) => setTimeout(r, n));
+
+await sleep(100);
+console.log("slept");
+
+window.addEventListener("load", () => {
+  console.log("load event");
+});
+
+setTimeout(() => {
+  console.log("timeout");
+}, 1000);

cli/tests/top_level_await_bug2.out

@@ -0,0 +1,4 @@
+Module { default: 1, [Symbol(Symbol.toStringTag)]: "Module" }
+slept
+load event
+timeout

cli/tests/top_level_await_bug_nested.js

@@ -0,0 +1,5 @@
+const sleep = (n) => new Promise((r) => setTimeout(r, n));
+
+await sleep(100);
+
+export default 1;

cli/worker.rs

@@ -189,7 +189,7 @@ impl Worker {
   ) -> Result<(), AnyError> {
     let id = self.preload_module(module_specifier).await?;
     self.wait_for_inspector_session();
-    self.isolate.mod_evaluate(id)
+    self.isolate.mod_evaluate(id).await
   }
 
   /// Loads, instantiates and executes provided source code
@@ -204,7 +204,7 @@ impl Worker {
       .load_module(module_specifier, Some(code))
       .await?;
     self.wait_for_inspector_session();
-    self.isolate.mod_evaluate(id)
+    self.isolate.mod_evaluate(id).await
   }
 
   /// Returns a way to communicate with the Worker from other threads.

core/modules.rs

@@ -341,6 +341,13 @@ pub struct ModuleInfo {
   pub name: String,
   pub handle: v8::Global<v8::Module>,
   pub import_specifiers: Vec<ModuleSpecifier>,
+  // TODO(bartlomieju): there should be "state"
+  // field that describes if module is already being loaded,
+  // so concurent dynamic imports don't introduce dead lock
+  // pub state: LoadState {
+  //   Loading(shared_future),
+  //   Loaded,
+  // },
 }
 
 /// A symbolic module entity.
@@ -667,7 +674,7 @@ mod tests {
     let a_id_fut = runtime.load_module(&spec, None);
     let a_id = futures::executor::block_on(a_id_fut).expect("Failed to load");
 
-    runtime.mod_evaluate(a_id).unwrap();
+    futures::executor::block_on(runtime.mod_evaluate(a_id)).unwrap();
     let l = loads.lock().unwrap();
     assert_eq!(
       l.to_vec(),
@@ -734,7 +741,7 @@ mod tests {
       let result = runtime.load_module(&spec, None).await;
       assert!(result.is_ok());
       let circular1_id = result.unwrap();
-      runtime.mod_evaluate(circular1_id).unwrap();
+      runtime.mod_evaluate(circular1_id).await.unwrap();
 
       let l = loads.lock().unwrap();
       assert_eq!(
@@ -811,7 +818,7 @@ mod tests {
       println!(">> result {:?}", result);
       assert!(result.is_ok());
       let redirect1_id = result.unwrap();
-      runtime.mod_evaluate(redirect1_id).unwrap();
+      runtime.mod_evaluate(redirect1_id).await.unwrap();
       let l = loads.lock().unwrap();
       assert_eq!(
         l.to_vec(),
@@ -961,7 +968,7 @@ mod tests {
     let main_id =
       futures::executor::block_on(main_id_fut).expect("Failed to load");
 
-    runtime.mod_evaluate(main_id).unwrap();
+    futures::executor::block_on(runtime.mod_evaluate(main_id)).unwrap();
 
     let l = loads.lock().unwrap();
     assert_eq!(