refactor: remove more compiler runtime code (#6841)

1 files changed, 57 insertions, 75 deletions

diff --git a/cli/tsc.rs b/cli/tsc.rs
index dafee0259..2ce498e3f 100644
--- a/cli/tsc.rs
+++ b/cli/tsc.rs
@@ -28,14 +28,11 @@ use crate::swc_ecma_visit::Visit;
 use crate::swc_util::AstParser;
 use crate::swc_util::SwcDiagnosticBuffer;
 use crate::version;
-use crate::web_worker::WebWorker;
-use crate::worker::WorkerEvent;
+use crate::worker::Worker;
 use core::task::Context;
-use deno_core::Buf;
 use deno_core::ErrBox;
 use deno_core::ModuleSpecifier;
 use deno_core::StartupData;
-use futures::future::Either;
 use futures::future::Future;
 use futures::future::FutureExt;
 use log::debug;
@@ -130,30 +127,47 @@ pub struct CompiledModule {
   pub name: String,
 }
 
-pub struct CompilerWorker(WebWorker);
+pub struct CompilerWorker {
+  worker: Worker,
+  response: Arc<Mutex<Option<String>>>,
+}
 
 impl CompilerWorker {
   pub fn new(name: String, startup_data: StartupData, state: State) -> Self {
     let state_ = state.clone();
-    let mut worker = WebWorker::new(name, startup_data, state_, false);
+    let mut worker = Worker::new(name, startup_data, state_);
+    let response = Arc::new(Mutex::new(None));
     {
       let isolate = &mut worker.isolate;
-      ops::compiler::init(isolate, &state);
+      ops::runtime::init(isolate, &state);
+      ops::errors::init(isolate, &state);
+      ops::timers::init(isolate, &state);
+      ops::compiler::init(isolate, &state, response.clone());
     }
-    Self(worker)
+
+    Self { worker, response }
+  }
+
+  pub fn get_response(&mut self) -> String {
+    let mut maybe_response = self.response.lock().unwrap();
+    assert!(
+      maybe_response.is_some(),
+      "Unexpected missing response from TS compiler"
+    );
+    maybe_response.take().unwrap()
   }
 }
 
 impl Deref for CompilerWorker {
-  type Target = WebWorker;
+  type Target = Worker;
   fn deref(&self) -> &Self::Target {
-    &self.0
+    &self.worker
   }
 }
 
 impl DerefMut for CompilerWorker {
   fn deref_mut(&mut self) -> &mut Self::Target {
-    &mut self.0
+    &mut self.worker
   }
 }
 
@@ -162,7 +176,7 @@ impl Future for CompilerWorker {
 
   fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
     let inner = self.get_mut();
-    inner.0.poll_unpin(cx)
+    inner.worker.poll_unpin(cx)
   }
 }
 
@@ -212,7 +226,9 @@ fn create_compiler_worker(
     startup_data::compiler_isolate_init(),
     worker_state,
   );
-  worker.execute("bootstrap.tsCompilerRuntime()").unwrap();
+  worker
+    .execute("globalThis.bootstrapCompilerRuntime()")
+    .unwrap();
   worker
 }
 
@@ -604,17 +620,15 @@ impl TsCompiler {
       }),
     };
 
-    let req_msg = j.to_string().into_boxed_str().into_boxed_bytes();
+    let req_msg = j.to_string();
 
     // TODO(bartlomieju): lift this call up - TSC shouldn't print anything
     info!("{} {}", colors::green("Check"), module_url.to_string());
 
-    let msg =
+    let json_str =
       execute_in_same_thread(global_state, permissions, req_msg).await?;
 
-    let json_str = std::str::from_utf8(&msg).unwrap();
-
-    let compile_response: CompileResponse = serde_json::from_str(json_str)?;
+    let compile_response: CompileResponse = serde_json::from_str(&json_str)?;
 
     if !compile_response.diagnostics.items.is_empty() {
       return Err(ErrBox::from(compile_response.diagnostics));
@@ -713,13 +727,12 @@ impl TsCompiler {
       }),
     };
 
-    let req_msg = j.to_string().into_boxed_str().into_boxed_bytes();
+    let req_msg = j.to_string();
 
-    let msg =
+    let json_str =
       execute_in_same_thread(global_state, permissions, req_msg).await?;
-    let json_str = std::str::from_utf8(&msg).unwrap();
 
-    let bundle_response: BundleResponse = serde_json::from_str(json_str)?;
+    let bundle_response: BundleResponse = serde_json::from_str(&json_str)?;
 
     maybe_log_stats(bundle_response.stats);
 
@@ -778,15 +791,14 @@ impl TsCompiler {
       }),
     };
 
-    let req_msg = j.to_string().into_boxed_str().into_boxed_bytes();
+    let req_msg = j.to_string();
 
-    let msg =
+    let json_str =
       execute_in_same_thread(global_state.clone(), permissions, req_msg)
         .await?;
 
-    let json_str = std::str::from_utf8(&msg).unwrap();
-
-    let transpile_response: TranspileResponse = serde_json::from_str(json_str)?;
+    let transpile_response: TranspileResponse =
+      serde_json::from_str(&json_str)?;
 
     if !transpile_response.diagnostics.items.is_empty() {
       return Err(ErrBox::from(transpile_response.diagnostics));
@@ -1079,35 +1091,13 @@ impl TsCompiler {
 async fn execute_in_same_thread(
   global_state: GlobalState,
   permissions: Permissions,
-  req: Buf,
-) -> Result<Buf, ErrBox> {
+  req: String,
+) -> Result<String, ErrBox> {
   let mut worker = create_compiler_worker(global_state.clone(), permissions);
-  let handle = worker.thread_safe_handle();
-  handle.post_message(req)?;
-
-  let mut event_fut = handle.get_event().boxed_local();
-
-  loop {
-    let select_result = futures::future::select(event_fut, &mut worker).await;
-    match select_result {
-      Either::Left((event_result, _worker)) => {
-        let event = event_result
-          .expect("Compiler didn't respond")
-          .expect("Empty message");
-
-        let buf = match event {
-          WorkerEvent::Message(buf) => Ok(buf),
-          WorkerEvent::Error(error) => Err(error),
-          WorkerEvent::TerminalError(error) => Err(error),
-        }?;
-        return Ok(buf);
-      }
-      Either::Right((worker_result, event_fut_)) => {
-        event_fut = event_fut_;
-        worker_result?;
-      }
-    }
-  }
+  let script = format!("globalThis.tsCompilerOnMessage({{ data: {} }});", req);
+  worker.execute2("<compiler>", &script)?;
+  (&mut *worker).await?;
+  Ok(worker.get_response())
 }
 
 async fn create_runtime_module_graph(
@@ -1200,18 +1190,15 @@ pub async fn runtime_compile(
     "options": maybe_options,
     "unstable": global_state.flags.unstable,
   })
-  .to_string()
-  .into_boxed_str()
-  .into_boxed_bytes();
+  .to_string();
 
   let compiler = global_state.ts_compiler.clone();
 
-  let msg = execute_in_same_thread(global_state, permissions, req_msg)
+  let json_str = execute_in_same_thread(global_state, permissions, req_msg)
     .await
     .map_err(js_error_to_op_error)?;
-  let json_str = std::str::from_utf8(&msg).unwrap();
 
-  let response: RuntimeCompileResponse = serde_json::from_str(json_str)?;
+  let response: RuntimeCompileResponse = serde_json::from_str(&json_str)?;
 
   if response.diagnostics.is_empty() && sources.is_none() {
     compiler.cache_emitted_files(response.emit_map)?;
@@ -1220,7 +1207,7 @@ pub async fn runtime_compile(
   // We're returning `Ok()` instead of `Err()` because it's not runtime
   // error if there were diagnostics produced; we want to let user handle
   // diagnostics in the runtime.
-  Ok(serde_json::from_str::<Value>(json_str).unwrap())
+  Ok(serde_json::from_str::<Value>(&json_str).unwrap())
 }
 
 /// This function is used by `Deno.bundle()` API.
@@ -1250,19 +1237,16 @@ pub async fn runtime_bundle(
     "options": maybe_options,
     "unstable": global_state.flags.unstable,
   })
-  .to_string()
-  .into_boxed_str()
-  .into_boxed_bytes();
+  .to_string();
 
-  let msg = execute_in_same_thread(global_state, permissions, req_msg)
+  let json_str = execute_in_same_thread(global_state, permissions, req_msg)
     .await
     .map_err(js_error_to_op_error)?;
-  let json_str = std::str::from_utf8(&msg).unwrap();
-  let _response: RuntimeBundleResponse = serde_json::from_str(json_str)?;
+  let _response: RuntimeBundleResponse = serde_json::from_str(&json_str)?;
   // We're returning `Ok()` instead of `Err()` because it's not runtime
   // error if there were diagnostics produced; we want to let user handle
   // diagnostics in the runtime.
-  Ok(serde_json::from_str::<Value>(json_str).unwrap())
+  Ok(serde_json::from_str::<Value>(&json_str).unwrap())
 }
 
 /// This function is used by `Deno.transpileOnly()` API.
@@ -1277,15 +1261,12 @@ pub async fn runtime_transpile(
     "sources": sources,
     "options": options,
   })
-  .to_string()
-  .into_boxed_str()
-  .into_boxed_bytes();
+  .to_string();
 
-  let msg = execute_in_same_thread(global_state, permissions, req_msg)
+  let json_str = execute_in_same_thread(global_state, permissions, req_msg)
     .await
     .map_err(js_error_to_op_error)?;
-  let json_str = std::str::from_utf8(&msg).unwrap();
-  let v = serde_json::from_str::<serde_json::Value>(json_str)
+  let v = serde_json::from_str::<serde_json::Value>(&json_str)
     .expect("Error decoding JSON string.");
   Ok(v)
 }
@@ -1775,6 +1756,7 @@ mod tests {
       .ts_compiler
       .bundle(mock_state.clone(), module_name)
       .await;
+
     assert!(result.is_ok());
   }