Revert "Remove unnecessary rspack_fs Error"

This reverts commit 46d63ff.

Author: CPunisher

crates/rspack_core/src/compiler/mod.rs

@@ -6,7 +6,7 @@ use std::sync::{atomic::AtomicU32, Arc};
 
 use futures::future::join_all;
 use rspack_cacheable::cacheable;
-use rspack_error::{miette::IntoDiagnostic, Result};
+use rspack_error::Result;
 use rspack_fs::{IntermediateFileSystem, NativeFileSystem, ReadableFileSystem, WritableFileSystem};
 use rspack_hook::define_hook;
 use rspack_paths::{Utf8Path, Utf8PathBuf};
@@ -436,8 +436,7 @@ impl Compiler {
             .parent()
             .unwrap_or_else(|| panic!("The parent of {file_path} can't found")),
         )
-        .await
-        .into_diagnostic()?;
+        .await?;
 
       let content = source.buffer();
 
@@ -481,11 +480,7 @@ impl Compiler {
       };
 
       if need_write {
-        self
-          .output_filesystem
-          .write(&file_path, &content)
-          .await
-          .into_diagnostic()?;
+        self.output_filesystem.write(&file_path, &content).await?;
         self.compilation.emitted_assets.insert(filename.to_string());
       }
 
@@ -518,8 +513,7 @@ impl Compiler {
           self
             .output_filesystem
             .remove_dir_all(&self.options.output.path)
-            .await
-            .into_diagnostic()?;
+            .await?;
         }
         CleanOptions::KeepPath(p) => {
           let path = self.options.output.path.join(p);
@@ -528,8 +522,7 @@ impl Compiler {
             &self.options.output.path,
             KeepPattern::Path(&path),
           )
-          .await
-          .into_diagnostic()?;
+          .await?;
         }
         CleanOptions::KeepRegex(r) => {
           let keep_pattern = KeepPattern::Regex(r);
@@ -538,8 +531,7 @@ impl Compiler {
             &self.options.output.path,
             keep_pattern,
           )
-          .await
-          .into_diagnostic()?;
+          .await?;
         }
         CleanOptions::KeepFunc(f) => {
           let keep_pattern = KeepPattern::Func(f);
@@ -548,8 +540,7 @@ impl Compiler {
             &self.options.output.path,
             keep_pattern,
           )
-          .await
-          .into_diagnostic()?;
+          .await?;
         }
         _ => {}
       }

crates/rspack_core/src/resolver/boxfs.rs

@@ -3,7 +3,7 @@ use std::{
   sync::Arc,
 };
 
-use rspack_fs::ReadableFileSystem;
+use rspack_fs::{Error, FsResultToIoResultExt, ReadableFileSystem};
 use rspack_paths::AssertUtf8;
 use rspack_resolver::{FileMetadata, FileSystem as ResolverFileSystem};
 
@@ -18,32 +18,40 @@ impl BoxFS {
 #[async_trait::async_trait]
 impl ResolverFileSystem for BoxFS {
   async fn read(&self, path: &std::path::Path) -> io::Result<Vec<u8>> {
-    self.0.read(path.assert_utf8()).await
+    self.0.read(path.assert_utf8()).await.to_io_result()
   }
   async fn read_to_string(&self, path: &std::path::Path) -> std::io::Result<String> {
-    let x = self.0.read(path.assert_utf8()).await?;
-    String::from_utf8(x).map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
+    match self.0.read(path.assert_utf8()).await {
+      Ok(x) => String::from_utf8(x).map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err)),
+      Err(Error::Io(e)) => Err(e),
+    }
   }
   async fn metadata(&self, path: &std::path::Path) -> io::Result<FileMetadata> {
-    let meta = self.0.metadata(path.assert_utf8()).await?;
-    Ok(FileMetadata {
-      is_dir: meta.is_directory,
-      is_file: meta.is_file,
-      is_symlink: meta.is_symlink,
-    })
+    match self.0.metadata(path.assert_utf8()).await {
+      Ok(meta) => Ok(FileMetadata {
+        is_dir: meta.is_directory,
+        is_file: meta.is_file,
+        is_symlink: meta.is_symlink,
+      }),
+      Err(Error::Io(e)) => Err(e),
+    }
   }
 
   async fn symlink_metadata(&self, path: &std::path::Path) -> io::Result<FileMetadata> {
-    let meta = self.0.symlink_metadata(path.assert_utf8()).await?;
-    Ok(FileMetadata {
-      is_dir: meta.is_directory,
-      is_file: meta.is_file,
-      is_symlink: meta.is_symlink,
-    })
+    match self.0.symlink_metadata(path.assert_utf8()).await {
+      Ok(meta) => Ok(FileMetadata {
+        is_dir: meta.is_directory,
+        is_file: meta.is_file,
+        is_symlink: meta.is_symlink,
+      }),
+      Err(Error::Io(e)) => Err(e),
+    }
   }
 
   async fn canonicalize(&self, path: &std::path::Path) -> io::Result<std::path::PathBuf> {
-    let path = self.0.canonicalize(path.assert_utf8()).await?;
-    Ok(path.into())
+    match self.0.canonicalize(path.assert_utf8()).await {
+      Ok(path) => Ok(path.into()),
+      Err(Error::Io(e)) => Err(e),
+    }
   }
 }

crates/rspack_core/src/utils/fs_trim.rs

@@ -1,5 +1,6 @@
 use cow_utils::CowUtils;
-use rspack_fs::{Result as FsResult, RspackResultToFsResultExt, WritableFileSystem};
+use rspack_error::Result;
+use rspack_fs::{Result as FsResult, WritableFileSystem};
 use rspack_paths::Utf8Path;
 use rspack_regex::RspackRegex;
 
@@ -12,13 +13,11 @@ pub enum KeepPattern<'a> {
 }
 
 impl<'a> KeepPattern<'a> {
-  pub async fn try_match(&self, path: &'a Utf8Path) -> FsResult<bool> {
+  pub async fn try_match(&self, path: &'a Utf8Path) -> Result<bool> {
     match self {
       KeepPattern::Path(p) => Ok(path.starts_with(p)),
       KeepPattern::Regex(r) => Ok(r.test(path.as_str().cow_replace("\\", "/").as_ref())),
-      KeepPattern::Func(f) => f(path.as_str().cow_replace("\\", "/").to_string())
-        .await
-        .to_fs_result(),
+      KeepPattern::Func(f) => f(path.as_str().cow_replace("\\", "/").to_string()).await,
     }
   }
 }

crates/rspack_fs/src/error.rs

@@ -1,13 +1,87 @@
-pub type Error = std::io::Error;
+use std::fmt::Display;
+
+use rspack_error::{
+  miette::{self, Diagnostic},
+  thiserror::{self, Error},
+};
+
+#[derive(Debug, Error, Diagnostic)]
+#[error("Rspack FS Error: {0}")]
+struct FsError(#[source] std::io::Error);
+
+#[derive(Debug)]
+pub enum Error {
+  /// Generic I/O error
+  Io(std::io::Error),
+}
+
+impl Error {
+  pub fn new(kind: std::io::ErrorKind, message: &str) -> Self {
+    Error::Io(std::io::Error::new(kind, message))
+  }
+}
+
+impl From<std::io::Error> for Error {
+  fn from(value: std::io::Error) -> Self {
+    Self::Io(value)
+  }
+}
+
+impl From<Error> for rspack_error::Error {
+  fn from(value: Error) -> Self {
+    match value {
+      Error::Io(err) => FsError(err).into(),
+    }
+  }
+}
+
+impl From<rspack_error::Error> for Error {
+  fn from(e: rspack_error::Error) -> Self {
+    Error::Io(std::io::Error::other(e.to_string()))
+  }
+}
+
+impl Display for Error {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Error::Io(err) => write!(f, "IO error: {err}"),
+    }
+  }
+}
 
 pub type Result<T> = std::result::Result<T, Error>;
 
 pub trait RspackResultToFsResultExt<T> {
   fn to_fs_result(self) -> Result<T>;
 }
 
-impl<T> RspackResultToFsResultExt<T> for rspack_error::Result<T> {
+impl<T, E: ToString> RspackResultToFsResultExt<T> for std::result::Result<T, E> {
   fn to_fs_result(self) -> Result<T> {
-    self.map_err(|e| Error::other(e.to_string()))
+    match self {
+      Ok(t) => Ok(t),
+      Err(e) => Err(Error::Io(std::io::Error::other(e.to_string()))),
+    }
+  }
+}
+
+pub trait IoResultToFsResultExt<T> {
+  fn to_fs_result(self) -> Result<T>;
+}
+
+impl<T> IoResultToFsResultExt<T> for std::io::Result<T> {
+  fn to_fs_result(self) -> Result<T> {
+    self.map_err(Error::from)
+  }
+}
+
+pub trait FsResultToIoResultExt<T> {
+  fn to_io_result(self) -> std::io::Result<T>;
+}
+
+impl<T> FsResultToIoResultExt<T> for Result<T> {
+  fn to_io_result(self) -> std::io::Result<T> {
+    self.map_err(|e| match e {
+      Error::Io(err) => err,
+    })
   }
 }

crates/rspack_fs/src/file_metadata.rs

@@ -1,6 +1,6 @@
 use std::{fs::Metadata, io::ErrorKind};
 
-use crate::{Error, Result};
+use crate::{Error, IoResultToFsResultExt, Result};
 
 #[derive(Debug, Clone)]
 pub struct FileMetadata {
@@ -17,7 +17,8 @@ impl TryFrom<Metadata> for FileMetadata {
 
   fn try_from(metadata: Metadata) -> Result<Self> {
     let mtime_ms = metadata
-      .modified()?
+      .modified()
+      .to_fs_result()?
       .duration_since(std::time::UNIX_EPOCH)
       .expect("mtime is before unix epoch")
       .as_millis() as u64;
@@ -37,7 +38,8 @@ impl TryFrom<Metadata> for FileMetadata {
       }
     };
     let atime_ms = metadata
-      .accessed()?
+      .accessed()
+      .to_fs_result()?
       .duration_since(std::time::UNIX_EPOCH)
       .expect("atime is before unix epoch")
       .as_millis() as u64;

crates/rspack_fs/src/intermediate.rs

@@ -3,7 +3,7 @@ use std::fmt::Debug;
 use rspack_paths::Utf8Path;
 
 use super::Result;
-use crate::WritableFileSystem;
+use crate::{Error, WritableFileSystem};
 
 pub trait IntermediateFileSystem:
   WritableFileSystem + IntermediateFileSystemExtras + Debug + Send + Sync
@@ -22,7 +22,7 @@ pub trait ReadStream: Debug + Sync + Send {
   async fn read_line(&mut self) -> Result<String> {
     match String::from_utf8(self.read_until(b'\n').await?) {
       Ok(s) => Ok(s),
-      Err(_) => Err(std::io::Error::other("invalid utf8 line")),
+      Err(_) => Err(Error::Io(std::io::Error::other("invalid utf8 line"))),
     }
   }
   async fn read(&mut self, length: usize) -> Result<Vec<u8>>;

crates/rspack_fs/src/lib.rs

@@ -20,4 +20,6 @@ mod memory_fs;
 pub use memory_fs::{MemoryFileSystem, MemoryReadStream, MemoryWriteStream};
 
 mod error;
-pub use error::{Error, Result, RspackResultToFsResultExt};
+pub use error::{
+  Error, FsResultToIoResultExt, IoResultToFsResultExt, Result, RspackResultToFsResultExt,
+};

crates/rspack_fs/src/memory_fs.rs

@@ -1,15 +1,15 @@
 use std::{
   collections::{HashMap, HashSet},
-  io::{BufRead, Cursor, ErrorKind, Read, Seek},
+  io::{BufRead, Cursor, Read, Seek},
   sync::{Arc, Mutex},
   time::{SystemTime, UNIX_EPOCH},
 };
 
 use rspack_paths::{AssertUtf8, Utf8Path, Utf8PathBuf};
 
 use crate::{
-  Error, FileMetadata, IntermediateFileSystem, IntermediateFileSystemExtras, ReadStream,
-  ReadableFileSystem, Result, WritableFileSystem, WriteStream,
+  Error, FileMetadata, IntermediateFileSystem, IntermediateFileSystemExtras, IoResultToFsResultExt,
+  ReadStream, ReadableFileSystem, Result, WritableFileSystem, WriteStream,
 };
 
 fn current_time() -> u64 {
@@ -20,7 +20,7 @@ fn current_time() -> u64 {
 }
 
 fn new_error(msg: &str) -> Error {
-  Error::other(msg)
+  Error::Io(std::io::Error::other(msg))
 }
 
 #[derive(Debug)]
@@ -240,7 +240,10 @@ impl ReadableFileSystem for MemoryFileSystem {
     let files = self.files.lock().expect("should get lock");
     match files.get(path) {
       Some(FileType::File { content, .. }) => Ok(content.clone()),
-      _ => Err(Error::new(ErrorKind::NotFound, "file not exist")),
+      _ => Err(Error::Io(std::io::Error::new(
+        std::io::ErrorKind::NotFound,
+        "file not exist",
+      ))),
     }
   }
 
@@ -252,7 +255,10 @@ impl ReadableFileSystem for MemoryFileSystem {
     let files = self.files.lock().expect("should get lock");
     match files.get(path) {
       Some(ft) => Ok(ft.metadata().clone()),
-      None => Err(Error::new(ErrorKind::NotFound, "file not exist")),
+      None => Err(Error::Io(std::io::Error::new(
+        std::io::ErrorKind::NotFound,
+        "file not exist",
+      ))),
     }
   }
 
@@ -308,25 +314,25 @@ impl MemoryReadStream {
 impl ReadStream for MemoryReadStream {
   async fn read(&mut self, length: usize) -> Result<Vec<u8>> {
     let mut buf = vec![0u8; length];
-    self.0.read_exact(&mut buf)?;
+    self.0.read_exact(&mut buf).to_fs_result()?;
     Ok(buf)
   }
 
   async fn read_until(&mut self, byte: u8) -> Result<Vec<u8>> {
     let mut buf = vec![];
-    self.0.read_until(byte, &mut buf)?;
+    self.0.read_until(byte, &mut buf).to_fs_result()?;
     if buf.last().is_some_and(|b| b == &byte) {
       buf.pop();
     }
     Ok(buf)
   }
   async fn read_to_end(&mut self) -> Result<Vec<u8>> {
     let mut buf = vec![];
-    self.0.read_to_end(&mut buf)?;
+    self.0.read_to_end(&mut buf).to_fs_result()?;
     Ok(buf)
   }
   async fn skip(&mut self, offset: usize) -> Result<()> {
-    self.0.seek_relative(offset as i64)
+    self.0.seek_relative(offset as i64).to_fs_result()
   }
   async fn close(&mut self) -> Result<()> {
     Ok(())