refactor(runtime/ops): use concrete error types (#26409)

1 files changed, 34 insertions, 24 deletions

diff --git a/runtime/ops/worker_host.rs b/runtime/ops/worker_host.rs
index d85541d51..82cc94924 100644
--- a/runtime/ops/worker_host.rs
+++ b/runtime/ops/worker_host.rs
@@ -10,8 +10,6 @@ use crate::web_worker::WorkerControlEvent;
 use crate::web_worker::WorkerId;
 use crate::web_worker::WorkerMetadata;
 use crate::worker::FormatJsErrorFn;
-use deno_core::error::custom_error;
-use deno_core::error::AnyError;
 use deno_core::op2;
 use deno_core::serde::Deserialize;
 use deno_core::CancelFuture;
@@ -22,6 +20,7 @@ use deno_permissions::ChildPermissionsArg;
 use deno_permissions::PermissionsContainer;
 use deno_web::deserialize_js_transferables;
 use deno_web::JsMessageData;
+use deno_web::MessagePortError;
 use log::debug;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -119,6 +118,20 @@ pub struct CreateWorkerArgs {
   close_on_idle: bool,
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum CreateWorkerError {
+  #[error("Classic workers are not supported.")]
+  ClassicWorkers,
+  #[error(transparent)]
+  Permission(deno_core::error::AnyError),
+  #[error(transparent)]
+  ModuleResolution(#[from] deno_core::ModuleResolutionError),
+  #[error(transparent)]
+  MessagePort(#[from] MessagePortError),
+  #[error("{0}")]
+  Io(#[from] std::io::Error),
+}
+
 /// Create worker as the host
 #[op2]
 #[serde]
@@ -126,7 +139,7 @@ fn op_create_worker(
   state: &mut OpState,
   #[serde] args: CreateWorkerArgs,
   #[serde] maybe_worker_metadata: Option<JsMessageData>,
-) -> Result<WorkerId, AnyError> {
+) -> Result<WorkerId, CreateWorkerError> {
   let specifier = args.specifier.clone();
   let maybe_source_code = if args.has_source_code {
     Some(args.source_code.clone())
@@ -137,10 +150,7 @@ fn op_create_worker(
   let worker_type = args.worker_type;
   if let WebWorkerType::Classic = worker_type {
     if let TestingFeaturesEnabled(false) = state.borrow() {
-      return Err(custom_error(
-        "DOMExceptionNotSupportedError",
-        "Classic workers are not supported.",
-      ));
+      return Err(CreateWorkerError::ClassicWorkers);
     }
   }
 
@@ -154,7 +164,9 @@ fn op_create_worker(
   let parent_permissions = state.borrow_mut::<PermissionsContainer>();
   let worker_permissions = if let Some(child_permissions_arg) = args.permissions
   {
-    parent_permissions.create_child_permissions(child_permissions_arg)?
+    parent_permissions
+      .create_child_permissions(child_permissions_arg)
+      .map_err(CreateWorkerError::Permission)?
   } else {
     parent_permissions.clone()
   };
@@ -166,9 +178,8 @@ fn op_create_worker(
   let module_specifier = deno_core::resolve_url(&specifier)?;
   let worker_name = args_name.unwrap_or_default();
 
-  let (handle_sender, handle_receiver) = std::sync::mpsc::sync_channel::<
-    Result<SendableWebWorkerHandle, AnyError>,
-  >(1);
+  let (handle_sender, handle_receiver) =
+    std::sync::mpsc::sync_channel::<SendableWebWorkerHandle>(1);
 
   // Setup new thread
   let thread_builder = std::thread::Builder::new().name(format!("{worker_id}"));
@@ -202,7 +213,7 @@ fn op_create_worker(
       });
 
     // Send thread safe handle from newly created worker to host thread
-    handle_sender.send(Ok(external_handle)).unwrap();
+    handle_sender.send(external_handle).unwrap();
     drop(handle_sender);
 
     // At this point the only method of communication with host
@@ -218,7 +229,7 @@ fn op_create_worker(
   })?;
 
   // Receive WebWorkerHandle from newly created worker
-  let worker_handle = handle_receiver.recv().unwrap()?;
+  let worker_handle = handle_receiver.recv().unwrap();
 
   let worker_thread = WorkerThread {
     worker_handle: worker_handle.into(),
@@ -291,7 +302,7 @@ fn close_channel(
 async fn op_host_recv_ctrl(
   state: Rc<RefCell<OpState>>,
   #[serde] id: WorkerId,
-) -> Result<WorkerControlEvent, AnyError> {
+) -> WorkerControlEvent {
   let (worker_handle, cancel_handle) = {
     let state = state.borrow();
     let workers_table = state.borrow::<WorkersTable>();
@@ -300,7 +311,7 @@ async fn op_host_recv_ctrl(
       (handle.worker_handle.clone(), handle.cancel_handle.clone())
     } else {
       // If handle was not found it means worker has already shutdown
-      return Ok(WorkerControlEvent::Close);
+      return WorkerControlEvent::Close;
     }
   };
 
@@ -309,22 +320,21 @@ async fn op_host_recv_ctrl(
     .or_cancel(cancel_handle)
     .await;
   match maybe_event {
-    Ok(Ok(Some(event))) => {
+    Ok(Some(event)) => {
       // Terminal error means that worker should be removed from worker table.
       if let WorkerControlEvent::TerminalError(_) = &event {
         close_channel(state, id, WorkerChannel::Ctrl);
       }
-      Ok(event)
+      event
     }
-    Ok(Ok(None)) => {
+    Ok(None) => {
       // If there was no event from worker it means it has already been closed.
       close_channel(state, id, WorkerChannel::Ctrl);
-      Ok(WorkerControlEvent::Close)
+      WorkerControlEvent::Close
     }
-    Ok(Err(err)) => Err(err),
     Err(_) => {
       // The worker was terminated.
-      Ok(WorkerControlEvent::Close)
+      WorkerControlEvent::Close
     }
   }
 }
@@ -334,7 +344,7 @@ async fn op_host_recv_ctrl(
 async fn op_host_recv_message(
   state: Rc<RefCell<OpState>>,
   #[serde] id: WorkerId,
-) -> Result<Option<JsMessageData>, AnyError> {
+) -> Result<Option<JsMessageData>, MessagePortError> {
   let (worker_handle, cancel_handle) = {
     let s = state.borrow();
     let workers_table = s.borrow::<WorkersTable>();
@@ -359,7 +369,7 @@ async fn op_host_recv_message(
       }
       Ok(ret)
     }
-    Ok(Err(err)) => Err(err.into()),
+    Ok(Err(err)) => Err(err),
     Err(_) => {
       // The worker was terminated.
       Ok(None)
@@ -373,7 +383,7 @@ fn op_host_post_message(
   state: &mut OpState,
   #[serde] id: WorkerId,
   #[serde] data: JsMessageData,
-) -> Result<(), AnyError> {
+) -> Result<(), MessagePortError> {
   if let Some(worker_thread) = state.borrow::<WorkersTable>().get(&id) {
     debug!("post message to worker {}", id);
     let worker_handle = worker_thread.worker_handle.clone();