eslint 9.0.0-alpha.0 → 9.0.0-alpha.1

package/README.md

@@ -245,6 +245,11 @@ The people who review and fix bugs and help triage issues.
 Bryan Mishkin
 </a>
 </td><td align="center" valign="top" width="11%">
+<a href="https://github.com/JoshuaKGoldberg">
+<img src="https://github.com/JoshuaKGoldberg.png?s=75" width="75" height="75" alt="Josh Goldberg ✨'s Avatar"><br />
+Josh Goldberg ✨
+</a>
+</td><td align="center" valign="top" width="11%">
 <a href="https://github.com/fasttime">
 <img src="https://github.com/fasttime.png?s=75" width="75" height="75" alt="Francesco Trotta's Avatar"><br />
 Francesco Trotta

package/conf/ecma-version.js

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Configuration related to ECMAScript versions
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+/**
+ * The latest ECMAScript version supported by ESLint.
+ * @type {number} year-based ECMAScript version
+ */
+const LATEST_ECMA_VERSION = 2024;
+
+module.exports = {
+    LATEST_ECMA_VERSION
+};

package/lib/cli-engine/cli-engine.js

@@ -732,7 +732,7 @@ class CLIEngine {
      * @returns {void}
      */
     static outputFixes(report) {
-        report.results.filter(result => Object.prototype.hasOwnProperty.call(result, "output")).forEach(result => {
+        report.results.filter(result => Object.hasOwn(result, "output")).forEach(result => {
             fs.writeFileSync(result.filePath, result.output);
         });
     }

package/lib/cli-engine/lint-result-cache.js

@@ -164,7 +164,7 @@ class LintResultCache {
      * @returns {void}
      */
     setCachedLintResults(filePath, config, result) {
-        if (result && Object.prototype.hasOwnProperty.call(result, "output")) {
+        if (result && Object.hasOwn(result, "output")) {
             return;
         }
 
@@ -181,7 +181,7 @@ class LintResultCache {
              * In `getCachedLintResults`, if source is explicitly null, we will
              * read the file from the filesystem to set the value again.
              */
-            if (Object.prototype.hasOwnProperty.call(resultToSerialize, "source")) {
+            if (Object.hasOwn(resultToSerialize, "source")) {
                 resultToSerialize.source = null;
             }
 

package/lib/cli.js

@@ -285,25 +285,23 @@ async function printResults(engine, results, format, outputFile, resultsMeta) {
 
     const output = await formatter.format(results, resultsMeta);
 
-    if (output) {
-        if (outputFile) {
-            const filePath = path.resolve(process.cwd(), outputFile);
+    if (outputFile) {
+        const filePath = path.resolve(process.cwd(), outputFile);
 
-            if (await isDirectory(filePath)) {
-                log.error("Cannot write to output file path, it is a directory: %s", outputFile);
-                return false;
-            }
+        if (await isDirectory(filePath)) {
+            log.error("Cannot write to output file path, it is a directory: %s", outputFile);
+            return false;
+        }
 
-            try {
-                await mkdir(path.dirname(filePath), { recursive: true });
-                await writeFile(filePath, output);
-            } catch (ex) {
-                log.error("There was a problem writing the output file:\n%s", ex);
-                return false;
-            }
-        } else {
-            log.info(output);
+        try {
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, output);
+        } catch (ex) {
+            log.error("There was a problem writing the output file:\n%s", ex);
+            return false;
         }
+    } else if (output) {
+        log.info(output);
     }
 
     return true;

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

@@ -171,7 +171,7 @@ function createCommentRemoval(directives, commentToken) {
     return {
         description: ruleIds.length <= 2
             ? ruleIds.join(" or ")
-            : `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds[ruleIds.length - 1]}`,
+            : `${ruleIds.slice(0, ruleIds.length - 1).join(", ")}, or ${ruleIds.at(-1)}`,
         fix: {
             range,
             text: " "
@@ -342,7 +342,7 @@ function applyDirectives(options) {
                 problem.suppressions = problem.suppressions.concat(suppressions);
             } else {
                 problem.suppressions = suppressions;
-                usedDisableDirectives.add(disableDirectivesForProblem[disableDirectivesForProblem.length - 1]);
+                usedDisableDirectives.add(disableDirectivesForProblem.at(-1));
             }
         }
 

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

@@ -125,20 +125,6 @@ class CodePath {
         return this.internal.thrownForkContext;
     }
 
-    /**
-     * Tracks the traversal of the code path through each segment. This array
-     * starts empty and segments are added or removed as the code path is
-     * traversed. This array always ends up empty at the end of a code path
-     * traversal. The `CodePathState` uses this to track its progress through
-     * the code path.
-     * This is a passthrough to the underlying `CodePathState`.
-     * @type {CodePathSegment[]}
-     * @deprecated
-     */
-    get currentSegments() {
-        return this.internal.currentSegments;
-    }
-
     /**
      * Traverses all segments in this code path.
      *
@@ -180,9 +166,9 @@ class CodePath {
         const lastSegment = resolvedOptions.last;
 
         // set up initial location information
-        let record = null;
-        let index = 0;
-        let end = 0;
+        let record;
+        let index;
+        let end;
         let segment = null;
 
         // segments that have already been visited during traversal
@@ -210,7 +196,7 @@ class CodePath {
                 if (stack.length <= 1) {
                     broken = true;
                 } else {
-                    skippedSegment = stack[stack.length - 2][0];
+                    skippedSegment = stack.at(-2)[0];
                 }
             },
 
@@ -251,7 +237,7 @@ class CodePath {
              * Otherwise, we just read the value and sometimes modify the
              * record as we traverse.
              */
-            record = stack[stack.length - 1];
+            record = stack.at(-1);
             segment = record[0];
             index = record[1];
 

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

@@ -207,7 +207,7 @@ class ForkContext {
     get head() {
         const list = this.segmentsList;
 
-        return list.length === 0 ? [] : list[list.length - 1];
+        return list.length === 0 ? [] : list.at(-1);
     }
 
     /**

package/lib/linter/config-comment-parser.js

@@ -75,11 +75,9 @@ module.exports = class ConfigCommentParser {
     parseJsonConfig(string, location) {
         debug("Parsing JSON config");
 
-        let items = {};
-
         // Parses a JSON-like comment by the same way as parsing CLI option.
         try {
-            items = levn.parse("Object", string) || {};
+            const items = levn.parse("Object", string) || {};
 
             // Some tests say that it should ignore invalid comments such as `/*eslint no-alert:abc*/`.
             // Also, commaless notations have invalid severity:
@@ -102,11 +100,15 @@ module.exports = class ConfigCommentParser {
          * Optionator cannot parse commaless notations.
          * But we are supporting that. So this is a fallback for that.
          */
-        items = {};
         const normalizedString = string.replace(/([-a-zA-Z0-9/]+):/gu, "\"$1\":").replace(/(\]|[0-9])\s+(?=")/u, "$1,");
 
         try {
-            items = JSON.parse(`{${normalizedString}}`);
+            const items = JSON.parse(`{${normalizedString}}`);
+
+            return {
+                success: true,
+                config: items
+            };
         } catch (ex) {
             debug("Manual parsing failed.");
 
@@ -124,11 +126,6 @@ module.exports = class ConfigCommentParser {
             };
 
         }
-
-        return {
-            success: true,
-            config: items
-        };
     }
 
     /**

package/lib/linter/linter.js

@@ -52,6 +52,7 @@ const DEFAULT_ECMA_VERSION = 5;
 const commentParser = new ConfigCommentParser();
 const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } };
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
+const { LATEST_ECMA_VERSION } = require("../../conf/ecma-version");
 
 //------------------------------------------------------------------------------
 // Typedefs
@@ -231,7 +232,7 @@ function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, ena
  * @private
  */
 function createMissingRuleMessage(ruleId) {
-    return Object.prototype.hasOwnProperty.call(ruleReplacements.rules, ruleId)
+    return Object.hasOwn(ruleReplacements.rules, ruleId)
         ? `Rule '${ruleId}' was removed and replaced by: ${ruleReplacements.rules[ruleId].join(", ")}`
         : `Definition for rule '${ruleId}' was not found.`;
 }
@@ -594,7 +595,7 @@ function normalizeEcmaVersionForLanguageOptions(ecmaVersion) {
      * 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 espree.latestEcmaVersion + 2009;
+    return LATEST_ECMA_VERSION;
 }
 
 const eslintEnvPattern = /\/\*\s*eslint-env\s(.+?)(?:\*\/|$)/gsu;
@@ -1331,7 +1332,56 @@ class Linter {
             { exportedVariables: commentDirectives.exportedVariables, enabledGlobals: commentDirectives.enabledGlobals }
         );
 
+        /*
+         * Now we determine the final configurations for rules.
+         * First, let all inline rule configurations override those from the config.
+         * Then, check for a special case: if a rule is configured in both places,
+         * inline rule configuration that only has severity should retain options from
+         * the config and just override the severity.
+         *
+         * Example:
+         *
+         *   {
+         *       rules: {
+         *           curly: ["error", "multi"]
+         *       }
+         *   }
+         *
+         *   /* eslint curly: ["warn"] * /
+         *
+         *   Results in:
+         *
+         *   curly: ["warn", "multi"]
+         */
         const configuredRules = Object.assign({}, config.rules, commentDirectives.configuredRules);
+
+        if (config.rules) {
+            for (const [ruleId, ruleInlineConfig] of Object.entries(commentDirectives.configuredRules)) {
+                if (
+
+                    /*
+                     * If inline config for the rule has only severity
+                     */
+                    (!Array.isArray(ruleInlineConfig) || ruleInlineConfig.length === 1) &&
+
+                    /*
+                     * And provided config for the rule has options
+                     */
+                    Object.hasOwn(config.rules, ruleId) &&
+                    (Array.isArray(config.rules[ruleId]) && config.rules[ruleId].length > 1)
+                ) {
+
+                    /*
+                     * Then use severity from the inline config and options from the provided config
+                     */
+                    configuredRules[ruleId] = [
+                        Array.isArray(ruleInlineConfig) ? ruleInlineConfig[0] : ruleInlineConfig, // severity from the inline config
+                        ...config.rules[ruleId].slice(1) // options from the provided config
+                    ];
+                }
+            }
+        }
+
         let lintingProblems;
 
         try {
@@ -1674,7 +1724,7 @@ class Linter {
                                     [ruleId]: ruleOptions
                                 }
                             });
-                            mergedInlineConfig.rules[ruleId] = ruleValue;
+                            mergedInlineConfig.rules[ruleId] = ruleOptions;
                         } catch (err) {
 
                             /*
@@ -1713,7 +1763,58 @@ class Linter {
             )
             : { problems: [], disableDirectives: [] };
 
+        /*
+         * Now we determine the final configurations for rules.
+         * First, let all inline rule configurations override those from the config.
+         * Then, check for a special case: if a rule is configured in both places,
+         * inline rule configuration that only has severity should retain options from
+         * the config and just override the severity.
+         *
+         * Example:
+         *
+         *   {
+         *       rules: {
+         *           curly: ["error", "multi"]
+         *       }
+         *   }
+         *
+         *   /* eslint curly: ["warn"] * /
+         *
+         *   Results in:
+         *
+         *   curly: ["warn", "multi"]
+         *
+         * At this point, all rule configurations are normalized to arrays.
+         */
         const configuredRules = Object.assign({}, config.rules, mergedInlineConfig.rules);
+
+        if (config.rules) {
+            for (const [ruleId, ruleInlineConfig] of Object.entries(mergedInlineConfig.rules)) {
+                if (
+
+                    /*
+                     * If inline config for the rule has only severity
+                     */
+                    ruleInlineConfig.length === 1 &&
+
+                    /*
+                     * And provided config for the rule has options
+                     */
+                    Object.hasOwn(config.rules, ruleId) &&
+                    config.rules[ruleId].length > 1
+                ) {
+
+                    /*
+                     * Then use severity from the inline config and options from the provided config
+                     */
+                    configuredRules[ruleId] = [
+                        ruleInlineConfig[0], // severity from the inline config
+                        ...config.rules[ruleId].slice(1) // options from the provided config
+                    ];
+                }
+            }
+        }
+
         let lintingProblems;
 
         sourceCode.finalize();
@@ -2039,7 +2140,7 @@ class Linter {
      *      SourceCodeFixer.
      */
     verifyAndFix(text, config, options) {
-        let messages = [],
+        let messages,
             fixedResult,
             fixed = false,
             passNumber = 0,

package/lib/linter/report-translator.js

@@ -160,7 +160,7 @@ function mergeFixes(fixes, sourceCode) {
 
     const originalText = sourceCode.text;
     const start = fixes[0].range[0];
-    const end = fixes[fixes.length - 1].range[1];
+    const end = fixes.at(-1).range[1];
     let text = "";
     let lastPos = Number.MIN_SAFE_INTEGER;
 
@@ -343,7 +343,7 @@ module.exports = function createReportTranslator(metadata) {
             if (descriptor.message) {
                 throw new TypeError("context.report() called with a message and a messageId. Please only pass one.");
             }
-            if (!messages || !Object.prototype.hasOwnProperty.call(messages, id)) {
+            if (!messages || !Object.hasOwn(messages, id)) {
                 throw new TypeError(`context.report() called with a messageId of '${id}' which is not present in the 'messages' config: ${JSON.stringify(messages, null, 2)}`);
             }
             computedMessage = messages[id];

package/lib/linter/source-code-fixer.js

@@ -107,7 +107,7 @@ SourceCodeFixer.applyFixes = function(sourceText, messages, shouldFix) {
     }
 
     messages.forEach(problem => {
-        if (Object.prototype.hasOwnProperty.call(problem, "fix")) {
+        if (Object.hasOwn(problem, "fix")) {
             fixes.push(problem);
         } else {
             remainingMessages.push(problem);

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

@@ -16,8 +16,7 @@ const
     equal = require("fast-deep-equal"),
     Traverser = require("../shared/traverser"),
     { getRuleOptionsSchema } = require("../config/flat-config-helpers"),
-    { Linter, SourceCodeFixer, interpolate } = require("../linter"),
-    CodePath = require("../linter/code-path-analysis/code-path");
+    { Linter, SourceCodeFixer, interpolate } = require("../linter");
 
 const { FlatConfigArray } = require("../config/flat-config-array");
 const { defaultConfig } = require("../config/default-config");
@@ -274,21 +273,6 @@ function wrapParser(parser) {
     };
 }
 
-/**
- * Emit a deprecation warning if rule uses CodePath#currentSegments.
- * @param {string} ruleName Name of the rule.
- * @returns {void}
- */
-function emitCodePathCurrentSegmentsWarning(ruleName) {
-    if (!emitCodePathCurrentSegmentsWarning[`warned-${ruleName}`]) {
-        emitCodePathCurrentSegmentsWarning[`warned-${ruleName}`] = true;
-        process.emitWarning(
-            `"${ruleName}" rule uses CodePath#currentSegments and will stop working in ESLint v9. Please read the documentation for how to update your code: https://eslint.org/docs/latest/extend/code-path-analysis#usage-examples`,
-            "DeprecationWarning"
-        );
-    }
-}
-
 /**
  * Function to replace forbidden `SourceCode` methods. Allows just one call per method.
  * @param {string} methodName The name of the method to forbid.
@@ -753,24 +737,15 @@ class RuleTester {
 
             // Verify the code.
             const { applyLanguageOptions, applyInlineConfig, finalize } = SourceCode.prototype;
-            const originalCurrentSegments = Object.getOwnPropertyDescriptor(CodePath.prototype, "currentSegments");
             let messages;
 
             try {
-                Object.defineProperty(CodePath.prototype, "currentSegments", {
-                    get() {
-                        emitCodePathCurrentSegmentsWarning(ruleName);
-                        return originalCurrentSegments.get.call(this);
-                    }
-                });
-
                 forbiddenMethods.forEach(methodName => {
                     SourceCode.prototype[methodName] = throwForbiddenMethodError(methodName, SourceCode.prototype);
                 });
 
                 messages = linter.verify(code, configs, filename);
             } finally {
-                Object.defineProperty(CodePath.prototype, "currentSegments", originalCurrentSegments);
                 SourceCode.prototype.applyInlineConfig = applyInlineConfig;
                 SourceCode.prototype.applyLanguageOptions = applyLanguageOptions;
                 SourceCode.prototype.finalize = finalize;

package/lib/rules/array-bracket-newline.js

@@ -74,7 +74,7 @@ module.exports = {
         function normalizeOptionValue(option) {
             let consistent = false;
             let multiline = false;
-            let minItems = 0;
+            let minItems;
 
             if (option) {
                 if (option === "consistent") {

package/lib/rules/array-bracket-spacing.js

@@ -199,7 +199,7 @@ module.exports = {
                     : sourceCode.getLastToken(node),
                 penultimate = sourceCode.getTokenBefore(last),
                 firstElement = node.elements[0],
-                lastElement = node.elements[node.elements.length - 1];
+                lastElement = node.elements.at(-1);
 
             const openingBracketMustBeSpaced =
                 options.objectsInArraysException && isObjectType(firstElement) ||

package/lib/rules/block-scoped-var.js

@@ -79,7 +79,7 @@ module.exports = {
             }
 
             // Defines a predicate to check whether or not a given reference is outside of valid scope.
-            const scopeRange = stack[stack.length - 1];
+            const scopeRange = stack.at(-1);
 
             /**
              * Check if a reference is out of scope

package/lib/rules/callback-return.js

@@ -147,7 +147,7 @@ module.exports = {
                 if (closestBlock.type === "BlockStatement") {
 
                     // find the last item in the block
-                    const lastItem = closestBlock.body[closestBlock.body.length - 1];
+                    const lastItem = closestBlock.body.at(-1);
 
                     // if the callback is the last thing in a block that might be ok
                     if (isCallbackExpression(node, lastItem)) {
@@ -168,7 +168,7 @@ module.exports = {
                     if (lastItem.type === "ReturnStatement") {
 
                         // but only if the callback is immediately before
-                        if (isCallbackExpression(node, closestBlock.body[closestBlock.body.length - 2])) {
+                        if (isCallbackExpression(node, closestBlock.body.at(-2))) {
                             return;
                         }
                     }

package/lib/rules/comma-dangle.js

@@ -154,7 +154,7 @@ module.exports = {
              * @returns {any} The last element
              */
             function last(array) {
-                return array[array.length - 1];
+                return array.at(-1);
             }
 
             switch (node.type) {

package/lib/rules/comma-style.js

@@ -66,7 +66,7 @@ module.exports = {
             NewExpression: true
         };
 
-        if (context.options.length === 2 && Object.prototype.hasOwnProperty.call(context.options[1], "exceptions")) {
+        if (context.options.length === 2 && Object.hasOwn(context.options[1], "exceptions")) {
             const keys = Object.keys(context.options[1].exceptions);
 
             for (let i = 0; i < keys.length; i++) {
@@ -218,7 +218,7 @@ module.exports = {
 
                         previousItemToken = tokenAfterItem
                             ? sourceCode.getTokenBefore(tokenAfterItem)
-                            : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
+                            : sourceCode.ast.tokens.at(-1);
                     } else {
                         previousItemToken = currentItemToken;
                     }

package/lib/rules/complexity.js

@@ -64,7 +64,7 @@ module.exports = {
 
         if (
             typeof option === "object" &&
-            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+            (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max"))
         ) {
             THRESHOLD = option.maximum || option.max;
         } else if (typeof option === "number") {

package/lib/rules/constructor-super.js

@@ -109,7 +109,7 @@ function isPossibleConstructor(node) {
             );
 
         case "SequenceExpression": {
-            const lastExpression = node.expressions[node.expressions.length - 1];
+            const lastExpression = node.expressions.at(-1);
 
             return isPossibleConstructor(lastExpression);
         }

package/lib/rules/default-case.js

@@ -54,7 +54,7 @@ module.exports = {
          * @returns {any} Last element
          */
         function last(collection) {
-            return collection[collection.length - 1];
+            return collection.at(-1);
         }
 
         //--------------------------------------------------------------------------

package/lib/rules/eol-last.js

@@ -45,7 +45,7 @@ module.exports = {
             Program: function checkBadEOF(node) {
                 const sourceCode = context.sourceCode,
                     src = sourceCode.getText(),
-                    lastLine = sourceCode.lines[sourceCode.lines.length - 1],
+                    lastLine = sourceCode.lines.at(-1),
                     location = {
                         column: lastLine.length,
                         line: sourceCode.lines.length
@@ -89,7 +89,7 @@ module.exports = {
                     });
                 } else if (mode === "never" && endsWithNewline) {
 
-                    const secondLastLine = sourceCode.lines[sourceCode.lines.length - 2];
+                    const secondLastLine = sourceCode.lines.at(-2);
 
                     // File is newline-terminated, but shouldn't be
                     context.report({

package/lib/rules/function-paren-newline.js

@@ -218,7 +218,7 @@ module.exports = {
                 case "FunctionExpression": {
                     const leftParen = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
                     const rightParen = node.params.length
-                        ? sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils.isClosingParenToken)
+                        ? sourceCode.getTokenAfter(node.params.at(-1), astUtils.isClosingParenToken)
                         : sourceCode.getTokenAfter(leftParen);
 
                     return { leftParen, rightParen };
@@ -234,7 +234,7 @@ module.exports = {
                     }
 
                     const rightParen = node.params.length
-                        ? sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils.isClosingParenToken)
+                        ? sourceCode.getTokenAfter(node.params.at(-1), astUtils.isClosingParenToken)
                         : sourceCode.getTokenAfter(firstToken);
 
                     return {

package/lib/rules/indent-legacy.js

@@ -789,7 +789,7 @@ module.exports = {
             if (elements.length > 0) {
 
                 // Skip last block line check if last item in same line
-                if (elements[elements.length - 1].loc.end.line === node.loc.end.line) {
+                if (elements.at(-1).loc.end.line === node.loc.end.line) {
                     return;
                 }
             }
@@ -830,7 +830,7 @@ module.exports = {
             }
 
             let indent;
-            let nodesToCheck = [];
+            let nodesToCheck;
 
             /*
              * For this statements we should check indent from statement beginning,
@@ -873,7 +873,7 @@ module.exports = {
          */
         function filterOutSameLineVars(node) {
             return node.declarations.reduce((finalCollection, elem) => {
-                const lastElem = finalCollection[finalCollection.length - 1];
+                const lastElem = finalCollection.at(-1);
 
                 if ((elem.loc.start.line !== node.loc.start.line && !lastElem) ||
                     (lastElem && lastElem.loc.start.line !== elem.loc.start.line)) {
@@ -892,7 +892,7 @@ module.exports = {
         function checkIndentInVariableDeclarations(node) {
             const elements = filterOutSameLineVars(node);
             const nodeIndent = getNodeIndent(node).goodChar;
-            const lastElement = elements[elements.length - 1];
+            const lastElement = elements.at(-1);
 
             const elementsIndent = nodeIndent + indentSize * options.VariableDeclarator[node.kind];
 
@@ -999,7 +999,7 @@ module.exports = {
             },
 
             VariableDeclaration(node) {
-                if (node.declarations[node.declarations.length - 1].loc.start.line > node.declarations[0].loc.start.line) {
+                if (node.declarations.at(-1).loc.start.line > node.declarations[0].loc.start.line) {
                     checkIndentInVariableDeclarations(node);
                 }
             },