refactor: use boxed_error in some places (#26887)

3 files changed, 53 insertions, 55 deletions

diff --git a/resolvers/deno/Cargo.toml b/resolvers/deno/Cargo.toml
index 89c0232dc..c2d4a3bc2 100644
--- a/resolvers/deno/Cargo.toml
+++ b/resolvers/deno/Cargo.toml
@@ -16,6 +16,7 @@ path = "lib.rs"
 [dependencies]
 anyhow.workspace = true
 base32.workspace = true
+boxed_error.workspace = true
 dashmap.workspace = true
 deno_config.workspace = true
 deno_media_type.workspace = true
diff --git a/resolvers/deno/lib.rs b/resolvers/deno/lib.rs
index a2b6b642f..303a82710 100644
--- a/resolvers/deno/lib.rs
+++ b/resolvers/deno/lib.rs
@@ -6,6 +6,7 @@
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use boxed_error::Boxed;
 use deno_config::workspace::MappedResolution;
 use deno_config::workspace::MappedResolutionDiagnostic;
 use deno_config::workspace::MappedResolutionError;
@@ -26,9 +27,9 @@ use node_resolver::NodeResolver;
 use npm::MissingPackageNodeModulesFolderError;
 use npm::NodeModulesOutOfDateError;
 use npm::NpmReqResolver;
-use npm::ResolveIfForNpmPackageError;
+use npm::ResolveIfForNpmPackageErrorKind;
 use npm::ResolvePkgFolderFromDenoReqError;
-use npm::ResolveReqWithSubPathError;
+use npm::ResolveReqWithSubPathErrorKind;
 use sloppy_imports::SloppyImportResolverFs;
 use sloppy_imports::SloppyImportsResolutionMode;
 use sloppy_imports::SloppyImportsResolver;
@@ -47,6 +48,9 @@ pub struct DenoResolution {
   pub found_package_json_dep: bool,
 }
 
+#[derive(Debug, Boxed)]
+pub struct DenoResolveError(pub Box<DenoResolveErrorKind>);
+
 #[derive(Debug, Error)]
 pub enum DenoResolveErrorKind {
   #[error("Importing from the vendor directory is not permitted. Use a remote specifier instead or disable vendoring.")]
@@ -71,35 +75,6 @@ pub enum DenoResolveErrorKind {
   WorkspaceResolvePkgJsonFolder(#[from] WorkspaceResolvePkgJsonFolderError),
 }
 
-impl DenoResolveErrorKind {
-  pub fn into_box(self) -> DenoResolveError {
-    DenoResolveError(Box::new(self))
-  }
-}
-
-#[derive(Error, Debug)]
-#[error(transparent)]
-pub struct DenoResolveError(pub Box<DenoResolveErrorKind>);
-
-impl DenoResolveError {
-  pub fn as_kind(&self) -> &DenoResolveErrorKind {
-    &self.0
-  }
-
-  pub fn into_kind(self) -> DenoResolveErrorKind {
-    *self.0
-  }
-}
-
-impl<E> From<E> for DenoResolveError
-where
-  DenoResolveErrorKind: From<E>,
-{
-  fn from(err: E) -> Self {
-    DenoResolveError(Box::new(DenoResolveErrorKind::from(err)))
-  }
-}
-
 #[derive(Debug)]
 pub struct NodeAndNpmReqResolver<
   Fs: DenoResolverFs,
@@ -378,16 +353,18 @@ impl<
                 maybe_diagnostic,
                 found_package_json_dep,
               })
-              .map_err(|err| match err {
-                ResolveReqWithSubPathError::MissingPackageNodeModulesFolder(
+              .map_err(|err| {
+                match err.into_kind() {
+                ResolveReqWithSubPathErrorKind::MissingPackageNodeModulesFolder(
                   err,
                 ) => err.into(),
-                ResolveReqWithSubPathError::ResolvePkgFolderFromDenoReq(
+                ResolveReqWithSubPathErrorKind::ResolvePkgFolderFromDenoReq(
                   err,
                 ) => err.into(),
-                ResolveReqWithSubPathError::PackageSubpathResolve(err) => {
+                ResolveReqWithSubPathErrorKind::PackageSubpathResolve(err) => {
                   err.into()
                 }
+              }
               });
           }
         }
@@ -410,11 +387,13 @@ impl<
               referrer_kind,
               mode,
             )
-            .map_err(|e| match e {
-              ResolveIfForNpmPackageError::NodeResolve(e) => {
+            .map_err(|e| match e.into_kind() {
+              ResolveIfForNpmPackageErrorKind::NodeResolve(e) => {
                 DenoResolveErrorKind::Node(e).into_box()
               }
-              ResolveIfForNpmPackageError::NodeModulesOutOfDate(e) => e.into(),
+              ResolveIfForNpmPackageErrorKind::NodeModulesOutOfDate(e) => {
+                e.into()
+              }
             })?;
           if let Some(res) = maybe_resolution {
             match res {
diff --git a/resolvers/deno/npm/mod.rs b/resolvers/deno/npm/mod.rs
index b0aec71b0..09e35b15c 100644
--- a/resolvers/deno/npm/mod.rs
+++ b/resolvers/deno/npm/mod.rs
@@ -4,6 +4,7 @@ use std::fmt::Debug;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use boxed_error::Boxed;
 use deno_semver::npm::NpmPackageReqReference;
 use deno_semver::package::PackageReq;
 use node_resolver::env::NodeResolverEnv;
@@ -45,16 +46,24 @@ pub struct MissingPackageNodeModulesFolderError {
   pub package_json_path: PathBuf,
 }
 
+#[derive(Debug, Boxed)]
+pub struct ResolveIfForNpmPackageError(
+  pub Box<ResolveIfForNpmPackageErrorKind>,
+);
+
 #[derive(Debug, Error)]
-pub enum ResolveIfForNpmPackageError {
+pub enum ResolveIfForNpmPackageErrorKind {
   #[error(transparent)]
   NodeResolve(#[from] NodeResolveError),
   #[error(transparent)]
   NodeModulesOutOfDate(#[from] NodeModulesOutOfDateError),
 }
 
+#[derive(Debug, Boxed)]
+pub struct ResolveReqWithSubPathError(pub Box<ResolveReqWithSubPathErrorKind>);
+
 #[derive(Debug, Error)]
-pub enum ResolveReqWithSubPathError {
+pub enum ResolveReqWithSubPathErrorKind {
   #[error(transparent)]
   MissingPackageNodeModulesFolder(#[from] MissingPackageNodeModulesFolderError),
   #[error(transparent)]
@@ -191,20 +200,21 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
           | NodeResolveErrorKind::UnsupportedEsmUrlScheme(_)
           | NodeResolveErrorKind::DataUrlReferrer(_)
           | NodeResolveErrorKind::TypesNotFound(_)
-          | NodeResolveErrorKind::FinalizeResolution(_) => {
-            Err(ResolveIfForNpmPackageError::NodeResolve(err.into()))
-          }
+          | NodeResolveErrorKind::FinalizeResolution(_) => Err(
+            ResolveIfForNpmPackageErrorKind::NodeResolve(err.into()).into_box(),
+          ),
           NodeResolveErrorKind::PackageResolve(err) => {
             let err = err.into_kind();
             match err {
               PackageResolveErrorKind::ClosestPkgJson(_)
               | PackageResolveErrorKind::InvalidModuleSpecifier(_)
               | PackageResolveErrorKind::ExportsResolve(_)
-              | PackageResolveErrorKind::SubpathResolve(_) => {
-                Err(ResolveIfForNpmPackageError::NodeResolve(
+              | PackageResolveErrorKind::SubpathResolve(_) => Err(
+                ResolveIfForNpmPackageErrorKind::NodeResolve(
                   NodeResolveErrorKind::PackageResolve(err.into()).into(),
-                ))
-              }
+                )
+                .into_box(),
+              ),
               PackageResolveErrorKind::PackageFolderResolve(err) => {
                 match err.as_kind() {
                   PackageFolderResolveErrorKind::Io(
@@ -214,9 +224,13 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
                     PackageNotFoundError { package_name, .. },
                   ) => {
                     if self.in_npm_pkg_checker.in_npm_package(referrer) {
-                      return Err(ResolveIfForNpmPackageError::NodeResolve(
-                        NodeResolveErrorKind::PackageResolve(err.into()).into(),
-                      ));
+                      return Err(
+                        ResolveIfForNpmPackageErrorKind::NodeResolve(
+                          NodeResolveErrorKind::PackageResolve(err.into())
+                            .into(),
+                        )
+                        .into_box(),
+                      );
                     }
                     if let Some(byonm_npm_resolver) = &self.byonm_resolver {
                       if byonm_npm_resolver
@@ -227,11 +241,11 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
                         .is_some()
                       {
                         return Err(
-                          ResolveIfForNpmPackageError::NodeModulesOutOfDate(
+                          ResolveIfForNpmPackageErrorKind::NodeModulesOutOfDate(
                             NodeModulesOutOfDateError {
                               specifier: specifier.to_string(),
                             },
-                          ),
+                          ).into_box(),
                         );
                       }
                     }
@@ -239,9 +253,13 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
                   }
                   PackageFolderResolveErrorKind::ReferrerNotFound(_) => {
                     if self.in_npm_pkg_checker.in_npm_package(referrer) {
-                      return Err(ResolveIfForNpmPackageError::NodeResolve(
-                        NodeResolveErrorKind::PackageResolve(err.into()).into(),
-                      ));
+                      return Err(
+                        ResolveIfForNpmPackageErrorKind::NodeResolve(
+                          NodeResolveErrorKind::PackageResolve(err.into())
+                            .into(),
+                        )
+                        .into_box(),
+                      );
                     }
                     Ok(None)
                   }