Add no-error-cause rule (#39)

ota-meshi · sosukesuzuki · web-flow · commit 8bff37e4f161 · 2023-01-20T18:39:44.000+09:00
* Add `no-error-cause` rule

* Add tests for `no-error-cause`

* Add docs for `no-error-cause`

* Add `no-error-cause` to `no-new-in-es2022`

* Export `no-error-cause`

* Update docs by script

* Track reference and AggregateError

* Support extended Error

* Update ruledoc by script

* Support more error constructors

* Support AggregateError constructor

* Check `SpreadElement`

* fix `no-error-cause`

* format

* update config

Co-authored-by: Sosuke Suzuki &lt;aosukeke@gmail.com&gt;
diff --git a/docs/rules/README.md b/docs/rules/README.md
@@ -23,6 +23,7 @@ There are multiple configs that enable all rules in this category: `plugin:es-x/
 | [es-x/no-array-string-prototype-at](./no-array-string-prototype-at.md) | disallow the `{Array,String}.prototype.at()` methods. |  |
 | [es-x/no-class-fields](./no-class-fields.md) | disallow class fields. |  |
 | [es-x/no-class-static-block](./no-class-static-block.md) | disallow class static block. |  |
+| [es-x/no-error-cause](./no-error-cause.md) | disallow Error Cause. |  |
 | [es-x/no-object-hasown](./no-object-hasown.md) | disallow the `Object.hasOwn` method. |  |
 | [es-x/no-private-in](./no-private-in.md) | disallow `#x in obj`. |  |
 | [es-x/no-regexp-d-flag](./no-regexp-d-flag.md) | disallow RegExp `d` flag. |  |
diff --git a/docs/rules/no-error-cause.md b/docs/rules/no-error-cause.md
@@ -0,0 +1,30 @@
+---
+title: "es-x/no-error-cause"
+description: "disallow Error Cause"
+---
+
+# es-x/no-error-cause
+> disallow Error Cause
+
+- ❗ <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- ✅ The following configurations enable this rule: `plugin:es-x/no-new-in-es2022`, `plugin:es-x/restrict-to-es3`, `plugin:es-x/restrict-to-es5`, `plugin:es-x/restrict-to-es2015`, `plugin:es-x/restrict-to-es2016`, `plugin:es-x/restrict-to-es2017`, `plugin:es-x/restrict-to-es2018`, `plugin:es-x/restrict-to-es2019`, `plugin:es-x/restrict-to-es2020`, and `plugin:es-x/restrict-to-es2021`
+
+This rule reports ES2022 [Error Cause](https://github.com/tc39/proposal-error-cause).
+
+## 💡 Examples
+
+⛔ Examples of **incorrect** code for this rule:
+
+<eslint-playground type="bad">
+
+```js
+/*eslint es-x/no-error-cause: error */
+throw new Error('failed', { cause: err });
+```
+
+</eslint-playground>
+
+## 📚 References
+
+- [Rule source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/lib/rules/no-error-cause.js)
+- [Test source](https://github.com/eslint-community/eslint-plugin-es-x/blob/master/tests/lib/rules/no-error-cause.js)
diff --git a/lib/configs/no-new-in-es2022.js b/lib/configs/no-new-in-es2022.js
@@ -11,6 +11,7 @@ module.exports = {
         "es-x/no-array-string-prototype-at": "error",
         "es-x/no-class-fields": "error",
         "es-x/no-class-static-block": "error",
+        "es-x/no-error-cause": "error",
         "es-x/no-object-hasown": "error",
         "es-x/no-private-in": "error",
         "es-x/no-regexp-d-flag": "error",
diff --git a/lib/index.js b/lib/index.js
@@ -96,6 +96,7 @@ module.exports = {
         "no-default-parameters": require("./rules/no-default-parameters"),
         "no-destructuring": require("./rules/no-destructuring"),
         "no-dynamic-import": require("./rules/no-dynamic-import"),
+        "no-error-cause": require("./rules/no-error-cause"),
         "no-escape-unescape": require("./rules/no-escape-unescape"),
         "no-exponential-operators": require("./rules/no-exponential-operators"),
         "no-export-ns-from": require("./rules/no-export-ns-from"),
diff --git a/lib/rules/no-error-cause.js b/lib/rules/no-error-cause.js
@@ -0,0 +1,186 @@
+/**
+ * @author Sosuke Suzuki <https://github.com/sosukesuzuki>
+ * See LICENSE file in root directory for full license.
+ */
+
+"use strict"
+
+const {
+    CONSTRUCT,
+    READ,
+    ReferenceTracker,
+    getPropertyName,
+} = require("eslint-utils")
+
+/**
+ * @typedef {import("estree").Node} Node
+ * @typedef {import("estree").ClassExpression | import("estree").ClassDeclaration} ClassNode
+ * @typedef {import("estree").CallExpression} CallExpression
+ */
+
+const errorConstructorNames = [
+    "Error",
+    "EvalError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TypeError",
+    "URIError",
+    "AggregateError",
+]
+const errorsTraceMap = {}
+for (const errorConstructorName of errorConstructorNames) {
+    errorsTraceMap[errorConstructorName] = { [CONSTRUCT]: true, [READ]: true }
+}
+
+/**
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isSuperCall(node) {
+    return node.type === "CallExpression" && node.callee.type === "Super"
+}
+
+/**
+ * @param {Node|undefined} node
+ * @returns {boolean}
+ */
+function isSpreadElement(node) {
+    return node && node.type === "SpreadElement"
+}
+
+/**
+ * @param {Node} node
+ * @returns {ClassNode | null}
+ */
+function findClassFromAncestors(node) {
+    if (node.type !== "ClassExpression" && node.type !== "ClassDeclaration") {
+        return findClassFromAncestors(node.parent)
+    }
+    if (!node) {
+        return null
+    }
+    return node
+}
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow Error Cause.",
+            category: "ES2022",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-error-cause.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2022 Error Cause is forbidden.",
+        },
+        schema: [],
+        type: "problem",
+    },
+    create(context) {
+        /** @type {Array<{ classNode: ClassNode, superCallNode: CallExpression }>} */
+        const maybeErrorSubclasses = []
+
+        /** @type {Array<{ classNode: ClassNode, superCallNode: CallExpression }>} */
+        const maybeAggregateErrorSubclasses = []
+
+        /**
+         * Checks if the received node is a constructor call with cause option.
+         * e.g. `new Error("message", { cause: foo })`, `super("message", { cause: foo })`
+         *
+         * @param {Node} node
+         * @param {boolean} isAggregateError
+         * @returns {boolean}
+         */
+        function isConstructCallWithCauseOption(node, isAggregateError) {
+            if (node.type !== "NewExpression" && !isSuperCall(node)) {
+                return false
+            }
+            const optionsArgIndex = isAggregateError ? 2 : 1
+            for (let index = 0; index < optionsArgIndex; index++) {
+                if (isSpreadElement(node.arguments[index])) {
+                    return false
+                }
+            }
+            const optionsArg = node.arguments[optionsArgIndex]
+            if (!optionsArg || optionsArg.type !== "ObjectExpression") {
+                return false
+            }
+            return optionsArg.properties.some((property) => {
+                if (property.type !== "Property") {
+                    return false
+                }
+                // new Error("msg", { cause: foo })
+                return getPropertyName(property, context.getScope()) === "cause"
+            })
+        }
+
+        /**
+         * @param {Node} node
+         * @param {isAggregateError} boolean
+         * @return {Node | null}
+         */
+        function getReportedNode(node, isAggregateError) {
+            const errorSubclasses = isAggregateError
+                ? maybeAggregateErrorSubclasses
+                : maybeErrorSubclasses
+
+            if (errorSubclasses.length > 0) {
+                for (const { classNode, superCallNode } of errorSubclasses) {
+                    if (classNode.superClass === node) {
+                        return superCallNode
+                    }
+                }
+            }
+            if (isConstructCallWithCauseOption(node, isAggregateError)) {
+                return node
+            }
+            return null
+        }
+
+        return {
+            Super(node) {
+                const superCallNode = node.parent
+
+                function findErrorSubclasses(isAggregateError) {
+                    const errorSubclasses = isAggregateError
+                        ? maybeAggregateErrorSubclasses
+                        : maybeErrorSubclasses
+
+                    if (
+                        isConstructCallWithCauseOption(
+                            superCallNode,
+                            isAggregateError,
+                        )
+                    ) {
+                        const classNode = findClassFromAncestors(superCallNode)
+                        if (classNode && classNode.superClass) {
+                            errorSubclasses.push({ classNode, superCallNode })
+                        }
+                    }
+                }
+
+                findErrorSubclasses(/* isAggregateError */ false)
+                findErrorSubclasses(/* isAggregateError */ true)
+            },
+            "Program:exit"() {
+                const tracker = new ReferenceTracker(context.getScope())
+                for (const { node, path } of tracker.iterateGlobalReferences(
+                    errorsTraceMap,
+                )) {
+                    const reportedNode = getReportedNode(
+                        node,
+                        path.join(",") === "AggregateError",
+                    )
+                    if (reportedNode) {
+                        context.report({
+                            node: reportedNode,
+                            messageId: "forbidden",
+                        })
+                    }
+                }
+            },
+        }
+    },
+}
diff --git a/scripts/rules.js b/scripts/rules.js
@@ -74,11 +74,17 @@ const rules = []
             .replace(/\.js$/u, "")
             .replace(/\\/gu, "/")
         const content = fs.readFileSync(filePath, "utf8")
+        const contentWithoutComments = content.replace(
+            /("(?:\\"|[^"])*?"|'(?:\\'|[^'])*?')|\/\/[^\n]*|\/\*[\s\S]*?\*\//gu,
+            "$1",
+        )
         const category = /category:[\s\n]+(?:undefined|"(.+)")/u.exec(
-            content,
+            contentWithoutComments,
         )[1]
-        const description = /description:[\s\n]+"(.+?)\.?"/u.exec(content)[1]
-        const fixable = /fixable:[\s\n]+"(.+)"/u.test(content)
+        const description = /description:[\s\n]+"(.+?)\.?"/u.exec(
+            contentWithoutComments,
+        )[1]
+        const fixable = /fixable:[\s\n]+"(.+)"/u.test(contentWithoutComments)
         const rule = {
             ruleId,
             description: JSON.parse(`"${description}"`),
diff --git a/tests/lib/rules/no-error-cause.js b/tests/lib/rules/no-error-cause.js
@@ -0,0 +1,77 @@
+/**
+ * @author Sosuke Suzuki <https://github.com/sosukesuzuki>
+ * See LICENSE file in root directory for full license.
+ */
+
+"use strict"
+
+const RuleTester = require("../../tester")
+const rule = require("../../../lib/rules/no-error-cause.js")
+
+if (!RuleTester.isSupported(2022)) {
+    //eslint-disable-next-line no-console
+    console.log("Skip the tests of no-error-cause.")
+    return
+}
+
+const errorConstructorNames = [
+    "Error",
+    "AggregateError",
+    "EvalError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TypeError",
+    "URIError",
+]
+
+function getErrors(errorConstructorName) {
+    return errorConstructorName === "AggregateError"
+        ? '[new Error("message")], '
+        : ""
+}
+
+const valid = errorConstructorNames
+    .map((errorConstructorName) => {
+        const errors = getErrors(errorConstructorName)
+        return [
+            `new ${errorConstructorName}(${errors}"message")`,
+            `new ${errorConstructorName}(${errors}"message", notObjectExpression)`,
+            `new ${errorConstructorName}(${errors}"message", { notCause: foo })`,
+            `new ${errorConstructorName}(${errors}...foo, { cause: foo });`,
+            `class MyError extends ${errorConstructorName} { constructor() { super(${errors}"message") } }`,
+            `class MyError extends ${errorConstructorName} { constructor() { super(${errors}"message", notObjectExpression) } }`,
+            `class MyError extends ${errorConstructorName} { constructor() { super(${errors}"message", { notCause: foo }) } }`,
+        ]
+    })
+    // alternative of `Array.prototype.flat`
+    .reduce((acc, val) => acc.concat(val), [])
+
+const invalid = errorConstructorNames
+    .map((errorConstructorName) => {
+        const errors = getErrors(errorConstructorName)
+        return [
+            {
+                code: `new ${errorConstructorName}(${errors}"message", { cause: foo });`,
+                errors: ["ES2022 Error Cause is forbidden."],
+            },
+            {
+                code: `new ${errorConstructorName}(${errors}"message", { ["cause"]: foo });`,
+                errors: ["ES2022 Error Cause is forbidden."],
+            },
+            {
+                code: `const MyError = ${errorConstructorName}; new MyError(${errors}"message", { ["cause"]: foo });`,
+                errors: ["ES2022 Error Cause is forbidden."],
+            },
+            {
+                code: `class MyError extends ${errorConstructorName} { constructor() { super(${errors}"message", { cause: foo }); } }`,
+                errors: ["ES2022 Error Cause is forbidden."],
+            },
+        ]
+    })
+    // alternative of `Array.prototype.flat`
+    .reduce((acc, val) => acc.concat(val), [])
+
+new RuleTester({
+    parserOptions: { sourceType: "module" },
+}).run("no-error-cause", rule, { valid, invalid })
