eslint 9.9.1 → 9.10.0

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;

package/lib/linter/linter.js

@@ -17,9 +17,6 @@ const
     espree = require("espree"),
     merge = require("lodash.merge"),
     pkg = require("../../package.json"),
-    {
-        directivesPattern
-    } = require("../shared/directives"),
     {
         Legacy: {
             ConfigOps,
@@ -30,7 +27,7 @@ const
     Traverser = require("../shared/traverser"),
     { SourceCode } = require("../languages/js/source-code"),
     applyDisableDirectives = require("./apply-disable-directives"),
-    ConfigCommentParser = require("./config-comment-parser"),
+    { ConfigCommentParser } = require("@eslint/plugin-kit"),
     NodeEventGenerator = require("./node-event-generator"),
     createReportTranslator = require("./report-translator"),
     Rules = require("./rules"),
@@ -56,6 +53,7 @@ const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 const { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
 const { VFile } = require("./vfile");
 const { ParserService } = require("../services/parser-service");
+const { FileContext } = require("./file-context");
 const STEP_KIND_VISIT = 1;
 const STEP_KIND_CALL = 2;
 
@@ -334,7 +332,7 @@ function createDisableDirectives({ type, value, justification, node }, ruleMappe
         directives: [], // valid disable directives
         directiveProblems: [] // problems in directives
     };
-    const parentDirective = { node, ruleIds };
+    const parentDirective = { node, value, ruleIds };
 
     for (const ruleId of directiveRules) {
 
@@ -402,15 +400,20 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
     });
 
     sourceCode.getInlineConfigNodes().filter(token => token.type !== "Shebang").forEach(comment => {
-        const { directivePart, justificationPart } = commentParser.extractDirectiveComment(comment.value);
 
-        const match = directivesPattern.exec(directivePart);
+        const directive = commentParser.parseDirective(comment.value);
 
-        if (!match) {
+        if (!directive) {
             return;
         }
-        const directiveText = match[1];
-        const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
+
+        const {
+            label,
+            value,
+            justification: justificationPart
+        } = directive;
+
+        const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(label);
 
         if (comment.type === "Line" && !lineCommentSupported) {
             return;
@@ -419,7 +422,7 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
         const loc = sourceCode.getLoc(comment);
 
         if (warnInlineConfig) {
-            const kind = comment.type === "Block" ? `/*${directiveText}*/` : `//${directiveText}`;
+            const kind = comment.type === "Block" ? `/*${label}*/` : `//${label}`;
 
             problems.push(createLintingProblem({
                 ruleId: null,
@@ -430,8 +433,8 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
             return;
         }
 
-        if (directiveText === "eslint-disable-line" && loc.start.line !== loc.end.line) {
-            const message = `${directiveText} comment should not span multiple lines.`;
+        if (label === "eslint-disable-line" && loc.start.line !== loc.end.line) {
+            const message = `${label} comment should not span multiple lines.`;
 
             problems.push(createLintingProblem({
                 ruleId: null,
@@ -441,17 +444,15 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
             return;
         }
 
-        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);
                 const { directives, directiveProblems } = createDisableDirectives({
                     type: directiveType,
-                    value: directiveValue,
+                    value,
                     justification: justificationPart,
                     node: comment
                 }, ruleMapper, jslang, sourceCode);
@@ -462,16 +463,16 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
             }
 
             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 = ConfigOps.normalizeConfigGlobal(value);
+                        normalizedValue = ConfigOps.normalizeConfigGlobal(idSetting);
                     } catch (err) {
                         problems.push(createLintingProblem({
                             ruleId: null,
@@ -494,9 +495,9 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                 break;
 
             case "eslint": {
-                const parseResult = commentParser.parseJsonConfig(directiveValue);
+                const parseResult = commentParser.parseJSONLikeConfig(value);
 
-                if (parseResult.success) {
+                if (parseResult.ok) {
                     Object.keys(parseResult.config).forEach(name => {
                         const rule = ruleMapper(name);
                         const ruleValue = parseResult.config[name];
@@ -713,7 +714,7 @@ function findEslintEnv(text) {
         if (match[0].endsWith("*/")) {
             retv = Object.assign(
                 retv || {},
-                commentParser.parseListConfig(commentParser.extractDirectiveComment(match[1]).directivePart)
+                commentParser.parseListConfig(commentParser.parseDirective(match[0].slice(2, -2)).value)
             );
         }
     }
@@ -979,24 +980,18 @@ function runRules(
      * All rule contexts will inherit from this object. This avoids the performance penalty of copying all the
      * properties once for each rule.
      */
-    const sharedTraversalContext = Object.freeze(
-        {
-            getCwd: () => cwd,
-            cwd,
-            getFilename: () => filename,
-            filename,
-            getPhysicalFilename: () => physicalFilename || filename,
-            physicalFilename: physicalFilename || filename,
-            getSourceCode: () => sourceCode,
-            sourceCode,
-            parserOptions: {
-                ...languageOptions.parserOptions
-            },
-            parserPath: parserName,
-            languageOptions,
-            settings
-        }
-    );
+    const sharedTraversalContext = new FileContext({
+        cwd,
+        filename,
+        physicalFilename: physicalFilename || filename,
+        sourceCode,
+        parserOptions: {
+            ...languageOptions.parserOptions
+        },
+        parserPath: parserName,
+        languageOptions,
+        settings
+    });
 
     const lintingProblems = [];
 

package/lib/rules/id-length.js

@@ -117,6 +117,7 @@ module.exports = {
                 return properties && !parent.computed && parent.key.name === node.name;
             },
             ImportDefaultSpecifier: true,
+            ImportNamespaceSpecifier: true,
             RestElement: true,
             FunctionExpression: true,
             ArrowFunctionExpression: true,