123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
// Copyright 2018-2022 the Deno authors. All rights reserved. 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_core::error::AnyError;use deno_core::serde_json;use deno_core::url;use deno_core::ModuleResolutionError;use deno_fetch::reqwest;use std::env;use std::error::Error;use std::io;use std::sync::Arc;
fn get_dlopen_error_class(error: &dlopen::Error) -> &'static str {  use dlopen::Error::*;  match error {    NullCharacter(_) => "InvalidData",    OpeningLibraryError(ref e) => get_io_error_class(e),    SymbolGettingError(ref e) => get_io_error_class(e),    AddrNotMatchingDll(ref e) => get_io_error_class(e),    NullSymbol => "NotFound",  }}
fn get_env_var_error_class(error: &env::VarError) -> &'static str {  use env::VarError::*;  match error {    NotPresent => "NotFound",    NotUnicode(..) => "InvalidData",  }}
fn get_io_error_class(error: &io::Error) -> &'static str {  use io::ErrorKind::*;  match error.kind() {    NotFound => "NotFound",    PermissionDenied => "PermissionDenied",    ConnectionRefused => "ConnectionRefused",    ConnectionReset => "ConnectionReset",    ConnectionAborted => "ConnectionAborted",    NotConnected => "NotConnected",    AddrInUse => "AddrInUse",    AddrNotAvailable => "AddrNotAvailable",    BrokenPipe => "BrokenPipe",    AlreadyExists => "AlreadyExists",    InvalidInput => "TypeError",    InvalidData => "InvalidData",    TimedOut => "TimedOut",    Interrupted => "Interrupted",    WriteZero => "WriteZero",    UnexpectedEof => "UnexpectedEof",    Other => "Error",    WouldBlock => unreachable!(),    // Non-exhaustive enum - might add new variants    // in the future    _ => "Error",  }}
fn get_module_resolution_error_class(  _: &ModuleResolutionError,) -> &'static str {  "URIError"}
fn get_notify_error_class(error: &notify::Error) -> &'static str {  use notify::ErrorKind::*;  match error.kind {    Generic(_) => "Error",    Io(ref e) => get_io_error_class(e),    PathNotFound => "NotFound",    WatchNotFound => "NotFound",    InvalidConfig(_) => "InvalidData",    MaxFilesWatch => "Error",  }}
fn get_regex_error_class(error: &regex::Error) -> &'static str {  use regex::Error::*;  match error {    Syntax(_) => "SyntaxError",    CompiledTooBig(_) => "RangeError",    _ => "Error",  }}
fn get_request_error_class(error: &reqwest::Error) -> &'static str {  error    .source()    .and_then(|inner_err| {      (inner_err        .downcast_ref::<io::Error>()        .map(get_io_error_class))      .or_else(|| {        inner_err          .downcast_ref::<serde_json::error::Error>()          .map(get_serde_json_error_class)      })      .or_else(|| {        inner_err          .downcast_ref::<url::ParseError>()          .map(get_url_parse_error_class)      })    })    .unwrap_or("Http")}
fn get_serde_json_error_class(  error: &serde_json::error::Error,) -> &'static str {  use deno_core::serde_json::error::*;  match error.classify() {    Category::Io => error      .source()      .and_then(|e| e.downcast_ref::<io::Error>())      .map(get_io_error_class)      .unwrap(),    Category::Syntax => "SyntaxError",    Category::Data => "InvalidData",    Category::Eof => "UnexpectedEof",  }}
fn get_url_parse_error_class(_error: &url::ParseError) -> &'static str {  "URIError"}
fn get_hyper_error_class(_error: &hyper::Error) -> &'static str {  "Http"}
#[cfg(unix)]pub fn get_nix_error_class(error: &nix::Error) -> &'static str {  match error {    nix::Error::ECHILD => "NotFound",    nix::Error::EINVAL => "TypeError",    nix::Error::ENOENT => "NotFound",    nix::Error::ENOTTY => "BadResource",    nix::Error::EPERM => "PermissionDenied",    nix::Error::ESRCH => "NotFound",    nix::Error::UnknownErrno => "Error",    &nix::Error::ENOTSUP => unreachable!(),    _ => "Error",  }}
pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {  deno_core::error::get_custom_error_class(e)    .or_else(|| deno_webgpu::error::get_error_class_name(e))    .or_else(|| deno_web::get_error_class_name(e))    .or_else(|| deno_webstorage::get_not_supported_error_class_name(e))    .or_else(|| deno_websocket::get_network_error_class_name(e))    .or_else(|| {      e.downcast_ref::<dlopen::Error>()        .map(get_dlopen_error_class)    })    .or_else(|| e.downcast_ref::<hyper::Error>().map(get_hyper_error_class))    .or_else(|| {      e.downcast_ref::<Arc<hyper::Error>>()        .map(|e| get_hyper_error_class(&**e))    })    .or_else(|| {      e.downcast_ref::<deno_core::Canceled>().map(|e| {        let io_err: io::Error = e.to_owned().into();        get_io_error_class(&io_err)      })    })    .or_else(|| {      e.downcast_ref::<env::VarError>()        .map(get_env_var_error_class)    })    .or_else(|| e.downcast_ref::<io::Error>().map(get_io_error_class))    .or_else(|| {      e.downcast_ref::<ModuleResolutionError>()        .map(get_module_resolution_error_class)    })    .or_else(|| {      e.downcast_ref::<notify::Error>()        .map(get_notify_error_class)    })    .or_else(|| {      e.downcast_ref::<reqwest::Error>()        .map(get_request_error_class)    })    .or_else(|| e.downcast_ref::<regex::Error>().map(get_regex_error_class))    .or_else(|| {      e.downcast_ref::<serde_json::error::Error>()        .map(get_serde_json_error_class)    })    .or_else(|| {      e.downcast_ref::<url::ParseError>()        .map(get_url_parse_error_class)    })    .or_else(|| {      #[cfg(unix)]      let maybe_get_nix_error_class =        || e.downcast_ref::<nix::Error>().map(get_nix_error_class);      #[cfg(not(unix))]      let maybe_get_nix_error_class = || Option::<&'static str>::None;      (maybe_get_nix_error_class)()    })}