feat(eslint-plugin): [prefer-nullish-coalescing] create ignoreIfStatements option (#11000)

* feat(eslint-plugin): [prefer-nullish-coalescing] create `ignoreIfStatements` option

* sorting

* update snapshots

Author: OlivierZal

packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx

@@ -118,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 */}

packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts

@@ -40,6 +40,7 @@ export type Options = [
     allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
     ignoreBooleanCoercion?: boolean;
     ignoreConditionalTests?: boolean;
+    ignoreIfStatements?: boolean;
     ignoreMixedLogicalExpressions?: boolean;
     ignorePrimitives?:
       | {
@@ -102,6 +103,11 @@ export default createRule<Options, MessageIds>({
             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:
@@ -154,6 +160,7 @@ export default createRule<Options, MessageIds>({
       allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
       ignoreBooleanCoercion: false,
       ignoreConditionalTests: true,
+      ignoreIfStatements: false,
       ignoreMixedLogicalExpressions: false,
       ignorePrimitives: {
         bigint: false,
@@ -171,6 +178,7 @@ export default createRule<Options, MessageIds>({
         allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing,
         ignoreBooleanCoercion,
         ignoreConditionalTests,
+        ignoreIfStatements,
         ignoreMixedLogicalExpressions,
         ignorePrimitives,
         ignoreTernaryTests,
@@ -516,7 +524,7 @@ export default createRule<Options, MessageIds>({
         }
       },
       IfStatement(node: TSESTree.IfStatement): void {
-        if (node.alternate != null) {
+        if (ignoreIfStatements || node.alternate != null) {
           return;
         }
 

packages/eslint-plugin/tests/docs-eslint-output-snapshots/prefer-nullish-coalescing.shot

@@ -518,6 +518,30 @@ x?.a ? y?.a : 'foo'
       code,
       options: [{ ignoreTernaryTests: false }] as const,
     })),
+    {
+      code: `
+declare let foo: { a: string } | null;
+declare function makeFoo(): { a: string };
+
+function lazyInitialize() {
+  if (!foo) {
+    foo = makeFoo();
+  }
+}
+      `,
+      options: [{ ignoreIfStatements: true }],
+    },
+    {
+      code: `
+declare let foo: { a: string } | null;
+declare function makeFoo(): { a: string };
+
+function lazyInitialize() {
+  if (!foo) foo = makeFoo();
+}
+      `,
+      options: [{ ignoreIfStatements: true }],
+    },
 
     // ignoreConditionalTests
     ...nullishTypeTest((nullish, type, equals) => ({