eslint 8.23.1 → 8.25.0

package/lib/cli.js

@@ -25,7 +25,6 @@ const fs = require("fs"),
     RuntimeInfo = require("./shared/runtime-info");
 const { Legacy: { naming } } = require("@eslint/eslintrc");
 const { findFlatConfigFile } = require("./eslint/flat-eslint");
-const { gitignoreToMinimatch } = require("@humanwhocodes/gitignore-to-minimatch");
 const { ModuleImporter } = require("@humanwhocodes/module-importer");
 
 const debug = require("debug")("eslint:cli");
@@ -38,6 +37,7 @@ const debug = require("debug")("eslint:cli");
 /** @typedef {import("./eslint/eslint").LintMessage} LintMessage */
 /** @typedef {import("./eslint/eslint").LintResult} LintResult */
 /** @typedef {import("./options").ParsedCLIOptions} ParsedCLIOptions */
+/** @typedef {import("./shared/types").ResultsMeta} ResultsMeta */
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -145,7 +145,7 @@ async function translateOptions({
 
         if (ignorePattern) {
             overrideConfig.push({
-                ignores: ignorePattern.map(gitignoreToMinimatch)
+                ignores: ignorePattern
             });
         }
 
@@ -182,7 +182,6 @@ async function translateOptions({
         fix: (fix || fixDryRun) && (quiet ? quietFixPredicate : true),
         fixTypes: fixType,
         ignore,
-        ignorePath,
         overrideConfig,
         overrideConfigFile,
         reportUnusedDisableDirectives: reportUnusedDisableDirectives ? "error" : void 0
@@ -193,6 +192,7 @@ async function translateOptions({
         options.rulePaths = rulesdir;
         options.useEslintrc = eslintrc;
         options.extensions = ext;
+        options.ignorePath = ignorePath;
     }
 
     return options;
@@ -201,7 +201,7 @@ async function translateOptions({
 /**
  * Count error messages.
  * @param {LintResult[]} results The lint results.
- * @returns {{errorCount:number;warningCount:number}} The number of error messages.
+ * @returns {{errorCount:number;fatalErrorCount:number,warningCount:number}} The number of error messages.
  */
 function countErrors(results) {
     let errorCount = 0;
@@ -239,10 +239,11 @@ async function isDirectory(filePath) {
  * @param {LintResult[]} results The results to print.
  * @param {string} format The name of the formatter to use or the path to the formatter.
  * @param {string} outputFile The path for the output file.
+ * @param {ResultsMeta} resultsMeta Warning count and max threshold.
  * @returns {Promise<boolean>} True if the printing succeeds, false if not.
  * @private
  */
-async function printResults(engine, results, format, outputFile) {
+async function printResults(engine, results, format, outputFile, resultsMeta) {
     let formatter;
 
     try {
@@ -252,7 +253,7 @@ async function printResults(engine, results, format, outputFile) {
         return false;
     }
 
-    const output = await formatter.format(results);
+    const output = await formatter.format(results, resultsMeta);
 
     if (output) {
         if (outputFile) {
@@ -407,17 +408,24 @@ const cli = {
             resultsToPrint = ActiveESLint.getErrorResults(resultsToPrint);
         }
 
-        if (await printResults(engine, resultsToPrint, options.format, options.outputFile)) {
+        const resultCounts = countErrors(results);
+        const tooManyWarnings = options.maxWarnings >= 0 && resultCounts.warningCount > options.maxWarnings;
+        const resultsMeta = tooManyWarnings
+            ? {
+                maxWarningsExceeded: {
+                    maxWarnings: options.maxWarnings,
+                    foundWarnings: resultCounts.warningCount
+                }
+            }
+            : {};
 
-            // Errors and warnings from the original unfiltered results should determine the exit code
-            const { errorCount, fatalErrorCount, warningCount } = countErrors(results);
+        if (await printResults(engine, resultsToPrint, options.format, options.outputFile, resultsMeta)) {
 
-            const tooManyWarnings =
-                options.maxWarnings >= 0 && warningCount > options.maxWarnings;
+            // Errors and warnings from the original unfiltered results should determine the exit code
             const shouldExitForFatalErrors =
-                options.exitOnFatalError && fatalErrorCount > 0;
+                options.exitOnFatalError && resultCounts.fatalErrorCount > 0;
 
-            if (!errorCount && tooManyWarnings) {
+            if (!resultCounts.errorCount && tooManyWarnings) {
                 log.error(
                     "ESLint found too many warnings (maximum: %s).",
                     options.maxWarnings
@@ -428,7 +436,7 @@ const cli = {
                 return 2;
             }
 
-            return (errorCount || tooManyWarnings) ? 1 : 0;
+            return (resultCounts.errorCount || tooManyWarnings) ? 1 : 0;
         }
 
         return 2;

package/lib/config/flat-config-array.js

@@ -70,7 +70,7 @@ class FlatConfigArray extends ConfigArray {
         }
 
         /**
-         * The baes config used to build the config array.
+         * The base config used to build the config array.
          * @type {Array<FlatConfig>}
          */
         this[originalBaseConfig] = baseConfig;

package/lib/eslint/eslint-helpers.js

@@ -67,9 +67,9 @@ function isNonEmptyString(x) {
 }
 
 /**
- * Check if a given value is an array of non-empty stringss or not.
+ * Check if a given value is an array of non-empty strings or not.
  * @param {any} x The value to check.
- * @returns {boolean} `true` if `x` is an array of non-empty stringss.
+ * @returns {boolean} `true` if `x` is an array of non-empty strings.
  */
 function isArrayOfNonEmptyString(x) {
     return Array.isArray(x) && x.every(isNonEmptyString);
@@ -410,7 +410,6 @@ function processOptions({
     fixTypes = null, // ← should be null by default because if it's an array then it suppresses rules that don't have the `meta.type` property.
     globInputPaths = true,
     ignore = true,
-    ignorePath = null, // ← should be null by default because if it's a string then it may throw ENOENT.
     ignorePatterns = null,
     overrideConfig = null,
     overrideConfigFile = null,
@@ -441,6 +440,9 @@ function processOptions({
         if (unknownOptionKeys.includes("globals")) {
             errors.push("'globals' has been removed. Please use the 'overrideConfig.languageOptions.globals' option instead.");
         }
+        if (unknownOptionKeys.includes("ignorePath")) {
+            errors.push("'ignorePath' has been removed.");
+        }
         if (unknownOptionKeys.includes("ignorePattern")) {
             errors.push("'ignorePattern' has been removed. Please use the 'overrideConfig.ignorePatterns' option instead.");
         }
@@ -493,9 +495,6 @@ function processOptions({
     if (typeof ignore !== "boolean") {
         errors.push("'ignore' must be a boolean.");
     }
-    if (!isNonEmptyString(ignorePath) && ignorePath !== null) {
-        errors.push("'ignorePath' must be a non-empty string or null.");
-    }
     if (typeof overrideConfig !== "object") {
         errors.push("'overrideConfig' must be an object or null.");
     }
@@ -538,7 +537,6 @@ function processOptions({
         fixTypes,
         globInputPaths,
         ignore,
-        ignorePath,
         ignorePatterns,
         reportUnusedDisableDirectives
     };

package/lib/eslint/eslint.js

@@ -36,11 +36,12 @@ const { version } = require("../../package.json");
 /** @typedef {import("../shared/types").Plugin} Plugin */
 /** @typedef {import("../shared/types").Rule} Rule */
 /** @typedef {import("../shared/types").LintResult} LintResult */
+/** @typedef {import("../shared/types").ResultsMeta} ResultsMeta */
 
 /**
  * The main formatter object.
  * @typedef LoadedFormatter
- * @property {function(LintResult[]): string | Promise<string>} format format function.
+ * @property {(results: LintResult[], resultsMeta: ResultsMeta) => string | Promise<string>} format format function.
  */
 
 /**
@@ -625,14 +626,16 @@ class ESLint {
             /**
              * The main formatter method.
              * @param {LintResult[]} results The lint results to format.
+             * @param {ResultsMeta} resultsMeta Warning count and max threshold.
              * @returns {string | Promise<string>} The formatted lint results.
              */
-            format(results) {
+            format(results, resultsMeta) {
                 let rulesMeta = null;
 
                 results.sort(compareResultsByFilePath);
 
                 return formatter(results, {
+                    ...resultsMeta,
                     get cwd() {
                         return options.cwd;
                     },

package/lib/eslint/flat-eslint.js

@@ -16,7 +16,6 @@ const findUp = require("find-up");
 const { version } = require("../../package.json");
 const { Linter } = require("../linter");
 const { getRuleFromConfig } = require("../config/flat-config-helpers");
-const { gitignoreToMinimatch } = require("@humanwhocodes/gitignore-to-minimatch");
 const {
     Legacy: {
         ConfigOps: {
@@ -28,7 +27,6 @@ const {
 } = require("@eslint/eslintrc");
 
 const {
-    fileExists,
     findFiles,
     getCacheFile,
 
@@ -59,6 +57,7 @@ const LintResultCache = require("../cli-engine/lint-result-cache");
 /** @typedef {import("../shared/types").LintMessage} LintMessage */
 /** @typedef {import("../shared/types").ParserOptions} ParserOptions */
 /** @typedef {import("../shared/types").Plugin} Plugin */
+/** @typedef {import("../shared/types").ResultsMeta} ResultsMeta */
 /** @typedef {import("../shared/types").RuleConf} RuleConf */
 /** @typedef {import("../shared/types").Rule} Rule */
 /** @typedef {ReturnType<ConfigArray.extractConfig>} ExtractedConfig */
@@ -76,9 +75,8 @@ const LintResultCache = require("../cli-engine/lint-result-cache");
  * @property {boolean|Function} [fix] Execute in autofix mode. If a function, should return a boolean.
  * @property {string[]} [fixTypes] Array of rule types to apply fixes for.
  * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
- * @property {boolean} [ignore] False disables use of .eslintignore.
- * @property {string} [ignorePath] The ignore file to use instead of .eslintignore.
- * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to .eslintignore.
+ * @property {boolean} [ignore] False disables all ignore patterns except for the default ones.
+ * @property {string[]} [ignorePatterns] Ignore file patterns to use in addition to config ignores.
  * @property {ConfigData} [overrideConfig] Override config object, overrides all configs used with this instance
  * @property {boolean|string} [overrideConfigFile] Searches for default config file when falsy;
  *      doesn't do any config file lookup when `true`; considered to be a config filename
@@ -151,30 +149,6 @@ function calculateStatsPerRun(results) {
     });
 }
 
-/**
- * Loads global ignore patterns from an ignore file (usually .eslintignore).
- * @param {string} filePath The filename to load.
- * @returns {ignore} A function encapsulating the ignore patterns.
- * @throws {Error} If the file cannot be read.
- * @private
- */
-async function loadIgnoreFilePatterns(filePath) {
-    debug(`Loading ignore file: ${filePath}`);
-
-    try {
-        const ignoreFileText = await fs.readFile(filePath, { encoding: "utf8" });
-
-        return ignoreFileText
-            .split(/\r?\n/gu)
-            .filter(line => line.trim() !== "" && !line.startsWith("#"));
-
-    } catch (e) {
-        debug(`Error reading ignore file: ${filePath}`);
-        e.message = `Cannot read ignore file: ${filePath}\nError: ${e.message}`;
-        throw e;
-    }
-}
-
 /**
  * Create rulesMeta object.
  * @param {Map<string,Rule>} rules a map of rules from which to generate the object.
@@ -319,7 +293,6 @@ async function calculateConfigArray(eslint, {
     overrideConfig,
     configFile,
     ignore: shouldIgnore,
-    ignorePath,
     ignorePatterns
 }) {
 
@@ -364,22 +337,6 @@ async function calculateConfigArray(eslint, {
     configs.push(...slots.defaultConfigs);
 
     let allIgnorePatterns = [];
-    let ignoreFilePath;
-
-    // load ignore file if necessary
-    if (shouldIgnore) {
-        if (ignorePath) {
-            ignoreFilePath = path.resolve(cwd, ignorePath);
-            allIgnorePatterns = await loadIgnoreFilePatterns(ignoreFilePath);
-        } else {
-            ignoreFilePath = path.resolve(cwd, ".eslintignore");
-
-            // no error if .eslintignore doesn't exist`
-            if (fileExists(ignoreFilePath)) {
-                allIgnorePatterns = await loadIgnoreFilePatterns(ignoreFilePath);
-            }
-        }
-    }
 
     // append command line ignore patterns
     if (ignorePatterns) {
@@ -428,7 +385,7 @@ async function calculateConfigArray(eslint, {
          * so they can override default ignores.
          */
         configs.push({
-            ignores: allIgnorePatterns.map(gitignoreToMinimatch)
+            ignores: allIgnorePatterns
         });
     }
 
@@ -872,7 +829,7 @@ class FlatESLint {
                 }
 
 
-                // set up fixer for fixtypes if necessary
+                // set up fixer for fixTypes if necessary
                 let fixer = fix;
 
                 if (fix && fixTypesSet) {
@@ -1048,7 +1005,7 @@ class FlatESLint {
      * The following values are allowed:
      * - `undefined` ... Load `stylish` builtin formatter.
      * - A builtin formatter name ... Load the builtin formatter.
-     * - A thirdparty formatter name:
+     * - A third-party formatter name:
      *   - `foo` → `eslint-formatter-foo`
      *   - `@foo` → `@foo/eslint-formatter`
      *   - `@foo/bar` → `@foo/eslint-formatter-bar`
@@ -1114,14 +1071,16 @@ class FlatESLint {
             /**
              * The main formatter method.
              * @param {LintResults[]} results The lint results to format.
+             * @param {ResultsMeta} resultsMeta Warning count and max threshold.
              * @returns {string} The formatted lint results.
              */
-            format(results) {
+            format(results, resultsMeta) {
                 let rulesMeta = null;
 
                 results.sort(compareResultsByFilePath);
 
                 return formatter(results, {
+                    ...resultsMeta,
                     cwd,
                     get rulesMeta() {
                         if (!rulesMeta) {

package/lib/linter/linter.js

@@ -1601,12 +1601,18 @@ class Linter {
             languageOptions.ecmaVersion
         );
 
-        // add configured globals and language globals
-        const configuredGlobals = {
-            ...(getGlobalsForEcmaVersion(languageOptions.ecmaVersion)),
-            ...(languageOptions.sourceType === "commonjs" ? globals.commonjs : void 0),
-            ...languageOptions.globals
-        };
+        /*
+         * add configured globals and language globals
+         *
+         * using Object.assign instead of object spread for performance reasons
+         * https://github.com/eslint/eslint/issues/16302
+         */
+        const configuredGlobals = Object.assign(
+            {},
+            getGlobalsForEcmaVersion(languageOptions.ecmaVersion),
+            languageOptions.sourceType === "commonjs" ? globals.commonjs : void 0,
+            languageOptions.globals
+        );
 
         // double check that there is a parser to avoid mysterious error messages
         if (!languageOptions.parser) {

package/lib/options.js

@@ -67,7 +67,7 @@ const optionator = require("optionator");
 /**
  * Creates the CLI options for ESLint.
  * @param {boolean} usingFlatConfig Indicates if flat config is being used.
- * @returns {Object} The opinionator instance.
+ * @returns {Object} The optionator instance.
  */
 module.exports = function(usingFlatConfig) {
 
@@ -129,6 +129,16 @@ module.exports = function(usingFlatConfig) {
         };
     }
 
+    let ignorePathFlag;
+
+    if (!usingFlatConfig) {
+        ignorePathFlag = {
+            option: "ignore-path",
+            type: "path::String",
+            description: "Specify path of ignore file"
+        };
+    }
+
     return optionator({
         prepend: "eslint [options] file.js [file.js] [dir]",
         defaults: {
@@ -203,11 +213,7 @@ module.exports = function(usingFlatConfig) {
             {
                 heading: "Ignoring files"
             },
-            {
-                option: "ignore-path",
-                type: "path::String",
-                description: "Specify path of ignore file"
-            },
+            ignorePathFlag,
             {
                 option: "ignore",
                 type: "Boolean",

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

@@ -16,7 +16,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
-const TARGET_METHODS = /^(?:every|filter|find(?:Index)?|flatMap|forEach|map|reduce(?:Right)?|some|sort)$/u;
+const TARGET_METHODS = /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|reduce(?:Right)?|some|sort)$/u;
 
 /**
  * Checks a given code path segment is reachable.

package/lib/rules/id-length.js

@@ -6,6 +6,45 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+const GraphemeSplitter = require("grapheme-splitter");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks if the string given as argument is ASCII or not.
+ * @param {string} value A string that you want to know if it is ASCII or not.
+ * @returns {boolean} `true` if `value` is ASCII string.
+ */
+function isASCII(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    return /^[\u0020-\u007f]*$/u.test(value);
+}
+
+/** @type {GraphemeSplitter | undefined} */
+let splitter;
+
+/**
+ * Gets the length of the string. If the string is not in ASCII, counts graphemes.
+ * @param {string} value A string that you want to get the length.
+ * @returns {number} The length of `value`.
+ */
+function getStringLength(value) {
+    if (isASCII(value)) {
+        return value.length;
+    }
+    if (!splitter) {
+        splitter = new GraphemeSplitter();
+    }
+    return splitter.countGraphemes(value);
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -130,8 +169,10 @@ module.exports = {
                 const name = node.name;
                 const parent = node.parent;
 
-                const isShort = name.length < minLength;
-                const isLong = name.length > maxLength;
+                const nameLength = getStringLength(name);
+
+                const isShort = nameLength < minLength;
+                const isLong = nameLength > maxLength;
 
                 if (!(isShort || isLong) || exceptions.has(name) || matchesExceptionPattern(name)) {
                     return; // Nothing to report

package/lib/rules/index.js

@@ -72,6 +72,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "lines-around-comment": () => require("./lines-around-comment"),
     "lines-around-directive": () => require("./lines-around-directive"),
     "lines-between-class-members": () => require("./lines-between-class-members"),
+    "logical-assignment-operators": () => require("./logical-assignment-operators"),
     "max-classes-per-file": () => require("./max-classes-per-file"),
     "max-depth": () => require("./max-depth"),
     "max-len": () => require("./max-len"),

package/lib/rules/lines-around-comment.js

@@ -15,7 +15,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 /**
- * Return an array with with any line numbers that are empty.
+ * Return an array with any line numbers that are empty.
  * @param {Array} lines An array of each line of the file.
  * @returns {Array} An array of line numbers.
  */
@@ -29,7 +29,7 @@ function getEmptyLineNums(lines) {
 }
 
 /**
- * Return an array with with any line numbers that contain comments.
+ * Return an array with any line numbers that contain comments.
  * @param {Array} comments An array of comment tokens.
  * @returns {Array} An array of line numbers.
  */

package/lib/rules/logical-assignment-operators.js

@@ -0,0 +1,474 @@
+/**
+ * @fileoverview Rule to replace assignment expressions with logical operator assignment
+ * @author Daniel Martens
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+const astUtils = require("./utils/ast-utils.js");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const baseTypes = new Set(["Identifier", "Super", "ThisExpression"]);
+
+/**
+ * Returns true iff either "undefined" or a void expression (eg. "void 0")
+ * @param {ASTNode} expression Expression to check
+ * @param {import('eslint-scope').Scope} scope Scope of the expression
+ * @returns {boolean} True iff "undefined" or "void ..."
+ */
+function isUndefined(expression, scope) {
+    if (expression.type === "Identifier" && expression.name === "undefined") {
+        return astUtils.isReferenceToGlobalVariable(scope, expression);
+    }
+
+    return expression.type === "UnaryExpression" &&
+           expression.operator === "void" &&
+           expression.argument.type === "Literal" &&
+           expression.argument.value === 0;
+}
+
+/**
+ * Returns true iff the reference is either an identifier or member expression
+ * @param {ASTNode} expression Expression to check
+ * @returns {boolean} True for identifiers and member expressions
+ */
+function isReference(expression) {
+    return (expression.type === "Identifier" && expression.name !== "undefined") ||
+           expression.type === "MemberExpression";
+}
+
+/**
+ * Returns true iff the expression checks for nullish with loose equals.
+ * Examples: value == null, value == void 0
+ * @param {ASTNode} expression Test condition
+ * @param {import('eslint-scope').Scope} scope Scope of the expression
+ * @returns {boolean} True iff implicit nullish comparison
+ */
+function isImplicitNullishComparison(expression, scope) {
+    if (expression.type !== "BinaryExpression" || expression.operator !== "==") {
+        return false;
+    }
+
+    const reference = isReference(expression.left) ? "left" : "right";
+    const nullish = reference === "left" ? "right" : "left";
+
+    return isReference(expression[reference]) &&
+           (astUtils.isNullLiteral(expression[nullish]) || isUndefined(expression[nullish], scope));
+}
+
+/**
+ * Condition with two equal comparisons.
+ * @param {ASTNode} expression Condition
+ * @returns {boolean} True iff matches ? === ? || ? === ?
+ */
+function isDoubleComparison(expression) {
+    return expression.type === "LogicalExpression" &&
+           expression.operator === "||" &&
+           expression.left.type === "BinaryExpression" &&
+           expression.left.operator === "===" &&
+           expression.right.type === "BinaryExpression" &&
+           expression.right.operator === "===";
+}
+
+/**
+ * Returns true iff the expression checks for undefined and null.
+ * Example: value === null || value === undefined
+ * @param {ASTNode} expression Test condition
+ * @param {import('eslint-scope').Scope} scope Scope of the expression
+ * @returns {boolean} True iff explicit nullish comparison
+ */
+function isExplicitNullishComparison(expression, scope) {
+    if (!isDoubleComparison(expression)) {
+        return false;
+    }
+    const leftReference = isReference(expression.left.left) ? "left" : "right";
+    const leftNullish = leftReference === "left" ? "right" : "left";
+    const rightReference = isReference(expression.right.left) ? "left" : "right";
+    const rightNullish = rightReference === "left" ? "right" : "left";
+
+    return astUtils.isSameReference(expression.left[leftReference], expression.right[rightReference]) &&
+           ((astUtils.isNullLiteral(expression.left[leftNullish]) && isUndefined(expression.right[rightNullish], scope)) ||
+           (isUndefined(expression.left[leftNullish], scope) && astUtils.isNullLiteral(expression.right[rightNullish])));
+}
+
+/**
+ * Returns true for Boolean(arg) calls
+ * @param {ASTNode} expression Test condition
+ * @param {import('eslint-scope').Scope} scope Scope of the expression
+ * @returns {boolean} Whether the expression is a boolean cast
+ */
+function isBooleanCast(expression, scope) {
+    return expression.type === "CallExpression" &&
+           expression.callee.name === "Boolean" &&
+           expression.arguments.length === 1 &&
+           astUtils.isReferenceToGlobalVariable(scope, expression.callee);
+}
+
+/**
+ * Returns true for:
+ * truthiness checks:  value, Boolean(value), !!value
+ * falsyness checks:   !value, !Boolean(value)
+ * nullish checks:     value == null, value === undefined || value === null
+ * @param {ASTNode} expression Test condition
+ * @param {import('eslint-scope').Scope} scope Scope of the expression
+ * @returns {?{ reference: ASTNode, operator: '??'|'||'|'&&'}} Null if not a known existence
+ */
+function getExistence(expression, scope) {
+    const isNegated = expression.type === "UnaryExpression" && expression.operator === "!";
+    const base = isNegated ? expression.argument : expression;
+
+    switch (true) {
+        case isReference(base):
+            return { reference: base, operator: isNegated ? "||" : "&&" };
+        case base.type === "UnaryExpression" && base.operator === "!" && isReference(base.argument):
+            return { reference: base.argument, operator: "&&" };
+        case isBooleanCast(base, scope) && isReference(base.arguments[0]):
+            return { reference: base.arguments[0], operator: isNegated ? "||" : "&&" };
+        case isImplicitNullishComparison(expression, scope):
+            return { reference: isReference(expression.left) ? expression.left : expression.right, operator: "??" };
+        case isExplicitNullishComparison(expression, scope):
+            return { reference: isReference(expression.left.left) ? expression.left.left : expression.left.right, operator: "??" };
+        default: return null;
+    }
+}
+
+/**
+ * Returns true iff the node is inside a with block
+ * @param {ASTNode} node Node to check
+ * @returns {boolean} True iff passed node is inside a with block
+ */
+function isInsideWithBlock(node) {
+    if (node.type === "Program") {
+        return false;
+    }
+
+    return node.parent.type === "WithStatement" && node.parent.body === node ? true : isInsideWithBlock(node.parent);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Require or disallow logical assignment logical operator shorthand",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/logical-assignment-operators"
+        },
+
+        schema: {
+            type: "array",
+            oneOf: [{
+                items: [
+                    { const: "always" },
+                    {
+                        type: "object",
+                        properties: {
+                            enforceForIfStatements: {
+                                type: "boolean"
+                            }
+                        },
+                        additionalProperties: false
+                    }
+                ],
+                minItems: 0, // 0 for allowing passing no options
+                maxItems: 2
+            }, {
+                items: [{ const: "never" }],
+                minItems: 1,
+                maxItems: 1
+            }]
+        },
+        fixable: "code",
+        // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- Does not detect conditional suggestions
+        hasSuggestions: true,
+        messages: {
+            assignment: "Assignment (=) can be replaced with operator assignment ({{operator}}).",
+            useLogicalOperator: "Convert this assignment to use the operator {{ operator }}.",
+            logical: "Logical expression can be replaced with an assignment ({{ operator }}).",
+            convertLogical: "Replace this logical expression with an assignment with the operator {{ operator }}.",
+            if: "'if' statement can be replaced with a logical operator assignment with operator {{ operator }}.",
+            convertIf: "Replace this 'if' statement with a logical assignment with operator {{ operator }}.",
+            unexpected: "Unexpected logical operator assignment ({{operator}}) shorthand.",
+            separate: "Separate the logical assignment into an assignment with a logical operator."
+        }
+    },
+
+    create(context) {
+        const mode = context.options[0] === "never" ? "never" : "always";
+        const checkIf = mode === "always" && context.options.length > 1 && context.options[1].enforceForIfStatements;
+        const sourceCode = context.getSourceCode();
+        const isStrict = context.getScope().isStrict;
+
+        /**
+         * Returns false if the access could be a getter
+         * @param {ASTNode} node Assignment expression
+         * @returns {boolean} True iff the fix is safe
+         */
+        function cannotBeGetter(node) {
+            return node.type === "Identifier" &&
+                   (isStrict || !isInsideWithBlock(node));
+        }
+
+        /**
+         * Check whether only a single property is accessed
+         * @param {ASTNode} node reference
+         * @returns {boolean} True iff a single property is accessed
+         */
+        function accessesSingleProperty(node) {
+            if (!isStrict && isInsideWithBlock(node)) {
+                return node.type === "Identifier";
+            }
+
+            return node.type === "MemberExpression" &&
+                   baseTypes.has(node.object.type) &&
+                   (!node.computed || (node.property.type !== "MemberExpression" && node.property.type !== "ChainExpression"));
+        }
+
+        /**
+         * Adds a fixer or suggestion whether on the fix is safe.
+         * @param {{ messageId: string, node: ASTNode }} descriptor Report descriptor without fix or suggest
+         * @param {{ messageId: string, fix: Function }} suggestion Adds the fix or the whole suggestion as only element in "suggest" to suggestion
+         * @param {boolean} shouldBeFixed Fix iff the condition is true
+         * @returns {Object} Descriptor with either an added fix or suggestion
+         */
+        function createConditionalFixer(descriptor, suggestion, shouldBeFixed) {
+            if (shouldBeFixed) {
+                return {
+                    ...descriptor,
+                    fix: suggestion.fix
+                };
+            }
+
+            return {
+                ...descriptor,
+                suggest: [suggestion]
+            };
+        }
+
+
+        /**
+         * Returns the operator token for assignments and binary expressions
+         * @param {ASTNode} node AssignmentExpression or BinaryExpression
+         * @returns {import('eslint').AST.Token} Operator token between the left and right expression
+         */
+        function getOperatorToken(node) {
+            return sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
+        }
+
+        if (mode === "never") {
+            return {
+
+                // foo ||= bar
+                "AssignmentExpression"(assignment) {
+                    if (!astUtils.isLogicalAssignmentOperator(assignment.operator)) {
+                        return;
+                    }
+
+                    const descriptor = {
+                        messageId: "unexpected",
+                        node: assignment,
+                        data: { operator: assignment.operator }
+                    };
+                    const suggestion = {
+                        messageId: "separate",
+                        *fix(ruleFixer) {
+                            if (sourceCode.getCommentsInside(assignment).length > 0) {
+                                return;
+                            }
+
+                            const operatorToken = getOperatorToken(assignment);
+
+                            // -> foo = bar
+                            yield ruleFixer.replaceText(operatorToken, "=");
+
+                            const assignmentText = sourceCode.getText(assignment.left);
+                            const operator = assignment.operator.slice(0, -1);
+
+                            // -> foo = foo || bar
+                            yield ruleFixer.insertTextAfter(operatorToken, ` ${assignmentText} ${operator}`);
+
+                            const precedence = astUtils.getPrecedence(assignment.right) <= astUtils.getPrecedence({ type: "LogicalExpression", operator });
+
+                            // ?? and || / && cannot be mixed but have same precedence
+                            const mixed = assignment.operator === "??=" && astUtils.isLogicalExpression(assignment.right);
+
+                            if (!astUtils.isParenthesised(sourceCode, assignment.right) && (precedence || mixed)) {
+
+                                // -> foo = foo || (bar)
+                                yield ruleFixer.insertTextBefore(assignment.right, "(");
+                                yield ruleFixer.insertTextAfter(assignment.right, ")");
+                            }
+                        }
+                    };
+
+                    context.report(createConditionalFixer(descriptor, suggestion, cannotBeGetter(assignment.left)));
+                }
+            };
+        }
+
+        return {
+
+            // foo = foo || bar
+            "AssignmentExpression[operator='='][right.type='LogicalExpression']"(assignment) {
+                if (!astUtils.isSameReference(assignment.left, assignment.right.left)) {
+                    return;
+                }
+
+                const descriptor = {
+                    messageId: "assignment",
+                    node: assignment,
+                    data: { operator: `${assignment.right.operator}=` }
+                };
+                const suggestion = {
+                    messageId: "useLogicalOperator",
+                    data: { operator: `${assignment.right.operator}=` },
+                    *fix(ruleFixer) {
+                        if (sourceCode.getCommentsInside(assignment).length > 0) {
+                            return;
+                        }
+
+                        // No need for parenthesis around the assignment based on precedence as the precedence stays the same even with changed operator
+                        const assignmentOperatorToken = getOperatorToken(assignment);
+
+                        // -> foo ||= foo || bar
+                        yield ruleFixer.insertTextBefore(assignmentOperatorToken, assignment.right.operator);
+
+                        // -> foo ||= bar
+                        const logicalOperatorToken = getOperatorToken(assignment.right);
+                        const firstRightOperandToken = sourceCode.getTokenAfter(logicalOperatorToken);
+
+                        yield ruleFixer.removeRange([assignment.right.range[0], firstRightOperandToken.range[0]]);
+                    }
+                };
+
+                context.report(createConditionalFixer(descriptor, suggestion, cannotBeGetter(assignment.left)));
+            },
+
+            // foo || (foo = bar)
+            'LogicalExpression[right.type="AssignmentExpression"][right.operator="="]'(logical) {
+
+                // Right side has to be parenthesized, otherwise would be parsed as (foo || foo) = bar which is illegal
+                if (isReference(logical.left) && astUtils.isSameReference(logical.left, logical.right.left)) {
+                    const descriptor = {
+                        messageId: "logical",
+                        node: logical,
+                        data: { operator: `${logical.operator}=` }
+                    };
+                    const suggestion = {
+                        messageId: "convertLogical",
+                        data: { operator: `${logical.operator}=` },
+                        *fix(ruleFixer) {
+                            if (sourceCode.getCommentsInside(logical).length > 0) {
+                                return;
+                            }
+
+                            const requiresOuterParenthesis = logical.parent.type !== "ExpressionStatement" &&
+                                                             (astUtils.getPrecedence({ type: "AssignmentExpression" }) < astUtils.getPrecedence(logical.parent));
+
+                            if (!astUtils.isParenthesised(sourceCode, logical) && requiresOuterParenthesis) {
+                                yield ruleFixer.insertTextBefore(logical, "(");
+                                yield ruleFixer.insertTextAfter(logical, ")");
+                            }
+
+                            // Also removes all opening parenthesis
+                            yield ruleFixer.removeRange([logical.range[0], logical.right.range[0]]); // -> foo = bar)
+
+                            // Also removes all ending parenthesis
+                            yield ruleFixer.removeRange([logical.right.range[1], logical.range[1]]); // -> foo = bar
+
+                            const operatorToken = getOperatorToken(logical.right);
+
+                            yield ruleFixer.insertTextBefore(operatorToken, logical.operator); // -> foo ||= bar
+                        }
+                    };
+                    const fix = cannotBeGetter(logical.left) || accessesSingleProperty(logical.left);
+
+                    context.report(createConditionalFixer(descriptor, suggestion, fix));
+                }
+            },
+
+            // if (foo) foo = bar
+            "IfStatement[alternate=null]"(ifNode) {
+                if (!checkIf) {
+                    return;
+                }
+
+                const hasBody = ifNode.consequent.type === "BlockStatement";
+
+                if (hasBody && ifNode.consequent.body.length !== 1) {
+                    return;
+                }
+
+                const body = hasBody ? ifNode.consequent.body[0] : ifNode.consequent;
+                const scope = context.getScope();
+                const existence = getExistence(ifNode.test, scope);
+
+                if (
+                    body.type === "ExpressionStatement" &&
+                    body.expression.type === "AssignmentExpression" &&
+                    body.expression.operator === "=" &&
+                    existence !== null &&
+                    astUtils.isSameReference(existence.reference, body.expression.left)
+                ) {
+                    const descriptor = {
+                        messageId: "if",
+                        node: ifNode,
+                        data: { operator: `${existence.operator}=` }
+                    };
+                    const suggestion = {
+                        messageId: "convertIf",
+                        data: { operator: `${existence.operator}=` },
+                        *fix(ruleFixer) {
+                            if (sourceCode.getCommentsInside(ifNode).length > 0) {
+                                return;
+                            }
+
+                            const firstBodyToken = sourceCode.getFirstToken(body);
+                            const prevToken = sourceCode.getTokenBefore(ifNode);
+
+                            if (
+                                prevToken !== null &&
+                                prevToken.value !== ";" &&
+                                prevToken.value !== "{" &&
+                                firstBodyToken.type !== "Identifier" &&
+                                firstBodyToken.type !== "Keyword"
+                            ) {
+
+                                // Do not fix if the fixed statement could be part of the previous statement (eg. fn() if (a == null) (a) = b --> fn()(a) ??= b)
+                                return;
+                            }
+
+
+                            const operatorToken = getOperatorToken(body.expression);
+
+                            yield ruleFixer.insertTextBefore(operatorToken, existence.operator); // -> if (foo) foo ||= bar
+
+                            yield ruleFixer.removeRange([ifNode.range[0], body.range[0]]); // -> foo ||= bar
+
+                            yield ruleFixer.removeRange([body.range[1], ifNode.range[1]]); // -> foo ||= bar, only present if "if" had a body
+
+                            const nextToken = sourceCode.getTokenAfter(body.expression);
+
+                            if (hasBody && (nextToken !== null && nextToken.value !== ";")) {
+                                yield ruleFixer.insertTextAfter(ifNode, ";");
+                            }
+                        }
+                    };
+                    const shouldBeFixed = cannotBeGetter(existence.reference) ||
+                                          (ifNode.test.type !== "LogicalExpression" && accessesSingleProperty(existence.reference));
+
+                    context.report(createConditionalFixer(descriptor, suggestion, shouldBeFixed));
+                }
+            }
+        };
+    }
+};

package/lib/rules/no-loss-of-precision.js

@@ -105,7 +105,7 @@ module.exports = {
         }
 
         /**
-         * Converts an integer to to an object containing the integer's coefficient and order of magnitude
+         * Converts an integer to an object containing the integer's coefficient and order of magnitude
          * @param {string} stringInteger the string representation of the integer being converted
          * @returns {Object} the object containing the integer's coefficient and order of magnitude
          */
@@ -120,7 +120,7 @@ module.exports = {
 
         /**
          *
-         * Converts a float to to an object containing the floats's coefficient and order of magnitude
+         * Converts a float to an object containing the floats's coefficient and order of magnitude
          * @param {string} stringFloat the string representation of the float being converted
          * @returns {Object} the object containing the integer's coefficient and order of magnitude
          */

package/lib/rules/no-use-before-define.js

@@ -68,7 +68,7 @@ function isInClassStaticInitializerRange(node, location) {
 }
 
 /**
- * Checks whether a given scope is the scope of a a class static initializer.
+ * Checks whether a given scope is the scope of a class static initializer.
  * Static initializers are static blocks and initializers of static fields.
  * @param {eslint-scope.Scope} scope A scope to check.
  * @returns {boolean} `true` if the scope is a class static initializer scope.

package/lib/rules/strict.js

@@ -105,7 +105,7 @@ module.exports = {
         if (ecmaFeatures.impliedStrict) {
             mode = "implied";
         } else if (mode === "safe") {
-            mode = ecmaFeatures.globalReturn ? "global" : "function";
+            mode = ecmaFeatures.globalReturn || context.languageOptions.sourceType === "commonjs" ? "global" : "function";
         }
 
         /**

package/lib/shared/traverser.js

@@ -74,7 +74,7 @@ class Traverser {
     }
 
     /**
-     * Gives a a copy of the ancestor nodes.
+     * Gives a copy of the ancestor nodes.
      * @returns {ASTNode[]} The ancestor nodes.
      */
     parents() {

package/lib/shared/types.js

@@ -190,10 +190,23 @@ module.exports = {};
  * @property {DeprecatedRuleInfo[]} usedDeprecatedRules The list of used deprecated rules.
  */
 
+/**
+ * Information provided when the maximum warning threshold is exceeded.
+ * @typedef {Object} MaxWarningsExceeded
+ * @property {number} maxWarnings Number of warnings to trigger nonzero exit code.
+ * @property {number} foundWarnings Number of warnings found while linting.
+ */
+
+/**
+ * Metadata about results for formatters.
+ * @typedef {Object} ResultsMeta
+ * @property {MaxWarningsExceeded} [maxWarningsExceeded] Present if the maxWarnings threshold was exceeded.
+ */
+
 /**
  * A formatter function.
  * @callback FormatterFunction
  * @param {LintResult[]} results The list of linting results.
- * @param {{cwd: string, rulesMeta: Record<string, RuleMeta>}} [context] A context object.
+ * @param {{cwd: string, maxWarningsExceeded?: MaxWarningsExceeded, rulesMeta: Record<string, RuleMeta>}} [context] A context object.
  * @returns {string | Promise<string>} Formatted text.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.23.1",
+  "version": "8.25.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -55,9 +55,8 @@
   "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
-    "@eslint/eslintrc": "^1.3.2",
-    "@humanwhocodes/config-array": "^0.10.4",
-    "@humanwhocodes/gitignore-to-minimatch": "^1.0.2",
+    "@eslint/eslintrc": "^1.3.3",
+    "@humanwhocodes/config-array": "^0.10.5",
     "@humanwhocodes/module-importer": "^1.0.1",
     "ajv": "^6.10.0",
     "chalk": "^4.0.0",
@@ -121,7 +120,6 @@
     "glob": "^7.1.6",
     "got": "^11.8.3",
     "gray-matter": "^4.0.3",
-    "jsdoc": "^3.5.5",
     "karma": "^6.1.1",
     "karma-chrome-launcher": "^3.1.0",
     "karma-mocha": "^2.0.1",