Refactor error to use dynamic dispatch and traits

This is in preperation for dynamic import (#1789), which is more easily
implemented when errors are dynamic.

1 files changed, 179 insertions, 339 deletions

diff --git a/cli/deno_error.rs b/cli/deno_error.rs
index 0410c35d2..717924701 100644
--- a/cli/deno_error.rs
+++ b/cli/deno_error.rs
@@ -1,346 +1,239 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-use crate::deno_dir;
-use crate::diagnostics;
-use crate::fmt_errors::JSErrorColor;
-use crate::import_map;
+use crate::diagnostics::Diagnostic;
+use crate::fmt_errors::JSError;
+use crate::import_map::ImportMapError;
 pub use crate::msg::ErrorKind;
-use crate::resolve_addr::ResolveAddrError;
-use crate::source_maps::apply_source_map;
-use crate::source_maps::SourceMapGetter;
-use deno::JSError;
+use deno::AnyError;
+use deno::ErrBox;
 use deno::ModuleResolutionError;
+use http::uri;
 use hyper;
-#[cfg(unix)]
-use nix::{errno::Errno, Error as UnixError};
 use std;
+use std::error::Error;
 use std::fmt;
 use std::io;
-use std::str;
 use url;
 
-pub type DenoResult<T> = std::result::Result<T, DenoError>;
-
 #[derive(Debug)]
 pub struct DenoError {
-  repr: Repr,
+  kind: ErrorKind,
+  msg: String,
 }
 
-#[derive(Debug)]
-enum Repr {
-  Simple(ErrorKind, String),
-  IoErr(io::Error),
-  UrlErr(url::ParseError),
-  HyperErr(hyper::Error),
-  ImportMapErr(import_map::ImportMapError),
-  ModuleResolutionErr(ModuleResolutionError),
-  Diagnostic(diagnostics::Diagnostic),
-  JSError(JSError),
-  DenoDirErr(deno_dir::DenoDirError),
+impl DenoError {
+  pub fn new(kind: ErrorKind, msg: String) -> Self {
+    Self { kind, msg }
+  }
 }
 
-/// Create a new simple DenoError.
-pub fn new(kind: ErrorKind, msg: String) -> DenoError {
-  DenoError {
-    repr: Repr::Simple(kind, msg),
+impl Error for DenoError {}
+
+impl fmt::Display for DenoError {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.pad(self.msg.as_str())
   }
 }
 
-impl DenoError {
-  fn url_error_kind(err: url::ParseError) -> ErrorKind {
-    use url::ParseError::*;
-    match err {
-      EmptyHost => ErrorKind::EmptyHost,
-      IdnaError => ErrorKind::IdnaError,
-      InvalidPort => ErrorKind::InvalidPort,
-      InvalidIpv4Address => ErrorKind::InvalidIpv4Address,
-      InvalidIpv6Address => ErrorKind::InvalidIpv6Address,
-      InvalidDomainCharacter => ErrorKind::InvalidDomainCharacter,
-      RelativeUrlWithoutBase => ErrorKind::RelativeUrlWithoutBase,
-      RelativeUrlWithCannotBeABaseBase => {
-        ErrorKind::RelativeUrlWithCannotBeABaseBase
-      }
-      SetHostOnCannotBeABaseUrl => ErrorKind::SetHostOnCannotBeABaseUrl,
-      Overflow => ErrorKind::Overflow,
-    }
-  }
+#[derive(Debug)]
+struct StaticError(ErrorKind, &'static str);
 
-  pub fn kind(&self) -> ErrorKind {
-    match self.repr {
-      Repr::Simple(kind, ref _msg) => kind,
-      // Repr::Simple(kind) => kind,
-      Repr::IoErr(ref err) => {
-        use std::io::ErrorKind::*;
-        match err.kind() {
-          NotFound => ErrorKind::NotFound,
-          PermissionDenied => ErrorKind::PermissionDenied,
-          ConnectionRefused => ErrorKind::ConnectionRefused,
-          ConnectionReset => ErrorKind::ConnectionReset,
-          ConnectionAborted => ErrorKind::ConnectionAborted,
-          NotConnected => ErrorKind::NotConnected,
-          AddrInUse => ErrorKind::AddrInUse,
-          AddrNotAvailable => ErrorKind::AddrNotAvailable,
-          BrokenPipe => ErrorKind::BrokenPipe,
-          AlreadyExists => ErrorKind::AlreadyExists,
-          WouldBlock => ErrorKind::WouldBlock,
-          InvalidInput => ErrorKind::InvalidInput,
-          InvalidData => ErrorKind::InvalidData,
-          TimedOut => ErrorKind::TimedOut,
-          Interrupted => ErrorKind::Interrupted,
-          WriteZero => ErrorKind::WriteZero,
-          Other => ErrorKind::Other,
-          UnexpectedEof => ErrorKind::UnexpectedEof,
-          _ => unreachable!(),
-        }
-      }
-      Repr::UrlErr(err) => Self::url_error_kind(err),
-      Repr::HyperErr(ref err) => {
-        // For some reason hyper::errors::Kind is private.
-        if err.is_parse() {
-          ErrorKind::HttpParse
-        } else if err.is_user() {
-          ErrorKind::HttpUser
-        } else if err.is_canceled() {
-          ErrorKind::HttpCanceled
-        } else if err.is_closed() {
-          ErrorKind::HttpClosed
-        } else {
-          ErrorKind::HttpOther
-        }
-      }
-      Repr::ImportMapErr(ref _err) => ErrorKind::ImportMapError,
-      Repr::ModuleResolutionErr(err) => {
-        use ModuleResolutionError::*;
-        match err {
-          InvalidUrl(err) | InvalidBaseUrl(err) => Self::url_error_kind(err),
-          InvalidPath => ErrorKind::InvalidPath,
-          ImportPrefixMissing => ErrorKind::ImportPrefixMissing,
-        }
-      }
-      Repr::Diagnostic(ref _err) => ErrorKind::Diagnostic,
-      Repr::JSError(ref _err) => ErrorKind::JSError,
-      Repr::DenoDirErr(ref _err) => ErrorKind::DenoDirError,
-    }
-  }
+impl Error for StaticError {}
 
-  pub fn apply_source_map<G: SourceMapGetter>(self, getter: &G) -> Self {
-    if let Repr::JSError(js_error) = self.repr {
-      return DenoError {
-        repr: Repr::JSError(apply_source_map(&js_error, getter)),
-      };
-    } else {
-      panic!("attempt to apply source map an unremappable error")
-    }
+impl fmt::Display for StaticError {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    f.pad(self.1)
   }
 }
 
-impl fmt::Display for DenoError {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    match self.repr {
-      Repr::Simple(_kind, ref err_str) => f.pad(err_str),
-      Repr::IoErr(ref err) => err.fmt(f),
-      Repr::UrlErr(ref err) => err.fmt(f),
-      Repr::HyperErr(ref err) => err.fmt(f),
-      Repr::ImportMapErr(ref err) => f.pad(&err.msg),
-      Repr::ModuleResolutionErr(ref err) => err.fmt(f),
-      Repr::Diagnostic(ref err) => err.fmt(f),
-      Repr::JSError(ref err) => JSErrorColor(err).fmt(f),
-      Repr::DenoDirErr(ref err) => err.fmt(f),
-    }
-  }
+pub fn bad_resource() -> ErrBox {
+  StaticError(ErrorKind::BadResource, "bad resource id").into()
 }
 
-impl std::error::Error for DenoError {
-  fn description(&self) -> &str {
-    match self.repr {
-      Repr::Simple(_kind, ref msg) => msg.as_str(),
-      Repr::IoErr(ref err) => err.description(),
-      Repr::UrlErr(ref err) => err.description(),
-      Repr::HyperErr(ref err) => err.description(),
-      Repr::ImportMapErr(ref err) => &err.msg,
-      Repr::ModuleResolutionErr(ref err) => err.description(),
-      Repr::Diagnostic(ref err) => &err.items[0].message,
-      Repr::JSError(ref err) => &err.description(),
-      Repr::DenoDirErr(ref err) => err.description(),
-    }
-  }
+pub fn permission_denied() -> ErrBox {
+  StaticError(ErrorKind::PermissionDenied, "permission denied").into()
+}
 
-  fn cause(&self) -> Option<&dyn std::error::Error> {
-    match self.repr {
-      Repr::Simple(_kind, ref _msg) => None,
-      Repr::IoErr(ref err) => Some(err),
-      Repr::UrlErr(ref err) => Some(err),
-      Repr::HyperErr(ref err) => Some(err),
-      Repr::ImportMapErr(ref _err) => None,
-      Repr::ModuleResolutionErr(ref err) => err.source(),
-      Repr::Diagnostic(ref _err) => None,
-      Repr::JSError(ref err) => Some(err),
-      Repr::DenoDirErr(ref err) => Some(err),
-    }
-  }
+pub fn op_not_implemented() -> ErrBox {
+  StaticError(ErrorKind::OpNotAvailable, "op not implemented").into()
 }
 
-impl From<io::Error> for DenoError {
-  #[inline]
-  fn from(err: io::Error) -> Self {
-    Self {
-      repr: Repr::IoErr(err),
-    }
-  }
+pub fn no_buffer_specified() -> ErrBox {
+  StaticError(ErrorKind::InvalidInput, "no buffer specified").into()
 }
 
-impl From<url::ParseError> for DenoError {
-  #[inline]
-  fn from(err: url::ParseError) -> Self {
-    Self {
-      repr: Repr::UrlErr(err),
-    }
-  }
+pub fn no_async_support() -> ErrBox {
+  StaticError(ErrorKind::NoAsyncSupport, "op doesn't support async calls")
+    .into()
 }
 
-impl From<hyper::Error> for DenoError {
-  #[inline]
-  fn from(err: hyper::Error) -> Self {
-    Self {
-      repr: Repr::HyperErr(err),
-    }
-  }
+pub fn no_sync_support() -> ErrBox {
+  StaticError(ErrorKind::NoSyncSupport, "op doesn't support sync calls").into()
 }
 
-impl From<ResolveAddrError> for DenoError {
-  fn from(e: ResolveAddrError) -> Self {
-    match e {
-      ResolveAddrError::Syntax => Self {
-        repr: Repr::Simple(
-          ErrorKind::InvalidInput,
-          "invalid address syntax".to_string(),
-        ),
-      },
-      ResolveAddrError::Resolution(io_err) => Self {
-        repr: Repr::IoErr(io_err),
-      },
-    }
+pub fn invalid_address_syntax() -> ErrBox {
+  StaticError(ErrorKind::InvalidInput, "invalid address syntax").into()
+}
+
+pub trait GetErrorKind {
+  fn kind(&self) -> ErrorKind;
+}
+
+impl GetErrorKind for DenoError {
+  fn kind(&self) -> ErrorKind {
+    self.kind
   }
 }
 
-#[cfg(unix)]
-impl From<UnixError> for DenoError {
-  fn from(e: UnixError) -> Self {
-    match e {
-      UnixError::Sys(Errno::EPERM) => Self {
-        repr: Repr::Simple(
-          ErrorKind::PermissionDenied,
-          Errno::EPERM.desc().to_owned(),
-        ),
-      },
-      UnixError::Sys(Errno::EINVAL) => Self {
-        repr: Repr::Simple(
-          ErrorKind::InvalidInput,
-          Errno::EINVAL.desc().to_owned(),
-        ),
-      },
-      UnixError::Sys(Errno::ENOENT) => Self {
-        repr: Repr::Simple(
-          ErrorKind::NotFound,
-          Errno::ENOENT.desc().to_owned(),
-        ),
-      },
-      UnixError::Sys(err) => Self {
-        repr: Repr::Simple(ErrorKind::UnixError, err.desc().to_owned()),
-      },
-      _ => Self {
-        repr: Repr::Simple(ErrorKind::Other, format!("{}", e)),
-      },
-    }
+impl GetErrorKind for StaticError {
+  fn kind(&self) -> ErrorKind {
+    self.0
   }
 }
 
-impl From<import_map::ImportMapError> for DenoError {
-  fn from(err: import_map::ImportMapError) -> Self {
-    Self {
-      repr: Repr::ImportMapErr(err),
-    }
+impl GetErrorKind for JSError {
+  fn kind(&self) -> ErrorKind {
+    ErrorKind::JSError
   }
 }
 
-impl From<deno_dir::DenoDirError> for DenoError {
-  fn from(err: deno_dir::DenoDirError) -> Self {
-    Self {
-      repr: Repr::DenoDirErr(err),
-    }
+impl GetErrorKind for Diagnostic {
+  fn kind(&self) -> ErrorKind {
+    ErrorKind::Diagnostic
   }
 }
 
-impl From<ModuleResolutionError> for DenoError {
-  fn from(err: ModuleResolutionError) -> Self {
-    Self {
-      repr: Repr::ModuleResolutionErr(err),
-    }
+impl GetErrorKind for ImportMapError {
+  fn kind(&self) -> ErrorKind {
+    ErrorKind::ImportMapError
   }
 }
 
-impl From<diagnostics::Diagnostic> for DenoError {
-  fn from(diagnostic: diagnostics::Diagnostic) -> Self {
-    Self {
-      repr: Repr::Diagnostic(diagnostic),
+impl GetErrorKind for ModuleResolutionError {
+  fn kind(&self) -> ErrorKind {
+    use ModuleResolutionError::*;
+    match self {
+      InvalidUrl(ref err) | InvalidBaseUrl(ref err) => err.kind(),
+      InvalidPath => ErrorKind::InvalidPath,
+      ImportPrefixMissing => ErrorKind::ImportPrefixMissing,
     }
   }
 }
 
-impl From<JSError> for DenoError {
-  fn from(err: JSError) -> Self {
-    Self {
-      repr: Repr::JSError(err),
+impl GetErrorKind for io::Error {
+  fn kind(&self) -> ErrorKind {
+    use io::ErrorKind::*;
+    match self.kind() {
+      NotFound => ErrorKind::NotFound,
+      PermissionDenied => ErrorKind::PermissionDenied,
+      ConnectionRefused => ErrorKind::ConnectionRefused,
+      ConnectionReset => ErrorKind::ConnectionReset,
+      ConnectionAborted => ErrorKind::ConnectionAborted,
+      NotConnected => ErrorKind::NotConnected,
+      AddrInUse => ErrorKind::AddrInUse,
+      AddrNotAvailable => ErrorKind::AddrNotAvailable,
+      BrokenPipe => ErrorKind::BrokenPipe,
+      AlreadyExists => ErrorKind::AlreadyExists,
+      WouldBlock => ErrorKind::WouldBlock,
+      InvalidInput => ErrorKind::InvalidInput,
+      InvalidData => ErrorKind::InvalidData,
+      TimedOut => ErrorKind::TimedOut,
+      Interrupted => ErrorKind::Interrupted,
+      WriteZero => ErrorKind::WriteZero,
+      UnexpectedEof => ErrorKind::UnexpectedEof,
+      _ => ErrorKind::Other,
     }
   }
 }
 
-pub fn bad_resource() -> DenoError {
-  new(ErrorKind::BadResource, String::from("bad resource id"))
+impl GetErrorKind for uri::InvalidUri {
+  fn kind(&self) -> ErrorKind {
+    // The http::uri::ErrorKind exists and is similar to url::ParseError.
+    // However it is also private, so we can't get any details out.
+    ErrorKind::InvalidUri
+  }
 }
 
-pub fn permission_denied() -> DenoError {
-  new(
-    ErrorKind::PermissionDenied,
-    String::from("permission denied"),
-  )
+impl GetErrorKind for url::ParseError {
+  fn kind(&self) -> ErrorKind {
+    use url::ParseError::*;
+    match self {
+      EmptyHost => ErrorKind::EmptyHost,
+      IdnaError => ErrorKind::IdnaError,
+      InvalidDomainCharacter => ErrorKind::InvalidDomainCharacter,
+      InvalidIpv4Address => ErrorKind::InvalidIpv4Address,
+      InvalidIpv6Address => ErrorKind::InvalidIpv6Address,
+      InvalidPort => ErrorKind::InvalidPort,
+      Overflow => ErrorKind::Overflow,
+      RelativeUrlWithCannotBeABaseBase => {
+        ErrorKind::RelativeUrlWithCannotBeABaseBase
+      }
+      RelativeUrlWithoutBase => ErrorKind::RelativeUrlWithoutBase,
+      SetHostOnCannotBeABaseUrl => ErrorKind::SetHostOnCannotBeABaseUrl,
+    }
+  }
 }
 
-pub fn op_not_implemented() -> DenoError {
-  new(
-    ErrorKind::OpNotAvailable,
-    String::from("op not implemented"),
-  )
+impl GetErrorKind for hyper::Error {
+  fn kind(&self) -> ErrorKind {
+    match self {
+      e if e.is_canceled() => ErrorKind::HttpCanceled,
+      e if e.is_closed() => ErrorKind::HttpClosed,
+      e if e.is_parse() => ErrorKind::HttpParse,
+      e if e.is_user() => ErrorKind::HttpUser,
+      _ => ErrorKind::HttpOther,
+    }
+  }
 }
 
-pub fn worker_init_failed() -> DenoError {
-  // TODO(afinch7) pass worker error data through here
-  new(
-    ErrorKind::WorkerInitFailed,
-    String::from("worker init failed"),
-  )
+#[cfg(unix)]
+mod unix {
+  use super::{ErrorKind, GetErrorKind};
+  use nix::errno::Errno::*;
+  pub use nix::Error;
+  use nix::Error::Sys;
+
+  impl GetErrorKind for Error {
+    fn kind(&self) -> ErrorKind {
+      match self {
+        Sys(EPERM) => ErrorKind::PermissionDenied,
+        Sys(EINVAL) => ErrorKind::InvalidInput,
+        Sys(ENOENT) => ErrorKind::NotFound,
+        Sys(_) => ErrorKind::UnixError,
+        _ => ErrorKind::Other,
+      }
+    }
+  }
 }
 
-pub fn no_buffer_specified() -> DenoError {
-  new(ErrorKind::InvalidInput, String::from("no buffer specified"))
-}
+impl GetErrorKind for dyn AnyError {
+  fn kind(&self) -> ErrorKind {
+    use self::GetErrorKind as Get;
 
-pub fn no_async_support() -> DenoError {
-  new(
-    ErrorKind::NoAsyncSupport,
-    String::from("op doesn't support async calls"),
-  )
-}
+    #[cfg(unix)]
+    fn unix_error_kind(err: &dyn AnyError) -> Option<ErrorKind> {
+      err.downcast_ref::<unix::Error>().map(Get::kind)
+    }
 
-pub fn no_sync_support() -> DenoError {
-  new(
-    ErrorKind::NoSyncSupport,
-    String::from("op doesn't support sync calls"),
-  )
-}
+    #[cfg(not(unix))]
+    fn unix_error_kind(_: &dyn AnyError) -> Option<ErrorKind> {
+      None
+    }
 
-pub fn err_check<R>(r: Result<R, DenoError>) {
-  if let Err(e) = r {
-    panic!(e.to_string());
+    None
+      .or_else(|| self.downcast_ref::<DenoError>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<Diagnostic>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<hyper::Error>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<ImportMapError>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<io::Error>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<JSError>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<ModuleResolutionError>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<StaticError>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<uri::InvalidUri>().map(Get::kind))
+      .or_else(|| self.downcast_ref::<url::ParseError>().map(Get::kind))
+      .or_else(|| unix_error_kind(self))
+      .unwrap_or_else(|| {
+        panic!("Can't get ErrorKind for {:?}", self);
+      })
   }
 }
 
@@ -348,16 +241,15 @@ pub fn err_check<R>(r: Result<R, DenoError>) {
 mod tests {
   use super::*;
   use crate::ansi::strip_ansi_codes;
-  use crate::deno_dir::DenoDirError;
-  use crate::deno_dir::DenoDirErrorKind;
   use crate::diagnostics::Diagnostic;
   use crate::diagnostics::DiagnosticCategory;
   use crate::diagnostics::DiagnosticItem;
-  use crate::import_map::ImportMapError;
+  use deno::ErrBox;
   use deno::StackFrame;
+  use deno::V8Exception;
 
   fn js_error() -> JSError {
-    JSError {
+    JSError::new(V8Exception {
       message: "Error: foo bar".to_string(),
       source_line: None,
       script_resource_name: None,
@@ -396,7 +288,7 @@ mod tests {
           is_wasm: false,
         },
       ],
-    }
+    })
   }
 
   fn diagnostic() -> Diagnostic {
@@ -436,22 +328,6 @@ mod tests {
     }
   }
 
-  struct MockSourceMapGetter {}
-
-  impl SourceMapGetter for MockSourceMapGetter {
-    fn get_source_map(&self, _script_name: &str) -> Option<Vec<u8>> {
-      Some(vec![])
-    }
-
-    fn get_source_line(
-      &self,
-      _script_name: &str,
-      _line: usize,
-    ) -> Option<String> {
-      None
-    }
-  }
-
   fn io_error() -> io::Error {
     io::Error::from(io::ErrorKind::NotFound)
   }
@@ -466,30 +342,24 @@ mod tests {
     }
   }
 
-  fn deno_dir_error() -> DenoDirError {
-    DenoDirError::new(
-      "a deno dir error".to_string(),
-      DenoDirErrorKind::UnsupportedFetchScheme,
-    )
-  }
-
   #[test]
   fn test_simple_error() {
-    let err = new(ErrorKind::NoError, "foo".to_string());
+    let err =
+      ErrBox::from(DenoError::new(ErrorKind::NoError, "foo".to_string()));
     assert_eq!(err.kind(), ErrorKind::NoError);
     assert_eq!(err.to_string(), "foo");
   }
 
   #[test]
   fn test_io_error() {
-    let err = DenoError::from(io_error());
+    let err = ErrBox::from(io_error());
     assert_eq!(err.kind(), ErrorKind::NotFound);
     assert_eq!(err.to_string(), "entity not found");
   }
 
   #[test]
   fn test_url_error() {
-    let err = DenoError::from(url_error());
+    let err = ErrBox::from(url_error());
     assert_eq!(err.kind(), ErrorKind::EmptyHost);
     assert_eq!(err.to_string(), "empty host");
   }
@@ -498,33 +368,26 @@ mod tests {
 
   #[test]
   fn test_diagnostic() {
-    let err = DenoError::from(diagnostic());
+    let err = ErrBox::from(diagnostic());
     assert_eq!(err.kind(), ErrorKind::Diagnostic);
     assert_eq!(strip_ansi_codes(&err.to_string()), "error TS2322: Example 1\n\n► deno/tests/complex_diagnostics.ts:19:3\n\n19   values: o => [\n     ~~~~~~\n\nerror TS2000: Example 2\n\n► /foo/bar.ts:129:3\n\n129   values: undefined,\n      ~~~~~~\n\n\nFound 2 errors.\n");
   }
 
   #[test]
   fn test_js_error() {
-    let err = DenoError::from(js_error());
+    let err = ErrBox::from(js_error());
     assert_eq!(err.kind(), ErrorKind::JSError);
     assert_eq!(strip_ansi_codes(&err.to_string()), "error: Error: foo bar\n    at foo (foo_bar.ts:5:17)\n    at qat (bar_baz.ts:6:21)\n    at deno_main.js:2:2");
   }
 
   #[test]
   fn test_import_map_error() {
-    let err = DenoError::from(import_map_error());
+    let err = ErrBox::from(import_map_error());
     assert_eq!(err.kind(), ErrorKind::ImportMapError);
     assert_eq!(err.to_string(), "an import map error");
   }
 
   #[test]
-  fn test_deno_dir_error() {
-    let err = DenoError::from(deno_dir_error());
-    assert_eq!(err.kind(), ErrorKind::DenoDirError);
-    assert_eq!(err.to_string(), "a deno dir error\n");
-  }
-
-  #[test]
   fn test_bad_resource() {
     let err = bad_resource();
     assert_eq!(err.kind(), ErrorKind::BadResource);
@@ -546,13 +409,6 @@ mod tests {
   }
 
   #[test]
-  fn test_worker_init_failed() {
-    let err = worker_init_failed();
-    assert_eq!(err.kind(), ErrorKind::WorkerInitFailed);
-    assert_eq!(err.to_string(), "worker init failed");
-  }
-
-  #[test]
   fn test_no_buffer_specified() {
     let err = no_buffer_specified();
     assert_eq!(err.kind(), ErrorKind::InvalidInput);
@@ -572,20 +428,4 @@ mod tests {
     assert_eq!(err.kind(), ErrorKind::NoSyncSupport);
     assert_eq!(err.to_string(), "op doesn't support sync calls");
   }
-
-  #[test]
-  #[should_panic]
-  fn test_apply_source_map_invalid() {
-    let getter = MockSourceMapGetter {};
-    let err = new(ErrorKind::NotFound, "not found".to_string());
-    err.apply_source_map(&getter);
-  }
-
-  #[test]
-  #[should_panic]
-  fn test_err_check() {
-    err_check(
-      Err(new(ErrorKind::NotFound, "foo".to_string())) as Result<(), DenoError>
-    );
-  }
 }