diff options
Diffstat (limited to 'resolvers')
| -rw-r--r-- | resolvers/deno/Cargo.toml | 1 | ||||
| -rw-r--r-- | resolvers/deno/lib.rs | 55 | ||||
| -rw-r--r-- | resolvers/deno/npm/mod.rs | 52 | ||||
| -rw-r--r-- | resolvers/node/Cargo.toml | 1 | ||||
| -rw-r--r-- | resolvers/node/errors.rs | 70 |
5 files changed, 81 insertions, 98 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) } 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 { |