eslint 8.23.0 → 8.24.0

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

@@ -122,7 +122,8 @@ function statSafeSync(filePath) {
     try {
         return fs.statSync(filePath);
     } catch (error) {
-        /* istanbul ignore next */
+
+        /* c8 ignore next */
         if (error.code !== "ENOENT") {
             throw error;
         }
@@ -141,7 +142,8 @@ function readdirSafeSync(directoryPath) {
     try {
         return fs.readdirSync(directoryPath, { withFileTypes: true });
     } catch (error) {
-        /* istanbul ignore next */
+
+        /* c8 ignore next */
         if (error.code !== "ENOENT") {
             throw error;
         }

package/lib/eslint/eslint-helpers.js

@@ -15,6 +15,7 @@ const fsp = fs.promises;
 const isGlob = require("is-glob");
 const globby = require("globby");
 const hash = require("../cli-engine/hash");
+const minimatch = require("minimatch");
 
 //-----------------------------------------------------------------------------
 // Errors
@@ -126,14 +127,14 @@ async function findFiles({
     const filePaths = patterns.map(filePath => path.resolve(cwd, filePath));
     const stats = await Promise.all(
         filePaths.map(
-            filePath => fsp.stat(filePath).catch(() => {})
+            filePath => fsp.stat(filePath).catch(() => { })
         )
     );
 
     stats.forEach((stat, index) => {
 
         const filePath = filePaths[index];
-        const pattern = patterns[index];
+        const pattern = normalizeToPosix(patterns[index]);
 
         if (stat) {
 
@@ -157,6 +158,11 @@ async function findFiles({
                             return false;
                         }
 
+                        // patterns starting with ** always apply
+                        if (filePattern.startsWith("**")) {
+                            return true;
+                        }
+
                         // patterns ending with * are not used for file search
                         if (filePattern.endsWith("*")) {
                             return false;
@@ -167,11 +173,27 @@ async function findFiles({
                             return false;
                         }
 
-                        // check if the pattern would be inside the cwd or not
+                        // check if the pattern would be inside the config base path or not
                         const fullFilePattern = path.join(cwd, filePattern);
-                        const relativeFilePattern = path.relative(configs.basePath, fullFilePattern);
+                        const patternRelativeToConfigBasePath = path.relative(configs.basePath, fullFilePattern);
+
+                        if (patternRelativeToConfigBasePath.startsWith("..")) {
+                            return false;
+                        }
+
+                        // check if the pattern matches
+                        if (minimatch(filePath, path.dirname(fullFilePattern), { partial: true })) {
+                            return true;
+                        }
+
+                        // check if the pattern is inside the directory or not
+                        const patternRelativeToFilePath = path.relative(filePath, fullFilePattern);
+
+                        if (patternRelativeToFilePath.startsWith("..")) {
+                            return false;
+                        }
 
-                        return !relativeFilePattern.startsWith("..");
+                        return true;
                     })
                     .map(filePattern => {
                         if (filePattern.startsWith("**")) {

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

@@ -88,10 +88,10 @@ class CodePathSegment {
             }
         });
 
-        /* istanbul ignore if */
+        /* c8 ignore start */
         if (debug.enabled) {
             this.internal.nodes = [];
-        }
+        }/* c8 ignore stop */
     }
 
     /**

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

@@ -59,7 +59,7 @@ function getContinueContext(state, label) {
         context = context.upper;
     }
 
-    /* istanbul ignore next: foolproof (syntax error) */
+    /* c8 ignore next */
     return null;
 }
 
@@ -79,7 +79,7 @@ function getBreakContext(state, label) {
         context = context.upper;
     }
 
-    /* istanbul ignore next: foolproof (syntax error) */
+    /* c8 ignore next */
     return null;
 }
 
@@ -433,7 +433,7 @@ class CodePathState {
                  */
                 return context;
 
-            /* istanbul ignore next */
+            /* c8 ignore next */
             default:
                 throw new Error("unreachable");
         }
@@ -1030,7 +1030,7 @@ class CodePathState {
                 };
                 break;
 
-            /* istanbul ignore next */
+            /* c8 ignore next */
             default:
                 throw new Error(`unknown type: "${type}"`);
         }
@@ -1095,7 +1095,7 @@ class CodePathState {
                 );
                 break;
 
-            /* istanbul ignore next */
+            /* c8 ignore next */
             default:
                 throw new Error("unreachable");
         }
@@ -1392,11 +1392,12 @@ class CodePathState {
 
         const context = getBreakContext(this, label);
 
-        /* istanbul ignore else: foolproof (syntax error) */
+
         if (context) {
             context.brokenForkContext.add(forkContext.head);
         }
 
+        /* c8 ignore next */
         forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));
     }
 
@@ -1417,7 +1418,6 @@ class CodePathState {
 
         const context = getContinueContext(this, label);
 
-        /* istanbul ignore else: foolproof (syntax error) */
         if (context) {
             if (context.continueDestSegments) {
                 makeLooped(this, forkContext.head, context.continueDestSegments);

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

@@ -20,7 +20,7 @@ const debug = require("debug")("eslint:code-path");
  * @param {CodePathSegment} segment A segment to get.
  * @returns {string} Id of the segment.
  */
-/* istanbul ignore next */
+/* c8 ignore next */
 function getId(segment) { // eslint-disable-line jsdoc/require-jsdoc -- Ignoring
     return segment.id + (segment.reachable ? "" : "!");
 }
@@ -67,7 +67,7 @@ module.exports = {
      * @param {boolean} leaving A flag whether or not it's leaving
      * @returns {void}
      */
-    dumpState: !debug.enabled ? debug : /* istanbul ignore next */ function(node, state, leaving) {
+    dumpState: !debug.enabled ? debug : /* c8 ignore next */ function(node, state, leaving) {
         for (let i = 0; i < state.currentSegments.length; ++i) {
             const segInternal = state.currentSegments[i].internal;
 
@@ -98,7 +98,7 @@ module.exports = {
      * @see http://www.graphviz.org
      * @see http://www.webgraphviz.com
      */
-    dumpDot: !debug.enabled ? debug : /* istanbul ignore next */ function(codePath) {
+    dumpDot: !debug.enabled ? debug : /* c8 ignore next */ function(codePath) {
         let text =
             "\n" +
             "digraph {\n" +

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

@@ -33,10 +33,10 @@ class IdGenerator {
     next() {
         this.n = 1 + this.n | 0;
 
-        /* istanbul ignore if */
+        /* c8 ignore start */
         if (this.n < 0) {
             this.n = 1;
-        }
+        }/* c8 ignore stop */
 
         return this.prefix + this.n;
     }

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/linter/timing.js

@@ -9,7 +9,7 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-/* istanbul ignore next */
+/* c8 ignore next */
 /**
  * Align the string to left
  * @param {string} str string to evaluate
@@ -22,7 +22,7 @@ function alignLeft(str, len, ch) {
     return str + new Array(len - str.length + 1).join(ch || " ");
 }
 
-/* istanbul ignore next */
+/* c8 ignore next */
 /**
  * Align the string to right
  * @param {string} str string to evaluate
@@ -64,7 +64,7 @@ function getListSize() {
     return TIMING_ENV_VAR_AS_INTEGER > 10 ? TIMING_ENV_VAR_AS_INTEGER : MINIMUM_SIZE;
 }
 
-/* istanbul ignore next */
+/* c8 ignore next */
 /**
  * display the data
  * @param {Object} data Data object to be displayed
@@ -119,7 +119,7 @@ function display(data) {
     console.log(table.join("\n")); // eslint-disable-line no-console -- Debugging function
 }
 
-/* istanbul ignore next */
+/* c8 ignore next */
 module.exports = (function() {
 
     const data = Object.create(null);

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.
@@ -125,7 +125,7 @@ function getArrayMethodName(node) {
         }
     }
 
-    /* istanbul ignore next: unreachable */
+    /* c8 ignore next */
     return null;
 }
 

package/lib/rules/global-require.js

@@ -28,10 +28,11 @@ function findReference(scope, node) {
     const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&
             reference.identifier.range[1] === node.range[1]);
 
-    /* istanbul ignore else: correctly returns null */
     if (references.length === 1) {
         return references[0];
     }
+
+    /* c8 ignore next */
     return null;
 
 }

package/lib/rules/indent-legacy.js

@@ -18,8 +18,8 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
-
-/* istanbul ignore next: this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway. */
+// this rule has known coverage issues, but it's deprecated and shouldn't be updated in the future anyway.
+/* c8 ignore next */
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
@@ -212,10 +212,10 @@ module.exports = {
             if (context.options[0] === "tab") {
                 indentSize = 1;
                 indentType = "tab";
-            } else /* istanbul ignore else : this will be caught by options validation */ if (typeof context.options[0] === "number") {
+            } else /* c8 ignore start */ if (typeof context.options[0] === "number") {
                 indentSize = context.options[0];
                 indentType = "space";
-            }
+            }/* c8 ignore stop */
 
             if (context.options[1]) {
                 const opts = context.options[1];

package/lib/rules/indent.js

@@ -12,7 +12,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const createTree = require("functional-red-black-tree");
+const { OrderedMap } = require("js-sdsl");
 
 const astUtils = require("./utils/ast-utils");
 
@@ -135,7 +135,8 @@ class BinarySearchTree {
      * Creates an empty tree
      */
     constructor() {
-        this._rbTree = createTree();
+        this._orderedMap = new OrderedMap();
+        this._orderedMapEnd = this._orderedMap.end();
     }
 
     /**
@@ -145,13 +146,7 @@ class BinarySearchTree {
      * @returns {void}
      */
     insert(key, value) {
-        const iterator = this._rbTree.find(key);
-
-        if (iterator.valid) {
-            this._rbTree = iterator.update(value);
-        } else {
-            this._rbTree = this._rbTree.insert(key, value);
-        }
+        this._orderedMap.setElement(key, value);
     }
 
     /**
@@ -160,9 +155,13 @@ class BinarySearchTree {
      * @returns {{key: number, value: *}|null} The found entry, or null if no such entry exists.
      */
     findLe(key) {
-        const iterator = this._rbTree.le(key);
+        const iterator = this._orderedMap.reverseLowerBound(key);
 
-        return iterator && { key: iterator.key, value: iterator.value };
+        if (iterator.equals(this._orderedMapEnd)) {
+            return {};
+        }
+
+        return { key: iterator.pointer[0], value: iterator.pointer[1] };
     }
 
     /**
@@ -177,11 +176,20 @@ class BinarySearchTree {
         if (start === end) {
             return;
         }
-        const iterator = this._rbTree.ge(start);
+        const iterator = this._orderedMap.lowerBound(start);
 
-        while (iterator.valid && iterator.key < end) {
-            this._rbTree = this._rbTree.remove(iterator.key);
-            iterator.next();
+        if (iterator.equals(this._orderedMapEnd)) {
+            return;
+        }
+
+        if (end > this._orderedMap.back()[0]) {
+            while (!iterator.equals(this._orderedMapEnd)) {
+                this._orderedMap.eraseElementByIterator(iterator);
+            }
+        } else {
+            while (iterator.pointer[0] < end) {
+                this._orderedMap.eraseElementByIterator(iterator);
+            }
         }
     }
 }

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/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/new-cap.js

@@ -39,10 +39,10 @@ const CAPS_ALLOWED = [
  */
 function checkArray(obj, key, fallback) {
 
-    /* istanbul ignore if */
+    /* c8 ignore start */
     if (Object.prototype.hasOwnProperty.call(obj, key) && !Array.isArray(obj[key])) {
         throw new TypeError(`${key}, if provided, must be an Array`);
-    }
+    }/* c8 ignore stop */
     return obj[key] || fallback;
 }
 

package/lib/rules/no-extra-boolean-cast.js

@@ -188,7 +188,7 @@ module.exports = {
                     }
                     return precedence(node) <= precedence(parent);
 
-                /* istanbul ignore next */
+                /* c8 ignore next */
                 default:
                     throw new Error(`Unexpected parent type: ${parent.type}`);
             }

package/lib/rules/no-extra-parens.js

@@ -634,10 +634,10 @@ module.exports = {
 
                 currentNode = currentNode.parent;
 
-                /* istanbul ignore if */
+                /* c8 ignore start */
                 if (currentNode === null) {
                     throw new Error("Nodes are not in the ancestor-descendant relationship.");
-                }
+                }/* c8 ignore stop */
 
                 path.push(currentNode);
             }

package/lib/rules/no-labels.js

@@ -98,7 +98,7 @@ module.exports = {
                 info = info.upper;
             }
 
-            /* istanbul ignore next: syntax error */
+            /* c8 ignore next */
             return "other";
         }
 

package/lib/rules/no-useless-computed-key.js

@@ -74,7 +74,7 @@ function hasUselessComputedKey(node) {
 
             return value !== "constructor";
 
-        /* istanbul ignore next */
+        /* c8 ignore next */
         default:
             throw new Error(`Unexpected node type: ${node.type}`);
     }

package/lib/rules/no-var.js

@@ -90,7 +90,7 @@ function getScopeNode(node) {
         }
     }
 
-    /* istanbul ignore next : unreachable */
+    /* c8 ignore next */
     return null;
 }
 

package/lib/rules/padded-blocks.js

@@ -186,7 +186,7 @@ module.exports = {
                 case "ClassBody":
                     return options.classes;
 
-                /* istanbul ignore next */
+                /* c8 ignore next */
                 default:
                     throw new Error("unreachable");
             }

package/lib/rules/prefer-arrow-callback.js

@@ -53,7 +53,7 @@ function getVariableOfArguments(scope) {
         }
     }
 
-    /* istanbul ignore next */
+    /* c8 ignore next */
     return null;
 }
 
@@ -126,7 +126,7 @@ function getCallbackInfo(node) {
         parent = parent.parent;
     }
 
-    /* istanbul ignore next */
+    /* c8 ignore next */
     throw new Error("unreachable");
 }
 

package/lib/rules/prefer-const.js

@@ -446,7 +446,19 @@ module.exports = {
 
                         reportCount += nodesToReport.length;
 
-                        shouldFix = shouldFix && (reportCount === varDeclParent.declarations.length);
+                        let totalDeclarationsCount = 0;
+
+                        varDeclParent.declarations.forEach(declaration => {
+                            if (declaration.id.type === "ObjectPattern") {
+                                totalDeclarationsCount += declaration.id.properties.length;
+                            } else if (declaration.id.type === "ArrayPattern") {
+                                totalDeclarationsCount += declaration.id.elements.length;
+                            } else {
+                                totalDeclarationsCount += 1;
+                            }
+                        });
+
+                        shouldFix = shouldFix && (reportCount === totalDeclarationsCount);
                     }
                 }
 

package/lib/rules/prefer-rest-params.js

@@ -30,7 +30,7 @@ function getVariableOfArguments(scope) {
         }
     }
 
-    /* istanbul ignore next : unreachable */
+    /* c8 ignore next */
     return null;
 }
 

package/lib/rules/require-yield.js

@@ -68,7 +68,6 @@ module.exports = {
             // Increases the count of `yield` keyword.
             YieldExpression() {
 
-                /* istanbul ignore else */
                 if (stack.length > 0) {
                     stack[stack.length - 1] += 1;
                 }

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/rules/utils/ast-utils.js

@@ -1350,7 +1350,7 @@ module.exports = {
             }
         }
 
-        /* istanbul ignore next */
+        /* c8 ignore next */
         return true;
     },
 

package/lib/shared/logging.js

@@ -7,7 +7,7 @@
 
 /* eslint no-console: "off" -- Logging util */
 
-/* istanbul ignore next */
+/* c8 ignore next */
 module.exports = {
 
     /**

package/lib/source-code/token-store/cursor.js

@@ -69,7 +69,7 @@ module.exports = class Cursor {
      * @returns {boolean} `true` if the next token exists.
      * @abstract
      */
-    /* istanbul ignore next */
+    /* c8 ignore next */
     moveNext() { // eslint-disable-line class-methods-use-this -- Unused
         throw new Error("Not implemented.");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.23.0",
+  "version": "8.24.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -55,8 +55,8 @@
   "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
-    "@eslint/eslintrc": "^1.3.1",
-    "@humanwhocodes/config-array": "^0.10.4",
+    "@eslint/eslintrc": "^1.3.2",
+    "@humanwhocodes/config-array": "^0.10.5",
     "@humanwhocodes/gitignore-to-minimatch": "^1.0.2",
     "@humanwhocodes/module-importer": "^1.0.1",
     "ajv": "^6.10.0",
@@ -74,7 +74,6 @@
     "fast-deep-equal": "^3.1.3",
     "file-entry-cache": "^6.0.1",
     "find-up": "^5.0.0",
-    "functional-red-black-tree": "^1.0.1",
     "glob-parent": "^6.0.1",
     "globals": "^13.15.0",
     "globby": "^11.1.0",
@@ -83,6 +82,7 @@
     "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
     "is-glob": "^4.0.0",
+    "js-sdsl": "^4.1.4",
     "js-yaml": "^4.1.0",
     "json-stable-stringify-without-jsonify": "^1.0.1",
     "levn": "^0.4.1",
@@ -99,6 +99,7 @@
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
     "babel-loader": "^8.0.5",
+    "c8": "^7.12.0",
     "chai": "^4.0.1",
     "cheerio": "^0.22.0",
     "common-tags": "^1.8.0",
@@ -142,7 +143,6 @@
     "mocha-junit-reporter": "^2.0.0",
     "node-polyfill-webpack-plugin": "^1.0.3",
     "npm-license": "^0.3.3",
-    "nyc": "^15.0.1",
     "pirates": "^4.0.5",
     "progress": "^2.0.3",
     "proxyquire": "^2.0.1",