eslint 9.0.0-alpha.0 → 9.0.0-alpha.1

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 {

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-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-vars.js

@@ -141,7 +141,7 @@ module.exports = {
             } else if (defType === "Parameter" && config.argsIgnorePattern) {
                 type = "args";
                 pattern = config.argsIgnorePattern.toString();
-            } else if (defType !== "Parameter" && config.varsIgnorePattern) {
+            } else if (defType !== "Parameter" && defType !== "CatchClause" && config.varsIgnorePattern) {
                 type = "vars";
                 pattern = config.varsIgnorePattern.toString();
             }
@@ -218,7 +218,7 @@ module.exports = {
         function hasRestSibling(node) {
             return node.type === "Property" &&
                 node.parent.type === "ObjectPattern" &&
-                REST_PROPERTY_TYPE.test(node.parent.properties[node.parent.properties.length - 1].type);
+                REST_PROPERTY_TYPE.test(node.parent.properties.at(-1).type);
         }
 
         /**
@@ -323,7 +323,7 @@ module.exports = {
             }
 
             if (parent.type === "SequenceExpression") {
-                const isLastExpression = parent.expressions[parent.expressions.length - 1] === node;
+                const isLastExpression = parent.expressions.at(-1) === node;
 
                 if (!isLastExpression) {
                     return true;
@@ -392,7 +392,7 @@ module.exports = {
             while (parent && isInside(parent, rhsNode)) {
                 switch (parent.type) {
                     case "SequenceExpression":
-                        if (parent.expressions[parent.expressions.length - 1] !== node) {
+                        if (parent.expressions.at(-1) !== node) {
                             return false;
                         }
                         break;
@@ -623,9 +623,7 @@ module.exports = {
                             if (config.caughtErrorsIgnorePattern && config.caughtErrorsIgnorePattern.test(def.name.name)) {
                                 continue;
                             }
-                        }
-
-                        if (type === "Parameter") {
+                        } else if (type === "Parameter") {
 
                             // skip any setter argument
                             if ((def.node.parent.type === "Property" || def.node.parent.type === "MethodDefinition") && def.node.parent.kind === "set") {
@@ -688,7 +686,7 @@ module.exports = {
                         let referenceToReport;
 
                         if (writeReferences.length > 0) {
-                            referenceToReport = writeReferences[writeReferences.length - 1];
+                            referenceToReport = writeReferences.at(-1);
                         }
 
                         context.report({