From 8272c225b12eb08f60d41791c68f3f1a28caec20 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Mon, 19 Feb 2018 01:49:30 +0100
Subject: [PATCH] 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: https://github.com/nodejs/node/pull/18857
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
---
 lib/internal/errors.js | 56 +++++++++++++++++++++++++++++++++++++-----
 1 file changed, 50 insertions(+), 6 deletions(-)

diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 92e1efbf2fb4b8..ea72ea714d8518 100644
--- a/lib/internal/errors.js
+++ b/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.
 };