eslint 8.56.0 → 9.0.0-alpha.1

package/lib/rules/no-implicit-coercion.js

@@ -12,7 +12,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u;
-const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
+const ALLOWABLE_OPERATORS = ["~", "!!", "+", "- -", "-", "*"];
 
 /**
  * Parses and normalizes an option object.
@@ -300,6 +300,14 @@ module.exports = {
 
                     report(node, recommendation, true);
                 }
+
+                // -(-foo)
+                operatorAllowed = options.allow.includes("- -");
+                if (!operatorAllowed && options.number && node.operator === "-" && node.argument.type === "UnaryExpression" && node.argument.operator === "-" && !isNumeric(node.argument.argument)) {
+                    const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
+
+                    report(node, recommendation, false);
+                }
             },
 
             // Use `:exit` to prevent double reporting
@@ -317,6 +325,14 @@ module.exports = {
                     report(node, recommendation, true);
                 }
 
+                // foo - 0
+                operatorAllowed = options.allow.includes("-");
+                if (!operatorAllowed && options.number && node.operator === "-" && node.right.type === "Literal" && node.right.value === 0 && !isNumeric(node.left)) {
+                    const recommendation = `Number(${sourceCode.getText(node.left)})`;
+
+                    report(node, recommendation, true);
+                }
+
                 // "" + foo
                 operatorAllowed = options.allow.includes("+");
                 if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {

package/lib/rules/no-inner-declarations.js

@@ -49,13 +49,22 @@ module.exports = {
 
         docs: {
             description: "Disallow variable or `function` declarations in nested blocks",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-inner-declarations"
         },
 
         schema: [
             {
                 enum: ["functions", "both"]
+            },
+            {
+                type: "object",
+                properties: {
+                    blockScopedFunctions: {
+                        enum: ["allow", "disallow"]
+                    }
+                },
+                additionalProperties: false
             }
         ],
 
@@ -66,6 +75,10 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.sourceCode;
+        const ecmaVersion = context.languageOptions.ecmaVersion;
+        const blockScopedFunctions = context.options[1]?.blockScopedFunctions ?? "allow";
+
         /**
          * Ensure that a given node is at a program or function body's root.
          * @param {ASTNode} node Declaration node to check.
@@ -97,7 +110,15 @@ module.exports = {
 
         return {
 
-            FunctionDeclaration: check,
+            FunctionDeclaration(node) {
+                const isInStrictCode = sourceCode.getScope(node).upper.isStrict;
+
+                if (blockScopedFunctions === "allow" && ecmaVersion >= 2015 && isInStrictCode) {
+                    return;
+                }
+
+                check(node);
+            },
             VariableDeclaration(node) {
                 if (context.options[0] === "both" && node.kind === "var") {
                     check(node);

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

@@ -55,7 +55,7 @@ module.exports = {
             const temp = options.allowConstructorFlags.join("").replace(validFlags, "");
 
             if (temp) {
-                allowedFlags = new RegExp(`[${temp}]`, "giu");
+                allowedFlags = new RegExp(`[${temp}]`, "gu");
             }
         }
 

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

@@ -74,7 +74,7 @@ module.exports = {
          *   an object which has a flag that whether or not `this` keyword is valid.
          */
         stack.getCurrent = function() {
-            const current = this[this.length - 1];
+            const current = this.at(-1);
 
             if (!current.init) {
                 current.init = true;

package/lib/rules/no-lone-blocks.js

@@ -78,7 +78,7 @@ module.exports = {
 
             const block = node.parent;
 
-            if (loneBlocks[loneBlocks.length - 1] === block) {
+            if (loneBlocks.at(-1) === block) {
                 loneBlocks.pop();
             }
         }
@@ -101,7 +101,7 @@ module.exports = {
                     }
                 },
                 "BlockStatement:exit"(node) {
-                    if (loneBlocks.length > 0 && loneBlocks[loneBlocks.length - 1] === node) {
+                    if (loneBlocks.length > 0 && loneBlocks.at(-1) === node) {
                         loneBlocks.pop();
                         report(node);
                     } else if (

package/lib/rules/no-loss-of-precision.js

@@ -64,7 +64,7 @@ module.exports = {
          */
         function notBaseTenLosesPrecision(node) {
             const rawString = getRaw(node).toUpperCase();
-            let base = 0;
+            let base;
 
             if (rawString.startsWith("0B")) {
                 base = 2;

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

@@ -62,7 +62,6 @@ 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.
@@ -73,80 +72,126 @@ function isUnicodeCodePointEscape(char) {
 }
 
 /**
- * Each function returns `true` if it detects that kind of problem.
- * @type {Record<string, (chars: Character[]) => boolean>}
+ * Each function returns matched characters if it detects that kind of problem.
+ * @type {Record<string, (chars: Character[]) => IterableIterator<Character[]>>}
  */
-const hasCharacterSequence = {
-    surrogatePairWithoutUFlag(chars) {
-        return chars.some((c, i) => {
-            if (i === 0) {
-                return false;
+const findCharacterSequences = {
+    *surrogatePairWithoutUFlag(chars) {
+        for (const [index, char] of chars.entries()) {
+            if (index === 0) {
+                continue;
+            }
+            const previous = chars[index - 1];
+
+            if (
+                isSurrogatePair(previous.value, char.value) &&
+                !isUnicodeCodePointEscape(previous) &&
+                !isUnicodeCodePointEscape(char)
+            ) {
+                yield [previous, char];
             }
-            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;
+    *surrogatePair(chars) {
+        for (const [index, char] of chars.entries()) {
+            if (index === 0) {
+                continue;
             }
-            const c1 = chars[i - 1];
+            const previous = chars[index - 1];
 
-            return (
-                isSurrogatePair(c1.value, c.value) &&
+            if (
+                isSurrogatePair(previous.value, char.value) &&
                 (
-                    isUnicodeCodePointEscape(c1) ||
-                    isUnicodeCodePointEscape(c)
+                    isUnicodeCodePointEscape(previous) ||
+                    isUnicodeCodePointEscape(char)
                 )
-            );
-        });
+            ) {
+                yield [previous, char];
+            }
+        }
     },
 
-    combiningClass(chars) {
-        return chars.some((c, i) => (
-            i !== 0 &&
-            isCombiningCharacter(c.value) &&
-            !isCombiningCharacter(chars[i - 1].value)
-        ));
+    *combiningClass(chars) {
+        for (const [index, char] of chars.entries()) {
+            if (index === 0) {
+                continue;
+            }
+            const previous = chars[index - 1];
+
+            if (
+                isCombiningCharacter(char.value) &&
+                !isCombiningCharacter(previous.value)
+            ) {
+                yield [previous, char];
+            }
+        }
     },
 
-    emojiModifier(chars) {
-        return chars.some((c, i) => (
-            i !== 0 &&
-            isEmojiModifier(c.value) &&
-            !isEmojiModifier(chars[i - 1].value)
-        ));
+    *emojiModifier(chars) {
+        for (const [index, char] of chars.entries()) {
+            if (index === 0) {
+                continue;
+            }
+            const previous = chars[index - 1];
+
+            if (
+                isEmojiModifier(char.value) &&
+                !isEmojiModifier(previous.value)
+            ) {
+                yield [previous, char];
+            }
+        }
     },
 
-    regionalIndicatorSymbol(chars) {
-        return chars.some((c, i) => (
-            i !== 0 &&
-            isRegionalIndicatorSymbol(c.value) &&
-            isRegionalIndicatorSymbol(chars[i - 1].value)
-        ));
+    *regionalIndicatorSymbol(chars) {
+        for (const [index, char] of chars.entries()) {
+            if (index === 0) {
+                continue;
+            }
+            const previous = chars[index - 1];
+
+            if (
+                isRegionalIndicatorSymbol(char.value) &&
+                isRegionalIndicatorSymbol(previous.value)
+            ) {
+                yield [previous, char];
+            }
+        }
     },
 
-    zwj(chars) {
-        const lastIndex = chars.length - 1;
+    *zwj(chars) {
+        let sequence = null;
 
-        return chars.some((c, i) => (
-            i !== 0 &&
-            i !== lastIndex &&
-            c.value === 0x200d &&
-            chars[i - 1].value !== 0x200d &&
-            chars[i + 1].value !== 0x200d
-        ));
+        for (const [index, char] of chars.entries()) {
+            if (index === 0 || index === chars.length - 1) {
+                continue;
+            }
+            if (
+                char.value === 0x200d &&
+                chars[index - 1].value !== 0x200d &&
+                chars[index + 1].value !== 0x200d
+            ) {
+                if (sequence) {
+                    if (sequence.at(-1) === chars[index - 1]) {
+                        sequence.push(char, chars[index + 1]); // append to the sequence
+                    } else {
+                        yield sequence;
+                        sequence = chars.slice(index - 1, index + 2);
+                    }
+                } else {
+                    sequence = chars.slice(index - 1, index + 2);
+                }
+            }
+        }
+
+        if (sequence) {
+            yield sequence;
+        }
     }
 };
 
-const kinds = Object.keys(hasCharacterSequence);
+const kinds = Object.keys(findCharacterSequences);
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -181,6 +226,62 @@ module.exports = {
         const sourceCode = context.sourceCode;
         const parser = new RegExpParser();
 
+        /**
+         * Generates a granular loc for context.report, if directly calculable.
+         * @param {Character[]} chars Individual characters being reported on.
+         * @param {Node} node Parent string node to report within.
+         * @returns {Object | null} Granular loc for context.report, if directly calculable.
+         * @see https://github.com/eslint/eslint/pull/17515
+         */
+        function generateReportLocation(chars, node) {
+
+            // Limit to to literals and expression-less templates with raw values === their value.
+            switch (node.type) {
+                case "TemplateLiteral":
+                    if (node.expressions.length || sourceCode.getText(node).slice(1, -1) !== node.quasis[0].value.cooked) {
+                        return null;
+                    }
+                    break;
+
+                case "Literal":
+                    if (typeof node.value === "string" && node.value !== node.raw.slice(1, -1)) {
+                        return null;
+                    }
+                    break;
+
+                default:
+                    return null;
+            }
+
+            return {
+                start: sourceCode.getLocFromIndex(node.range[0] + 1 + chars[0].start),
+                end: sourceCode.getLocFromIndex(node.range[0] + 1 + chars.at(-1).end)
+            };
+        }
+
+        /**
+         * Finds the report loc(s) for a range of matches.
+         * @param {Character[][]} matches Characters that should trigger a report.
+         * @param {Node} node The node to report.
+         * @returns {Object | null} Node loc(s) for context.report.
+         */
+        function getNodeReportLocations(matches, node) {
+            const locs = [];
+
+            for (const chars of matches) {
+                const loc = generateReportLocation(chars, node);
+
+                // If a report can't match to a range, don't report any others
+                if (!loc) {
+                    return [node.loc];
+                }
+
+                locs.push(loc);
+            }
+
+            return locs;
+        }
+
         /**
          * Verify a given regular expression.
          * @param {Node} node The node to report.
@@ -208,21 +309,24 @@ module.exports = {
                 return;
             }
 
-            const foundKinds = new Set();
+            const foundKindMatches = new Map();
 
             visitRegExpAST(patternNode, {
                 onCharacterClassEnter(ccNode) {
                     for (const chars of iterateCharacterSequence(ccNode.elements)) {
                         for (const kind of kinds) {
-                            if (hasCharacterSequence[kind](chars)) {
-                                foundKinds.add(kind);
+                            if (foundKindMatches.has(kind)) {
+                                foundKindMatches.get(kind).push(...findCharacterSequences[kind](chars));
+                            } else {
+                                foundKindMatches.set(kind, [...findCharacterSequences[kind](chars)]);
                             }
+
                         }
                     }
                 }
             });
 
-            for (const kind of foundKinds) {
+            for (const [kind, matches] of foundKindMatches) {
                 let suggest;
 
                 if (kind === "surrogatePairWithoutUFlag") {
@@ -232,11 +336,16 @@ module.exports = {
                     }];
                 }
 
-                context.report({
-                    node,
-                    messageId: kind,
-                    suggest
-                });
+                const locs = getNodeReportLocations(matches, node);
+
+                for (const loc of locs) {
+                    context.report({
+                        node,
+                        loc,
+                        messageId: kind,
+                        suggest
+                    });
+                }
             }
         }
 
@@ -267,7 +376,7 @@ module.exports = {
                     const flags = getStringIfConstant(flagsNode, scope);
 
                     if (typeof pattern === "string") {
-                        verify(refNode, pattern, flags || "", fixer => {
+                        verify(patternNode, pattern, flags || "", fixer => {
 
                             if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)) {
                                 return null;

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

@@ -18,7 +18,7 @@ module.exports = {
 
         docs: {
             description: "Disallow mixed spaces and tabs for indentation",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs"
         },
 

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

@@ -70,7 +70,7 @@ module.exports = {
         const sourceCode = context.sourceCode;
 
         // Swallow the final newline, as some editors add it automatically and we don't want it to cause an issue
-        const allLines = sourceCode.lines[sourceCode.lines.length - 1] === "" ? sourceCode.lines.slice(0, -1) : sourceCode.lines;
+        const allLines = sourceCode.lines.at(-1) === "" ? sourceCode.lines.slice(0, -1) : sourceCode.lines;
         const templateLiteralLines = new Set();
 
         //--------------------------------------------------------------------------

package/lib/rules/no-new-native-nonconstructor.js

@@ -22,7 +22,7 @@ module.exports = {
 
         docs: {
             description: "Disallow `new` operators with global non-constructor functions",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor"
         },
 

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

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to disallow use of the new operator with the `Symbol` object
  * @author Alberto Rodríguez
+ * @deprecated in ESLint v9.0.0
  */
 
 "use strict";
@@ -16,10 +17,16 @@ module.exports = {
 
         docs: {
             description: "Disallow `new` operators with the `Symbol` object",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-new-symbol"
         },
 
+        deprecated: true,
+
+        replacedBy: [
+            "no-new-native-nonconstructor"
+        ],
+
         schema: [],
 
         messages: {

package/lib/rules/no-restricted-globals.js

@@ -97,7 +97,7 @@ module.exports = {
          * @private
          */
         function isRestricted(name) {
-            return Object.prototype.hasOwnProperty.call(restrictedGlobalMessages, name);
+            return Object.hasOwn(restrictedGlobalMessages, name);
         }
 
         return {

package/lib/rules/no-restricted-imports.js

@@ -158,7 +158,7 @@ module.exports = {
         const options = Array.isArray(context.options) ? context.options : [];
         const isPathAndPatternsObject =
             typeof options[0] === "object" &&
-            (Object.prototype.hasOwnProperty.call(options[0], "paths") || Object.prototype.hasOwnProperty.call(options[0], "patterns"));
+            (Object.hasOwn(options[0], "paths") || Object.hasOwn(options[0], "patterns"));
 
         const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
         const restrictedPathMessages = restrictedPaths.reduce((memo, importSource) => {
@@ -203,7 +203,7 @@ module.exports = {
          * @private
          */
         function checkRestrictedPathAndReport(importSource, importNames, node) {
-            if (!Object.prototype.hasOwnProperty.call(restrictedPathMessages, importSource)) {
+            if (!Object.hasOwn(restrictedPathMessages, importSource)) {
                 return;
             }
 

package/lib/rules/no-restricted-modules.js

@@ -90,7 +90,7 @@ module.exports = {
         const options = Array.isArray(context.options) ? context.options : [];
         const isPathAndPatternsObject =
             typeof options[0] === "object" &&
-            (Object.prototype.hasOwnProperty.call(options[0], "paths") || Object.prototype.hasOwnProperty.call(options[0], "patterns"));
+            (Object.hasOwn(options[0], "paths") || Object.hasOwn(options[0], "patterns"));
 
         const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
         const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
@@ -178,7 +178,7 @@ module.exports = {
          * @private
          */
         function isRestrictedPath(name) {
-            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, name);
+            return Object.hasOwn(restrictedPathMessages, name);
         }
 
         return {

package/lib/rules/no-return-await.js

@@ -118,7 +118,7 @@ module.exports = {
             if (node.parent.type === "LogicalExpression" && node === node.parent.right) {
                 return isInTailCallPosition(node.parent);
             }
-            if (node.parent.type === "SequenceExpression" && node === node.parent.expressions[node.parent.expressions.length - 1]) {
+            if (node.parent.type === "SequenceExpression" && node === node.parent.expressions.at(-1)) {
                 return isInTailCallPosition(node.parent);
             }
             return false;

package/lib/rules/no-sequences.js

@@ -35,6 +35,7 @@ module.exports = {
         },
 
         schema: [{
+            type: "object",
             properties: {
                 allowInParentheses: {
                     type: "boolean",

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

@@ -129,8 +129,7 @@ module.exports = {
                     comments = sourceCode.getAllComments(),
                     commentLineNumbers = getCommentLineNumbers(comments);
 
-                let totalLength = 0,
-                    fixRange = [];
+                let totalLength = 0;
 
                 for (let i = 0, ii = lines.length; i < ii; i++) {
                     const lineNumber = i + 1;
@@ -177,7 +176,7 @@ module.exports = {
                             continue;
                         }
 
-                        fixRange = [rangeStart, rangeEnd];
+                        const fixRange = [rangeStart, rangeEnd];
 
                         if (!ignoreComments || !commentLineNumbers.has(lineNumber)) {
                             report(node, location, fixRange);

package/lib/rules/no-unneeded-ternary.js

@@ -76,7 +76,7 @@ module.exports = {
          * @returns {string} A string representing an inverted expression
          */
         function invertExpression(node) {
-            if (node.type === "BinaryExpression" && Object.prototype.hasOwnProperty.call(OPERATOR_INVERSES, node.operator)) {
+            if (node.type === "BinaryExpression" && Object.hasOwn(OPERATOR_INVERSES, node.operator)) {
                 const operatorToken = sourceCode.getFirstTokenBetween(
                     node.left,
                     node.right,

package/lib/rules/no-unsafe-optional-chaining.js

@@ -94,7 +94,7 @@ module.exports = {
                     break;
                 case "SequenceExpression":
                     checkUndefinedShortCircuit(
-                        node.expressions[node.expressions.length - 1],
+                        node.expressions.at(-1),
                         reportFunc
                     );
                     break;

package/lib/rules/no-unused-private-class-members.js

@@ -16,7 +16,7 @@ module.exports = {
 
         docs: {
             description: "Disallow unused private class members",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
         },