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

1 files changed, 25 insertions, 9 deletions

diff --git a/runtime/ops/fs_events.rs b/runtime/ops/fs_events.rs
index d88a32d91..89a0606db 100644
--- a/runtime/ops/fs_events.rs
+++ b/runtime/ops/fs_events.rs
@@ -1,6 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-use deno_core::error::AnyError;
 use deno_core::parking_lot::Mutex;
 use deno_core::AsyncRefCell;
 use deno_core::CancelFuture;
@@ -37,7 +36,7 @@ deno_core::extension!(
 struct FsEventsResource {
   #[allow(unused)]
   watcher: RecommendedWatcher,
-  receiver: AsyncRefCell<mpsc::Receiver<Result<FsEvent, AnyError>>>,
+  receiver: AsyncRefCell<mpsc::Receiver<Result<FsEvent, NotifyError>>>,
   cancel: CancelHandle,
 }
 
@@ -93,6 +92,18 @@ impl From<NotifyEvent> for FsEvent {
   }
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum FsEventsError {
+  #[error(transparent)]
+  Resource(deno_core::error::AnyError),
+  #[error(transparent)]
+  Permission(deno_core::error::AnyError),
+  #[error(transparent)]
+  Notify(#[from] NotifyError),
+  #[error(transparent)]
+  Canceled(#[from] deno_core::Canceled),
+}
+
 #[derive(Deserialize)]
 pub struct OpenArgs {
   recursive: bool,
@@ -104,12 +115,12 @@ pub struct OpenArgs {
 fn op_fs_events_open(
   state: &mut OpState,
   #[serde] args: OpenArgs,
-) -> Result<ResourceId, AnyError> {
-  let (sender, receiver) = mpsc::channel::<Result<FsEvent, AnyError>>(16);
+) -> Result<ResourceId, FsEventsError> {
+  let (sender, receiver) = mpsc::channel::<Result<FsEvent, NotifyError>>(16);
   let sender = Mutex::new(sender);
   let mut watcher: RecommendedWatcher = Watcher::new(
     move |res: Result<NotifyEvent, NotifyError>| {
-      let res2 = res.map(FsEvent::from).map_err(AnyError::from);
+      let res2 = res.map(FsEvent::from);
       let sender = sender.lock();
       // Ignore result, if send failed it means that watcher was already closed,
       // but not all messages have been flushed.
@@ -125,7 +136,8 @@ fn op_fs_events_open(
   for path in &args.paths {
     let path = state
       .borrow_mut::<PermissionsContainer>()
-      .check_read(path, "Deno.watchFs()")?;
+      .check_read(path, "Deno.watchFs()")
+      .map_err(FsEventsError::Permission)?;
     watcher.watch(&path, recursive_mode)?;
   }
   let resource = FsEventsResource {
@@ -142,14 +154,18 @@ fn op_fs_events_open(
 async fn op_fs_events_poll(
   state: Rc<RefCell<OpState>>,
   #[smi] rid: ResourceId,
-) -> Result<Option<FsEvent>, AnyError> {
-  let resource = state.borrow().resource_table.get::<FsEventsResource>(rid)?;
+) -> Result<Option<FsEvent>, FsEventsError> {
+  let resource = state
+    .borrow()
+    .resource_table
+    .get::<FsEventsResource>(rid)
+    .map_err(FsEventsError::Resource)?;
   let mut receiver = RcRef::map(&resource, |r| &r.receiver).borrow_mut().await;
   let cancel = RcRef::map(resource, |r| &r.cancel);
   let maybe_result = receiver.recv().or_cancel(cancel).await?;
   match maybe_result {
     Some(Ok(value)) => Ok(Some(value)),
-    Some(Err(err)) => Err(err),
+    Some(Err(err)) => Err(FsEventsError::Notify(err)),
     None => Ok(None),
   }
 }