typescript-eslint · bradzacher · Nov 3, 2024 · Sep 3, 2024 · Sep 4, 2024 · Sep 9, 2024
diff --git a/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx b/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx
@@ -172,6 +172,28 @@ foo ?? 'a string';
 
 Also, if you would like to ignore all primitives types, you can set `ignorePrimitives: true`. It is equivalent to `ignorePrimitives: { string: true, number: true, bigint: true, boolean: true }`.
 
+### `ignoreBooleanCoercion`
+
+Whether to ignore expressions that coerce a value into a boolean: `Boolean(...)`.
+
+Incorrect code for `ignoreBooleanCoercion: false`, and correct code for `ignoreBooleanCoercion: true`:
+
+```ts option='{ "ignoreBooleanCoercion": true }' showPlaygroundButton
+let a: string | true | undefined;
+let b: string | boolean | undefined;
+
+const x = Boolean(a || b);
+```
+
+Correct code for `ignoreBooleanCoercion: false`:
+
+```ts option='{ "ignoreBooleanCoercion": false }' showPlaygroundButton
+let a: string | true | undefined;
+let b: string | boolean | undefined;
+
+const x = Boolean(a ?? b);
+```
+
 ### `allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing`
 
 {/* insert option description */}

diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -21,6 +21,7 @@
 export type Options = [
   {
     allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+    ignoreBooleanCoercion?: boolean;
     ignoreConditionalTests?: boolean;
     ignoreMixedLogicalExpressions?: boolean;
     ignorePrimitives?:
@@ -71,6 +72,11 @@
             description:
               'Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.',
           },
+          ignoreBooleanCoercion: {
+            type: 'boolean',
+            description:
+              'Whether to ignore arguments to the `Boolean` constructor',
+          },
           ignoreConditionalTests: {
             type: 'boolean',
             description:
@@ -126,6 +132,7 @@
   defaultOptions: [
     {
       allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+      ignoreBooleanCoercion: false,
       ignoreConditionalTests: true,
       ignoreMixedLogicalExpressions: false,
       ignorePrimitives: {
@@ -142,6 +149,7 @@
     [
       {
         allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing,
+        ignoreBooleanCoercion,
         ignoreConditionalTests,
         ignoreMixedLogicalExpressions,
         ignorePrimitives,
@@ -431,46 +439,102 @@
       'LogicalExpression[operator = "||"]'(
         node: TSESTree.LogicalExpression,
       ): void {
+        if (
+          ignoreBooleanCoercion === true &&
+          isBooleanConstructorContext(node, context)
+        ) {
+          return;
+        }
+
         checkAssignmentOrLogicalExpression(node, 'or', '');
       },
     };
   },
 });
 
 function isConditionalTest(node: TSESTree.Node): boolean {
-  const parents = new Set<TSESTree.Node | null>([node]);
-  let current = node.parent;
-  while (current) {
-    parents.add(current);
+  const parent = node.parent;
+  if (parent == null) {
+    return false;
+  }
 
-    if (
-      (current.type === AST_NODE_TYPES.ConditionalExpression ||
-        current.type === AST_NODE_TYPES.DoWhileStatement ||
-        current.type === AST_NODE_TYPES.IfStatement ||
-        current.type === AST_NODE_TYPES.ForStatement ||
-        current.type === AST_NODE_TYPES.WhileStatement) &&
-      parents.has(current.test)
-    ) {
-      return true;
-    }
+  if (parent.type === AST_NODE_TYPES.LogicalExpression) {
+    return isConditionalTest(parent);
+  }
 
-    if (
-      [
-        AST_NODE_TYPES.ArrowFunctionExpression,
-        AST_NODE_TYPES.FunctionExpression,
-      ].includes(current.type)
-    ) {
-      /**
-       * This is a weird situation like:
-       * `if (() => a || b) {}`
-       * `if (function () { return a || b }) {}`
-       */
-      return false;
-    }
+  if (
+    parent.type === AST_NODE_TYPES.ConditionalExpression &&
+    (parent.consequent === node || parent.alternate === node)
+  ) {
+    return isConditionalTest(parent);
+  }
+
+  if (
+    parent.type === AST_NODE_TYPES.SequenceExpression &&
+    parent.expressions.at(-1) === node
+  ) {
+    return isConditionalTest(parent);
+  }
 
-    current = current.parent;
+  if (
+    (parent.type === AST_NODE_TYPES.ConditionalExpression ||
+      parent.type === AST_NODE_TYPES.DoWhileStatement ||
+      parent.type === AST_NODE_TYPES.IfStatement ||
+      parent.type === AST_NODE_TYPES.ForStatement ||
+      parent.type === AST_NODE_TYPES.WhileStatement) &&
+    parent.test === node
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function isBooleanConstructorContext(
+  node: TSESTree.Node,
+  context: Readonly<TSESLint.RuleContext<MessageIds, Options>>,
+): boolean {
+  const parent = node.parent;
+  if (parent == null) {
+    return false;
+  }
+
+  if (parent.type === AST_NODE_TYPES.LogicalExpression) {
+    return isBooleanConstructorContext(parent, context);
+  }
+
+  if (
+    parent.type === AST_NODE_TYPES.ConditionalExpression &&
+    (parent.consequent === node || parent.alternate === node)
+  ) {
+    return isBooleanConstructorContext(parent, context);
+  }
+
+  if (
+    parent.type === AST_NODE_TYPES.SequenceExpression &&
+    parent.expressions.at(-1) === node
+  ) {
+    return isBooleanConstructorContext(parent, context);
   }
 
+  return isBuiltInBooleanCall(parent, context);
+}
+
+function isBuiltInBooleanCall(
+  node: TSESTree.Node,
+  context: Readonly<TSESLint.RuleContext<MessageIds, Options>>,
+): boolean {
+  if (
+    node.type === AST_NODE_TYPES.CallExpression &&
+    node.callee.type === AST_NODE_TYPES.Identifier &&
+    // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum
+    node.callee.name === 'Boolean' &&
+    node.arguments[0]
+  ) {
+    const scope = context.sourceCode.getScope(node);
+    const variable = scope.set.get(AST_TOKEN_TYPES.Boolean);
+    return variable == null || variable.defs.length === 0;
+  }
   return false;
 }
 

diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/prefer-nullish-coalescing.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/prefer-nullish-coalescing.shot