refactor: use boxed_error in some places (#26887)

3 files changed, 39 insertions, 28 deletions

diff --git a/ext/fs/Cargo.toml b/ext/fs/Cargo.toml
index e85f349b1..ace1b89f3 100644
--- a/ext/fs/Cargo.toml
+++ b/ext/fs/Cargo.toml
@@ -19,6 +19,7 @@ sync_fs = []
 [dependencies]
 async-trait.workspace = true
 base32.workspace = true
+boxed_error.workspace = true
 deno_core.workspace = true
 deno_io.workspace = true
 deno_path_util.workspace = true
diff --git a/ext/fs/lib.rs b/ext/fs/lib.rs
index dd852e6be..aed9a7085 100644
--- a/ext/fs/lib.rs
+++ b/ext/fs/lib.rs
@@ -15,6 +15,7 @@ pub use crate::interface::FsDirEntry;
 pub use crate::interface::FsFileType;
 pub use crate::interface::OpenOptions;
 pub use crate::ops::FsOpsError;
+pub use crate::ops::FsOpsErrorKind;
 pub use crate::ops::OperationError;
 pub use crate::std_fs::RealFs;
 pub use crate::sync::MaybeSend;
diff --git a/ext/fs/ops.rs b/ext/fs/ops.rs
index 3d0d96ce6..e3a511f8e 100644
--- a/ext/fs/ops.rs
+++ b/ext/fs/ops.rs
@@ -16,6 +16,7 @@ use crate::interface::FsDirEntry;
 use crate::interface::FsFileType;
 use crate::FsPermissions;
 use crate::OpenOptions;
+use boxed_error::Boxed;
 use deno_core::op2;
 use deno_core::CancelFuture;
 use deno_core::CancelHandle;
@@ -32,8 +33,11 @@ use rand::thread_rng;
 use rand::Rng;
 use serde::Serialize;
 
+#[derive(Debug, Boxed)]
+pub struct FsOpsError(pub Box<FsOpsErrorKind>);
+
 #[derive(Debug, thiserror::Error)]
-pub enum FsOpsError {
+pub enum FsOpsErrorKind {
   #[error("{0}")]
   Io(#[source] std::io::Error),
   #[error("{0}")]
@@ -73,15 +77,16 @@ pub enum FsOpsError {
 impl From<FsError> for FsOpsError {
   fn from(err: FsError) -> Self {
     match err {
-      FsError::Io(err) => FsOpsError::Io(err),
+      FsError::Io(err) => FsOpsErrorKind::Io(err),
       FsError::FileBusy => {
-        FsOpsError::Other(deno_core::error::resource_unavailable())
+        FsOpsErrorKind::Other(deno_core::error::resource_unavailable())
       }
       FsError::NotSupported => {
-        FsOpsError::Other(deno_core::error::not_supported())
+        FsOpsErrorKind::Other(deno_core::error::not_supported())
       }
-      FsError::NotCapable(err) => FsOpsError::NotCapable(err),
+      FsError::NotCapable(err) => FsOpsErrorKind::NotCapable(err),
     }
+    .into_box()
   }
 }
 
@@ -127,11 +132,12 @@ fn map_permission_error(
         (path.as_str(), "")
       };
 
-      FsOpsError::NotCapableAccess {
+      FsOpsErrorKind::NotCapableAccess {
         standalone: deno_permissions::is_standalone(),
         err,
         path: format!("{path}{truncated}"),
       }
+      .into_box()
     }
     err => Err::<(), _>(err)
       .context_path(operation, path)
@@ -1176,7 +1182,9 @@ fn validate_temporary_filename_component(
 ) -> Result<(), FsOpsError> {
   // Ban ASCII and Unicode control characters: these will often fail
   if let Some(c) = component.matches(|c: char| c.is_control()).next() {
-    return Err(FsOpsError::InvalidControlCharacter(c.to_string()));
+    return Err(
+      FsOpsErrorKind::InvalidControlCharacter(c.to_string()).into_box(),
+    );
   }
   // Windows has the most restrictive filenames. As temp files aren't normal files, we just
   // use this set of banned characters for all platforms because wildcard-like files can also
@@ -1192,13 +1200,13 @@ fn validate_temporary_filename_component(
     .matches(|c: char| "<>:\"/\\|?*".contains(c))
     .next()
   {
-    return Err(FsOpsError::InvalidCharacter(c.to_string()));
+    return Err(FsOpsErrorKind::InvalidCharacter(c.to_string()).into_box());
   }
 
   // This check is only for Windows
   #[cfg(windows)]
   if suffix && component.ends_with(|c: char| ". ".contains(c)) {
-    return Err(FsOpsError::InvalidTrailingCharacter);
+    return Err(FsOpsErrorKind::InvalidTrailingCharacter.into_box());
   }
 
   Ok(())
@@ -1440,7 +1448,7 @@ fn to_seek_from(offset: i64, whence: i32) -> Result<SeekFrom, FsOpsError> {
     1 => SeekFrom::Current(offset),
     2 => SeekFrom::End(offset),
     _ => {
-      return Err(FsOpsError::InvalidSeekMode(whence));
+      return Err(FsOpsErrorKind::InvalidSeekMode(whence).into_box());
     }
   };
   Ok(seek_from)
@@ -1456,7 +1464,7 @@ pub fn op_fs_seek_sync(
 ) -> Result<u64, FsOpsError> {
   let pos = to_seek_from(offset, whence)?;
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   let cursor = file.seek_sync(pos)?;
   Ok(cursor)
 }
@@ -1471,7 +1479,7 @@ pub async fn op_fs_seek_async(
 ) -> Result<u64, FsOpsError> {
   let pos = to_seek_from(offset, whence)?;
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   let cursor = file.seek_async(pos).await?;
   Ok(cursor)
 }
@@ -1482,7 +1490,7 @@ pub fn op_fs_file_sync_data_sync(
   #[smi] rid: ResourceId,
 ) -> Result<(), FsOpsError> {
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   file.datasync_sync()?;
   Ok(())
 }
@@ -1493,7 +1501,7 @@ pub async fn op_fs_file_sync_data_async(
   #[smi] rid: ResourceId,
 ) -> Result<(), FsOpsError> {
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   file.datasync_async().await?;
   Ok(())
 }
@@ -1504,7 +1512,7 @@ pub fn op_fs_file_sync_sync(
   #[smi] rid: ResourceId,
 ) -> Result<(), FsOpsError> {
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   file.sync_sync()?;
   Ok(())
 }
@@ -1515,7 +1523,7 @@ pub async fn op_fs_file_sync_async(
   #[smi] rid: ResourceId,
 ) -> Result<(), FsOpsError> {
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   file.sync_async().await?;
   Ok(())
 }
@@ -1527,7 +1535,7 @@ pub fn op_fs_file_stat_sync(
   #[buffer] stat_out_buf: &mut [u32],
 ) -> Result<(), FsOpsError> {
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   let stat = file.stat_sync()?;
   let serializable_stat = SerializableStat::from(stat);
   serializable_stat.write(stat_out_buf);
@@ -1541,7 +1549,7 @@ pub async fn op_fs_file_stat_async(
   #[smi] rid: ResourceId,
 ) -> Result<SerializableStat, FsOpsError> {
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   let stat = file.stat_async().await?;
   Ok(stat.into())
 }
@@ -1553,7 +1561,7 @@ pub fn op_fs_flock_sync(
   exclusive: bool,
 ) -> Result<(), FsOpsError> {
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   file.lock_sync(exclusive)?;
   Ok(())
 }
@@ -1565,7 +1573,7 @@ pub async fn op_fs_flock_async(
   exclusive: bool,
 ) -> Result<(), FsOpsError> {
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   file.lock_async(exclusive).await?;
   Ok(())
 }
@@ -1576,7 +1584,7 @@ pub fn op_fs_funlock_sync(
   #[smi] rid: ResourceId,
 ) -> Result<(), FsOpsError> {
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   file.unlock_sync()?;
   Ok(())
 }
@@ -1587,7 +1595,7 @@ pub async fn op_fs_funlock_async(
   #[smi] rid: ResourceId,
 ) -> Result<(), FsOpsError> {
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   file.unlock_async().await?;
   Ok(())
 }
@@ -1599,7 +1607,7 @@ pub fn op_fs_ftruncate_sync(
   #[number] len: u64,
 ) -> Result<(), FsOpsError> {
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   file.truncate_sync(len)?;
   Ok(())
 }
@@ -1611,7 +1619,7 @@ pub async fn op_fs_file_truncate_async(
   #[number] len: u64,
 ) -> Result<(), FsOpsError> {
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   file.truncate_async(len).await?;
   Ok(())
 }
@@ -1626,7 +1634,7 @@ pub fn op_fs_futime_sync(
   #[smi] mtime_nanos: u32,
 ) -> Result<(), FsOpsError> {
   let file =
-    FileResource::get_file(state, rid).map_err(FsOpsError::Resource)?;
+    FileResource::get_file(state, rid).map_err(FsOpsErrorKind::Resource)?;
   file.utime_sync(atime_secs, atime_nanos, mtime_secs, mtime_nanos)?;
   Ok(())
 }
@@ -1641,7 +1649,7 @@ pub async fn op_fs_futime_async(
   #[smi] mtime_nanos: u32,
 ) -> Result<(), FsOpsError> {
   let file = FileResource::get_file(&state.borrow(), rid)
-    .map_err(FsOpsError::Resource)?;
+    .map_err(FsOpsErrorKind::Resource)?;
   file
     .utime_async(atime_secs, atime_nanos, mtime_secs, mtime_nanos)
     .await?;
@@ -1717,7 +1725,7 @@ impl<T> MapErrContext for Result<T, FsError> {
   where
     F: FnOnce(FsError) -> OperationError,
   {
-    self.map_err(|err| FsOpsError::OperationError(f(err)))
+    self.map_err(|err| FsOpsErrorKind::OperationError(f(err)).into_box())
   }
 
   fn context(self, operation: &'static str) -> Self::R {
@@ -1754,7 +1762,8 @@ impl<T> MapErrContext for Result<T, FsError> {
 }
 
 fn path_into_string(s: std::ffi::OsString) -> Result<String, FsOpsError> {
-  s.into_string().map_err(FsOpsError::InvalidUtf8)
+  s.into_string()
+    .map_err(|e| FsOpsErrorKind::InvalidUtf8(e).into_box())
 }
 
 macro_rules! create_struct_writer {