eslint 9.0.0-beta.2 → 9.0.0

package/lib/linter/linter.js

@@ -30,7 +30,6 @@ const
     } = require("@eslint/eslintrc/universal"),
     Traverser = require("../shared/traverser"),
     { SourceCode } = require("../source-code"),
-    CodePathAnalyzer = require("./code-path-analysis/code-path-analyzer"),
     applyDisableDirectives = require("./apply-disable-directives"),
     ConfigCommentParser = require("./config-comment-parser"),
     NodeEventGenerator = require("./node-event-generator"),
@@ -42,6 +41,7 @@ const
     ruleReplacements = require("../../conf/replacements.json");
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
 const { FlatConfigArray } = require("../config/flat-config-array");
+const { startTime, endTime } = require("../shared/stats");
 const { RuleValidator } = require("../config/rule-validator");
 const { assertIsRuleSeverity } = require("../config/flat-config-schema");
 const { normalizeSeverityToString } = require("../shared/severity");
@@ -53,13 +53,13 @@ const commentParser = new ConfigCommentParser();
 const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } };
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 const { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
+const STEP_KIND_VISIT = 1;
+const STEP_KIND_CALL = 2;
 
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 
-/** @typedef {InstanceType<import("../cli-engine/config-array").ConfigArray>} ConfigArray */
-/** @typedef {InstanceType<import("../cli-engine/config-array").ExtractedConfig>} ExtractedConfig */
 /** @typedef {import("../shared/types").ConfigData} ConfigData */
 /** @typedef {import("../shared/types").Environment} Environment */
 /** @typedef {import("../shared/types").GlobalConf} GlobalConf */
@@ -69,6 +69,7 @@ const { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
 /** @typedef {import("../shared/types").LanguageOptions} LanguageOptions */
 /** @typedef {import("../shared/types").Processor} Processor */
 /** @typedef {import("../shared/types").Rule} Rule */
+/** @typedef {import("../shared/types").Times} Times */
 
 /* eslint-disable jsdoc/valid-types -- https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/4#issuecomment-778805577 */
 /**
@@ -93,6 +94,7 @@ const { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
  * @property {SourceCode|null} lastSourceCode The `SourceCode` instance that the last `verify()` call used.
  * @property {SuppressedLintMessage[]} lastSuppressedMessages The `SuppressedLintMessage[]` instance that the last `verify()` call produced.
  * @property {Map<string, Parser>} parserMap The loaded parsers.
+ * @property {Times} times The times spent on applying a rule to a file (see `stats` option).
  * @property {Rules} ruleMap The loaded rules.
  */
 
@@ -737,6 +739,7 @@ function normalizeVerifyOptions(providedOptions, config) {
             : null,
         reportUnusedDisableDirectives,
         disableFixes: Boolean(providedOptions.disableFixes),
+        stats: providedOptions.stats,
         ruleFilter
     };
 }
@@ -826,6 +829,36 @@ function stripUnicodeBOM(text) {
     return text;
 }
 
+/**
+ * Store time measurements in map
+ * @param {number} time Time measurement
+ * @param {Object} timeOpts Options relating which time was measured
+ * @param {WeakMap<Linter, LinterInternalSlots>} slots Linter internal slots map
+ * @returns {void}
+ */
+function storeTime(time, timeOpts, slots) {
+    const { type, key } = timeOpts;
+
+    if (!slots.times) {
+        slots.times = { passes: [{}] };
+    }
+
+    const passIndex = slots.fixPasses;
+
+    if (passIndex > slots.times.passes.length - 1) {
+        slots.times.passes.push({});
+    }
+
+    if (key) {
+        slots.times.passes[passIndex][type] ??= {};
+        slots.times.passes[passIndex][type][key] ??= { total: 0 };
+        slots.times.passes[passIndex][type][key].total += time;
+    } else {
+        slots.times.passes[passIndex][type] ??= { total: 0 };
+        slots.times.passes[passIndex][type].total += time;
+    }
+}
+
 /**
  * Get the options for a rule (not including severity), if any
  * @param {Array|number} ruleConfig rule configuration
@@ -987,23 +1020,17 @@ function createRuleListeners(rule, ruleContext) {
  * @param {string | undefined} cwd cwd of the cli
  * @param {string} physicalFilename The full path of the file on disk without any code block information
  * @param {Function} ruleFilter A predicate function to filter which rules should be executed.
+ * @param {boolean} stats If true, stats are collected appended to the result
+ * @param {WeakMap<Linter, LinterInternalSlots>} slots InternalSlotsMap of linter
  * @returns {LintMessage[]} An array of reported problems
+ * @throws {Error} If traversal into a node fails.
  */
-function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageOptions, settings, filename, disableFixes, cwd, physicalFilename, ruleFilter) {
+function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageOptions, settings, filename, disableFixes, cwd, physicalFilename, ruleFilter,
+    stats, slots) {
     const emitter = createEmitter();
-    const nodeQueue = [];
-    let currentNode = sourceCode.ast;
-
-    Traverser.traverse(sourceCode.ast, {
-        enter(node, parent) {
-            node.parent = parent;
-            nodeQueue.push({ isEntering: true, node });
-        },
-        leave(node) {
-            nodeQueue.push({ isEntering: false, node });
-        },
-        visitorKeys: sourceCode.visitorKeys
-    });
+
+    // must happen first to assign all node.parent properties
+    const eventQueue = sourceCode.traverse();
 
     /*
      * Create a frozen object with the ruleContext properties and methods that are shared by all rules.
@@ -1098,7 +1125,14 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
             )
         );
 
-        const ruleListeners = timing.enabled ? timing.time(ruleId, createRuleListeners)(rule, ruleContext) : createRuleListeners(rule, ruleContext);
+        const ruleListenersReturn = (timing.enabled || stats)
+            ? timing.time(ruleId, createRuleListeners, stats)(rule, ruleContext) : createRuleListeners(rule, ruleContext);
+
+        const ruleListeners = stats ? ruleListenersReturn.result : ruleListenersReturn;
+
+        if (stats) {
+            storeTime(ruleListenersReturn.tdiff, { type: "rules", key: ruleId }, slots);
+        }
 
         /**
          * Include `ruleId` in error logs
@@ -1108,7 +1142,15 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
         function addRuleErrorHandler(ruleListener) {
             return function ruleErrorHandler(...listenerArgs) {
                 try {
-                    return ruleListener(...listenerArgs);
+                    const ruleListenerReturn = ruleListener(...listenerArgs);
+
+                    const ruleListenerResult = stats ? ruleListenerReturn.result : ruleListenerReturn;
+
+                    if (stats) {
+                        storeTime(ruleListenerReturn.tdiff, { type: "rules", key: ruleId }, slots);
+                    }
+
+                    return ruleListenerResult;
                 } catch (e) {
                     e.ruleId = ruleId;
                     throw e;
@@ -1122,9 +1164,8 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
 
         // add all the selectors from the rule as listeners
         Object.keys(ruleListeners).forEach(selector => {
-            const ruleListener = timing.enabled
-                ? timing.time(ruleId, ruleListeners[selector])
-                : ruleListeners[selector];
+            const ruleListener = (timing.enabled || stats)
+                ? timing.time(ruleId, ruleListeners[selector], stats) : ruleListeners[selector];
 
             emitter.on(
                 selector,
@@ -1133,25 +1174,34 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
         });
     });
 
-    // only run code path analyzer if the top level node is "Program", skip otherwise
-    const eventGenerator = nodeQueue[0].node.type === "Program"
-        ? new CodePathAnalyzer(new NodeEventGenerator(emitter, { visitorKeys: sourceCode.visitorKeys, fallback: Traverser.getKeys }))
-        : new NodeEventGenerator(emitter, { visitorKeys: sourceCode.visitorKeys, fallback: Traverser.getKeys });
+    const eventGenerator = new NodeEventGenerator(emitter, { visitorKeys: sourceCode.visitorKeys, fallback: Traverser.getKeys });
 
-    nodeQueue.forEach(traversalInfo => {
-        currentNode = traversalInfo.node;
+    for (const step of eventQueue) {
+        switch (step.kind) {
+            case STEP_KIND_VISIT: {
+                try {
+                    if (step.phase === 1) {
+                        eventGenerator.enterNode(step.target);
+                    } else {
+                        eventGenerator.leaveNode(step.target);
+                    }
+                } catch (err) {
+                    err.currentNode = step.target;
+                    throw err;
+                }
+                break;
+            }
 
-        try {
-            if (traversalInfo.isEntering) {
-                eventGenerator.enterNode(currentNode);
-            } else {
-                eventGenerator.leaveNode(currentNode);
+            case STEP_KIND_CALL: {
+                emitter.emit(step.target, ...step.args);
+                break;
             }
-        } catch (err) {
-            err.currentNode = currentNode;
-            throw err;
+
+            default:
+                throw new Error(`Invalid traversal step found: "${step.type}".`);
         }
-    });
+
+    }
 
     return lintingProblems;
 }
@@ -1237,7 +1287,6 @@ function assertEslintrcConfig(linter) {
     }
 }
 
-
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -1343,12 +1392,25 @@ class Linter {
         });
 
         if (!slots.lastSourceCode) {
+            let t;
+
+            if (options.stats) {
+                t = startTime();
+            }
+
             const parseResult = parse(
                 text,
                 languageOptions,
                 options.filename
             );
 
+            if (options.stats) {
+                const time = endTime(t);
+                const timeOpts = { type: "parse" };
+
+                storeTime(time, timeOpts, slots);
+            }
+
             if (!parseResult.success) {
                 return [parseResult.error];
             }
@@ -1399,7 +1461,9 @@ class Linter {
                 options.disableFixes,
                 slots.cwd,
                 providedOptions.physicalFilename,
-                null
+                null,
+                options.stats,
+                slots
             );
         } catch (err) {
             err.message += `\nOccurred while linting ${options.filename}`;
@@ -1627,12 +1691,24 @@ class Linter {
         const settings = config.settings || {};
 
         if (!slots.lastSourceCode) {
+            let t;
+
+            if (options.stats) {
+                t = startTime();
+            }
+
             const parseResult = parse(
                 text,
                 languageOptions,
                 options.filename
             );
 
+            if (options.stats) {
+                const time = endTime(t);
+
+                storeTime(time, { type: "parse" }, slots);
+            }
+
             if (!parseResult.success) {
                 return [parseResult.error];
             }
@@ -1842,7 +1918,9 @@ class Linter {
                 options.disableFixes,
                 slots.cwd,
                 providedOptions.physicalFilename,
-                options.ruleFilter
+                options.ruleFilter,
+                options.stats,
+                slots
             );
         } catch (err) {
             err.message += `\nOccurred while linting ${options.filename}`;
@@ -2082,6 +2160,22 @@ class Linter {
         return internalSlotsMap.get(this).lastSourceCode;
     }
 
+    /**
+     * Gets the times spent on (parsing, fixing, linting) a file.
+     * @returns {LintTimes} The times.
+     */
+    getTimes() {
+        return internalSlotsMap.get(this).times ?? { passes: [] };
+    }
+
+    /**
+     * Gets the number of autofix passes that were made in the last run.
+     * @returns {number} The number of autofix passes.
+     */
+    getFixPassCount() {
+        return internalSlotsMap.get(this).fixPasses ?? 0;
+    }
+
     /**
      * Gets the list of SuppressedLintMessage produced in the last running.
      * @returns {SuppressedLintMessage[]} The list of SuppressedLintMessage
@@ -2158,6 +2252,7 @@ class Linter {
             currentText = text;
         const debugTextDescription = options && options.filename || `${text.slice(0, 10)}...`;
         const shouldFix = options && typeof options.fix !== "undefined" ? options.fix : true;
+        const stats = options?.stats;
 
         /**
          * This loop continues until one of the following is true:
@@ -2168,15 +2263,46 @@ class Linter {
          * That means anytime a fix is successfully applied, there will be another pass.
          * Essentially, guaranteeing a minimum of two passes.
          */
+        const slots = internalSlotsMap.get(this);
+
+        // Remove lint times from the last run.
+        if (stats) {
+            delete slots.times;
+            slots.fixPasses = 0;
+        }
+
         do {
             passNumber++;
+            let tTotal;
+
+            if (stats) {
+                tTotal = startTime();
+            }
 
             debug(`Linting code for ${debugTextDescription} (pass ${passNumber})`);
             messages = this.verify(currentText, config, options);
 
             debug(`Generating fixed text for ${debugTextDescription} (pass ${passNumber})`);
+            let t;
+
+            if (stats) {
+                t = startTime();
+            }
+
             fixedResult = SourceCodeFixer.applyFixes(currentText, messages, shouldFix);
 
+            if (stats) {
+
+                if (fixedResult.fixed) {
+                    const time = endTime(t);
+
+                    storeTime(time, { type: "fix" }, slots);
+                    slots.fixPasses++;
+                } else {
+                    storeTime(0, { type: "fix" }, slots);
+                }
+            }
+
             /*
              * stop if there are any syntax errors.
              * 'fixedResult.output' is a empty string.
@@ -2191,6 +2317,13 @@ class Linter {
             // update to use the fixed output instead of the original text
             currentText = fixedResult.output;
 
+            if (stats) {
+                tTotal = endTime(tTotal);
+                const passIndex = slots.times.passes.length - 1;
+
+                slots.times.passes[passIndex].total = tTotal;
+            }
+
         } while (
             fixedResult.fixed &&
             passNumber < MAX_AUTOFIX_PASSES
@@ -2201,7 +2334,18 @@ class Linter {
          * the most up-to-date information.
          */
         if (fixedResult.fixed) {
+            let tTotal;
+
+            if (stats) {
+                tTotal = startTime();
+            }
+
             fixedResult.messages = this.verify(currentText, config, options);
+
+            if (stats) {
+                storeTime(0, { type: "fix" }, slots);
+                slots.times.passes.at(-1).total = endTime(tTotal);
+            }
         }
 
         // ensure the last result properly reflects if fixes were done

package/lib/linter/timing.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { startTime, endTime } = require("../shared/stats");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -128,21 +130,27 @@ module.exports = (function() {
      * Time the run
      * @param {any} key key from the data object
      * @param {Function} fn function to be called
+     * @param {boolean} stats if 'stats' is true, return the result and the time difference
      * @returns {Function} function to be executed
      * @private
      */
-    function time(key, fn) {
-        if (typeof data[key] === "undefined") {
-            data[key] = 0;
-        }
+    function time(key, fn, stats) {
 
         return function(...args) {
-            let t = process.hrtime();
+
+            const t = startTime();
             const result = fn(...args);
+            const tdiff = endTime(t);
+
+            if (enabled) {
+                if (typeof data[key] === "undefined") {
+                    data[key] = 0;
+                }
+
+                data[key] += tdiff;
+            }
 
-            t = process.hrtime(t);
-            data[key] += t[0] * 1e3 + t[1] / 1e6;
-            return result;
+            return stats ? { result, tdiff } : result;
         };
     }
 

package/lib/options.js

@@ -60,6 +60,7 @@ const optionator = require("optionator");
  * @property {boolean} [passOnNoPatterns=false] When set to true, missing patterns cause
  *      the linting operation to short circuit and not report any failures.
  * @property {string[]} _ Positional filenames or patterns
+ * @property {boolean} [stats] Report additional statistics
  */
 
 //------------------------------------------------------------------------------
@@ -103,6 +104,16 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let inspectConfigFlag;
+
+    if (usingFlatConfig) {
+        inspectConfigFlag = {
+            option: "inspect-config",
+            type: "Boolean",
+            description: "Open the config inspector with the current configuration"
+        };
+    }
+
     let extFlag;
 
     if (!usingFlatConfig) {
@@ -143,6 +154,17 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let statsFlag;
+
+    if (usingFlatConfig) {
+        statsFlag = {
+            option: "stats",
+            type: "Boolean",
+            default: "false",
+            description: "Add statistics to the lint report"
+        };
+    }
+
     let warnIgnoredFlag;
 
     if (usingFlatConfig) {
@@ -173,6 +195,7 @@ module.exports = function(usingFlatConfig) {
                     ? "Use this configuration instead of eslint.config.js, eslint.config.mjs, or eslint.config.cjs"
                     : "Use this configuration, overriding .eslintrc.* config options if present"
             },
+            inspectConfigFlag,
             envFlag,
             extFlag,
             {
@@ -400,7 +423,8 @@ module.exports = function(usingFlatConfig) {
                 option: "print-config",
                 type: "path::String",
                 description: "Print the configuration for the given file"
-            }
+            },
+            statsFlag
         ].filter(value => !!value)
     });
 };

package/lib/rule-tester/index.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const RuleTester = require("./rule-tester");
+
 module.exports = {
-    RuleTester: require("./rule-tester")
+    RuleTester
 };

package/lib/rule-tester/rule-tester.js

@@ -136,6 +136,15 @@ const suggestionObjectParameters = new Set([
 ]);
 const friendlySuggestionObjectParameterList = `[${[...suggestionObjectParameters].map(key => `'${key}'`).join(", ")}]`;
 
+/*
+ * Ignored test case properties when checking for test case duplicates.
+ */
+const duplicationIgnoredParameters = new Set([
+    "name",
+    "errors",
+    "output"
+]);
+
 const forbiddenMethods = [
     "applyInlineConfig",
     "applyLanguageOptions",
@@ -848,7 +857,7 @@ class RuleTester {
 
         /**
          * Check if this test case is a duplicate of one we have seen before.
-         * @param {Object} item test case object
+         * @param {string|Object} item test case object
          * @param {Set<string>} seenTestCases set of serialized test cases we have seen so far (managed by this function)
          * @returns {void}
          * @private
@@ -863,7 +872,14 @@ class RuleTester {
                 return;
             }
 
-            const serializedTestCase = stringify(item);
+            const normalizedItem = typeof item === "string" ? { code: item } : item;
+            const serializedTestCase = stringify(normalizedItem, {
+                replacer(key, value) {
+
+                    // "this" is the currently stringified object --> only ignore top-level properties
+                    return (normalizedItem !== this || !duplicationIgnoredParameters.has(key)) ? value : void 0;
+                }
+            });
 
             assert(
                 !seenTestCases.has(serializedTestCase),

package/lib/rules/camelcase.js

@@ -47,11 +47,9 @@ module.exports = {
                     },
                     allow: {
                         type: "array",
-                        items: [
-                            {
-                                type: "string"
-                            }
-                        ],
+                        items: {
+                            type: "string"
+                        },
                         minItems: 0,
                         uniqueItems: true
                     }