@typescript-eslint/eslint-plugin 8.27.1-alpha.2 → 8.28.1-alpha.0

package/dist/rules/consistent-type-exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consistent-type-exports.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-type-exports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sCAAsC,EAAE,OAAO,CAAC;KACjD;CACF,CAAC;AAgBF,MAAM,MAAM,UAAU,GAClB,yBAAyB,GACzB,oBAAoB,GACpB,eAAe,CAAC;;AAEpB,wBAgSG"}
+{"version":3,"file":"consistent-type-exports.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-type-exports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sCAAsC,EAAE,OAAO,CAAC;KACjD;CACF,CAAC;AAgBF,MAAM,MAAM,UAAU,GAClB,yBAAyB,GACzB,oBAAoB,GACpB,eAAe,CAAC;;AAEpB,wBA8RG"}

package/dist/rules/consistent-type-exports.js

@@ -158,14 +158,12 @@ exports.default = (0, util_1.createRule)({
                 // Cache the first encountered exports for the package. We will need to come
                 // back to these later when fixing the problems.
                 if (node.exportKind === 'type') {
-                    if (sourceExports.typeOnlyNamedExport == null) {
-                        // The export is a type export
-                        sourceExports.typeOnlyNamedExport = node;
-                    }
+                    // The export is a type export
+                    sourceExports.typeOnlyNamedExport ??= node;
                 }
-                else if (sourceExports.valueOnlyNamedExport == null) {
+                else {
                     // The export is a value export
-                    sourceExports.valueOnlyNamedExport = node;
+                    sourceExports.valueOnlyNamedExport ??= node;
                 }
                 // Next for the current export, we will separate type/value specifiers.
                 const typeBasedSpecifiers = [];

package/dist/rules/no-unnecessary-condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-unnecessary-condition.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-condition.ts"],"names":[],"mappings":"AAyHA,KAAK,iCAAiC,GAAG,OAAO,CAAC;AAEjD,KAAK,2BAA2B,GAAG,QAAQ,GAAG,OAAO,GAAG,uBAAuB,CAAC;AAShF,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,2BAA2B,CAAC,EACxB,2BAA2B,GAC3B,iCAAiC,CAAC;QACtC,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,aAAa,GACb,iBAAiB,GACjB,eAAe,GACf,cAAc,GACd,kBAAkB,GAClB,+BAA+B,GAC/B,OAAO,GACP,cAAc,GACd,oBAAoB,GACpB,4BAA4B,GAC5B,mBAAmB,GACnB,wBAAwB,CAAC;;AAE7B,wBAgwBG"}
+{"version":3,"file":"no-unnecessary-condition.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-condition.ts"],"names":[],"mappings":"AAyHA,KAAK,iCAAiC,GAAG,OAAO,CAAC;AAEjD,KAAK,2BAA2B,GAAG,QAAQ,GAAG,OAAO,GAAG,uBAAuB,CAAC;AAShF,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,2BAA2B,CAAC,EACxB,2BAA2B,GAC3B,iCAAiC,CAAC;QACtC,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,aAAa,GACb,iBAAiB,GACjB,eAAe,GACf,cAAc,GACd,kBAAkB,GAClB,+BAA+B,GAC/B,OAAO,GACP,cAAc,GACd,oBAAoB,GACpB,4BAA4B,GAC5B,mBAAmB,GACnB,wBAAwB,CAAC;;AAE7B,wBAowBG"}

package/dist/rules/no-unnecessary-condition.js

@@ -258,7 +258,7 @@ exports.default = (0, util_1.createRule)({
             // Since typescript array index signature types don't represent the
             //  possibility of out-of-bounds access, if we're indexing into an array
             //  just skip the check, to avoid false positives
-            if (isArrayIndexExpression(expression)) {
+            if (!isNoUncheckedIndexedAccess && isArrayIndexExpression(expression)) {
                 return;
             }
             // When checking logical expressions, only check the right side
@@ -308,10 +308,11 @@ exports.default = (0, util_1.createRule)({
                 // Since typescript array index signature types don't represent the
                 //  possibility of out-of-bounds access, if we're indexing into an array
                 //  just skip the check, to avoid false positives
-                if (!isArrayIndexExpression(node) &&
-                    !(node.type === utils_1.AST_NODE_TYPES.ChainExpression &&
-                        node.expression.type !== utils_1.AST_NODE_TYPES.TSNonNullExpression &&
-                        optionChainContainsOptionArrayIndex(node.expression))) {
+                if (isNoUncheckedIndexedAccess ||
+                    (!isArrayIndexExpression(node) &&
+                        !(node.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                            node.expression.type !== utils_1.AST_NODE_TYPES.TSNonNullExpression &&
+                            optionChainContainsOptionArrayIndex(node.expression)))) {
                     messageId = 'neverNullish';
                 }
             }
@@ -598,7 +599,8 @@ exports.default = (0, util_1.createRule)({
             // Since typescript array index signature types don't represent the
             //  possibility of out-of-bounds access, if we're indexing into an array
             //  just skip the check, to avoid false positives
-            if (optionChainContainsOptionArrayIndex(node)) {
+            if (!isNoUncheckedIndexedAccess &&
+                optionChainContainsOptionArrayIndex(node)) {
                 return;
             }
             const nodeToCheck = node.type === utils_1.AST_NODE_TYPES.CallExpression ? node.callee : node.object;

package/dist/rules/no-unsafe-function-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-unsafe-function-type.d.ts","sourceRoot":"","sources":["../../src/rules/no-unsafe-function-type.ts"],"names":[],"mappings":";AAMA,wBA4CG"}
+{"version":3,"file":"no-unsafe-function-type.d.ts","sourceRoot":"","sources":["../../src/rules/no-unsafe-function-type.ts"],"names":[],"mappings":";AAMA,wBA2CG"}

package/dist/rules/no-unsafe-function-type.js

@@ -10,7 +10,6 @@ exports.default = (0, util_1.createRule)({
             description: 'Disallow using the unsafe built-in Function type',
             recommended: 'recommended',
         },
-        fixable: 'code',
         messages: {
             bannedFunctionType: [
                 'The `Function` type accepts any function-like value.',

package/dist/rules/no-unsafe-return.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-unsafe-return.d.ts","sourceRoot":"","sources":["../../src/rules/no-unsafe-return.ts"],"names":[],"mappings":";AAqBA,wBAwMG"}
+{"version":3,"file":"no-unsafe-return.d.ts","sourceRoot":"","sources":["../../src/rules/no-unsafe-return.ts"],"names":[],"mappings":";AAqBA,wBAsMG"}

package/dist/rules/no-unsafe-return.js

@@ -81,9 +81,7 @@ exports.default = (0, util_1.createRule)({
                 ts.isArrowFunction(functionTSNode)
                 ? (0, util_1.getContextualType)(checker, functionTSNode)
                 : services.getTypeAtLocation(functionNode);
-            if (!functionType) {
-                functionType = services.getTypeAtLocation(functionNode);
-            }
+            functionType ??= services.getTypeAtLocation(functionNode);
             const callSignatures = tsutils.getCallSignaturesOfType(functionType);
             // If there is an explicit type annotation *and* that type matches the actual
             // function return type, we shouldn't complain (it's intentional, even if unsafe)

package/dist/rules/prefer-nullish-coalescing.d.ts

@@ -4,6 +4,7 @@ export type Options = [
         allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
         ignoreBooleanCoercion?: boolean;
         ignoreConditionalTests?: boolean;
+        ignoreIfStatements?: boolean;
         ignoreMixedLogicalExpressions?: boolean;
         ignorePrimitives?: {
             bigint?: boolean;
@@ -14,7 +15,7 @@ export type Options = [
         ignoreTernaryTests?: boolean;
     }
 ];
-export type MessageIds = 'noStrictNullCheck' | 'preferNullishOverOr' | 'preferNullishOverTernary' | 'suggestNullish';
+export type MessageIds = 'noStrictNullCheck' | 'preferNullishOverAssignment' | 'preferNullishOverOr' | 'preferNullishOverTernary' | 'suggestNullish';
 declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
 export default _default;
 //# sourceMappingURL=prefer-nullish-coalescing.d.ts.map

package/dist/rules/prefer-nullish-coalescing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-nullish-coalescing.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-nullish-coalescing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AA8BnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,gBAAgB,CAAC,EACb;YACE,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,MAAM,CAAC,EAAE,OAAO,CAAC;SAClB,GACD,IAAI,CAAC;QACT,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,qBAAqB,GACrB,0BAA0B,GAC1B,gBAAgB,CAAC;;AAErB,wBAsfG"}
+{"version":3,"file":"prefer-nullish-coalescing.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-nullish-coalescing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAqCnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,gBAAgB,CAAC,EACb;YACE,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,MAAM,CAAC,EAAE,OAAO,CAAC;SAClB,GACD,IAAI,CAAC;QACT,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,6BAA6B,GAC7B,qBAAqB,GACrB,0BAA0B,GAC1B,gBAAgB,CAAC;;AAErB,wBA8jBG"}

package/dist/rules/prefer-nullish-coalescing.js

@@ -37,11 +37,14 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
-const isIdentifierOrMemberOrChainExpression = (0, util_1.isNodeOfTypes)([
+const isMemberAccessLike = (0, util_1.isNodeOfTypes)([
     utils_1.AST_NODE_TYPES.ChainExpression,
     utils_1.AST_NODE_TYPES.Identifier,
     utils_1.AST_NODE_TYPES.MemberExpression,
 ]);
+const isNullLiteralOrUndefinedIdentifier = (node) => (0, util_1.isNullLiteral)(node) || (0, util_1.isUndefinedIdentifier)(node);
+const isNodeNullishComparison = (node) => isNullLiteralOrUndefinedIdentifier(node.left) &&
+    isNullLiteralOrUndefinedIdentifier(node.right);
 exports.default = (0, util_1.createRule)({
     name: 'prefer-nullish-coalescing',
     meta: {
@@ -54,6 +57,7 @@ exports.default = (0, util_1.createRule)({
         hasSuggestions: true,
         messages: {
             noStrictNullCheck: 'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
+            preferNullishOverAssignment: 'Prefer using nullish coalescing operator (`??{{ equals }}`) instead of an assignment expression, as it is simpler to read.',
             preferNullishOverOr: 'Prefer using nullish coalescing operator (`??{{ equals }}`) instead of a logical {{ description }} (`||{{ equals }}`), as it is a safer operator.',
             preferNullishOverTernary: 'Prefer using nullish coalescing operator (`??{{ equals }}`) instead of a ternary expression, as it is simpler to read.',
             suggestNullish: 'Fix to nullish coalescing operator (`??{{ equals }}`).',
@@ -75,6 +79,10 @@ exports.default = (0, util_1.createRule)({
                         type: 'boolean',
                         description: 'Whether to ignore cases that are located within a conditional test.',
                     },
+                    ignoreIfStatements: {
+                        type: 'boolean',
+                        description: 'Whether to ignore any if statements that could be simplified by using the nullish coalescing operator.',
+                    },
                     ignoreMixedLogicalExpressions: {
                         type: 'boolean',
                         description: 'Whether to ignore any logical or expressions that are part of a mixed logical expression (with `&&`).',
@@ -124,6 +132,7 @@ exports.default = (0, util_1.createRule)({
             allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
             ignoreBooleanCoercion: false,
             ignoreConditionalTests: true,
+            ignoreIfStatements: false,
             ignoreMixedLogicalExpressions: false,
             ignorePrimitives: {
                 bigint: false,
@@ -134,7 +143,7 @@ exports.default = (0, util_1.createRule)({
             ignoreTernaryTests: false,
         },
     ],
-    create(context, [{ allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing, ignoreBooleanCoercion, ignoreConditionalTests, ignoreMixedLogicalExpressions, ignorePrimitives, ignoreTernaryTests, },]) {
+    create(context, [{ allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing, ignoreBooleanCoercion, ignoreConditionalTests, ignoreIfStatements, ignoreMixedLogicalExpressions, ignorePrimitives, ignoreTernaryTests, },]) {
         const parserServices = (0, util_1.getParserServices)(context);
         const compilerOptions = parserServices.program.getCompilerOptions();
         const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks');
@@ -258,6 +267,81 @@ exports.default = (0, util_1.createRule)({
                 ],
             });
         }
+        function getNullishCoalescingParams(node, nonNullishNode, nodesInsideTestExpression, operator) {
+            let nullishCoalescingLeftNode;
+            let hasTruthinessCheck = false;
+            let hasNullCheckWithoutTruthinessCheck = false;
+            let hasUndefinedCheckWithoutTruthinessCheck = false;
+            if (!nodesInsideTestExpression.length) {
+                hasTruthinessCheck = true;
+                nullishCoalescingLeftNode =
+                    node.test.type === utils_1.AST_NODE_TYPES.UnaryExpression
+                        ? node.test.argument
+                        : node.test;
+                if (!areNodesSimilarMemberAccess(nullishCoalescingLeftNode, nonNullishNode)) {
+                    return { isFixable: false };
+                }
+            }
+            else {
+                // we check that the test only contains null, undefined and the identifier
+                for (const testNode of nodesInsideTestExpression) {
+                    if ((0, util_1.isNullLiteral)(testNode)) {
+                        hasNullCheckWithoutTruthinessCheck = true;
+                    }
+                    else if ((0, util_1.isUndefinedIdentifier)(testNode)) {
+                        hasUndefinedCheckWithoutTruthinessCheck = true;
+                    }
+                    else if (areNodesSimilarMemberAccess(testNode, nonNullishNode)) {
+                        // Only consider the first expression in a multi-part nullish check,
+                        // as subsequent expressions might not require all the optional chaining operators.
+                        // For example: a?.b?.c !== undefined && a.b.c !== null ? a.b.c : 'foo';
+                        // This works because `node.test` is always evaluated first in the loop
+                        // and has the same or more necessary optional chaining operators
+                        // than `node.alternate` or `node.consequent`.
+                        nullishCoalescingLeftNode ??= testNode;
+                    }
+                    else {
+                        return { isFixable: false };
+                    }
+                }
+            }
+            if (!nullishCoalescingLeftNode) {
+                return { isFixable: false };
+            }
+            const isFixable = (() => {
+                if (hasTruthinessCheck) {
+                    return isTruthinessCheckEligibleForPreferNullish({
+                        node,
+                        testNode: nullishCoalescingLeftNode,
+                    });
+                }
+                // it is fixable if we check for both null and undefined, or not if neither
+                if (hasUndefinedCheckWithoutTruthinessCheck ===
+                    hasNullCheckWithoutTruthinessCheck) {
+                    return hasUndefinedCheckWithoutTruthinessCheck;
+                }
+                // it is fixable if we loosely check for either null or undefined
+                if (['==', '!='].includes(operator)) {
+                    return true;
+                }
+                const type = parserServices.getTypeAtLocation(nullishCoalescingLeftNode);
+                const flags = (0, util_1.getTypeFlags)(type);
+                if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+                    return false;
+                }
+                const hasNullType = (flags & ts.TypeFlags.Null) !== 0;
+                // it is fixable if we check for undefined and the type is not nullable
+                if (hasUndefinedCheckWithoutTruthinessCheck && !hasNullType) {
+                    return true;
+                }
+                const hasUndefinedType = (flags & ts.TypeFlags.Undefined) !== 0;
+                // it is fixable if we check for null and the type can't be undefined
+                return hasNullCheckWithoutTruthinessCheck && !hasUndefinedType;
+            })();
+            return isFixable
+                ? { isFixable: true, nullishCoalescingLeftNode }
+                : { isFixable: false };
+        }
         return {
             'AssignmentExpression[operator = "||="]'(node) {
                 checkAndFixWithPreferNullishOverOr(node, 'assignment', '=');
@@ -266,134 +350,12 @@ exports.default = (0, util_1.createRule)({
                 if (ignoreTernaryTests) {
                     return;
                 }
-                let operator;
-                let nodesInsideTestExpression = [];
-                if (node.test.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                    nodesInsideTestExpression = [node.test.left, node.test.right];
-                    if (node.test.operator === '==' ||
-                        node.test.operator === '!=' ||
-                        node.test.operator === '===' ||
-                        node.test.operator === '!==') {
-                        operator = node.test.operator;
-                    }
-                }
-                else if (node.test.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
-                    node.test.left.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
-                    node.test.right.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                    nodesInsideTestExpression = [
-                        node.test.left.left,
-                        node.test.left.right,
-                        node.test.right.left,
-                        node.test.right.right,
-                    ];
-                    if (['||', '||='].includes(node.test.operator)) {
-                        if (node.test.left.operator === '===' &&
-                            node.test.right.operator === '===') {
-                            operator = '===';
-                        }
-                        else if (((node.test.left.operator === '===' ||
-                            node.test.right.operator === '===') &&
-                            (node.test.left.operator === '==' ||
-                                node.test.right.operator === '==')) ||
-                            (node.test.left.operator === '==' &&
-                                node.test.right.operator === '==')) {
-                            operator = '==';
-                        }
-                    }
-                    else if (node.test.operator === '&&') {
-                        if (node.test.left.operator === '!==' &&
-                            node.test.right.operator === '!==') {
-                            operator = '!==';
-                        }
-                        else if (((node.test.left.operator === '!==' ||
-                            node.test.right.operator === '!==') &&
-                            (node.test.left.operator === '!=' ||
-                                node.test.right.operator === '!=')) ||
-                            (node.test.left.operator === '!=' &&
-                                node.test.right.operator === '!=')) {
-                            operator = '!=';
-                        }
-                    }
-                }
-                let nullishCoalescingLeftNode;
-                let hasTruthinessCheck = false;
-                let hasNullCheckWithoutTruthinessCheck = false;
-                let hasUndefinedCheckWithoutTruthinessCheck = false;
-                if (!operator) {
-                    let testNode;
-                    hasTruthinessCheck = true;
-                    if (isIdentifierOrMemberOrChainExpression(node.test)) {
-                        testNode = node.test;
-                    }
-                    else if (node.test.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
-                        isIdentifierOrMemberOrChainExpression(node.test.argument) &&
-                        node.test.operator === '!') {
-                        testNode = node.test.argument;
-                        operator = '!';
-                    }
-                    if (testNode &&
-                        areNodesSimilarMemberAccess(testNode, getBranchNodes(node, operator).nonNullishBranch)) {
-                        nullishCoalescingLeftNode = testNode;
-                    }
-                }
-                else {
-                    // we check that the test only contains null, undefined and the identifier
-                    for (const testNode of nodesInsideTestExpression) {
-                        if ((0, util_1.isNullLiteral)(testNode)) {
-                            hasNullCheckWithoutTruthinessCheck = true;
-                        }
-                        else if ((0, util_1.isUndefinedIdentifier)(testNode)) {
-                            hasUndefinedCheckWithoutTruthinessCheck = true;
-                        }
-                        else if (areNodesSimilarMemberAccess(testNode, getBranchNodes(node, operator).nonNullishBranch)) {
-                            // Only consider the first expression in a multi-part nullish check,
-                            // as subsequent expressions might not require all the optional chaining operators.
-                            // For example: a?.b?.c !== undefined && a.b.c !== null ? a.b.c : 'foo';
-                            // This works because `node.test` is always evaluated first in the loop
-                            // and has the same or more necessary optional chaining operators
-                            // than `node.alternate` or `node.consequent`.
-                            nullishCoalescingLeftNode ??= testNode;
-                        }
-                        else {
-                            return;
-                        }
-                    }
-                }
-                if (!nullishCoalescingLeftNode) {
+                const { nodesInsideTestExpression, operator } = getOperatorAndNodesInsideTestExpression(node);
+                if (operator == null) {
                     return;
                 }
-                const isFixableWithPreferNullishOverTernary = (() => {
-                    // x ? x : y and !x ? y : x patterns
-                    if (hasTruthinessCheck) {
-                        return isTruthinessCheckEligibleForPreferNullish({
-                            node,
-                            testNode: nullishCoalescingLeftNode,
-                        });
-                    }
-                    // it is fixable if we check for both null and undefined, or not if neither
-                    if (hasUndefinedCheckWithoutTruthinessCheck ===
-                        hasNullCheckWithoutTruthinessCheck) {
-                        return hasUndefinedCheckWithoutTruthinessCheck;
-                    }
-                    // it is fixable if we loosely check for either null or undefined
-                    if (operator === '==' || operator === '!=') {
-                        return true;
-                    }
-                    const type = parserServices.getTypeAtLocation(nullishCoalescingLeftNode);
-                    const flags = (0, util_1.getTypeFlags)(type);
-                    if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
-                        return false;
-                    }
-                    const hasNullType = (flags & ts.TypeFlags.Null) !== 0;
-                    // it is fixable if we check for undefined and the type is not nullable
-                    if (hasUndefinedCheckWithoutTruthinessCheck && !hasNullType) {
-                        return true;
-                    }
-                    const hasUndefinedType = (flags & ts.TypeFlags.Undefined) !== 0;
-                    // it is fixable if we check for null and the type can't be undefined
-                    return hasNullCheckWithoutTruthinessCheck && !hasUndefinedType;
-                })();
-                if (isFixableWithPreferNullishOverTernary) {
+                const nullishCoalescingParams = getNullishCoalescingParams(node, getBranchNodes(node, operator).nonNullishBranch, nodesInsideTestExpression, operator);
+                if (nullishCoalescingParams.isFixable) {
                     context.report({
                         node,
                         messageId: 'preferNullishOverTernary',
@@ -404,7 +366,63 @@ exports.default = (0, util_1.createRule)({
                                 messageId: 'suggestNullish',
                                 data: { equals: '' },
                                 fix(fixer) {
-                                    return fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingLeftNode)} ?? ${(0, util_1.getTextWithParentheses)(context.sourceCode, getBranchNodes(node, operator).nullishBranch)}`);
+                                    return fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingParams.nullishCoalescingLeftNode)} ?? ${(0, util_1.getTextWithParentheses)(context.sourceCode, getBranchNodes(node, operator).nullishBranch)}`);
+                                },
+                            },
+                        ],
+                    });
+                }
+            },
+            IfStatement(node) {
+                if (ignoreIfStatements || node.alternate != null) {
+                    return;
+                }
+                let assignmentExpression;
+                if (node.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                    node.consequent.body.length === 1 &&
+                    node.consequent.body[0].type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                    assignmentExpression = node.consequent.body[0].expression;
+                }
+                else if (node.consequent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                    assignmentExpression = node.consequent.expression;
+                }
+                if (!assignmentExpression ||
+                    assignmentExpression.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                    !isMemberAccessLike(assignmentExpression.left)) {
+                    return;
+                }
+                const nullishCoalescingLeftNode = assignmentExpression.left;
+                const nullishCoalescingRightNode = assignmentExpression.right;
+                const { nodesInsideTestExpression, operator } = getOperatorAndNodesInsideTestExpression(node);
+                if (operator == null || !['!', '==', '==='].includes(operator)) {
+                    return;
+                }
+                const nullishCoalescingParams = getNullishCoalescingParams(node, nullishCoalescingLeftNode, nodesInsideTestExpression, operator);
+                if (nullishCoalescingParams.isFixable) {
+                    // Handle comments
+                    const isConsequentNodeBlockStatement = node.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement;
+                    const commentsBefore = formatComments(context.sourceCode.getCommentsBefore(assignmentExpression), isConsequentNodeBlockStatement ? '\n' : ' ');
+                    const commentsAfter = isConsequentNodeBlockStatement
+                        ? formatComments(context.sourceCode.getCommentsAfter(assignmentExpression.parent), '\n')
+                        : '';
+                    context.report({
+                        node,
+                        messageId: 'preferNullishOverAssignment',
+                        data: { equals: '=' },
+                        suggest: [
+                            {
+                                messageId: 'suggestNullish',
+                                data: { equals: '=' },
+                                fix(fixer) {
+                                    const fixes = [];
+                                    if (commentsBefore) {
+                                        fixes.push(fixer.insertTextBefore(node, commentsBefore));
+                                    }
+                                    fixes.push(fixer.replaceText(node, `${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingLeftNode)} ??= ${(0, util_1.getTextWithParentheses)(context.sourceCode, nullishCoalescingRightNode)};`));
+                                    if (commentsAfter) {
+                                        fixes.push(fixer.insertTextAfter(node, ` ${commentsAfter.slice(0, -1)}`));
+                                    }
+                                    return fixes;
                                 },
                             },
                         ],
@@ -512,8 +530,21 @@ function isMixedLogicalExpression(node) {
 function areNodesSimilarMemberAccess(a, b) {
     if (a.type === utils_1.AST_NODE_TYPES.MemberExpression &&
         b.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-        return ((0, util_1.isNodeEqual)(a.property, b.property) &&
-            areNodesSimilarMemberAccess(a.object, b.object));
+        if (!areNodesSimilarMemberAccess(a.object, b.object)) {
+            return false;
+        }
+        if (a.computed === b.computed) {
+            return (0, util_1.isNodeEqual)(a.property, b.property);
+        }
+        if (a.property.type === utils_1.AST_NODE_TYPES.Literal &&
+            b.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return a.property.value === b.property.name;
+        }
+        if (a.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            b.property.type === utils_1.AST_NODE_TYPES.Literal) {
+            return a.property.name === b.property.value;
+        }
+        return false;
     }
     if (a.type === utils_1.AST_NODE_TYPES.ChainExpression ||
         b.type === utils_1.AST_NODE_TYPES.ChainExpression) {
@@ -527,8 +558,82 @@ function areNodesSimilarMemberAccess(a, b) {
  * - the "nullish branch" is the branch when test node is nullish
  */
 function getBranchNodes(node, operator) {
-    if (!operator || ['!=', '!=='].includes(operator)) {
+    if (['', '!=', '!=='].includes(operator)) {
         return { nonNullishBranch: node.consequent, nullishBranch: node.alternate };
     }
     return { nonNullishBranch: node.alternate, nullishBranch: node.consequent };
 }
+function getOperatorAndNodesInsideTestExpression(node) {
+    let operator = null;
+    let nodesInsideTestExpression = [];
+    if (isMemberAccessLike(node.test) ||
+        node.test.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
+        operator = getNonBinaryNodeOperator(node.test);
+    }
+    else if (node.test.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        nodesInsideTestExpression = [node.test.left, node.test.right];
+        if (node.test.operator === '==' ||
+            node.test.operator === '!=' ||
+            node.test.operator === '===' ||
+            node.test.operator === '!==') {
+            operator = node.test.operator;
+        }
+    }
+    else if (node.test.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+        node.test.left.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+        node.test.right.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        if (isNodeNullishComparison(node.test.left) ||
+            isNodeNullishComparison(node.test.right)) {
+            return { nodesInsideTestExpression, operator };
+        }
+        nodesInsideTestExpression = [
+            node.test.left.left,
+            node.test.left.right,
+            node.test.right.left,
+            node.test.right.right,
+        ];
+        if (['||', '||='].includes(node.test.operator)) {
+            if (node.test.left.operator === '===' &&
+                node.test.right.operator === '===') {
+                operator = '===';
+            }
+            else if (((node.test.left.operator === '===' ||
+                node.test.right.operator === '===') &&
+                (node.test.left.operator === '==' ||
+                    node.test.right.operator === '==')) ||
+                (node.test.left.operator === '==' && node.test.right.operator === '==')) {
+                operator = '==';
+            }
+        }
+        else if (node.test.operator === '&&') {
+            if (node.test.left.operator === '!==' &&
+                node.test.right.operator === '!==') {
+                operator = '!==';
+            }
+            else if (((node.test.left.operator === '!==' ||
+                node.test.right.operator === '!==') &&
+                (node.test.left.operator === '!=' ||
+                    node.test.right.operator === '!=')) ||
+                (node.test.left.operator === '!=' && node.test.right.operator === '!=')) {
+                operator = '!=';
+            }
+        }
+    }
+    return { nodesInsideTestExpression, operator };
+}
+function getNonBinaryNodeOperator(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.UnaryExpression) {
+        return '';
+    }
+    if (isMemberAccessLike(node.argument) && node.operator === '!') {
+        return '!';
+    }
+    return null;
+}
+function formatComments(comments, separator) {
+    return comments
+        .map(({ type, value }) => type === utils_1.AST_TOKEN_TYPES.Line
+        ? `//${value}${separator}`
+        : `/*${value}*/${separator}`)
+        .join('');
+}

package/dist/rules/use-unknown-in-catch-callback-variable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-unknown-in-catch-callback-variable.d.ts","sourceRoot":"","sources":["../../src/rules/use-unknown-in-catch-callback-variable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,MAAM,MAAM,UAAU,GAClB,wCAAwC,GACxC,oCAAoC,GACpC,YAAY,GACZ,qCAAqC,GACrC,sCAAsC,GACtC,mCAAmC,GACnC,+BAA+B,CAAC;;AAKpC,wBAmSG"}
+{"version":3,"file":"use-unknown-in-catch-callback-variable.d.ts","sourceRoot":"","sources":["../../src/rules/use-unknown-in-catch-callback-variable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,MAAM,MAAM,UAAU,GAClB,wCAAwC,GACxC,oCAAoC,GACpC,YAAY,GACZ,qCAAqC,GACrC,sCAAsC,GACtC,mCAAmC,GACnC,+BAA+B,CAAC;;AAKpC,wBAkSG"}

package/dist/rules/use-unknown-in-catch-callback-variable.js

@@ -46,7 +46,6 @@ exports.default = (0, util_1.createRule)({
             recommended: 'strict',
             requiresTypeChecking: true,
         },
-        fixable: 'code',
         hasSuggestions: true,
         messages: {
             addUnknownRestTypeAnnotationSuggestion: 'Add an explicit `: [unknown]` type annotation to the rejection callback rest variable.',

package/dist/util/isAssignee.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isAssignee.d.ts","sourceRoot":"","sources":["../../src/util/isAssignee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAoDvD"}
+{"version":3,"file":"isAssignee.d.ts","sourceRoot":"","sources":["../../src/util/isAssignee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CA+DvD"}

package/dist/util/isAssignee.js

@@ -38,5 +38,13 @@ function isAssignee(node) {
         isAssignee(parent.parent)) {
         return true;
     }
+    // (a[i] as number)++, [...a[i]!] = [0], etc.
+    if ((parent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+        parent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        parent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+        parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) &&
+        isAssignee(parent)) {
+        return true;
+    }
     return false;
 }

package/docs/rules/prefer-nullish-coalescing.mdx

@@ -17,6 +17,54 @@ This rule reports when you may consider replacing:
 - An `||` operator with `??`
 - An `||=` operator with `??=`
 - Ternary expressions (`?:`) that are equivalent to `||` or `??` with `??`
+- Assignment expressions (`=`) that can be safely replaced by `??=`
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+declare const a: string | null;
+declare const b: string | null;
+
+const c = a || b;
+
+declare let foo: { a: string } | null;
+declare function makeFoo(): { a: string };
+
+function lazyInitializeFooByTruthiness() {
+  if (!foo) {
+    foo = makeFoo();
+  }
+}
+
+function lazyInitializeFooByNullCheck() {
+  if (foo == null) {
+    foo = makeFoo();
+  }
+}
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+declare const a: string | null;
+declare const b: string | null;
+
+const c = a ?? b;
+
+declare let foo: { a: string } | null;
+declare function makeFoo(): { a: string };
+
+function lazyInitializeFoo() {
+  foo ??= makeFoo();
+}
+```
+
+</TabItem>
+</Tabs>
 
 :::caution
 This rule will not work as expected if [`strictNullChecks`](https://www.typescriptlang.org/tsconfig#strictNullChecks) is not enabled.
@@ -70,6 +118,49 @@ c ?? 'a string';
 </TabItem>
 </Tabs>
 
+### `ignoreIfStatements`
+
+{/* insert option description */}
+
+Examples of code for this rule with `{ ignoreIfStatements: false }`:
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts option='{ "ignoreIfStatements": false }'
+declare let foo: { a: string } | null;
+declare function makeFoo(): { a: string };
+
+function lazyInitializeFoo1() {
+  if (!foo) {
+    foo = makeFoo();
+  }
+}
+
+function lazyInitializeFoo2() {
+  if (!foo) foo = makeFoo();
+}
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts option='{ "ignoreIfStatements": false }'
+declare let foo: { a: string } | null;
+declare function makeFoo(): { a: string };
+
+function lazyInitializeFoo1() {
+  foo ??= makeFoo();
+}
+
+function lazyInitializeFoo2() {
+  foo ??= makeFoo();
+}
+```
+
+</TabItem>
+</Tabs>
+
 ### `ignoreConditionalTests`
 
 {/* insert option description */}
@@ -255,3 +346,4 @@ If you are not using TypeScript 3.7 (or greater), then you will not be able to u
 
 - [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
 - [Nullish Coalescing Operator Proposal](https://github.com/tc39/proposal-nullish-coalescing/)
+- [`logical-assignment-operators`](https://eslint.org/docs/latest/rules/logical-assignment-operators)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.27.1-alpha.2",
+  "version": "8.28.1-alpha.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -62,10 +62,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.27.1-alpha.2",
-    "@typescript-eslint/type-utils": "8.27.1-alpha.2",
-    "@typescript-eslint/utils": "8.27.1-alpha.2",
-    "@typescript-eslint/visitor-keys": "8.27.1-alpha.2",
+    "@typescript-eslint/scope-manager": "8.28.1-alpha.0",
+    "@typescript-eslint/type-utils": "8.28.1-alpha.0",
+    "@typescript-eslint/utils": "8.28.1-alpha.0",
+    "@typescript-eslint/visitor-keys": "8.28.1-alpha.0",
     "graphemer": "^1.4.0",
     "ignore": "^5.3.1",
     "natural-compare": "^1.4.0",
@@ -76,8 +76,8 @@
     "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.27.1-alpha.2",
-    "@typescript-eslint/rule-tester": "8.27.1-alpha.2",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.28.1-alpha.0",
+    "@typescript-eslint/rule-tester": "8.28.1-alpha.0",
     "ajv": "^6.12.6",
     "cross-env": "^7.0.3",
     "cross-fetch": "*",