refactor(core): simplify error handling (#10297)

- register builtin v8 errors in core.js so consumers don't have to
- remove complexity of error args handling (consumers must provide a 
  constructor with custom args, core simply provides msg arg)

bench_util/src/js_runtime.rs

@@ -20,7 +20,6 @@ pub fn create_js_runtime(setup: impl FnOnce(&mut JsRuntime)) -> JsRuntime {
     "init",
     r#"
       Deno.core.ops();
-      Deno.core.registerErrorClass('Error', Error);
     "#,
   )
   .unwrap();

cli/tsc/99_main_compiler.js

@@ -799,7 +799,6 @@ delete Object.prototype.__proto__;
 
   // Setup the compiler runtime during the build process.
   core.ops();
-  core.registerErrorClass("Error", Error);
 
   // A build time only op that provides some setup information that is used to
   // ensure the snapshot is setup properly.

core/benches/op_baseline.rs

@@ -27,7 +27,6 @@ fn create_js_runtime() -> JsRuntime {
       "init",
       r#"
       Deno.core.ops();
-      Deno.core.registerErrorClass('Error', Error);
     "#,
     )
     .unwrap();

core/core.js

@@ -6,7 +6,15 @@
   const { send } = window.Deno.core;
 
   let opsCache = {};
-  const errorMap = {};
+  const errorMap = {
+    // Builtin v8 / JS errors
+    Error,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    TypeError,
+    URIError,
+  };
   let nextPromiseId = 1;
   const promiseMap = new Map();
   const RING_SIZE = 4 * 1024;
@@ -71,28 +79,24 @@
     return send(opsCache[opName], promiseId, control, zeroCopy);
   }
 
-  function registerErrorClass(errorName, className, args) {
+  function registerErrorClass(className, errorClass) {
-    if (typeof errorMap[errorName] !== "undefined") {
+    if (typeof errorMap[className] !== "undefined") {
-      throw new TypeError(`Error class for "${errorName}" already registered`);
+      throw new TypeError(`Error class for "${className}" already registered`);
     }
-    errorMap[errorName] = [className, args ?? []];
+    errorMap[className] = errorClass;
-  }
-
-  function getErrorClassAndArgs(errorName) {
-    return errorMap[errorName] ?? [undefined, []];
   }
 
   function unwrapOpResult(res) {
     // .$err_class_name is a special key that should only exist on errors
     if (res?.$err_class_name) {
       const className = res.$err_class_name;
-      const [ErrorClass, args] = getErrorClassAndArgs(className);
+      const ErrorClass = errorMap[className];
       if (!ErrorClass) {
         throw new Error(
           `Unregistered error class: "${className}"\n  ${res.message}\n  Classes of errors returned from ops should be registered via Deno.core.registerErrorClass().`,
         );
       }
-      throw new ErrorClass(res.message, ...args);
+      throw new ErrorClass(res.message);
     }
     return res;
   }

core/examples/hello_world.rs

@@ -74,10 +74,6 @@ const _newline = new Uint8Array([10]);
 function print(value) {
   Deno.core.dispatchByName('op_print', 0, value.toString(), _newline);
 }
-
-// Finally we register the error class used by op_sum
-// so that it throws the correct class.
-Deno.core.registerErrorClass('Error', Error);
 "#,
     )
     .unwrap();

core/examples/http_bench_json_ops.js

@@ -55,7 +55,6 @@ async function serve(rid) {
 
 async function main() {
   Deno.core.ops();
-  Deno.core.registerErrorClass("Error", Error);
 
   const listenerRid = listen();
   Deno.core.print(`http_bench_ops listening on http://127.0.0.1:4544/\n`);

core/ops_json.rs

@@ -122,8 +122,6 @@ mod tests {
         r#"
     // First we initialize the ops cache. This maps op names to their id's.
     Deno.core.ops();
-    // Register the error class.
-    Deno.core.registerErrorClass('Error', Error);
 
     async function f1() {
       await Deno.core.opAsync('op_throw', 'hello');

op_crates/url/benches/url_ops.rs

@@ -28,7 +28,6 @@ fn create_js_runtime() -> JsRuntime {
       "init",
       r#"
       Deno.core.ops();
-      Deno.core.registerErrorClass('Error', Error);
     "#,
     )
     .unwrap();

runtime/js/99_main.js

@@ -186,16 +186,11 @@ delete Object.prototype.__proto__;
     core.registerErrorClass("Http", errors.Http);
     core.registerErrorClass("Busy", errors.Busy);
     core.registerErrorClass("NotSupported", errors.NotSupported);
-    core.registerErrorClass("Error", Error);
-    core.registerErrorClass("RangeError", RangeError);
-    core.registerErrorClass("ReferenceError", ReferenceError);
-    core.registerErrorClass("SyntaxError", SyntaxError);
-    core.registerErrorClass("TypeError", TypeError);
-    core.registerErrorClass("URIError", URIError);
     core.registerErrorClass(
       "DOMExceptionOperationError",
-      DOMException,
+      function DOMExceptionOperationError(msg) {
-      "OperationError",
+        DOMException.prototype.constructor.call(this, msg, "OperationError");
+      },
     );
   }