refactor: use boxed_error in some places (#26887)

2 files changed, 28 insertions, 43 deletions

diff --git a/resolvers/node/Cargo.toml b/resolvers/node/Cargo.toml
index 6c2407ad9..eeac79c25 100644
--- a/resolvers/node/Cargo.toml
+++ b/resolvers/node/Cargo.toml
@@ -19,6 +19,7 @@ sync = ["deno_package_json/sync"]
 [dependencies]
 anyhow.workspace = true
 async-trait.workspace = true
+boxed_error.workspace = true
 deno_media_type.workspace = true
 deno_package_json.workspace = true
 deno_path_util.workspace = true
diff --git a/resolvers/node/errors.rs b/resolvers/node/errors.rs
index aacbecefb..0f332d2c9 100644
--- a/resolvers/node/errors.rs
+++ b/resolvers/node/errors.rs
@@ -4,39 +4,13 @@ use std::borrow::Cow;
 use std::fmt::Write;
 use std::path::PathBuf;
 
+use boxed_error::Boxed;
 use thiserror::Error;
 use url::Url;
 
 use crate::NodeModuleKind;
 use crate::NodeResolutionMode;
 
-macro_rules! kinded_err {
-  ($name:ident, $kind_name:ident) => {
-    #[derive(Error, Debug)]
-    #[error(transparent)]
-    pub struct $name(pub Box<$kind_name>);
-
-    impl $name {
-      pub fn as_kind(&self) -> &$kind_name {
-        &self.0
-      }
-
-      pub fn into_kind(self) -> $kind_name {
-        *self.0
-      }
-    }
-
-    impl<E> From<E> for $name
-    where
-      $kind_name: From<E>,
-    {
-      fn from(err: E) -> Self {
-        $name(Box::new($kind_name::from(err)))
-      }
-    }
-  };
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 #[allow(non_camel_case_types)]
 pub enum NodeJsErrorCode {
@@ -102,7 +76,8 @@ impl NodeJsErrorCoded for InvalidModuleSpecifierError {
   }
 }
 
-kinded_err!(LegacyResolveError, LegacyResolveErrorKind);
+#[derive(Debug, Boxed)]
+pub struct LegacyResolveError(pub Box<LegacyResolveErrorKind>);
 
 #[derive(Debug, Error)]
 pub enum LegacyResolveErrorKind {
@@ -121,8 +96,6 @@ impl NodeJsErrorCoded for LegacyResolveError {
   }
 }
 
-kinded_err!(PackageFolderResolveError, PackageFolderResolveErrorKind);
-
 #[derive(Debug, Error)]
 #[error(
   "Could not find package '{}' from referrer '{}'{}.",
@@ -186,6 +159,9 @@ impl NodeJsErrorCoded for PackageFolderResolveError {
   }
 }
 
+#[derive(Debug, Boxed)]
+pub struct PackageFolderResolveError(pub Box<PackageFolderResolveErrorKind>);
+
 #[derive(Debug, Error)]
 pub enum PackageFolderResolveErrorKind {
   #[error(transparent)]
@@ -196,8 +172,6 @@ pub enum PackageFolderResolveErrorKind {
   Io(#[from] PackageFolderResolveIoError),
 }
 
-kinded_err!(PackageSubpathResolveError, PackageSubpathResolveErrorKind);
-
 impl NodeJsErrorCoded for PackageSubpathResolveError {
   fn code(&self) -> NodeJsErrorCode {
     match self.as_kind() {
@@ -208,6 +182,9 @@ impl NodeJsErrorCoded for PackageSubpathResolveError {
   }
 }
 
+#[derive(Debug, Boxed)]
+pub struct PackageSubpathResolveError(pub Box<PackageSubpathResolveErrorKind>);
+
 #[derive(Debug, Error)]
 pub enum PackageSubpathResolveErrorKind {
   #[error(transparent)]
@@ -252,8 +229,6 @@ impl NodeJsErrorCoded for PackageTargetNotFoundError {
   }
 }
 
-kinded_err!(PackageTargetResolveError, PackageTargetResolveErrorKind);
-
 impl NodeJsErrorCoded for PackageTargetResolveError {
   fn code(&self) -> NodeJsErrorCode {
     match self.as_kind() {
@@ -266,6 +241,9 @@ impl NodeJsErrorCoded for PackageTargetResolveError {
   }
 }
 
+#[derive(Debug, Boxed)]
+pub struct PackageTargetResolveError(pub Box<PackageTargetResolveErrorKind>);
+
 #[derive(Debug, Error)]
 pub enum PackageTargetResolveErrorKind {
   #[error(transparent)]
@@ -280,8 +258,6 @@ pub enum PackageTargetResolveErrorKind {
   TypesNotFound(#[from] TypesNotFoundError),
 }
 
-kinded_err!(PackageExportsResolveError, PackageExportsResolveErrorKind);
-
 impl NodeJsErrorCoded for PackageExportsResolveError {
   fn code(&self) -> NodeJsErrorCode {
     match self.as_kind() {
@@ -291,6 +267,9 @@ impl NodeJsErrorCoded for PackageExportsResolveError {
   }
 }
 
+#[derive(Debug, Boxed)]
+pub struct PackageExportsResolveError(pub Box<PackageExportsResolveErrorKind>);
+
 #[derive(Debug, Error)]
 pub enum PackageExportsResolveErrorKind {
   #[error(transparent)]
@@ -338,8 +317,6 @@ impl NodeJsErrorCoded for PackageJsonLoadError {
   }
 }
 
-kinded_err!(ClosestPkgJsonError, ClosestPkgJsonErrorKind);
-
 impl NodeJsErrorCoded for ClosestPkgJsonError {
   fn code(&self) -> NodeJsErrorCode {
     match self.as_kind() {
@@ -349,6 +326,9 @@ impl NodeJsErrorCoded for ClosestPkgJsonError {
   }
 }
 
+#[derive(Debug, Boxed)]
+pub struct ClosestPkgJsonError(pub Box<ClosestPkgJsonErrorKind>);
+
 #[derive(Debug, Error)]
 pub enum ClosestPkgJsonErrorKind {
   #[error(transparent)]
@@ -392,7 +372,8 @@ impl NodeJsErrorCoded for PackageImportNotDefinedError {
   }
 }
 
-kinded_err!(PackageImportsResolveError, PackageImportsResolveErrorKind);
+#[derive(Debug, Boxed)]
+pub struct PackageImportsResolveError(pub Box<PackageImportsResolveErrorKind>);
 
 #[derive(Debug, Error)]
 pub enum PackageImportsResolveErrorKind {
@@ -417,8 +398,6 @@ impl NodeJsErrorCoded for PackageImportsResolveErrorKind {
   }
 }
 
-kinded_err!(PackageResolveError, PackageResolveErrorKind);
-
 impl NodeJsErrorCoded for PackageResolveError {
   fn code(&self) -> NodeJsErrorCode {
     match self.as_kind() {
@@ -431,6 +410,9 @@ impl NodeJsErrorCoded for PackageResolveError {
   }
 }
 
+#[derive(Debug, Boxed)]
+pub struct PackageResolveError(pub Box<PackageResolveErrorKind>);
+
 #[derive(Debug, Error)]
 pub enum PackageResolveErrorKind {
   #[error(transparent)]
@@ -461,7 +443,8 @@ pub struct DataUrlReferrerError {
   pub source: url::ParseError,
 }
 
-kinded_err!(NodeResolveError, NodeResolveErrorKind);
+#[derive(Debug, Boxed)]
+pub struct NodeResolveError(pub Box<NodeResolveErrorKind>);
 
 #[derive(Debug, Error)]
 pub enum NodeResolveErrorKind {
@@ -481,7 +464,8 @@ pub enum NodeResolveErrorKind {
   FinalizeResolution(#[from] FinalizeResolutionError),
 }
 
-kinded_err!(FinalizeResolutionError, FinalizeResolutionErrorKind);
+#[derive(Debug, Boxed)]
+pub struct FinalizeResolutionError(pub Box<FinalizeResolutionErrorKind>);
 
 #[derive(Debug, Error)]
 pub enum FinalizeResolutionErrorKind {