eslint 9.9.0 → 9.10.0

package/lib/eslint/eslint.js

@@ -646,6 +646,23 @@ function createExtraneousResultsError() {
     return new TypeError("Results object was not created from this ESLint instance.");
 }
 
+/**
+ * Creates a fixer function based on the provided fix, fixTypesSet, and config.
+ * @param {Function|boolean} fix The original fix option.
+ * @param {Set<string>} fixTypesSet A set of fix types to filter messages for fixing.
+ * @param {FlatConfig} config The config for the file that generated the message.
+ * @returns {Function|boolean} The fixer function or the original fix value.
+ */
+function getFixerForFixTypes(fix, fixTypesSet, config) {
+    if (!fix || !fixTypesSet) {
+        return fix;
+    }
+
+    const originalFix = (typeof fix === "function") ? fix : () => true;
+
+    return message => shouldMessageBeFixed(message, config, fixTypesSet) && originalFix(message);
+}
+
 //-----------------------------------------------------------------------------
 // Main API
 //-----------------------------------------------------------------------------
@@ -994,16 +1011,7 @@ class ESLint {
 
 
                 // set up fixer for fixTypes if necessary
-                let fixer = fix;
-
-                if (fix && fixTypesSet) {
-
-                    // save original value of options.fix in case it's a function
-                    const originalFix = (typeof fix === "function")
-                        ? fix : () => true;
-
-                    fixer = message => shouldMessageBeFixed(message, config, fixTypesSet) && originalFix(message);
-                }
+                const fixer = getFixerForFixTypes(fix, fixTypesSet, config);
 
                 return retrier.retry(() => fs.readFile(filePath, { encoding: "utf8", signal: controller.signal })
                     .then(text => {
@@ -1108,13 +1116,18 @@ class ESLint {
             allowInlineConfig,
             cwd,
             fix,
+            fixTypes,
             warnIgnored: constructorWarnIgnored,
             ruleFilter,
             stats
         } = eslintOptions;
         const results = [];
         const startTime = Date.now();
+        const fixTypesSet = fixTypes ? new Set(fixTypes) : null;
         const resolvedFilename = path.resolve(cwd, filePath || "__placeholder__.js");
+        const config = configs.getConfig(resolvedFilename);
+
+        const fixer = getFixerForFixTypes(fix, fixTypesSet, config);
 
         // Clear the last used config arrays.
         if (resolvedFilename && await this.isPathIgnored(resolvedFilename)) {
@@ -1133,7 +1146,7 @@ class ESLint {
                 filePath: resolvedFilename.endsWith("__placeholder__.js") ? "<text>" : resolvedFilename,
                 configs,
                 cwd,
-                fix,
+                fix: fixer,
                 allowInlineConfig,
                 ruleFilter,
                 stats,

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

@@ -20,7 +20,7 @@ const
 
     CodePathAnalyzer = require("../../../linter/code-path-analysis/code-path-analyzer"),
     createEmitter = require("../../../linter/safe-emitter"),
-    ConfigCommentParser = require("../../../linter/config-comment-parser"),
+    { ConfigCommentParser, VisitNodeStep, CallMethodStep } = require("@eslint/plugin-kit"),
 
     eslintScope = require("eslint-scope");
 
@@ -316,65 +316,6 @@ function markExportedVariables(globalScope, variables) {
 
 }
 
-const STEP_KIND = {
-    visit: 1,
-    call: 2
-};
-
-/**
- * A class to represent a step in the traversal process.
- */
-class TraversalStep {
-
-    /**
-     * The type of the step.
-     * @type {string}
-     */
-    type;
-
-    /**
-     * The kind of the step. Represents the same data as the `type` property
-     * but it's a number for performance.
-     * @type {number}
-     */
-    kind;
-
-    /**
-     * The target of the step.
-     * @type {ASTNode|string}
-     */
-    target;
-
-    /**
-     * The phase of the step.
-     * @type {number|undefined}
-     */
-    phase;
-
-    /**
-     * The arguments of the step.
-     * @type {Array<any>}
-     */
-    args;
-
-    /**
-     * Creates a new instance.
-     * @param {Object} options The options for the step.
-     * @param {string} options.type The type of the step.
-     * @param {ASTNode|string} options.target The target of the step.
-     * @param {number|undefined} [options.phase] The phase of the step.
-     * @param {Array<any>} options.args The arguments of the step.
-     * @returns {void}
-     */
-    constructor({ type, target, phase, args }) {
-        this.type = type;
-        this.kind = STEP_KIND[type];
-        this.target = target;
-        this.phase = phase;
-        this.args = args;
-    }
-}
-
 /**
  * A class to represent a directive comment.
  * @implements {IDirective}
@@ -1002,16 +943,18 @@ class SourceCode extends TokenStore {
                 return false;
             }
 
-            const { directivePart } = commentParser.extractDirectiveComment(comment.value);
+            const directive = commentParser.parseDirective(comment.value);
 
-            const directiveMatch = directivesPattern.exec(directivePart);
+            if (!directive) {
+                return false;
+            }
 
-            if (!directiveMatch) {
+            if (!directivesPattern.test(directive.label)) {
                 return false;
             }
 
             // only certain comment types are supported as line comments
-            return comment.type !== "Line" || !!/^eslint-disable-(next-)?line$/u.test(directiveMatch[1]);
+            return comment.type !== "Line" || !!/^eslint-disable-(next-)?line$/u.test(directive.label);
         });
 
         this[caches].set("configNodes", configNodes);
@@ -1038,27 +981,24 @@ class SourceCode extends TokenStore {
         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 1: Parse the directive
+            const {
+                label,
+                value,
+                justification: justificationPart
+            } = commentParser.parseDirective(comment.value);
 
             // Step 2: Extract the directive value
-            const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
+            const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(label);
 
             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.`;
+            if (label === "eslint-disable-line" && comment.loc.start.line !== comment.loc.end.line) {
+                const message = `${label} comment should not span multiple lines.`;
 
                 problems.push({
                     ruleId: null,
@@ -1069,19 +1009,17 @@ class SourceCode extends TokenStore {
             }
 
             // Step 4: Extract the directive value and create the Directive object
-            const directiveValue = directivePart.slice(match.index + directiveText.length);
-
-            switch (directiveText) {
+            switch (label) {
                 case "eslint-disable":
                 case "eslint-enable":
                 case "eslint-disable-next-line":
                 case "eslint-disable-line": {
-                    const directiveType = directiveText.slice("eslint-".length);
+                    const directiveType = label.slice("eslint-".length);
 
                     directives.push(new Directive({
                         type: directiveType,
                         node: comment,
-                        value: directiveValue,
+                        value,
                         justification: justificationPart
                     }));
                 }
@@ -1136,20 +1074,20 @@ class SourceCode extends TokenStore {
 
         this.getInlineConfigNodes().forEach(comment => {
 
-            const { directiveText, directiveValue } = commentParser.parseDirective(comment);
+            const { label, value } = commentParser.parseDirective(comment.value);
 
-            switch (directiveText) {
+            switch (label) {
                 case "exported":
-                    Object.assign(exportedVariables, commentParser.parseListConfig(directiveValue, comment));
+                    Object.assign(exportedVariables, commentParser.parseListConfig(value));
                     break;
 
                 case "globals":
                 case "global":
-                    for (const [id, { value }] of Object.entries(commentParser.parseStringConfig(directiveValue, comment))) {
+                    for (const [id, idSetting] of Object.entries(commentParser.parseStringConfig(value))) {
                         let normalizedValue;
 
                         try {
-                            normalizedValue = normalizeConfigGlobal(value);
+                            normalizedValue = normalizeConfigGlobal(idSetting);
                         } catch (err) {
                             problems.push({
                                 ruleId: null,
@@ -1172,9 +1110,9 @@ class SourceCode extends TokenStore {
                     break;
 
                 case "eslint": {
-                    const parseResult = commentParser.parseJsonConfig(directiveValue);
+                    const parseResult = commentParser.parseJSONLikeConfig(value);
 
-                    if (parseResult.success) {
+                    if (parseResult.ok) {
                         configs.push({
                             config: {
                                 rules: parseResult.config
@@ -1251,16 +1189,14 @@ class SourceCode extends TokenStore {
         const emitter = createEmitter();
         let analyzer = {
             enterNode(node) {
-                steps.push(new TraversalStep({
-                    type: "visit",
+                steps.push(new VisitNodeStep({
                     target: node,
                     phase: 1,
                     args: [node, node.parent]
                 }));
             },
             leaveNode(node) {
-                steps.push(new TraversalStep({
-                    type: "visit",
+                steps.push(new VisitNodeStep({
                     target: node,
                     phase: 2,
                     args: [node, node.parent]
@@ -1283,8 +1219,7 @@ class SourceCode extends TokenStore {
 
             CODE_PATH_EVENTS.forEach(eventName => {
                 emitter.on(eventName, (...args) => {
-                    steps.push(new TraversalStep({
-                        type: "call",
+                    steps.push(new CallMethodStep({
                         target: eventName,
                         args
                     }));

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

@@ -60,34 +60,23 @@ function groupByParentDirective(directives) {
 /**
  * Creates removal details for a set of directives within the same comment.
  * @param {Directive[]} directives Unused directives to be removed.
- * @param {Token} node The backing Comment token.
+ * @param {{node: Token, value: string}} parentDirective Data about the backing directive.
  * @param {SourceCode} sourceCode The source code object for the file being linted.
  * @returns {{ description, fix, unprocessedDirective }[]} Details for later creation of output Problems.
  */
-function createIndividualDirectivesRemoval(directives, node, sourceCode) {
-
-    const range = sourceCode.getRange(node);
-
-    /*
-     * `node.value` starts right after `//` or `/*`.
-     * All calculated offsets will be relative to this index.
-     */
-    const commentValueStart = 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(node.value)[0].length;
+function createIndividualDirectivesRemoval(directives, parentDirective, sourceCode) {
 
     /*
-     * Get the list text without any surrounding whitespace. In order to preserve the original
+     * Get the list of the rules text without any surrounding whitespace. In order to preserve the original
      * formatting, we don't want to change that whitespace.
      *
      *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
      *                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      */
-    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
+    const listText = parentDirective.value.trim();
+
+    // Calculate where it starts in the source code text
+    const listStart = sourceCode.text.indexOf(listText, sourceCode.getRange(parentDirective.node)[0]);
 
     /*
      * We can assume that `listText` contains multiple elements.
@@ -101,13 +90,13 @@ function createIndividualDirectivesRemoval(directives, node, sourceCode) {
         const regex = new RegExp(String.raw`(?:^|\s*,\s*)(?<quote>['"]?)${escapeRegExp(ruleId)}\k<quote>(?:\s*,\s*|$)`, "u");
         const match = regex.exec(listText);
         const matchedText = match[0];
-        const matchStartOffset = listStartOffset + match.index;
-        const matchEndOffset = matchStartOffset + matchedText.length;
+        const matchStart = listStart + match.index;
+        const matchEnd = matchStart + matchedText.length;
 
         const firstIndexOfComma = matchedText.indexOf(",");
         const lastIndexOfComma = matchedText.lastIndexOf(",");
 
-        let removalStartOffset, removalEndOffset;
+        let removalStart, removalEnd;
 
         if (firstIndexOfComma !== lastIndexOfComma) {
 
@@ -123,8 +112,8 @@ function createIndividualDirectivesRemoval(directives, node, sourceCode) {
              *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
              *                                     ^^^^^^^^^^^
              */
-            removalStartOffset = matchStartOffset + firstIndexOfComma;
-            removalEndOffset = matchStartOffset + lastIndexOfComma;
+            removalStart = matchStart + firstIndexOfComma;
+            removalEnd = matchStart + lastIndexOfComma;
 
         } else {
 
@@ -146,16 +135,16 @@ function createIndividualDirectivesRemoval(directives, node, sourceCode) {
              *     // eslint-disable-line rule-one , rule-two , rule-three -- comment
              *                                               ^^^^^^^^^^^^^
              */
-            removalStartOffset = matchStartOffset;
-            removalEndOffset = matchEndOffset;
+            removalStart = matchStart;
+            removalEnd = matchEnd;
         }
 
         return {
             description: `'${ruleId}'`,
             fix: {
                 range: [
-                    commentValueStart + removalStartOffset,
-                    commentValueStart + removalEndOffset
+                    removalStart,
+                    removalEnd
                 ],
                 text: ""
             },
@@ -206,7 +195,7 @@ function processUnusedDirectives(allDirectives, sourceCode) {
             }
 
             return remainingRuleIds.size
-                ? createIndividualDirectivesRemoval(directives, parentDirective.node, sourceCode)
+                ? createIndividualDirectivesRemoval(directives, parentDirective, sourceCode)
                 : [createDirectiveRemoval(directives, parentDirective.node, sourceCode)];
         }
     );

package/lib/linter/file-context.js

@@ -0,0 +1,134 @@
+/**
+ * @fileoverview The FileContext class.
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+/**
+ * Represents a file context that the linter can use to lint a file.
+ */
+class FileContext {
+
+    /**
+     * The current working directory.
+     * @type {string}
+     */
+    cwd;
+
+    /**
+     * The filename of the file being linted.
+     * @type {string}
+     */
+    filename;
+
+    /**
+     * The physical filename of the file being linted.
+     * @type {string}
+     */
+    physicalFilename;
+
+    /**
+     * The source code of the file being linted.
+     * @type {SourceCode}
+     */
+    sourceCode;
+
+    /**
+     * The parser options for the file being linted.
+     * @type {Record<string, unknown>}
+     * @deprecated Use `languageOptions` instead.
+     */
+    parserOptions;
+
+    /**
+     * The path to the parser used to parse this file.
+     * @type {string}
+     * @deprecated No longer supported.
+     */
+    parserPath;
+
+    /**
+     * The language options used when parsing this file.
+     * @type {Record<string, unknown>}
+     */
+    languageOptions;
+
+    /**
+     * The settings for the file being linted.
+     * @type {Record<string, unknown>}
+     */
+    settings;
+
+    /**
+     * Creates a new instance.
+     * @param {Object} config The configuration object for the file context.
+     * @param {string} config.cwd The current working directory.
+     * @param {string} config.filename The filename of the file being linted.
+     * @param {string} config.physicalFilename The physical filename of the file being linted.
+     * @param {SourceCode} config.sourceCode The source code of the file being linted.
+     * @param {Record<string, unknown>} config.parserOptions The parser options for the file being linted.
+     * @param {string} config.parserPath The path to the parser used to parse this file.
+     * @param {Record<string, unknown>} config.languageOptions The language options used when parsing this file.
+     * @param {Record<string, unknown>} config.settings The settings for the file being linted.
+     */
+    constructor({
+        cwd,
+        filename,
+        physicalFilename,
+        sourceCode,
+        parserOptions,
+        parserPath,
+        languageOptions,
+        settings
+    }) {
+        this.cwd = cwd;
+        this.filename = filename;
+        this.physicalFilename = physicalFilename;
+        this.sourceCode = sourceCode;
+        this.parserOptions = parserOptions;
+        this.parserPath = parserPath;
+        this.languageOptions = languageOptions;
+        this.settings = settings;
+
+        Object.freeze(this);
+    }
+
+    /**
+     * Gets the current working directory.
+     * @returns {string} The current working directory.
+     * @deprecated Use `cwd` instead.
+     */
+    getCwd() {
+        return this.cwd;
+    }
+
+    /**
+     * Gets the filename of the file being linted.
+     * @returns {string} The filename of the file being linted.
+     * @deprecated Use `filename` instead.
+     */
+    getFilename() {
+        return this.filename;
+    }
+
+    /**
+     * Gets the physical filename of the file being linted.
+     * @returns {string} The physical filename of the file being linted.
+     * @deprecated Use `physicalFilename` instead.
+     */
+    getPhysicalFilename() {
+        return this.physicalFilename;
+    }
+
+    /**
+     * Gets the source code of the file being linted.
+     * @returns {SourceCode} The source code of the file being linted.
+     * @deprecated Use `sourceCode` instead.
+     */
+    getSourceCode() {
+        return this.sourceCode;
+    }
+}
+
+exports.FileContext = FileContext;