eslint 9.0.0-alpha.0 → 9.0.0-alpha.2

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

@@ -188,6 +188,7 @@ function getNonEmptyOperand(node) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        hasSuggestions: true,
         type: "suggestion",
 
         docs: {
@@ -229,7 +230,8 @@ module.exports = {
         }],
 
         messages: {
-            useRecommendation: "use `{{recommendation}}` instead."
+            implicitCoercion: "Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.",
+            useRecommendation: "Use `{{recommendation}}` instead."
         }
     },
 
@@ -241,32 +243,54 @@ module.exports = {
          * Reports an error and autofixes the node
          * @param {ASTNode} node An ast node to report the error on.
          * @param {string} recommendation The recommended code for the issue
+         * @param {bool} shouldSuggest Whether this report should offer a suggestion
          * @param {bool} shouldFix Whether this report should fix the node
          * @returns {void}
          */
-        function report(node, recommendation, shouldFix) {
+        function report(node, recommendation, shouldSuggest, shouldFix) {
+
+            /**
+             * Fix function
+             * @param {RuleFixer} fixer The fixer to fix.
+             * @returns {Fix} The fix object.
+             */
+            function fix(fixer) {
+                const tokenBefore = sourceCode.getTokenBefore(node);
+
+                if (
+                    tokenBefore?.range[1] === node.range[0] &&
+                    !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
+                ) {
+                    return fixer.replaceText(node, ` ${recommendation}`);
+                }
+
+                return fixer.replaceText(node, recommendation);
+            }
+
             context.report({
                 node,
-                messageId: "useRecommendation",
-                data: {
-                    recommendation
-                },
+                messageId: "implicitCoercion",
+                data: { recommendation },
                 fix(fixer) {
                     if (!shouldFix) {
                         return null;
                     }
 
-                    const tokenBefore = sourceCode.getTokenBefore(node);
-
-                    if (
-                        tokenBefore &&
-                        tokenBefore.range[1] === node.range[0] &&
-                        !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
-                    ) {
-                        return fixer.replaceText(node, ` ${recommendation}`);
+                    return fix(fixer);
+                },
+                suggest: [
+                    {
+                        messageId: "useRecommendation",
+                        data: { recommendation },
+                        fix(fixer) {
+                            if (shouldFix || !shouldSuggest) {
+                                return null;
+                            }
+
+                            return fix(fixer);
+                        }
                     }
-                    return fixer.replaceText(node, recommendation);
-                }
+                ]
             });
         }
 
@@ -278,8 +302,10 @@ module.exports = {
                 operatorAllowed = options.allow.includes("!!");
                 if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
                     const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+                    const variable = astUtils.getVariableByName(sourceCode.getScope(node), "Boolean");
+                    const booleanExists = variable?.identifiers.length === 0;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, booleanExists);
                 }
 
                 // ~foo.indexOf(bar)
@@ -290,7 +316,7 @@ module.exports = {
                     const comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
                     const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
 
-                    report(node, recommendation, false);
+                    report(node, recommendation, false, false);
                 }
 
                 // +foo
@@ -298,7 +324,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
                     const recommendation = `Number(${sourceCode.getText(node.argument)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // -(-foo)
@@ -306,7 +332,7 @@ module.exports = {
                 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);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -322,7 +348,7 @@ module.exports = {
                 if (nonNumericOperand) {
                     const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
 
                 // foo - 0
@@ -330,7 +356,7 @@ module.exports = {
                 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);
+                    report(node, recommendation, true, false);
                 }
 
                 // "" + foo
@@ -338,7 +364,7 @@ module.exports = {
                 if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
                     const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -351,7 +377,7 @@ module.exports = {
                     const code = sourceCode.getText(getNonEmptyOperand(node));
                     const recommendation = `${code} = String(${code})`;
 
-                    report(node, recommendation, true);
+                    report(node, recommendation, true, false);
                 }
             },
 
@@ -389,7 +415,7 @@ module.exports = {
                 const code = sourceCode.getText(node.expressions[0]);
                 const recommendation = `String(${code})`;
 
-                report(node, recommendation, true);
+                report(node, recommendation, true, false);
             }
         };
     }

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

@@ -56,6 +56,15 @@ module.exports = {
         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-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-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-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 {