fix(core): prevent multiple main module loading (#12128)

This commit fixes a problem where loading and executing multiple 
modules leads to all of the having "import.meta.main" set to true.

Following Rust APIs were deprecated:
- deno_core::JsRuntime::load_module
- deno_runtime::Worker::execute_module
- deno_runtime::WebWorker::execute_module

Following Rust APIs were added:
- deno_core::JsRuntime::load_main_module
- deno_core::JsRuntime::load_side_module
- deno_runtime::Worker::execute_main_module
- deno_runtime::Worker::execute_side_module
- deno_runtime::WebWorker::execute_main_module

Trying to load multiple "main" modules into the runtime now results in an
error. If user needs to load additional "non-main" modules they should use
APIs for "side" module.

1 files changed, 51 insertions, 13 deletions

diff --git a/runtime/worker.rs b/runtime/worker.rs
index 92bebe92a..54b8a8d68 100644
--- a/runtime/worker.rs
+++ b/runtime/worker.rs
@@ -207,21 +207,27 @@ impl MainWorker {
     Ok(())
   }
 
-  /// Loads and instantiates specified JavaScript module.
+  /// Loads and instantiates specified JavaScript module
+  /// as "main" or "side" module.
   pub async fn preload_module(
     &mut self,
     module_specifier: &ModuleSpecifier,
+    main: bool,
   ) -> Result<ModuleId, AnyError> {
-    self.js_runtime.load_module(module_specifier, None).await
+    if main {
+      self
+        .js_runtime
+        .load_main_module(module_specifier, None)
+        .await
+    } else {
+      self
+        .js_runtime
+        .load_side_module(module_specifier, None)
+        .await
+    }
   }
 
-  /// Loads, instantiates and executes specified JavaScript module.
-  pub async fn execute_module(
-    &mut self,
-    module_specifier: &ModuleSpecifier,
-  ) -> Result<(), AnyError> {
-    let id = self.preload_module(module_specifier).await?;
-    self.wait_for_inspector_session();
+  async fn evaluate_module(&mut self, id: ModuleId) -> Result<(), AnyError> {
     let mut receiver = self.js_runtime.mod_evaluate(id);
     tokio::select! {
       maybe_result = &mut receiver => {
@@ -237,6 +243,38 @@ impl MainWorker {
     }
   }
 
+  /// Loads, instantiates and executes specified JavaScript module.
+  pub async fn execute_side_module(
+    &mut self,
+    module_specifier: &ModuleSpecifier,
+  ) -> Result<(), AnyError> {
+    let id = self.preload_module(module_specifier, false).await?;
+    self.evaluate_module(id).await
+  }
+
+  /// Loads, instantiates and executes specified JavaScript module.
+  ///
+  /// This module will have "import.meta.main" equal to true.
+  pub async fn execute_main_module(
+    &mut self,
+    module_specifier: &ModuleSpecifier,
+  ) -> Result<(), AnyError> {
+    let id = self.preload_module(module_specifier, true).await?;
+    self.wait_for_inspector_session();
+    self.evaluate_module(id).await
+  }
+
+  #[deprecated(
+    since = "0.26.0",
+    note = "This method had a bug, marking multiple modules loaded as \"main\". Use `execute_main_module` or `execute_side_module` instead."
+  )]
+  pub async fn execute_module(
+    &mut self,
+    module_specifier: &ModuleSpecifier,
+  ) -> Result<(), AnyError> {
+    self.execute_main_module(module_specifier).await
+  }
+
   fn wait_for_inspector_session(&mut self) {
     if self.should_break_on_first_statement {
       self
@@ -330,7 +368,7 @@ mod tests {
     let p = test_util::testdata_path().join("esm_imports_a.js");
     let module_specifier = resolve_url_or_path(&p.to_string_lossy()).unwrap();
     let mut worker = create_test_worker();
-    let result = worker.execute_module(&module_specifier).await;
+    let result = worker.execute_main_module(&module_specifier).await;
     if let Err(err) = result {
       eprintln!("execute_mod err {:?}", err);
     }
@@ -347,7 +385,7 @@ mod tests {
       .join("tests/circular1.js");
     let module_specifier = resolve_url_or_path(&p.to_string_lossy()).unwrap();
     let mut worker = create_test_worker();
-    let result = worker.execute_module(&module_specifier).await;
+    let result = worker.execute_main_module(&module_specifier).await;
     if let Err(err) = result {
       eprintln!("execute_mod err {:?}", err);
     }
@@ -361,7 +399,7 @@ mod tests {
     // "foo" is not a valid module specifier so this should return an error.
     let mut worker = create_test_worker();
     let module_specifier = resolve_url_or_path("does-not-exist").unwrap();
-    let result = worker.execute_module(&module_specifier).await;
+    let result = worker.execute_main_module(&module_specifier).await;
     assert!(result.is_err());
   }
 
@@ -372,7 +410,7 @@ mod tests {
     let mut worker = create_test_worker();
     let p = test_util::testdata_path().join("001_hello.js");
     let module_specifier = resolve_url_or_path(&p.to_string_lossy()).unwrap();
-    let result = worker.execute_module(&module_specifier).await;
+    let result = worker.execute_main_module(&module_specifier).await;
     assert!(result.is_ok());
   }
 }