eslint 9.0.0-beta.2 → 9.0.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/no-useless-return.js

@@ -146,7 +146,9 @@ module.exports = {
                     continue;
                 }
 
-                uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
+                if (segmentInfoMap.has(segment)) {
+                    uselessReturns.push(...segmentInfoMap.get(segment).uselessReturns);
+                }
             }
 
             return uselessReturns;
@@ -182,6 +184,10 @@ module.exports = {
 
             const info = segmentInfoMap.get(segment);
 
+            if (!info) {
+                return;
+            }
+
             info.uselessReturns = info.uselessReturns.filter(node => {
                 if (scopeInfo.traversedTryBlockStatements && scopeInfo.traversedTryBlockStatements.length > 0) {
                     const returnInitialRange = node.range[0];
@@ -275,7 +281,6 @@ module.exports = {
              * NOTE: This event is notified for only reachable segments.
              */
             onCodePathSegmentStart(segment) {
-
                 scopeInfo.currentSegments.add(segment);
 
                 const info = {

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/rules/utils/lazy-loading-rule-map.js

@@ -6,7 +6,7 @@
 
 const debug = require("debug")("eslint:rules");
 
-/** @typedef {import("./types").Rule} Rule */
+/** @typedef {import("../../shared/types").Rule} Rule */
 
 /**
  * The `Map` object that loads each rule when it's accessed.

package/lib/rules/utils/unicode/index.js

@@ -3,9 +3,14 @@
  */
 "use strict";
 
+const isCombiningCharacter = require("./is-combining-character");
+const isEmojiModifier = require("./is-emoji-modifier");
+const isRegionalIndicatorSymbol = require("./is-regional-indicator-symbol");
+const isSurrogatePair = require("./is-surrogate-pair");
+
 module.exports = {
-    isCombiningCharacter: require("./is-combining-character"),
-    isEmojiModifier: require("./is-emoji-modifier"),
-    isRegionalIndicatorSymbol: require("./is-regional-indicator-symbol"),
-    isSurrogatePair: require("./is-surrogate-pair")
+    isCombiningCharacter,
+    isEmojiModifier,
+    isRegionalIndicatorSymbol,
+    isSurrogatePair
 };

package/lib/shared/runtime-info.js

@@ -162,6 +162,7 @@ function version() {
 //------------------------------------------------------------------------------
 
 module.exports = {
+    __esModule: true, // Indicate intent for imports, remove ambiguity for Knip (see: https://github.com/eslint/eslint/pull/18005#discussion_r1484422616)
     environment,
     version
 };

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/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/index.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const SourceCode = require("./source-code");
+
 module.exports = {
-    SourceCode: require("./source-code")
+    SourceCode
 };