feat(eslint-plugin): [prefer-nullish-coalescing] add ignorePrimitives option

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

@@ -131,6 +131,29 @@ a ?? (b && c && d);
 
 **_NOTE:_** Errors for this specific case will be presented as suggestions (see below), instead of fixes. This is because it is not always safe to automatically convert `||` to `??` within a mixed logical expression, as we cannot tell the intended precedence of the operator. Note that by design, `??` requires parentheses when used with `&&` or `||` in the same expression.
 
+### `ignorePrimitives`
+
+If you would like to ignore certain primitive types that can be falsy then you may pass an object containing a boolean value for each primitive:
+
+- `string: true`, ignores `null` or `undefined` unions with `string` (default: false).
+- `number: true`, ignores `null` or `undefined` unions with `number` (default: false).
+- `bigint: true`, ignores `null` or `undefined` unions with `bigint` (default: false).
+- `boolean: true`, ignores `null` or `undefined` unions with `boolean` (default: false).
+
+Incorrect code for `ignorePrimitives: { string: true }`, and correct code for `ignorePrimitives: { string: false }`:
+
+```ts
+const foo: string | undefined = 'bar';
+foo || 'a string';
+```
+
+Correct code for `ignorePrimitives: { string: true }`:
+
+```ts
+const foo: string | undefined = 'bar';
+foo ?? 'a string';
+```
+
 ## When Not To Use It
 
 If you are not using TypeScript 3.7 (or greater), then you will not be able to use this rule, as the operator is not supported.

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

@@ -7,10 +7,16 @@ import * as util from '../util';
 
 export type Options = [
   {
+    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
     ignoreConditionalTests?: boolean;
-    ignoreTernaryTests?: boolean;
     ignoreMixedLogicalExpressions?: boolean;
-    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+    ignorePrimitives?: {
+      bigint?: boolean;
+      boolean?: boolean;
+      number?: boolean;
+      string?: boolean;
+    };
+    ignoreTernaryTests?: boolean;
   },
 ];
 
@@ -44,16 +50,25 @@ export default util.createRule<Options, MessageIds>({
       {
         type: 'object',
         properties: {
-          ignoreConditionalTests: {
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
             type: 'boolean',
           },
-          ignoreTernaryTests: {
+          ignoreConditionalTests: {
             type: 'boolean',
           },
           ignoreMixedLogicalExpressions: {
             type: 'boolean',
           },
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+          ignorePrimitives: {
+            type: 'object',
+            properties: {
+              bigint: { type: 'boolean' },
+              boolean: { type: 'boolean' },
+              number: { type: 'boolean' },
+              string: { type: 'boolean' },
+            },
+          },
+          ignoreTernaryTests: {
             type: 'boolean',
           },
         },
@@ -63,20 +78,27 @@ export default util.createRule<Options, MessageIds>({
   },
   defaultOptions: [
     {
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
       ignoreConditionalTests: true,
       ignoreTernaryTests: true,
       ignoreMixedLogicalExpressions: true,
-      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      ignorePrimitives: {
+        bigint: false,
+        boolean: false,
+        number: false,
+        string: false,
+      },
     },
   ],
   create(
     context,
     [
       {
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing,
         ignoreConditionalTests,
-        ignoreTernaryTests,
         ignoreMixedLogicalExpressions,
-        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing,
+        ignorePrimitives,
+        ignoreTernaryTests,
       },
     ],
   ) {
@@ -279,6 +301,22 @@ export default util.createRule<Options, MessageIds>({
           return;
         }
 
+        const ignorableFlags = [
+          ignorePrimitives!.bigint && ts.TypeFlags.BigInt,
+          ignorePrimitives!.boolean && ts.TypeFlags.BooleanLiteral,
+          ignorePrimitives!.number && ts.TypeFlags.Number,
+          ignorePrimitives!.string && ts.TypeFlags.String,
+        ]
+          .filter((flag): flag is number => flag !== undefined)
+          .reduce((previous, flag) => previous | flag, 0);
+        if (
+          (type as ts.UnionOrIntersectionType).types.some(t =>
+            tsutils.isTypeFlagSet(t, ignorableFlags),
+          )
+        ) {
+          return;
+        }
+
         const barBarOperator = util.nullThrows(
           sourceCode.getTokenAfter(
             node.left,