refactor: rework error handling

core/00_infra.js

@@ -180,9 +180,11 @@
       const err = errorBuilder ? errorBuilder(res.message) : new Error(
         `Unregistered error class: "${className}"\n  ${res.message}\n  Classes of errors returned from ops should be registered via Deno.core.registerErrorClass().`,
       );
-      // Set .code if error was a known OS error, see error_codes.rs
-      if (res.code) {
-        err.code = res.code;
+
+      if (res.additional_properties) {
+        for (const [key, value] of res.additional_properties) {
+          res[key] = value;
+        }
       }
       // Strip eventLoopTick() calls from stack trace
       ErrorCaptureStackTrace(err, eventLoopTick);

core/Cargo.toml

@@ -47,6 +47,7 @@ static_assertions.workspace = true
 tokio.workspace = true
 url.workspace = true
 v8.workspace = true
+thiserror = "1.0.60"
 
 [dev-dependencies]
 bencher.workspace = true

core/async_cancel.rs

@@ -10,16 +10,16 @@ use std::io;
 use std::pin::Pin;
 use std::rc::Rc;
 
+use crate::error::JsErrorClass;
+use crate::RcLike;
+use crate::Resource;
 use futures::future::FusedFuture;
 use futures::future::Future;
 use futures::future::TryFuture;
 use futures::task::Context;
 use futures::task::Poll;
 use pin_project::pin_project;
 
-use crate::RcLike;
-use crate::Resource;
-
 use self::internal as i;
 
 #[derive(Debug, Default)]
@@ -242,6 +242,25 @@ impl From<Canceled> for io::Error {
   }
 }
 
+impl JsErrorClass for Canceled {
+  fn get_class(&self) -> &'static str {
+    let io_err: io::Error = self.to_owned().into();
+    io_err.get_class()
+  }
+
+  fn get_message(&self) -> Cow<'static, str> {
+    let io_err: io::Error = self.to_owned().into();
+    io_err.get_message()
+  }
+
+  fn get_additional_properties(
+    &self,
+  ) -> Option<Vec<(Cow<'static, str>, Cow<'static, str>)>> {
+    let io_err: io::Error = self.to_owned().into();
+    io_err.get_additional_properties()
+  }
+}
+
 mod internal {
   use super::Abortable;
   use super::CancelHandle;
@@ -666,7 +685,6 @@ mod internal {
 #[cfg(test)]
 mod tests {
   use super::*;
-  use anyhow::Error;
   use futures::future::pending;
   use futures::future::poll_fn;
   use futures::future::ready;
@@ -782,7 +800,7 @@ mod tests {
       // Cancel a spawned task before it actually runs.
       let cancel_handle = Rc::new(CancelHandle::new());
       let future = spawn(async { panic!("the task should not be spawned") })
-        .map_err(Error::from)
+        .map_err(anyhow::Error::from)
         .try_or_cancel(&cancel_handle);
       cancel_handle.cancel();
       let error = future.await.unwrap_err();

core/benches/ops/async.rs

@@ -1,6 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 use bencher::*;
-use deno_core::error::generic_error;
+use deno_core::error::JsNativeError;
 use deno_core::*;
 use std::ffi::c_void;
 use tokio::runtime::Runtime;
@@ -118,7 +118,7 @@ fn bench_op(
     ..Default::default()
   });
   let err_mapper =
-    |err| generic_error(format!("{op} test failed ({call}): {err:?}"));
+    |err| JsNativeError::generic(format!("{op} test failed ({call}): {err:?}"));
 
   let args = (0..arg_count)
     .map(|n| format!("arg{n}"))

core/benches/ops/sync.rs

@@ -1,7 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 #![allow(deprecated)]
 use bencher::*;
-use deno_core::error::generic_error;
 use deno_core::*;
 use std::borrow::Cow;
 use std::ffi::c_void;
@@ -183,8 +182,9 @@ fn bench_op(
     })),
     ..Default::default()
   });
-  let err_mapper =
-    |err| generic_error(format!("{op} test failed ({call}): {err:?}"));
+  let err_mapper = |err| {
+    error::JsNativeError::generic(format!("{op} test failed ({call}): {err:?}"))
+  };
 
   let args = (0..arg_count)
     .map(|n| format!("arg{n}"))

core/benches/snapshot/snapshot.rs

@@ -3,7 +3,7 @@ use criterion::*;
 use deno_ast::MediaType;
 use deno_ast::ParseParams;
 use deno_ast::SourceMapOption;
-use deno_core::error::AnyError;
+use deno_core::error::JsNativeError;
 use deno_core::Extension;
 use deno_core::JsRuntime;
 use deno_core::JsRuntimeForSnapshot;
@@ -49,10 +49,22 @@ fn make_extensions_ops() -> Vec<Extension> {
   fake_extensions!(init_ops, a, b, c, d, e, f, g, h, i, j, k, l, m, n)
 }
 
+deno_core::js_error_wrapper!(
+  deno_ast::ParseDiagnostic,
+  JsParseDiagnostic,
+  "TypeError"
+);
+
+deno_core::js_error_wrapper!(
+  deno_ast::TranspileError,
+  JsTranspileError,
+  "TypeError"
+);
+
 pub fn maybe_transpile_source(
   specifier: ModuleName,
   source: ModuleCodeString,
-) -> Result<(ModuleCodeString, Option<SourceMapData>), AnyError> {
+) -> Result<(ModuleCodeString, Option<SourceMapData>), JsNativeError> {
   let media_type = MediaType::TypeScript;
 
   let parsed = deno_ast::parse_module(ParseParams {
@@ -62,7 +74,8 @@ pub fn maybe_transpile_source(
     capture_tokens: false,
     scope_analysis: false,
     maybe_syntax: None,
-  })?;
+  })
+  .map_err(|e| JsNativeError::from_err(JsParseDiagnostic(e)))?;
   let transpiled_source = parsed
     .transpile(
       &deno_ast::TranspileOptions {
@@ -74,7 +87,8 @@ pub fn maybe_transpile_source(
         inline_sources: true,
         ..Default::default()
       },
-    )?
+    )
+    .map_err(|e| JsNativeError::from_err(JsTranspileError(e)))?
     .into_source();
   Ok((
     String::from_utf8(transpiled_source.source).unwrap().into(),

core/convert.rs

@@ -1,6 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-use crate::error::StdAnyError;
+use crate::error::JsNativeError;
 use crate::runtime::ops;
 use std::convert::Infallible;
 
@@ -87,15 +87,16 @@ pub trait ToV8<'a> {
 ///
 /// ```ignore
 /// use deno_core::FromV8;
+/// use deno_core::error::JsNativeError;
 /// use deno_core::convert::Smi;
 /// use deno_core::op2;
 ///
 /// struct Foo(i32);
 ///
 /// impl<'a> FromV8<'a> for Foo {
-///   // This conversion can fail, so we use `deno_core::error::StdAnyError` as the error type.
+///   // This conversion can fail, so we use `JsNativeError` as the error type.
 ///   // Any error type that implements `std::error::Error` can be used here.
-///   type Error = deno_core::error::StdAnyError;
+///   type Error = JsNativeError;
 ///
 ///   fn from_v8(scope: &mut v8::HandleScope<'a>, value: v8::Local<'a, v8::Value>) -> Result<Self, Self::Error> {
 ///     /// We expect this value to be a `v8::Integer`, so we use the [`Smi`][deno_core::convert::Smi] wrapper type to convert it.
@@ -122,7 +123,7 @@ pub trait FromV8<'a>: Sized {
 // impls
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-/// Marks a numeric type as being serialized as a v8 `smi` in a `v8::Integer`.  
+/// Marks a numeric type as being serialized as a v8 `smi` in a `v8::Integer`.
 #[repr(transparent)]
 pub struct Smi<T: SmallInt>(pub T);
 
@@ -170,22 +171,22 @@ impl<'a, T: SmallInt> ToV8<'a> for Smi<T> {
 }
 
 impl<'a, T: SmallInt> FromV8<'a> for Smi<T> {
-  type Error = StdAnyError;
+  type Error = JsNativeError;
 
   #[inline]
   fn from_v8(
     _scope: &mut v8::HandleScope<'a>,
     value: v8::Local<'a, v8::Value>,
   ) -> Result<Self, Self::Error> {
-    let v = crate::runtime::ops::to_i32_option(&value).ok_or_else(|| {
-      crate::error::type_error(format!("Expected {}", T::NAME))
+    let v = ops::to_i32_option(&value).ok_or_else(|| {
+      JsNativeError::type_error(format!("Expected {}", T::NAME))
     })?;
     Ok(Smi(T::from_i32(v)))
   }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-/// Marks a numeric type as being serialized as a v8 `number` in a `v8::Number`.  
+/// Marks a numeric type as being serialized as a v8 `number` in a `v8::Number`.
 #[repr(transparent)]
 pub struct Number<T: Numeric>(pub T);
 
@@ -240,15 +241,15 @@ impl<'a, T: Numeric> ToV8<'a> for Number<T> {
 }
 
 impl<'a, T: Numeric> FromV8<'a> for Number<T> {
-  type Error = StdAnyError;
+  type Error = JsNativeError;
   #[inline]
   fn from_v8(
     _scope: &mut v8::HandleScope<'a>,
     value: v8::Local<'a, v8::Value>,
   ) -> Result<Self, Self::Error> {
-    T::from_value(&value).map(Number).ok_or_else(|| {
-      crate::error::type_error(format!("Expected {}", T::NAME)).into()
-    })
+    T::from_value(&value)
+      .map(Number)
+      .ok_or_else(|| JsNativeError::type_error(format!("Expected {}", T::NAME)))
   }
 }
 
@@ -264,7 +265,7 @@ impl<'a> ToV8<'a> for bool {
 }
 
 impl<'a> FromV8<'a> for bool {
-  type Error = StdAnyError;
+  type Error = JsNativeError;
   #[inline]
   fn from_v8(
     _scope: &mut v8::HandleScope<'a>,
@@ -273,6 +274,6 @@ impl<'a> FromV8<'a> for bool {
     value
       .try_cast::<v8::Boolean>()
       .map(|v| v.is_true())
-      .map_err(|_| crate::error::type_error("Expected boolean").into())
+      .map_err(|_| JsNativeError::type_error("Expected boolean"))
   }
 }