mirror of
https://github.com/denoland/deno.git
synced 2025-01-08 07:08:27 -05:00
89c92b84fa
Instead of hard erroring, we now surface module not found errors as TypeScript diagnostics (we have yet to show the source code of the error, but something we can improve over time).
123 lines
4.2 KiB
Rust
123 lines
4.2 KiB
Rust
// Copyright 2018-2025 the Deno authors. MIT license.
|
|
|
|
//! There are many types of errors in Deno:
|
|
//! - AnyError: a generic wrapper that can encapsulate any type of error.
|
|
//! - JsError: a container for the error message and stack trace for exceptions
|
|
//! thrown in JavaScript code. We use this to pretty-print stack traces.
|
|
//! - Diagnostic: these are errors that originate in TypeScript's compiler.
|
|
//! They're similar to JsError, in that they have line numbers. But
|
|
//! Diagnostics are compile-time type errors, whereas JsErrors are runtime
|
|
//! exceptions.
|
|
|
|
use deno_ast::ParseDiagnostic;
|
|
use deno_core::error::AnyError;
|
|
use deno_graph::source::ResolveError;
|
|
use deno_graph::ModuleError;
|
|
use deno_graph::ModuleGraphError;
|
|
use deno_graph::ModuleLoadError;
|
|
use deno_graph::ResolutionError;
|
|
use import_map::ImportMapError;
|
|
|
|
fn get_import_map_error_class(_: &ImportMapError) -> &'static str {
|
|
"URIError"
|
|
}
|
|
|
|
fn get_diagnostic_class(_: &ParseDiagnostic) -> &'static str {
|
|
"SyntaxError"
|
|
}
|
|
|
|
pub fn get_module_graph_error_class(err: &ModuleGraphError) -> &'static str {
|
|
match err {
|
|
ModuleGraphError::ResolutionError(err)
|
|
| ModuleGraphError::TypesResolutionError(err) => {
|
|
get_resolution_error_class(err)
|
|
}
|
|
ModuleGraphError::ModuleError(err) => get_module_error_class(err),
|
|
}
|
|
}
|
|
|
|
pub fn get_module_error_class(err: &ModuleError) -> &'static str {
|
|
use deno_graph::JsrLoadError;
|
|
use deno_graph::NpmLoadError;
|
|
|
|
match err {
|
|
ModuleError::InvalidTypeAssertion { .. } => "SyntaxError",
|
|
ModuleError::ParseErr(_, diagnostic) => get_diagnostic_class(diagnostic),
|
|
ModuleError::WasmParseErr(..) => "SyntaxError",
|
|
ModuleError::UnsupportedMediaType { .. }
|
|
| ModuleError::UnsupportedImportAttributeType { .. } => "TypeError",
|
|
ModuleError::Missing(_, _) | ModuleError::MissingDynamic(_, _) => {
|
|
"NotFound"
|
|
}
|
|
ModuleError::LoadingErr(_, _, err) => match err {
|
|
ModuleLoadError::Loader(err) => get_error_class_name(err.as_ref()),
|
|
ModuleLoadError::HttpsChecksumIntegrity(_)
|
|
| ModuleLoadError::TooManyRedirects => "Error",
|
|
ModuleLoadError::NodeUnknownBuiltinModule(_) => "NotFound",
|
|
ModuleLoadError::Decode(_) => "TypeError",
|
|
ModuleLoadError::Npm(err) => match err {
|
|
NpmLoadError::NotSupportedEnvironment
|
|
| NpmLoadError::PackageReqResolution(_)
|
|
| NpmLoadError::RegistryInfo(_) => "Error",
|
|
NpmLoadError::PackageReqReferenceParse(_) => "TypeError",
|
|
},
|
|
ModuleLoadError::Jsr(err) => match err {
|
|
JsrLoadError::UnsupportedManifestChecksum
|
|
| JsrLoadError::PackageFormat(_) => "TypeError",
|
|
JsrLoadError::ContentLoadExternalSpecifier
|
|
| JsrLoadError::ContentLoad(_)
|
|
| JsrLoadError::ContentChecksumIntegrity(_)
|
|
| JsrLoadError::PackageManifestLoad(_, _)
|
|
| JsrLoadError::PackageVersionManifestChecksumIntegrity(..)
|
|
| JsrLoadError::PackageVersionManifestLoad(_, _)
|
|
| JsrLoadError::RedirectInPackage(_) => "Error",
|
|
JsrLoadError::PackageNotFound(_)
|
|
| JsrLoadError::PackageReqNotFound(_)
|
|
| JsrLoadError::PackageVersionNotFound(_)
|
|
| JsrLoadError::UnknownExport { .. } => "NotFound",
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
fn get_resolution_error_class(err: &ResolutionError) -> &'static str {
|
|
match err {
|
|
ResolutionError::ResolverError { error, .. } => {
|
|
use ResolveError::*;
|
|
match error.as_ref() {
|
|
Specifier(_) => "TypeError",
|
|
Other(e) => get_error_class_name(e),
|
|
}
|
|
}
|
|
_ => "TypeError",
|
|
}
|
|
}
|
|
|
|
fn get_try_from_int_error_class(_: &std::num::TryFromIntError) -> &'static str {
|
|
"TypeError"
|
|
}
|
|
|
|
pub fn get_error_class_name(e: &AnyError) -> &'static str {
|
|
deno_runtime::errors::get_error_class_name(e)
|
|
.or_else(|| {
|
|
e.downcast_ref::<ImportMapError>()
|
|
.map(get_import_map_error_class)
|
|
})
|
|
.or_else(|| {
|
|
e.downcast_ref::<ParseDiagnostic>()
|
|
.map(get_diagnostic_class)
|
|
})
|
|
.or_else(|| {
|
|
e.downcast_ref::<ModuleGraphError>()
|
|
.map(get_module_graph_error_class)
|
|
})
|
|
.or_else(|| {
|
|
e.downcast_ref::<ResolutionError>()
|
|
.map(get_resolution_error_class)
|
|
})
|
|
.or_else(|| {
|
|
e.downcast_ref::<std::num::TryFromIntError>()
|
|
.map(get_try_from_int_error_class)
|
|
})
|
|
.unwrap_or("Error")
|
|
}
|