eslint 9.0.0-rc.0 → 9.1.0

package/lib/rules/no-unused-vars.js

@@ -15,6 +15,11 @@ const astUtils = require("./utils/ast-utils");
 // Typedefs
 //------------------------------------------------------------------------------
 
+/**
+ * A simple name for the types of variables that this rule supports
+ * @typedef {'array-destructure'|'catch-clause'|'parameter'|'variable'} VariableType
+ */
+
 /**
  * Bag of data used for formatting the `unusedVar` lint message.
  * @typedef {Object} UnusedVarMessageData
@@ -23,6 +28,13 @@ const astUtils = require("./utils/ast-utils");
  * @property {string} additional Any additional info to be appended at the end.
  */
 
+/**
+ * Bag of data used for formatting the `usedIgnoredVar` lint message.
+ * @typedef {Object} UsedIgnoredVarMessageData
+ * @property {string} varName The name of the unused var.
+ * @property {string} additional Any additional info to be appended at the end.
+ */
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -73,6 +85,9 @@ module.exports = {
                             },
                             ignoreClassWithStaticInitBlock: {
                                 type: "boolean"
+                            },
+                            reportUsedIgnorePattern: {
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -82,7 +97,8 @@ module.exports = {
         ],
 
         messages: {
-            unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}."
+            unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
+            usedIgnoredVar: "'{{varName}}' is marked as ignored but is used{{additional}}."
         }
     },
 
@@ -96,7 +112,8 @@ module.exports = {
             args: "after-used",
             ignoreRestSiblings: false,
             caughtErrors: "all",
-            ignoreClassWithStaticInitBlock: false
+            ignoreClassWithStaticInitBlock: false,
+            reportUsedIgnorePattern: false
         };
 
         const firstOption = context.options[0];
@@ -110,6 +127,7 @@ module.exports = {
                 config.ignoreRestSiblings = firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
                 config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;
                 config.ignoreClassWithStaticInitBlock = firstOption.ignoreClassWithStaticInitBlock || config.ignoreClassWithStaticInitBlock;
+                config.reportUsedIgnorePattern = firstOption.reportUsedIgnorePattern || config.reportUsedIgnorePattern;
 
                 if (firstOption.varsIgnorePattern) {
                     config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern, "u");
@@ -129,6 +147,50 @@ module.exports = {
             }
         }
 
+        /**
+         * Gets a given variable's description and configured ignore pattern
+         * based on the provided variableType
+         * @param {VariableType} variableType a simple name for the types of variables that this rule supports
+         * @throws {Error} (Unreachable)
+         * @returns {[string | undefined, string | undefined]} the given variable's description and
+         * ignore pattern
+         */
+        function getVariableDescription(variableType) {
+            let pattern;
+            let variableDescription;
+
+            switch (variableType) {
+                case "array-destructure":
+                    pattern = config.destructuredArrayIgnorePattern;
+                    variableDescription = "elements of array destructuring";
+                    break;
+
+                case "catch-clause":
+                    pattern = config.caughtErrorsIgnorePattern;
+                    variableDescription = "args";
+                    break;
+
+                case "parameter":
+                    pattern = config.argsIgnorePattern;
+                    variableDescription = "args";
+                    break;
+
+                case "variable":
+                    pattern = config.varsIgnorePattern;
+                    variableDescription = "vars";
+                    break;
+
+                default:
+                    throw new Error(`Unexpected variable type: ${variableType}`);
+            }
+
+            if (pattern) {
+                pattern = pattern.toString();
+            }
+
+            return [variableDescription, pattern];
+        }
+
         /**
          * Generates the message data about the variable being defined and unused,
          * including the ignore pattern if configured.
@@ -136,27 +198,42 @@ module.exports = {
          * @returns {UnusedVarMessageData} The message data to be used with this unused variable.
          */
         function getDefinedMessageData(unusedVar) {
-            const defType = unusedVar.defs && unusedVar.defs[0] && unusedVar.defs[0].type;
-            let type;
-            let pattern;
+            const def = unusedVar.defs && unusedVar.defs[0];
+            let additionalMessageData = "";
 
-            if (defType === "CatchClause" && config.caughtErrorsIgnorePattern) {
-                type = "args";
-                pattern = config.caughtErrorsIgnorePattern.toString();
-            } else if (defType === "Parameter" && config.argsIgnorePattern) {
-                type = "args";
-                pattern = config.argsIgnorePattern.toString();
-            } else if (defType !== "Parameter" && defType !== "CatchClause" && config.varsIgnorePattern) {
-                type = "vars";
-                pattern = config.varsIgnorePattern.toString();
-            }
+            if (def) {
+                let pattern;
+                let variableDescription;
+
+                switch (def.type) {
+                    case "CatchClause":
+                        if (config.caughtErrorsIgnorePattern) {
+                            [variableDescription, pattern] = getVariableDescription("catch-clause");
+                        }
+                        break;
 
-            const additional = type ? `. Allowed unused ${type} must match ${pattern}` : "";
+                    case "Parameter":
+                        if (config.argsIgnorePattern) {
+                            [variableDescription, pattern] = getVariableDescription("parameter");
+                        }
+                        break;
+
+                    default:
+                        if (config.varsIgnorePattern) {
+                            [variableDescription, pattern] = getVariableDescription("variable");
+                        }
+                        break;
+                }
+
+                if (pattern && variableDescription) {
+                    additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
+                }
+            }
 
             return {
                 varName: unusedVar.name,
                 action: "defined",
-                additional
+                additional: additionalMessageData
             };
         }
 
@@ -167,19 +244,51 @@ module.exports = {
          * @returns {UnusedVarMessageData} The message data to be used with this unused variable.
          */
         function getAssignedMessageData(unusedVar) {
-            const def = unusedVar.defs[0];
-            let additional = "";
+            const def = unusedVar.defs && unusedVar.defs[0];
+            let additionalMessageData = "";
+
+            if (def) {
+                let pattern;
+                let variableDescription;
 
-            if (config.destructuredArrayIgnorePattern && def && def.name.parent.type === "ArrayPattern") {
-                additional = `. Allowed unused elements of array destructuring patterns must match ${config.destructuredArrayIgnorePattern.toString()}`;
-            } else if (config.varsIgnorePattern) {
-                additional = `. Allowed unused vars must match ${config.varsIgnorePattern.toString()}`;
+                if (def.name.parent.type === "ArrayPattern" && config.destructuredArrayIgnorePattern) {
+                    [variableDescription, pattern] = getVariableDescription("array-destructure");
+                } else if (config.varsIgnorePattern) {
+                    [variableDescription, pattern] = getVariableDescription("variable");
+                }
+
+                if (pattern && variableDescription) {
+                    additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
+                }
             }
 
             return {
                 varName: unusedVar.name,
                 action: "assigned a value",
-                additional
+                additional: additionalMessageData
+            };
+        }
+
+        /**
+         * Generate the warning message about a variable being used even though
+         * it is marked as being ignored.
+         * @param {Variable} variable eslint-scope variable object
+         * @param {VariableType} variableType a simple name for the types of variables that this rule supports
+         * @returns {UsedIgnoredVarMessageData} The message data to be used with
+         * this used ignored variable.
+         */
+        function getUsedIgnoredMessageData(variable, variableType) {
+            const [variableDescription, pattern] = getVariableDescription(variableType);
+
+            let additionalMessageData = "";
+
+            if (pattern && variableDescription) {
+                additionalMessageData = `. Used ${variableDescription} must not match ${pattern}`;
+            }
+
+            return {
+                varName: variable.name,
+                additional: additionalMessageData
             };
         }
 
@@ -532,8 +641,13 @@ module.exports = {
          * @private
          */
         function isUsedVariable(variable) {
-            const functionNodes = getFunctionDefinitions(variable),
-                isFunctionDefinition = functionNodes.length > 0;
+            if (variable.eslintUsed) {
+                return true;
+            }
+
+            const functionNodes = getFunctionDefinitions(variable);
+            const isFunctionDefinition = functionNodes.length > 0;
+
             let rhsNode = null;
 
             return variable.references.some(ref => {
@@ -589,8 +703,13 @@ module.exports = {
                         continue;
                     }
 
-                    // skip function expression names and variables marked with markVariableAsUsed()
-                    if (scope.functionExpressionScope || variable.eslintUsed) {
+                    // skip function expression names
+                    if (scope.functionExpressionScope) {
+                        continue;
+                    }
+
+                    // skip variables marked with markVariableAsUsed()
+                    if (!config.reportUsedIgnorePattern && variable.eslintUsed) {
                         continue;
                     }
 
@@ -615,6 +734,14 @@ module.exports = {
                             config.destructuredArrayIgnorePattern &&
                             config.destructuredArrayIgnorePattern.test(def.name.name)
                         ) {
+                            if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                context.report({
+                                    node: def.name,
+                                    messageId: "usedIgnoredVar",
+                                    data: getUsedIgnoredMessageData(variable, "array-destructure")
+                                });
+                            }
+
                             continue;
                         }
 
@@ -634,6 +761,14 @@ module.exports = {
 
                             // skip ignored parameters
                             if (config.caughtErrorsIgnorePattern && config.caughtErrorsIgnorePattern.test(def.name.name)) {
+                                if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                    context.report({
+                                        node: def.name,
+                                        messageId: "usedIgnoredVar",
+                                        data: getUsedIgnoredMessageData(variable, "catch-clause")
+                                    });
+                                }
+
                                 continue;
                             }
                         } else if (type === "Parameter") {
@@ -650,6 +785,14 @@ module.exports = {
 
                             // skip ignored parameters
                             if (config.argsIgnorePattern && config.argsIgnorePattern.test(def.name.name)) {
+                                if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                    context.report({
+                                        node: def.name,
+                                        messageId: "usedIgnoredVar",
+                                        data: getUsedIgnoredMessageData(variable, "parameter")
+                                    });
+                                }
+
                                 continue;
                             }
 
@@ -661,6 +804,14 @@ module.exports = {
 
                             // skip ignored variables
                             if (config.varsIgnorePattern && config.varsIgnorePattern.test(def.name.name)) {
+                                if (config.reportUsedIgnorePattern && isUsedVariable(variable)) {
+                                    context.report({
+                                        node: def.name,
+                                        messageId: "usedIgnoredVar",
+                                        data: getUsedIgnoredMessageData(variable, "variable")
+                                    });
+                                }
+
                                 continue;
                             }
                         }
@@ -724,6 +875,5 @@ module.exports = {
                 }
             }
         };
-
     }
 };

package/lib/rules/use-isnan.js

@@ -182,7 +182,7 @@ module.exports = {
 
                 if (
                     (methodName === "indexOf" || methodName === "lastIndexOf") &&
-                    node.arguments.length === 1 &&
+                    node.arguments.length <= 2 &&
                     isNaNIdentifier(node.arguments[0])
                 ) {
 
@@ -190,7 +190,7 @@ module.exports = {
                      * To retain side effects, it's essential to address `NaN` beforehand, which
                      * is not possible with fixes like `arr.findIndex(Number.isNaN)`.
                      */
-                    const isSuggestable = node.arguments[0].type !== "SequenceExpression";
+                    const isSuggestable = node.arguments[0].type !== "SequenceExpression" && !node.arguments[1];
                     const suggestedFixes = [];
 
                     if (isSuggestable) {

package/lib/shared/stats.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Provides helper functions to start/stop the time measurements
+ * that are provided by the ESLint 'stats' option.
+ * @author Mara Kiefer <http://github.com/mnkiefer>
+ */
+"use strict";
+
+/**
+ * Start time measurement
+ * @returns {[number, number]} t variable for tracking time
+ */
+function startTime() {
+    return process.hrtime();
+}
+
+/**
+ * End time measurement
+ * @param {[number, number]} t Variable for tracking time
+ * @returns {number} The measured time in milliseconds
+ */
+function endTime(t) {
+    const time = process.hrtime(t);
+
+    return time[0] * 1e3 + time[1] / 1e6;
+}
+
+module.exports = {
+    startTime,
+    endTime
+};

package/lib/shared/string-utils.js

@@ -5,12 +5,6 @@
 
 "use strict";
 
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const Graphemer = require("graphemer").default;
-
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -18,8 +12,8 @@ const Graphemer = require("graphemer").default;
 // eslint-disable-next-line no-control-regex -- intentionally including control characters
 const ASCII_REGEX = /^[\u0000-\u007f]*$/u;
 
-/** @type {Graphemer | undefined} */
-let splitter;
+/** @type {Intl.Segmenter | undefined} */
+let segmenter;
 
 //------------------------------------------------------------------------------
 // Public Interface
@@ -47,11 +41,15 @@ function getGraphemeCount(value) {
         return value.length;
     }
 
-    if (!splitter) {
-        splitter = new Graphemer();
+    segmenter ??= new Intl.Segmenter("en-US"); // en-US locale should be supported everywhere
+    let graphemeCount = 0;
+
+    // eslint-disable-next-line no-unused-vars -- for-of needs a variable
+    for (const unused of segmenter.segment(value)) {
+        graphemeCount++;
     }
 
-    return splitter.countGraphemes(value);
+    return graphemeCount;
 }
 
 module.exports = {

package/lib/shared/types.js

@@ -189,11 +189,45 @@ module.exports = {};
  * @property {number} warningCount Number of warnings for the result.
  * @property {number} fixableErrorCount Number of fixable errors for the result.
  * @property {number} fixableWarningCount Number of fixable warnings for the result.
+ * @property {Stats} [stats] The performance statistics collected with the `stats` flag.
  * @property {string} [source] The source code of the file that was linted.
  * @property {string} [output] The source code of the file that was linted, with as many fixes applied as possible.
  * @property {DeprecatedRuleInfo[]} usedDeprecatedRules The list of used deprecated rules.
  */
 
+/**
+ * Performance statistics
+ * @typedef {Object} Stats
+ * @property {number} fixPasses The number of times ESLint has applied at least one fix after linting.
+ * @property {Times} times The times spent on (parsing, fixing, linting) a file.
+ */
+
+/**
+ * Performance Times for each ESLint pass
+ * @typedef {Object} Times
+ * @property {TimePass[]} passes Time passes
+ */
+
+/**
+ * @typedef {Object} TimePass
+ * @property {ParseTime} parse The parse object containing all parse time information.
+ * @property {Record<string, RuleTime>} [rules] The rules object containing all lint time information for each rule.
+ * @property {FixTime} fix The parse object containing all fix time information.
+ * @property {number} total The total time that is spent on (parsing, fixing, linting) a file.
+ */
+/**
+ * @typedef {Object} ParseTime
+ * @property {number} total The total time that is spent when parsing a file.
+ */
+/**
+ * @typedef {Object} RuleTime
+ * @property {number} total The total time that is spent on a rule.
+ */
+/**
+ * @typedef {Object} FixTime
+ * @property {number} total The total time that is spent on applying fixes to the code.
+ */
+
 /**
  * Information provided when the maximum warning threshold is exceeded.
  * @typedef {Object} MaxWarningsExceeded

package/lib/source-code/source-code.js

@@ -373,6 +373,56 @@ class TraversalStep {
     }
 }
 
+/**
+ * A class to represent a directive comment.
+ */
+class Directive {
+
+    /**
+     * The type of directive.
+     * @type {"disable"|"enable"|"disable-next-line"|"disable-line"}
+     * @readonly
+     */
+    type;
+
+    /**
+     * The node representing the directive.
+     * @type {ASTNode|Comment}
+     * @readonly
+     */
+    node;
+
+    /**
+     * Everything after the "eslint-disable" portion of the directive,
+     * but before the "--" that indicates the justification.
+     * @type {string}
+     * @readonly
+     */
+    value;
+
+    /**
+     * The justification for the directive.
+     * @type {string}
+     * @readonly
+     */
+    justification;
+
+    /**
+     * Creates a new instance.
+     * @param {Object} options The options for the directive.
+     * @param {"disable"|"enable"|"disable-next-line"|"disable-line"} options.type The type of directive.
+     * @param {ASTNode|Comment} options.node The node representing the directive.
+     * @param {string} options.value The value of the directive.
+     * @param {string} options.justification The justification for the directive.
+     */
+    constructor({ type, node, value, justification }) {
+        this.type = type;
+        this.node = node;
+        this.value = value;
+        this.justification = justification;
+    }
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -921,6 +971,84 @@ class SourceCode extends TokenStore {
         return configNodes;
     }
 
+    /**
+     * Returns an all directive nodes that enable or disable rules along with any problems
+     * encountered while parsing the directives.
+     * @returns {{problems:Array<Problem>,directives:Array<Directive>}} Information
+     *      that ESLint needs to further process the directives.
+     */
+    getDisableDirectives() {
+
+        // check the cache first
+        const cachedDirectives = this[caches].get("disableDirectives");
+
+        if (cachedDirectives) {
+            return cachedDirectives;
+        }
+
+        const problems = [];
+        const directives = [];
+
+        this.getInlineConfigNodes().forEach(comment => {
+            const { directivePart, justificationPart } = commentParser.extractDirectiveComment(comment.value);
+
+            // Step 1: Extract the directive text
+            const match = directivesPattern.exec(directivePart);
+
+            if (!match) {
+                return;
+            }
+
+            const directiveText = match[1];
+
+            // Step 2: Extract the directive value
+            const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
+
+            if (comment.type === "Line" && !lineCommentSupported) {
+                return;
+            }
+
+            // Step 3: Validate the directive does not span multiple lines
+            if (directiveText === "eslint-disable-line" && comment.loc.start.line !== comment.loc.end.line) {
+                const message = `${directiveText} comment should not span multiple lines.`;
+
+                problems.push({
+                    ruleId: null,
+                    message,
+                    loc: comment.loc
+                });
+                return;
+            }
+
+            // Step 4: Extract the directive value and create the Directive object
+            const directiveValue = directivePart.slice(match.index + directiveText.length);
+
+            switch (directiveText) {
+                case "eslint-disable":
+                case "eslint-enable":
+                case "eslint-disable-next-line":
+                case "eslint-disable-line": {
+                    const directiveType = directiveText.slice("eslint-".length);
+
+                    directives.push(new Directive({
+                        type: directiveType,
+                        node: comment,
+                        value: directiveValue,
+                        justification: justificationPart
+                    }));
+                }
+
+                // no default
+            }
+        });
+
+        const result = { problems, directives };
+
+        this[caches].set("disableDirectives", result);
+
+        return result;
+    }
+
     /**
      * Applies language options sent in from the core.
      * @param {Object} languageOptions The language options for this run.

package/lib/source-code/token-store/backward-token-cursor.js

@@ -9,7 +9,7 @@
 //------------------------------------------------------------------------------
 
 const Cursor = require("./cursor");
-const utils = require("./utils");
+const { getLastIndex, getFirstIndex } = require("./utils");
 
 //------------------------------------------------------------------------------
 // Exports
@@ -31,8 +31,8 @@ module.exports = class BackwardTokenCursor extends Cursor {
     constructor(tokens, comments, indexMap, startLoc, endLoc) {
         super();
         this.tokens = tokens;
-        this.index = utils.getLastIndex(tokens, indexMap, endLoc);
-        this.indexEnd = utils.getFirstIndex(tokens, indexMap, startLoc);
+        this.index = getLastIndex(tokens, indexMap, endLoc);
+        this.indexEnd = getFirstIndex(tokens, indexMap, startLoc);
     }
 
     /** @inheritdoc */

package/lib/source-code/token-store/cursors.js

@@ -86,5 +86,7 @@ class CursorFactory {
 // Exports
 //------------------------------------------------------------------------------
 
-exports.forward = new CursorFactory(ForwardTokenCursor, ForwardTokenCommentCursor);
-exports.backward = new CursorFactory(BackwardTokenCursor, BackwardTokenCommentCursor);
+module.exports = {
+    forward: new CursorFactory(ForwardTokenCursor, ForwardTokenCommentCursor),
+    backward: new CursorFactory(BackwardTokenCursor, BackwardTokenCommentCursor)
+};

package/lib/source-code/token-store/forward-token-comment-cursor.js

@@ -9,7 +9,7 @@
 //------------------------------------------------------------------------------
 
 const Cursor = require("./cursor");
-const utils = require("./utils");
+const { getFirstIndex, search } = require("./utils");
 
 //------------------------------------------------------------------------------
 // Exports
@@ -32,8 +32,8 @@ module.exports = class ForwardTokenCommentCursor extends Cursor {
         super();
         this.tokens = tokens;
         this.comments = comments;
-        this.tokenIndex = utils.getFirstIndex(tokens, indexMap, startLoc);
-        this.commentIndex = utils.search(comments, startLoc);
+        this.tokenIndex = getFirstIndex(tokens, indexMap, startLoc);
+        this.commentIndex = search(comments, startLoc);
         this.border = endLoc;
     }
 

package/lib/source-code/token-store/forward-token-cursor.js

@@ -9,7 +9,7 @@
 //------------------------------------------------------------------------------
 
 const Cursor = require("./cursor");
-const utils = require("./utils");
+const { getFirstIndex, getLastIndex } = require("./utils");
 
 //------------------------------------------------------------------------------
 // Exports
@@ -31,8 +31,8 @@ module.exports = class ForwardTokenCursor extends Cursor {
     constructor(tokens, comments, indexMap, startLoc, endLoc) {
         super();
         this.tokens = tokens;
-        this.index = utils.getFirstIndex(tokens, indexMap, startLoc);
-        this.indexEnd = utils.getLastIndex(tokens, indexMap, endLoc);
+        this.index = getFirstIndex(tokens, indexMap, startLoc);
+        this.indexEnd = getLastIndex(tokens, indexMap, endLoc);
     }
 
     /** @inheritdoc */