eslint 8.47.0 → 8.57.0

package/lib/rules/newline-per-chained-call.js

@@ -2,6 +2,7 @@
  * @fileoverview Rule to ensure newline per method call when chaining calls
  * @author Rajendra Patil
  * @author Burak Yigit Kaya
+ * @deprecated in ESLint v8.53.0
  */
 
 "use strict";
@@ -15,6 +16,8 @@ const astUtils = require("./utils/ast-utils");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "layout",
 
         docs: {

package/lib/rules/no-array-constructor.js

@@ -5,6 +5,18 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const {
+    getVariableByName,
+    isClosingParenToken,
+    isOpeningParenToken,
+    isStartOfExpressionStatement,
+    needsPrecedingSemicolon
+} = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -20,15 +32,45 @@ module.exports = {
             url: "https://eslint.org/docs/latest/rules/no-array-constructor"
         },
 
+        hasSuggestions: true,
+
         schema: [],
 
         messages: {
-            preferLiteral: "The array literal notation [] is preferable."
+            preferLiteral: "The array literal notation [] is preferable.",
+            useLiteral: "Replace with an array literal.",
+            useLiteralAfterSemicolon: "Replace with an array literal, add preceding semicolon."
         }
     },
 
     create(context) {
 
+        const sourceCode = context.sourceCode;
+
+        /**
+         * Gets the text between the calling parentheses of a CallExpression or NewExpression.
+         * @param {ASTNode} node A CallExpression or NewExpression node.
+         * @returns {string} The text between the calling parentheses, or an empty string if there are none.
+         */
+        function getArgumentsText(node) {
+            const lastToken = sourceCode.getLastToken(node);
+
+            if (!isClosingParenToken(lastToken)) {
+                return "";
+            }
+
+            let firstToken = node.callee;
+
+            do {
+                firstToken = sourceCode.getTokenAfter(firstToken);
+                if (!firstToken || firstToken === lastToken) {
+                    return "";
+                }
+            } while (!isOpeningParenToken(firstToken));
+
+            return sourceCode.text.slice(firstToken.range[1], lastToken.range[0]);
+        }
+
         /**
          * Disallow construction of dense arrays using the Array constructor
          * @param {ASTNode} node node to evaluate
@@ -37,11 +79,48 @@ module.exports = {
          */
         function check(node) {
             if (
-                node.arguments.length !== 1 &&
-                node.callee.type === "Identifier" &&
-                node.callee.name === "Array"
-            ) {
-                context.report({ node, messageId: "preferLiteral" });
+                node.callee.type !== "Identifier" ||
+                node.callee.name !== "Array" ||
+                node.arguments.length === 1 &&
+                node.arguments[0].type !== "SpreadElement") {
+                return;
+            }
+
+            const variable = getVariableByName(sourceCode.getScope(node), "Array");
+
+            /*
+             * Check if `Array` is a predefined global variable: predefined globals have no declarations,
+             * meaning that the `identifiers` list of the variable object is empty.
+             */
+            if (variable && variable.identifiers.length === 0) {
+                const argsText = getArgumentsText(node);
+                let fixText;
+                let messageId;
+
+                /*
+                 * Check if the suggested change should include a preceding semicolon or not.
+                 * Due to JavaScript's ASI rules, a missing semicolon may be inserted automatically
+                 * before an expression like `Array()` or `new Array()`, but not when the expression
+                 * is changed into an array literal like `[]`.
+                 */
+                if (isStartOfExpressionStatement(node) && needsPrecedingSemicolon(sourceCode, node)) {
+                    fixText = `;[${argsText}]`;
+                    messageId = "useLiteralAfterSemicolon";
+                } else {
+                    fixText = `[${argsText}]`;
+                    messageId = "useLiteral";
+                }
+
+                context.report({
+                    node,
+                    messageId: "preferLiteral",
+                    suggest: [
+                        {
+                            messageId,
+                            fix: fixer => fixer.replaceText(node, fixText)
+                        }
+                    ]
+                });
             }
         }
 

package/lib/rules/no-confusing-arrow.js

@@ -2,6 +2,7 @@
  * @fileoverview A rule to warn against using arrow functions when they could be
  * confused with comparisons
  * @author Jxck <https://github.com/Jxck>
+ * @deprecated in ESLint v8.53.0
  */
 
 "use strict";
@@ -28,6 +29,8 @@ function isConditional(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "suggestion",
 
         docs: {

package/lib/rules/no-console.js

@@ -43,8 +43,11 @@ module.exports = {
             }
         ],
 
+        hasSuggestions: true,
+
         messages: {
-            unexpected: "Unexpected console statement."
+            unexpected: "Unexpected console statement.",
+            removeConsole: "Remove the console.{{ propertyName }}()."
         }
     },
 
@@ -94,6 +97,64 @@ module.exports = {
             );
         }
 
+        /**
+         * Checks if removing the ExpressionStatement node will cause ASI to
+         * break.
+         * eg.
+         * foo()
+         * console.log();
+         * [1, 2, 3].forEach(a => doSomething(a))
+         *
+         * Removing the console.log(); statement should leave two statements, but
+         * here the two statements will become one because [ causes continuation after
+         * foo().
+         * @param {ASTNode} node The ExpressionStatement node to check.
+         * @returns {boolean} `true` if ASI will break after removing the ExpressionStatement
+         *      node.
+         */
+        function maybeAsiHazard(node) {
+            const SAFE_TOKENS_BEFORE = /^[:;{]$/u; // One of :;{
+            const UNSAFE_CHARS_AFTER = /^[-[(/+`]/u; // One of [(/+-`
+
+            const tokenBefore = sourceCode.getTokenBefore(node);
+            const tokenAfter = sourceCode.getTokenAfter(node);
+
+            return (
+                Boolean(tokenAfter) &&
+                UNSAFE_CHARS_AFTER.test(tokenAfter.value) &&
+                tokenAfter.value !== "++" &&
+                tokenAfter.value !== "--" &&
+                Boolean(tokenBefore) &&
+                !SAFE_TOKENS_BEFORE.test(tokenBefore.value)
+            );
+        }
+
+        /**
+         * Checks if the MemberExpression node's parent.parent.parent is a
+         * Program, BlockStatement, StaticBlock, or SwitchCase node. This check
+         * is necessary to avoid providing a suggestion that might cause a syntax error.
+         *
+         * eg. if (a) console.log(b), removing console.log() here will lead to a
+         *     syntax error.
+         *     if (a) { console.log(b) }, removing console.log() here is acceptable.
+         *
+         * Additionally, it checks if the callee of the CallExpression node is
+         * the node itself.
+         *
+         * eg. foo(console.log), cannot provide a suggestion here.
+         * @param {ASTNode} node The MemberExpression node to check.
+         * @returns {boolean} `true` if a suggestion can be provided for a node.
+         */
+        function canProvideSuggestions(node) {
+            return (
+                node.parent.type === "CallExpression" &&
+                node.parent.callee === node &&
+                node.parent.parent.type === "ExpressionStatement" &&
+                astUtils.STATEMENT_LIST_PARENTS.has(node.parent.parent.parent.type) &&
+                !maybeAsiHazard(node.parent.parent)
+            );
+        }
+
         /**
          * Reports the given reference as a violation.
          * @param {eslint-scope.Reference} reference The reference to report.
@@ -102,10 +163,21 @@ module.exports = {
         function report(reference) {
             const node = reference.identifier.parent;
 
+            const propertyName = astUtils.getStaticPropertyName(node);
+
             context.report({
                 node,
                 loc: node.loc,
-                messageId: "unexpected"
+                messageId: "unexpected",
+                suggest: canProvideSuggestions(node)
+                    ? [{
+                        messageId: "removeConsole",
+                        data: { propertyName },
+                        fix(fixer) {
+                            return fixer.remove(node.parent.parent);
+                        }
+                    }]
+                    : []
             });
         }
 

package/lib/rules/no-extra-parens.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Disallow parenthesising higher precedence subexpressions.
  * @author Michael Ficarra
+ * @deprecated in ESLint v8.53.0
  */
 "use strict";
 
@@ -14,6 +15,8 @@ const astUtils = require("./utils/ast-utils.js");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "layout",
 
         docs: {

package/lib/rules/no-extra-semi.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to flag use of unnecessary semicolons
  * @author Nicholas C. Zakas
+ * @deprecated in ESLint v8.53.0
  */
 
 "use strict";
@@ -19,6 +20,8 @@ const astUtils = require("./utils/ast-utils");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "suggestion",
 
         docs: {

package/lib/rules/no-fallthrough.js

@@ -16,6 +16,22 @@ const { directivesPattern } = require("../shared/directives");
 
 const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
 
+/**
+ * Checks all segments in a set and returns true if any are reachable.
+ * @param {Set<CodePathSegment>} segments The segments to check.
+ * @returns {boolean} True if any segment is reachable; false otherwise.
+ */
+function isAnySegmentReachable(segments) {
+
+    for (const segment of segments) {
+        if (segment.reachable) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /**
  * Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive.
  * @param {string} comment The comment string to check.
@@ -51,15 +67,6 @@ function hasFallthroughComment(caseWhichFallsThrough, subsequentCase, context, f
     return Boolean(comment && isFallThroughComment(comment.value, fallthroughCommentPattern));
 }
 
-/**
- * Checks whether or not a given code path segment is reachable.
- * @param {CodePathSegment} segment A CodePathSegment to check.
- * @returns {boolean} `true` if the segment is reachable.
- */
-function isReachable(segment) {
-    return segment.reachable;
-}
-
 /**
  * Checks whether a node and a token are separated by blank lines
  * @param {ASTNode} node The node to check
@@ -109,7 +116,8 @@ module.exports = {
 
     create(context) {
         const options = context.options[0] || {};
-        let currentCodePath = null;
+        const codePathSegments = [];
+        let currentCodePathSegments = new Set();
         const sourceCode = context.sourceCode;
         const allowEmptyCase = options.allowEmptyCase || false;
 
@@ -126,13 +134,33 @@ module.exports = {
             fallthroughCommentPattern = DEFAULT_FALLTHROUGH_COMMENT;
         }
         return {
-            onCodePathStart(codePath) {
-                currentCodePath = codePath;
+
+            onCodePathStart() {
+                codePathSegments.push(currentCodePathSegments);
+                currentCodePathSegments = new Set();
             },
+
             onCodePathEnd() {
-                currentCodePath = currentCodePath.upper;
+                currentCodePathSegments = codePathSegments.pop();
+            },
+
+            onUnreachableCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
+            },
+
+            onUnreachableCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+
+            onCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
             },
 
+            onCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+
+
             SwitchCase(node) {
 
                 /*
@@ -157,7 +185,7 @@ module.exports = {
                  * `break`, `return`, or `throw` are unreachable.
                  * And allows empty cases and the last case.
                  */
-                if (currentCodePath.currentSegments.some(isReachable) &&
+                if (isAnySegmentReachable(currentCodePathSegments) &&
                     (node.consequent.length > 0 || (!allowEmptyCase && hasBlankLinesBetween(node, nextToken))) &&
                     node.parent.cases[node.parent.cases.length - 1] !== node) {
                     fallthroughCase = node;

package/lib/rules/no-floating-decimal.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to flag use of a leading/trailing decimal point in a numeric literal
  * @author James Allardice
+ * @deprecated in ESLint v8.53.0
  */
 
 "use strict";
@@ -18,6 +19,8 @@ const astUtils = require("./utils/ast-utils");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "suggestion",
 
         docs: {

package/lib/rules/no-invalid-this.js

@@ -96,7 +96,7 @@ module.exports = {
 
                 if (codePath.origin === "program") {
                     const scope = sourceCode.getScope(node);
-                    const features = context.parserOptions.ecmaFeatures || {};
+                    const features = context.languageOptions.parserOptions.ecmaFeatures || {};
 
                     // `this` at the top level of scripts always refers to the global object
                     stack.push({

package/lib/rules/no-misleading-character-class.js

@@ -13,27 +13,34 @@ const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
 // Helpers
 //------------------------------------------------------------------------------
 
+/**
+ * @typedef {import('@eslint-community/regexpp').AST.Character} Character
+ * @typedef {import('@eslint-community/regexpp').AST.CharacterClassElement} CharacterClassElement
+ */
+
 /**
  * Iterate character sequences of a given nodes.
  *
  * CharacterClassRange syntax can steal a part of character sequence,
  * so this function reverts CharacterClassRange syntax and restore the sequence.
- * @param {import('@eslint-community/regexpp').AST.CharacterClassElement[]} nodes The node list to iterate character sequences.
- * @returns {IterableIterator<number[]>} The list of character sequences.
+ * @param {CharacterClassElement[]} nodes The node list to iterate character sequences.
+ * @returns {IterableIterator<Character[]>} The list of character sequences.
  */
 function *iterateCharacterSequence(nodes) {
+
+    /** @type {Character[]} */
     let seq = [];
 
     for (const node of nodes) {
         switch (node.type) {
             case "Character":
-                seq.push(node.value);
+                seq.push(node);
                 break;
 
             case "CharacterClassRange":
-                seq.push(node.min.value);
+                seq.push(node.min);
                 yield seq;
-                seq = [node.max.value];
+                seq = [node.max];
                 break;
 
             case "CharacterSet":
@@ -55,32 +62,74 @@ function *iterateCharacterSequence(nodes) {
     }
 }
 
+
+/**
+ * Checks whether the given character node is a Unicode code point escape or not.
+ * @param {Character} char the character node to check.
+ * @returns {boolean} `true` if the character node is a Unicode code point escape.
+ */
+function isUnicodeCodePointEscape(char) {
+    return /^\\u\{[\da-f]+\}$/iu.test(char.raw);
+}
+
+/**
+ * Each function returns `true` if it detects that kind of problem.
+ * @type {Record<string, (chars: Character[]) => boolean>}
+ */
 const hasCharacterSequence = {
     surrogatePairWithoutUFlag(chars) {
-        return chars.some((c, i) => i !== 0 && isSurrogatePair(chars[i - 1], c));
+        return chars.some((c, i) => {
+            if (i === 0) {
+                return false;
+            }
+            const c1 = chars[i - 1];
+
+            return (
+                isSurrogatePair(c1.value, c.value) &&
+                !isUnicodeCodePointEscape(c1) &&
+                !isUnicodeCodePointEscape(c)
+            );
+        });
+    },
+
+    surrogatePair(chars) {
+        return chars.some((c, i) => {
+            if (i === 0) {
+                return false;
+            }
+            const c1 = chars[i - 1];
+
+            return (
+                isSurrogatePair(c1.value, c.value) &&
+                (
+                    isUnicodeCodePointEscape(c1) ||
+                    isUnicodeCodePointEscape(c)
+                )
+            );
+        });
     },
 
     combiningClass(chars) {
         return chars.some((c, i) => (
             i !== 0 &&
-            isCombiningCharacter(c) &&
-            !isCombiningCharacter(chars[i - 1])
+            isCombiningCharacter(c.value) &&
+            !isCombiningCharacter(chars[i - 1].value)
         ));
     },
 
     emojiModifier(chars) {
         return chars.some((c, i) => (
             i !== 0 &&
-            isEmojiModifier(c) &&
-            !isEmojiModifier(chars[i - 1])
+            isEmojiModifier(c.value) &&
+            !isEmojiModifier(chars[i - 1].value)
         ));
     },
 
     regionalIndicatorSymbol(chars) {
         return chars.some((c, i) => (
             i !== 0 &&
-            isRegionalIndicatorSymbol(c) &&
-            isRegionalIndicatorSymbol(chars[i - 1])
+            isRegionalIndicatorSymbol(c.value) &&
+            isRegionalIndicatorSymbol(chars[i - 1].value)
         ));
     },
 
@@ -90,9 +139,9 @@ const hasCharacterSequence = {
         return chars.some((c, i) => (
             i !== 0 &&
             i !== lastIndex &&
-            c === 0x200d &&
-            chars[i - 1] !== 0x200d &&
-            chars[i + 1] !== 0x200d
+            c.value === 0x200d &&
+            chars[i - 1].value !== 0x200d &&
+            chars[i + 1].value !== 0x200d
         ));
     }
 };
@@ -120,6 +169,7 @@ module.exports = {
 
         messages: {
             surrogatePairWithoutUFlag: "Unexpected surrogate pair in character class. Use 'u' flag.",
+            surrogatePair: "Unexpected surrogate pair in character class.",
             combiningClass: "Unexpected combined character in character class.",
             emojiModifier: "Unexpected modified Emoji in character class.",
             regionalIndicatorSymbol: "Unexpected national flag in character class.",

package/lib/rules/no-mixed-operators.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to disallow mixed binary operators.
  * @author Toru Nagashima
+ * @deprecated in ESLint v8.53.0
  */
 
 "use strict";
@@ -85,6 +86,8 @@ function getChildNode(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "suggestion",
 
         docs: {

package/lib/rules/no-mixed-spaces-and-tabs.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Disallow mixed spaces and tabs for indentation
  * @author Jary Niebur
+ * @deprecated in ESLint v8.53.0
  */
 "use strict";
 
@@ -11,6 +12,8 @@
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "layout",
 
         docs: {

package/lib/rules/no-multi-spaces.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Disallow use of multiple spaces.
  * @author Nicholas C. Zakas
+ * @deprecated in ESLint v8.53.0
  */
 
 "use strict";
@@ -14,6 +15,8 @@ const astUtils = require("./utils/ast-utils");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "layout",
 
         docs: {

package/lib/rules/no-multiple-empty-lines.js

@@ -2,6 +2,7 @@
  * @fileoverview Disallows multiple blank lines.
  * implementation adapted from the no-trailing-spaces rule.
  * @author Greg Cochard
+ * @deprecated in ESLint v8.53.0
  */
 "use strict";
 
@@ -12,6 +13,8 @@
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        deprecated: true,
+        replacedBy: [],
         type: "layout",
 
         docs: {

package/lib/rules/no-new-object.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview A rule to disallow calls to the Object constructor
  * @author Matt DuVall <http://www.mattduvall.com/>
+ * @deprecated in ESLint v8.50.0
  */
 
 "use strict";
@@ -26,6 +27,12 @@ module.exports = {
             url: "https://eslint.org/docs/latest/rules/no-new-object"
         },
 
+        deprecated: true,
+
+        replacedBy: [
+            "no-object-constructor"
+        ],
+
         schema: [],
 
         messages: {