eslint 9.13.0 → 9.15.0

package/lib/eslint/eslint-helpers.js

@@ -155,16 +155,14 @@ function isGlobPattern(pattern) {
  * Used primarily to help with useful error messages.
  * @param {Object} options The options for the function.
  * @param {string} options.basePath The directory to search.
- * @param {string} options.pattern A glob pattern to match.
+ * @param {string} options.pattern An absolute path glob pattern to match.
  * @returns {Promise<boolean>} True if there is a glob match, false if not.
  */
 async function globMatch({ basePath, pattern }) {
 
     let found = false;
     const { hfs } = await import("@humanfs/node");
-    const patternToUse = path.isAbsolute(pattern)
-        ? normalizeToPosix(path.relative(basePath, pattern))
-        : pattern;
+    const patternToUse = normalizeToPosix(path.relative(basePath, pattern));
 
     const matcher = new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 
@@ -202,7 +200,7 @@ async function globMatch({ basePath, pattern }) {
  * ESLint.
  * @param {Object} options The options for this function.
  * @param {string} options.basePath The directory to search.
- * @param {Array<string>} options.patterns An array of glob patterns
+ * @param {Array<string>} options.patterns An array of absolute path glob patterns
  *      to match.
  * @param {Array<string>} options.rawPatterns An array of glob patterns
  *      as the user inputted them. Used for errors.
@@ -241,9 +239,7 @@ async function globSearch({
      */
     const relativeToPatterns = new Map();
     const matchers = patterns.map((pattern, i) => {
-        const patternToUse = path.isAbsolute(pattern)
-            ? normalizeToPosix(path.relative(basePath, pattern))
-            : pattern;
+        const patternToUse = normalizeToPosix(path.relative(basePath, pattern));
 
         relativeToPatterns.set(patternToUse, patterns[i]);
 
@@ -353,7 +349,7 @@ async function globSearch({
  *      that were used in the original search.
  * @param {Array<string>} options.rawPatterns An array of glob patterns
  *      as the user inputted them. Used for errors.
- * @param {Array<string>} options.unmatchedPatterns A non-empty array of glob patterns
+ * @param {Array<string>} options.unmatchedPatterns A non-empty array of absolute path glob patterns
  *      that were unmatched in the original search.
  * @returns {void} Always throws an error.
  * @throws {NoFilesFoundError} If the first unmatched pattern
@@ -388,7 +384,7 @@ async function throwErrorForUnmatchedPatterns({
  * Performs multiple glob searches in parallel.
  * @param {Object} options The options for this function.
  * @param {Map<string,GlobSearch>} options.searches
- *      An array of glob patterns to match.
+ *      A map of absolute path glob patterns to match.
  * @param {ConfigLoader|LegacyConfigLoader} options.configLoader The config loader to use for
  *      determining what to ignore.
  * @param {boolean} options.errorOnUnmatchedPattern Determines if an
@@ -421,20 +417,19 @@ async function globMultiSearch({ searches, configLoader, errorOnUnmatchedPattern
         )
     );
 
-    const filePaths = [];
-
+    /*
+     * The first loop handles errors from the glob searches. Since we can't
+     * use `await` inside `flatMap`, we process errors separately in this loop.
+     * This results in two iterations over `results`, but since the length is
+     * less than or equal to the number of globs and directories passed on the
+     * command line, the performance impact should be minimal.
+     */
     for (let i = 0; i < results.length; i++) {
 
         const result = results[i];
         const currentSearch = normalizedSearches[i];
 
         if (result.status === "fulfilled") {
-
-            // if the search was successful just add the results
-            if (result.value.length > 0) {
-                filePaths.push(...result.value);
-            }
-
             continue;
         }
 
@@ -457,7 +452,8 @@ async function globMultiSearch({ searches, configLoader, errorOnUnmatchedPattern
 
     }
 
-    return filePaths;
+    // second loop for `fulfulled` results
+    return results.flatMap(result => result.value);
 
 }
 
@@ -597,7 +593,7 @@ async function findFiles({
     return [
         ...new Set([
             ...results,
-            ...globbyResults.map(filePath => path.resolve(filePath))
+            ...globbyResults
         ])
     ];
 }
@@ -618,7 +614,7 @@ function isErrorMessage(message) {
 
 /**
  * Returns result with warning by ignore settings
- * @param {string} filePath File path of checked code
+ * @param {string} filePath Absolute file path of checked code
  * @param {string} baseDir Absolute path of base directory
  * @param {"ignored"|"external"|"unconfigured"} configStatus A status that determines why the file is ignored
  * @returns {LintResult} Result with single warning
@@ -648,7 +644,7 @@ function createIgnoreResult(filePath, baseDir, configStatus) {
     }
 
     return {
-        filePath: path.resolve(filePath),
+        filePath,
         messages: [
             {
                 ruleId: null,

package/lib/eslint/eslint.js

@@ -746,7 +746,7 @@ class ESLint {
         });
         const controller = new AbortController();
         const retryCodes = new Set(["ENFILE", "EMFILE"]);
-        const retrier = new Retrier(error => retryCodes.has(error.code));
+        const retrier = new Retrier(error => retryCodes.has(error.code), { concurrency: 100 });
 
         debug(`${filePaths.length} files found in: ${Date.now() - startTime}ms`);
 
@@ -830,7 +830,7 @@ class ESLint {
                         }
 
                         return result;
-                    }))
+                    }), { signal: controller.signal })
                     .catch(error => {
                         controller.abort(error);
                         throw error;

package/lib/languages/js/index.js

@@ -16,6 +16,7 @@ const espree = require("espree");
 const eslintScope = require("eslint-scope");
 const evk = require("eslint-visitor-keys");
 const { validateLanguageOptions } = require("./validate-language-options");
+const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version");
 
 //-----------------------------------------------------------------------------
 // Type Definitions
@@ -31,6 +32,7 @@ const { validateLanguageOptions } = require("./validate-language-options");
 
 const debug = createDebug("eslint:languages:js");
 const DEFAULT_ECMA_VERSION = 5;
+const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 
 /**
  * Analyze scope of the given AST.
@@ -55,6 +57,47 @@ function analyzeScope(ast, languageOptions, visitorKeys) {
     });
 }
 
+/**
+ * Determines if a given object is Espree.
+ * @param {Object} parser The parser to check.
+ * @returns {boolean} True if the parser is Espree or false if not.
+ */
+function isEspree(parser) {
+    return !!(parser === espree || parser[parserSymbol] === espree);
+}
+
+/**
+ * Normalize ECMAScript version from the initial config into languageOptions (year)
+ * format.
+ * @param {any} [ecmaVersion] ECMAScript version from the initial config
+ * @returns {number} normalized ECMAScript version
+ */
+function normalizeEcmaVersionForLanguageOptions(ecmaVersion) {
+
+    switch (ecmaVersion) {
+        case 3:
+            return 3;
+
+        // void 0 = no ecmaVersion specified so use the default
+        case 5:
+        case void 0:
+            return 5;
+
+        default:
+            if (typeof ecmaVersion === "number") {
+                return ecmaVersion >= 2015 ? ecmaVersion : ecmaVersion + 2009;
+            }
+    }
+
+    /*
+     * We default to the latest supported ecmaVersion for everything else.
+     * Remember, this is for languageOptions.ecmaVersion, which sets the version
+     * that is used for a number of processes inside of ESLint. It's normally
+     * safe to assume people want the latest unless otherwise specified.
+     */
+    return LATEST_ECMA_VERSION;
+}
+
 //-----------------------------------------------------------------------------
 // Exports
 //-----------------------------------------------------------------------------
@@ -79,6 +122,39 @@ module.exports = {
 
     validateLanguageOptions,
 
+    /**
+     * Normalizes the language options.
+     * @param {Object} languageOptions The language options to normalize.
+     * @returns {Object} The normalized language options.
+     */
+    normalizeLanguageOptions(languageOptions) {
+
+        languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions(
+            languageOptions.ecmaVersion
+        );
+
+        // Espree expects this information to be passed in
+        if (isEspree(languageOptions.parser)) {
+            const parserOptions = languageOptions.parserOptions;
+
+            if (languageOptions.sourceType) {
+
+                parserOptions.sourceType = languageOptions.sourceType;
+
+                if (
+                    parserOptions.sourceType === "module" &&
+                    parserOptions.ecmaFeatures &&
+                    parserOptions.ecmaFeatures.globalReturn
+                ) {
+                    parserOptions.ecmaFeatures.globalReturn = false;
+                }
+            }
+        }
+
+        return languageOptions;
+
+    },
+
     /**
      * Determines if a given node matches a given selector class.
      * @param {string} className The class name to check.

package/lib/languages/js/source-code/token-store/index.js

@@ -8,8 +8,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("node:assert");
 const { isCommentToken } = require("@eslint-community/eslint-utils");
+const assert = require("../../../../shared/assert");
 const cursors = require("./cursors");
 const ForwardTokenCursor = require("./forward-token-cursor");
 const PaddedTokenCursor = require("./padded-token-cursor");

package/lib/linter/code-path-analysis/code-path-analyzer.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("node:assert"),
+const assert = require("../../shared/assert"),
     { breakableTypePattern } = require("../../shared/ast-utils"),
     CodePath = require("./code-path"),
     CodePathSegment = require("./code-path-segment"),

package/lib/linter/code-path-analysis/fork-context.js

@@ -13,7 +13,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("node:assert"),
+const assert = require("../../shared/assert"),
     CodePathSegment = require("./code-path-segment");
 
 //------------------------------------------------------------------------------

package/lib/linter/linter.js

@@ -41,6 +41,7 @@ const { startTime, endTime } = require("../shared/stats");
 const { RuleValidator } = require("../config/rule-validator");
 const { assertIsRuleSeverity } = require("../config/flat-config-schema");
 const { normalizeSeverityToString } = require("../shared/severity");
+const { deepMergeArrays } = require("../shared/deep-merge-arrays");
 const jslang = require("../languages/js");
 const { activeFlags, inactiveFlags } = require("../shared/flags");
 const debug = require("debug")("eslint:linter");
@@ -892,14 +893,14 @@ function storeTime(time, timeOpts, slots) {
 /**
  * Get the options for a rule (not including severity), if any
  * @param {RuleConfig} ruleConfig rule configuration
+ * @param {Object|undefined} defaultOptions rule.meta.defaultOptions
  * @returns {Array} of rule options, empty Array if none
  */
-function getRuleOptions(ruleConfig) {
+function getRuleOptions(ruleConfig, defaultOptions) {
     if (Array.isArray(ruleConfig)) {
-        return ruleConfig.slice(1);
+        return deepMergeArrays(defaultOptions, ruleConfig.slice(1));
     }
-    return [];
-
+    return defaultOptions ?? [];
 }
 
 /**
@@ -957,6 +958,7 @@ function createRuleListeners(rule, ruleContext) {
  * @param {LanguageOptions} languageOptions The options for parsing the code.
  * @param {Object} settings The settings that were enabled in the config
  * @param {string} filename The reported filename of the code
+ * @param {boolean} applyDefaultOptions If true, apply rules' meta.defaultOptions in computing their config options.
  * @param {boolean} disableFixes If true, it doesn't make `fix` properties.
  * @param {string | undefined} cwd cwd of the cli
  * @param {string} physicalFilename The full path of the file on disk without any code block information
@@ -967,9 +969,21 @@ function createRuleListeners(rule, ruleContext) {
  * @throws {Error} If traversal into a node fails.
  */
 function runRules(
-    sourceCode, configuredRules, ruleMapper, parserName, language, languageOptions,
-    settings, filename, disableFixes, cwd, physicalFilename, ruleFilter,
-    stats, slots
+    sourceCode,
+    configuredRules,
+    ruleMapper,
+    parserName,
+    language,
+    languageOptions,
+    settings,
+    filename,
+    applyDefaultOptions,
+    disableFixes,
+    cwd,
+    physicalFilename,
+    ruleFilter,
+    stats,
+    slots
 ) {
     const emitter = createEmitter();
 
@@ -1022,7 +1036,7 @@ function runRules(
                 Object.create(sharedTraversalContext),
                 {
                     id: ruleId,
-                    options: getRuleOptions(configuredRules[ruleId]),
+                    options: getRuleOptions(configuredRules[ruleId], applyDefaultOptions ? rule.meta?.defaultOptions : void 0),
                     report(...args) {
 
                         /*
@@ -1419,6 +1433,7 @@ class Linter {
                 languageOptions,
                 settings,
                 options.filename,
+                true,
                 options.disableFixes,
                 slots.cwd,
                 providedOptions.physicalFilename,
@@ -1640,34 +1655,8 @@ class Linter {
 
         const slots = internalSlotsMap.get(this);
         const config = providedConfig || {};
+        const { settings = {}, languageOptions } = config;
         const options = normalizeVerifyOptions(providedOptions, config);
-        const languageOptions = config.languageOptions;
-
-        if (config.language === jslang) {
-            languageOptions.ecmaVersion = normalizeEcmaVersionForLanguageOptions(
-                languageOptions.ecmaVersion
-            );
-
-            // Espree expects this information to be passed in
-            if (isEspree(languageOptions.parser)) {
-                const parserOptions = languageOptions.parserOptions;
-
-                if (languageOptions.sourceType) {
-
-                    parserOptions.sourceType = languageOptions.sourceType;
-
-                    if (
-                        parserOptions.sourceType === "module" &&
-                        parserOptions.ecmaFeatures &&
-                        parserOptions.ecmaFeatures.globalReturn
-                    ) {
-                        parserOptions.ecmaFeatures.globalReturn = false;
-                    }
-                }
-            }
-        }
-
-        const settings = config.settings || {};
 
         if (!slots.lastSourceCode) {
             let t;
@@ -1848,6 +1837,17 @@ class Linter {
                                     if (config.rules[ruleId][0] > 0) {
                                         shouldValidateOptions = false;
                                     }
+                                } else {
+
+                                    /**
+                                     * Since we know the user provided options, apply defaults on top of them
+                                     */
+                                    const slicedOptions = ruleOptions.slice(1);
+                                    const mergedOptions = deepMergeArrays(rule.meta?.defaultOptions, slicedOptions);
+
+                                    if (mergedOptions.length) {
+                                        ruleOptions = [ruleOptions[0], ...mergedOptions];
+                                    }
                                 }
 
                                 if (shouldValidateOptions) {
@@ -1917,6 +1917,7 @@ class Linter {
                 languageOptions,
                 settings,
                 options.filename,
+                false,
                 options.disableFixes,
                 slots.cwd,
                 providedOptions.physicalFilename,

package/lib/linter/report-translator.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("node:assert");
+const assert = require("../shared/assert");
 const { RuleFixer } = require("./rule-fixer");
 const { interpolate } = require("./interpolate");
 

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

@@ -653,7 +653,7 @@ class RuleTester {
             };
 
             if (item.filename) {
-                flatConfigArrayOptions.basePath = path.parse(item.filename).root;
+                flatConfigArrayOptions.basePath = path.parse(item.filename).root || void 0;
             }
 
             const configs = new FlatConfigArray(testerConfig, flatConfigArrayOptions);

package/lib/rules/accessor-pairs.js

@@ -139,6 +139,12 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            enforceForClassMembers: true,
+            getWithoutSet: false,
+            setWithoutGet: true
+        }],
+
         docs: {
             description: "Enforce getter and setter pairs in objects and classes",
             recommended: false,
@@ -149,16 +155,13 @@ module.exports = {
             type: "object",
             properties: {
                 getWithoutSet: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 },
                 setWithoutGet: {
-                    type: "boolean",
-                    default: true
+                    type: "boolean"
                 },
                 enforceForClassMembers: {
-                    type: "boolean",
-                    default: true
+                    type: "boolean"
                 }
             },
             additionalProperties: false
@@ -174,7 +177,7 @@ module.exports = {
         }
     },
     create(context) {
-        const config = context.options[0] || {};
+        const [config] = context.options;
         const checkGetWithoutSet = config.getWithoutSet === true;
         const checkSetWithoutGet = config.setWithoutGet !== false;
         const enforceForClassMembers = config.enforceForClassMembers !== false;

package/lib/rules/array-callback-return.js

@@ -215,6 +215,12 @@ module.exports = {
     meta: {
         type: "problem",
 
+        defaultOptions: [{
+            allowImplicit: false,
+            checkForEach: false,
+            allowVoid: false
+        }],
+
         docs: {
             description: "Enforce `return` statements in callbacks of array methods",
             recommended: false,
@@ -229,16 +235,13 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowImplicit: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     checkForEach: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     allowVoid: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -256,8 +259,7 @@ module.exports = {
     },
 
     create(context) {
-
-        const options = context.options[0] || { allowImplicit: false, checkForEach: false, allowVoid: false };
+        const [options] = context.options;
         const sourceCode = context.sourceCode;
 
         let funcInfo = {

package/lib/rules/arrow-body-style.js

@@ -19,6 +19,8 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: ["as-needed"],
+
         docs: {
             description: "Require braces around arrow function bodies",
             recommended: false,
@@ -71,7 +73,7 @@ module.exports = {
     create(context) {
         const options = context.options;
         const always = options[0] === "always";
-        const asNeeded = !options[0] || options[0] === "as-needed";
+        const asNeeded = options[0] === "as-needed";
         const never = options[0] === "never";
         const requireReturnForObjectLiteral = options[1] && options[1].requireReturnForObjectLiteral;
         const sourceCode = context.sourceCode;

package/lib/rules/camelcase.js

@@ -20,6 +20,14 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            allow: [],
+            ignoreDestructuring: false,
+            ignoreGlobals: false,
+            ignoreImports: false,
+            properties: "always"
+        }],
+
         docs: {
             description: "Enforce camelcase naming convention",
             recommended: false,
@@ -31,16 +39,13 @@ module.exports = {
                 type: "object",
                 properties: {
                     ignoreDestructuring: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     ignoreImports: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     ignoreGlobals: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     },
                     properties: {
                         enum: ["always", "never"]
@@ -65,12 +70,13 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options[0] || {};
-        const properties = options.properties === "never" ? "never" : "always";
-        const ignoreDestructuring = options.ignoreDestructuring;
-        const ignoreImports = options.ignoreImports;
-        const ignoreGlobals = options.ignoreGlobals;
-        const allow = options.allow || [];
+        const [{
+            allow,
+            ignoreDestructuring,
+            ignoreGlobals,
+            ignoreImports,
+            properties
+        }] = context.options;
         const sourceCode = context.sourceCode;
 
         //--------------------------------------------------------------------------
@@ -238,6 +244,13 @@ module.exports = {
                 return;
             }
 
+            /*
+             * Import attribute keys are always ignored
+             */
+            if (astUtils.isImportAttributeKey(node)) {
+                return;
+            }
+
             report(node);
         }
 
@@ -272,7 +285,7 @@ module.exports = {
                 for (const reference of scope.through) {
                     const id = reference.identifier;
 
-                    if (isGoodName(id.name)) {
+                    if (isGoodName(id.name) || astUtils.isImportAttributeKey(id)) {
                         continue;
                     }
 
@@ -326,7 +339,7 @@ module.exports = {
                 "MethodDefinition > PrivateIdentifier.key",
                 "PropertyDefinition > PrivateIdentifier.key"
             ]](node) {
-                if (properties === "never" || isGoodName(node.name)) {
+                if (properties === "never" || astUtils.isImportAttributeKey(node) || isGoodName(node.name)) {
                     return;
                 }
                 report(node);

package/lib/rules/class-methods-use-this.js

@@ -20,6 +20,11 @@ module.exports = {
     meta: {
         type: "suggestion",
 
+        defaultOptions: [{
+            enforceForClassFields: true,
+            exceptMethods: []
+        }],
+
         docs: {
             description: "Enforce that class methods utilize `this`",
             recommended: false,
@@ -36,8 +41,7 @@ module.exports = {
                     }
                 },
                 enforceForClassFields: {
-                    type: "boolean",
-                    default: true
+                    type: "boolean"
                 }
             },
             additionalProperties: false
@@ -48,9 +52,9 @@ module.exports = {
         }
     },
     create(context) {
-        const config = Object.assign({}, context.options[0]);
-        const enforceForClassFields = config.enforceForClassFields !== false;
-        const exceptMethods = new Set(config.exceptMethods || []);
+        const [options] = context.options;
+        const { enforceForClassFields } = options;
+        const exceptMethods = new Set(options.exceptMethods);
 
         const stack = [];