errors: implement new error handling

This implements a function based system. Instead of passing in the
error code as first argument, the error code itself is a error class.
It already contains the correct error type, so while adding a new
error no one has to think about the error type anymore. In case a
single error code has more than one error type, the error class has
properties for the non default error types. Those can be used as
fallback.

This prevents typos, makes the implementation easier and it is less
verbose when writing the code for a new error.

The implementation itself does not interfere with the old
implementation. So the old and the new system can co-exist and it is
possible to slowly migrate the old ones to the new system.

PR-URL: nodejs#18857
Reviewed-By: Anna Henningsen <[email protected]>
Reviewed-By: Gus Caplan <[email protected]>
Reviewed-By: James M Snell <[email protected]>
Reviewed-By: Joyee Cheung <[email protected]>

Author: BridgeAR

lib/internal/errors.js

@@ -13,6 +13,7 @@
 const kCode = Symbol('code');
 const kInfo = Symbol('info');
 const messages = new Map();
+const codes = {};
 
 var green = '';
 var red = '';
@@ -86,6 +87,54 @@ function makeNodeError(Base) {
   };
 }
 
+function makeNodeErrorWithCode(Base, key) {
+  return class NodeError extends Base {
+    constructor(...args) {
+      super(message(key, args));
+    }
+
+    get name() {
+      return `${super.name} [${key}]`;
+    }
+
+    set name(value) {
+      defineProperty(this, 'name', {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+      });
+    }
+
+    get code() {
+      return key;
+    }
+
+    set code(value) {
+      defineProperty(this, 'code', {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+      });
+    }
+  };
+}
+
+// Utility function for registering the error codes. Only used here. Exported
+// *only* to allow for testing.
+function E(sym, val, def, ...otherClasses) {
+  messages.set(sym, val);
+  if (def === undefined) return;
+  def = makeNodeErrorWithCode(def, sym);
+  if (otherClasses.length !== 0) {
+    otherClasses.forEach((clazz) => {
+      def[clazz.name] = makeNodeErrorWithCode(clazz, sym);
+    });
+  }
+  codes[sym] = def;
+}
+
 function lazyBuffer() {
   if (buffer === undefined)
     buffer = require('buffer').Buffer;
@@ -367,12 +416,6 @@ function message(key, args) {
   return String(fmt.apply(null, args));
 }
 
-// Utility function for registering the error codes. Only used here. Exported
-// *only* to allow for testing.
-function E(sym, val) {
-  messages.set(sym, typeof val === 'function' ? val : String(val));
-}
-
 /**
  * This creates an error compatible with errors produced in the C++
  * function UVException using a context object with data assembled in C++.
@@ -523,6 +566,7 @@ module.exports = exports = {
   URIError: makeNodeError(URIError),
   AssertionError,
   SystemError,
+  codes,
   E, // This is exported only to facilitate testing.
   errorCache: new Map() // This is in here only to facilitate testing.
 };