eslint 9.0.0-rc.0 → 9.1.0

package/lib/linter/apply-disable-directives.js

@@ -38,16 +38,16 @@ function compareLocations(itemA, itemB) {
  * @param {Iterable<Directive>} directives Unused directives to be removed.
  * @returns {Directive[][]} Directives grouped by their parent comment.
  */
-function groupByParentComment(directives) {
+function groupByParentDirective(directives) {
     const groups = new Map();
 
     for (const directive of directives) {
-        const { unprocessedDirective: { parentComment } } = directive;
+        const { unprocessedDirective: { parentDirective } } = directive;
 
-        if (groups.has(parentComment)) {
-            groups.get(parentComment).push(directive);
+        if (groups.has(parentDirective)) {
+            groups.get(parentDirective).push(directive);
         } else {
-            groups.set(parentComment, [directive]);
+            groups.set(parentDirective, [directive]);
         }
     }
 
@@ -57,19 +57,19 @@ function groupByParentComment(directives) {
 /**
  * Creates removal details for a set of directives within the same comment.
  * @param {Directive[]} directives Unused directives to be removed.
- * @param {Token} commentToken The backing Comment token.
+ * @param {Token} node The backing Comment token.
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
-function createIndividualDirectivesRemoval(directives, commentToken) {
+function createIndividualDirectivesRemoval(directives, node) {
 
     /*
-     * `commentToken.value` starts right after `//` or `/*`.
+     * `node.value` starts right after `//` or `/*`.
      * All calculated offsets will be relative to this index.
      */
-    const commentValueStart = commentToken.range[0] + "//".length;
+    const commentValueStart = node.range[0] + "//".length;
 
     // Find where the list of rules starts. `\S+` matches with the directive name (e.g. `eslint-disable-line`)
-    const listStartOffset = /^\s*\S+\s+/u.exec(commentToken.value)[0].length;
+    const listStartOffset = /^\s*\S+\s+/u.exec(node.value)[0].length;
 
     /*
      * Get the list text without any surrounding whitespace. In order to preserve the original
@@ -78,7 +78,7 @@ function createIndividualDirectivesRemoval(directives, commentToken) {
      *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
      *                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      */
-    const listText = commentToken.value
+    const listText = node.value
         .slice(listStartOffset) // remove directive name and all whitespace before the list
         .split(/\s-{2,}\s/u)[0] // remove `-- comment`, if it exists
         .trimEnd(); // remove all whitespace after the list
@@ -159,13 +159,13 @@ function createIndividualDirectivesRemoval(directives, commentToken) {
 }
 
 /**
- * Creates a description of deleting an entire unused disable comment.
+ * Creates a description of deleting an entire unused disable directive.
  * @param {Directive[]} directives Unused directives to be removed.
- * @param {Token} commentToken The backing Comment token.
- * @returns {{ description, fix, unprocessedDirective }} Details for later creation of an output Problem.
+ * @param {Token} node The backing Comment token.
+ * @returns {{ description, fix, unprocessedDirective }} Details for later creation of an output problem.
  */
-function createCommentRemoval(directives, commentToken) {
-    const { range } = commentToken;
+function createDirectiveRemoval(directives, node) {
+    const { range } = node;
     const ruleIds = directives.filter(directive => directive.ruleId).map(directive => `'${directive.ruleId}'`);
 
     return {
@@ -186,20 +186,20 @@ function createCommentRemoval(directives, commentToken) {
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
 function processUnusedDirectives(allDirectives) {
-    const directiveGroups = groupByParentComment(allDirectives);
+    const directiveGroups = groupByParentDirective(allDirectives);
 
     return directiveGroups.flatMap(
         directives => {
-            const { parentComment } = directives[0].unprocessedDirective;
-            const remainingRuleIds = new Set(parentComment.ruleIds);
+            const { parentDirective } = directives[0].unprocessedDirective;
+            const remainingRuleIds = new Set(parentDirective.ruleIds);
 
             for (const directive of directives) {
                 remainingRuleIds.delete(directive.ruleId);
             }
 
             return remainingRuleIds.size
-                ? createIndividualDirectivesRemoval(directives, parentComment.commentToken)
-                : [createCommentRemoval(directives, parentComment.commentToken)];
+                ? createIndividualDirectivesRemoval(directives, parentDirective.node)
+                : [createDirectiveRemoval(directives, parentDirective.node)];
         }
     );
 }
@@ -372,7 +372,7 @@ function applyDirectives(options) {
 
     const unusedDirectives = processed
         .map(({ description, fix, unprocessedDirective }) => {
-            const { parentComment, type, line, column } = unprocessedDirective;
+            const { parentDirective, type, line, column } = unprocessedDirective;
 
             let message;
 
@@ -388,8 +388,8 @@ function applyDirectives(options) {
             return {
                 ruleId: null,
                 message,
-                line: type === "disable-next-line" ? parentComment.commentToken.loc.start.line : line,
-                column: type === "disable-next-line" ? parentComment.commentToken.loc.start.column + 1 : column,
+                line: type === "disable-next-line" ? parentDirective.node.loc.start.line : line,
+                column: type === "disable-next-line" ? parentDirective.node.loc.start.column + 1 : column,
                 severity: options.reportUnusedDisableDirectives === "warn" ? 1 : 2,
                 nodeType: null,
                 ...options.disableFixes ? {} : { fix }

package/lib/linter/linter.js

@@ -41,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");
@@ -68,6 +69,7 @@ const STEP_KIND_CALL = 2;
 /** @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 */
 /**
@@ -92,6 +94,7 @@ const STEP_KIND_CALL = 2;
  * @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.
  */
 
@@ -270,23 +273,21 @@ function createLintingProblem(options) {
  * Creates a collection of disable directives from a comment
  * @param {Object} options to create disable directives
  * @param {("disable"|"enable"|"disable-line"|"disable-next-line")} options.type The type of directive comment
- * @param {token} options.commentToken The Comment token
  * @param {string} options.value The value after the directive in the comment
  * comment specified no specific rules, so it applies to all rules (e.g. `eslint-disable`)
  * @param {string} options.justification The justification of the directive
- * @param {function(string): {create: Function}} options.ruleMapper A map from rule IDs to defined rules
+ * @param {ASTNode|token} options.node The Comment node/token.
+ * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules
  * @returns {Object} Directives and problems from the comment
  */
-function createDisableDirectives(options) {
-    const { commentToken, type, value, justification, ruleMapper } = options;
+function createDisableDirectives({ type, value, justification, node }, ruleMapper) {
     const ruleIds = Object.keys(commentParser.parseListConfig(value));
     const directiveRules = ruleIds.length ? ruleIds : [null];
     const result = {
         directives: [], // valid disable directives
         directiveProblems: [] // problems in directives
     };
-
-    const parentComment = { commentToken, ruleIds };
+    const parentDirective = { node, ruleIds };
 
     for (const ruleId of directiveRules) {
 
@@ -294,25 +295,25 @@ function createDisableDirectives(options) {
         if (ruleId === null || !!ruleMapper(ruleId)) {
             if (type === "disable-next-line") {
                 result.directives.push({
-                    parentComment,
+                    parentDirective,
                     type,
-                    line: commentToken.loc.end.line,
-                    column: commentToken.loc.end.column + 1,
+                    line: node.loc.end.line,
+                    column: node.loc.end.column + 1,
                     ruleId,
                     justification
                 });
             } else {
                 result.directives.push({
-                    parentComment,
+                    parentDirective,
                     type,
-                    line: commentToken.loc.start.line,
-                    column: commentToken.loc.start.column + 1,
+                    line: node.loc.start.line,
+                    column: node.loc.start.column + 1,
                     ruleId,
                     justification
                 });
             }
         } else {
-            result.directiveProblems.push(createLintingProblem({ ruleId, loc: commentToken.loc }));
+            result.directiveProblems.push(createLintingProblem({ ruleId, loc: node.loc }));
         }
     }
     return result;
@@ -385,8 +386,12 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
             case "eslint-disable-next-line":
             case "eslint-disable-line": {
                 const directiveType = directiveText.slice("eslint-".length);
-                const options = { commentToken: comment, type: directiveType, value: directiveValue, justification: justificationPart, ruleMapper };
-                const { directives, directiveProblems } = createDisableDirectives(options);
+                const { directives, directiveProblems } = createDisableDirectives({
+                    type: directiveType,
+                    value: directiveValue,
+                    justification: justificationPart,
+                    node: comment
+                }, ruleMapper);
 
                 disableDirectives.push(...directives);
                 problems.push(...directiveProblems);
@@ -540,53 +545,21 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
  * A collection of the directive comments that were found, along with any problems that occurred when parsing
  */
 function getDirectiveCommentsForFlatConfig(sourceCode, ruleMapper) {
-    const problems = [];
     const disableDirectives = [];
+    const problems = [];
 
-    sourceCode.getInlineConfigNodes().filter(token => token.type !== "Shebang").forEach(comment => {
-        const { directivePart, justificationPart } = commentParser.extractDirectiveComment(comment.value);
-
-        const match = directivesPattern.exec(directivePart);
-
-        if (!match) {
-            return;
-        }
-        const directiveText = match[1];
-        const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
-
-        if (comment.type === "Line" && !lineCommentSupported) {
-            return;
-        }
-
-        if (directiveText === "eslint-disable-line" && comment.loc.start.line !== comment.loc.end.line) {
-            const message = `${directiveText} comment should not span multiple lines.`;
-
-            problems.push(createLintingProblem({
-                ruleId: null,
-                message,
-                loc: comment.loc
-            }));
-            return;
-        }
-
-        const directiveValue = directivePart.slice(match.index + directiveText.length);
+    const {
+        directives: directivesSources,
+        problems: directivesProblems
+    } = sourceCode.getDisableDirectives();
 
-        switch (directiveText) {
-            case "eslint-disable":
-            case "eslint-enable":
-            case "eslint-disable-next-line":
-            case "eslint-disable-line": {
-                const directiveType = directiveText.slice("eslint-".length);
-                const options = { commentToken: comment, type: directiveType, value: directiveValue, justification: justificationPart, ruleMapper };
-                const { directives, directiveProblems } = createDisableDirectives(options);
+    problems.push(...directivesProblems.map(createLintingProblem));
 
-                disableDirectives.push(...directives);
-                problems.push(...directiveProblems);
-                break;
-            }
+    directivesSources.forEach(directive => {
+        const { directives, directiveProblems } = createDisableDirectives(directive, ruleMapper);
 
-            // no default
-        }
+        disableDirectives.push(...directives);
+        problems.push(...directiveProblems);
     });
 
     return {
@@ -736,6 +709,7 @@ function normalizeVerifyOptions(providedOptions, config) {
             : null,
         reportUnusedDisableDirectives,
         disableFixes: Boolean(providedOptions.disableFixes),
+        stats: providedOptions.stats,
         ruleFilter
     };
 }
@@ -825,6 +799,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
@@ -986,10 +990,13 @@ 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();
 
     // must happen first to assign all node.parent properties
@@ -1088,7 +1095,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
@@ -1098,7 +1112,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;
@@ -1112,9 +1134,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,
@@ -1236,7 +1257,6 @@ function assertEslintrcConfig(linter) {
     }
 }
 
-
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -1342,12 +1362,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];
             }
@@ -1398,7 +1431,9 @@ class Linter {
                 options.disableFixes,
                 slots.cwd,
                 providedOptions.physicalFilename,
-                null
+                null,
+                options.stats,
+                slots
             );
         } catch (err) {
             err.message += `\nOccurred while linting ${options.filename}`;
@@ -1626,12 +1661,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];
             }
@@ -1841,7 +1888,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}`;
@@ -2081,6 +2130,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
@@ -2157,6 +2222,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:
@@ -2167,15 +2233,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.
@@ -2190,6 +2287,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
@@ -2200,7 +2304,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;
         };
     }