reduce variants on LoaderError

Author: dsherret

Cargo.lock

@@ -201,7 +201,7 @@ pub enum JsrLoadError {
   PackageVersionNotFound(Box<PackageNv>),
   #[class(generic)] // TODO: maybe inherit?
   #[error("JSR package version manifest for '{}' failed to load: {:#}", .0, .1)]
-  PackageVersionManifestLoad(Box<PackageNv>, Arc<LoadError>),
+  PackageVersionManifestLoad(Box<PackageNv>, Arc<dyn JsErrorClass>),
   #[class(inherit)]
   #[error("JSR package version manifest for '{}' failed to load: {:#}", .0, .1)]
   PackageVersionManifestChecksumIntegrity(

src/graph.rs

@@ -163,9 +163,9 @@ impl JsrMetadataStore {
                 err,
               )
             }
-            err => JsrLoadError::PackageVersionManifestLoad(
+            LoadError::Other(err) => JsrLoadError::PackageVersionManifestLoad(
               Box::new(package_nv),
-              Arc::new(err),
+              err,
             ),
           }
         }
@@ -210,7 +210,7 @@ impl JsrMetadataStore {
         match data {
           Some(LoadResponse::Module { content, .. }) => {
             handle_content(&content)
-              .map_err(|e| create_failed_load_err(e.into()))
+              .map_err(|e| create_failed_load_err(LoadError::Other(Arc::new(e))))
           }
           Some(LoadResponse::Redirect { specifier }) => {
             Err(JsrLoadError::RedirectInPackage(specifier))

src/jsr.rs

@@ -102,29 +102,14 @@ pub enum LoadResponse {
 
 #[derive(Debug, Error, deno_error::JsError)]
 pub enum LoadError {
-  #[class(type)]
-  #[error("Unsupported scheme: {0}")]
-  UnsupportedScheme(String),
   #[class(inherit)]
   #[error(transparent)]
   ChecksumIntegrity(#[from] ChecksumIntegrityError),
   #[class(inherit)]
   #[error(transparent)]
-  JsonParse(#[from] serde_json::Error),
-  #[class(inherit)]
-  #[error(transparent)]
-  DataUrl(std::io::Error),
-  #[class(inherit)]
-  #[error(transparent)]
   Other(Arc<dyn JsErrorClass>),
 }
 
-impl<T: JsErrorClass> From<Arc<T>> for LoadError {
-  fn from(value: Arc<T>) -> Self {
-    Self::Other(value)
-  }
-}
-
 pub type LoadResult = Result<Option<LoadResponse>, LoadError>;
 pub type LoadFuture = LocalBoxFuture<'static, LoadResult>;
 
@@ -558,8 +543,8 @@ pub trait NpmResolver: fmt::Debug {
 
 pub fn load_data_url(
   specifier: &ModuleSpecifier,
-) -> Result<Option<LoadResponse>, LoadError> {
-  let data_url = RawDataUrl::parse(specifier).map_err(LoadError::DataUrl)?;
+) -> Result<Option<LoadResponse>, std::io::Error> {
+  let data_url = RawDataUrl::parse(specifier)?;
   let (bytes, headers) = data_url.into_bytes_and_headers();
   Ok(Some(LoadResponse::Module {
     specifier: specifier.clone(),
@@ -786,7 +771,9 @@ impl Loader for MemoryLoader {
     let response = match self.sources.get(specifier) {
       Some(Ok(response)) => Ok(Some(response.clone())),
       Some(Err(err)) => Err(LoadError::Other(err.clone())),
-      None if specifier.scheme() == "data" => load_data_url(specifier),
+      None if specifier.scheme() == "data" => {
+        load_data_url(specifier).map_err(|e| LoadError::Other(Arc::new(e)))
+      }
       _ => Ok(None),
     };
     Box::pin(future::ready(response))

src/source/mod.rs

@@ -5,6 +5,7 @@
 use std::collections::HashSet;
 use std::io::Write as _;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use deno_ast::diagnostics::Diagnostic;
 use deno_ast::MediaType;
@@ -29,6 +30,7 @@ use indexmap::IndexMap;
 use serde::Deserialize;
 use std::fmt::Write;
 use tempfile::tempdir;
+use thiserror::Error;
 use url::Url;
 
 #[derive(Debug, Clone, Deserialize)]
@@ -156,6 +158,11 @@ struct VersionMeta {
   exports: IndexMap<String, String>,
 }
 
+#[derive(Debug, Clone, Deserialize, Error, deno_error::JsError)]
+#[class(type)]
+#[error("Unsupported scheme: {0}")]
+struct UnsupportedScheme(String);
+
 struct Loader<'a> {
   scope: &'a str,
   name: &'a str,
@@ -188,13 +195,14 @@ impl deno_graph::source::Loader for Loader<'_> {
           )),
         }
       }
-      "data" => deno_graph::source::load_data_url(specifier),
+      "data" => deno_graph::source::load_data_url(specifier)
+        .map_err(|e| deno_graph::source::LoadError::Other(Arc::new(e))),
       "jsr" | "npm" | "node" => Ok(Some(LoadResponse::External {
         specifier: specifier.clone(),
       })),
-      _ => Err(deno_graph::source::LoadError::UnsupportedScheme(
-        specifier.scheme().to_string(),
-      )),
+      _ => Err(deno_graph::source::LoadError::Other(Arc::new(
+        UnsupportedScheme(specifier.scheme().to_string()),
+      ))),
     };
     async move { res }.boxed()
   }