feat(eslint-plugin): [no-unnecessary-boolean-literal-compare] enforce strictNullChecks (#10712)

* feat(eslint-plugin): [no-unnecessary-boolean-literal-compare] enforce strictNullChecks

* fixup

Author: yeonjuan

packages/eslint-plugin/docs/rules/no-unnecessary-boolean-literal-compare.mdx

@@ -129,6 +129,22 @@ if (someNullCondition ?? true) {
 </TabItem>
 </Tabs>
 
+### `allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing`
+
+:::danger Deprecated
+
+This option will be removed in the next major version of typescript-eslint.
+
+:::
+
+{/* insert option description */}
+
+Without `strictNullChecks`, TypeScript essentially erases `undefined` and `null` from the types. This means when this rule inspects the types from a variable, **it will not be able to tell that the variable might be `null` or `undefined`**, which essentially makes this rule useless.
+
+You should be using `strictNullChecks` to ensure complete type-safety in your codebase.
+
+If for some reason you cannot turn on `strictNullChecks`, but still want to use this rule - you can use this option to allow it - but know that the behavior of this rule is _undefined_ with the compiler option turned off. We will not accept bug reports if you are using this option.
+
 ## Fixer
 
 |           Comparison           | Fixer Output                    | Notes                                                                               |

packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts

@@ -16,12 +16,14 @@ export type MessageIds =
   | 'comparingNullableToTrueDirect'
   | 'comparingNullableToTrueNegated'
   | 'direct'
-  | 'negated';
+  | 'negated'
+  | 'noStrictNullCheck';
 
 export type Options = [
   {
     allowComparingNullableBooleansToFalse?: boolean;
     allowComparingNullableBooleansToTrue?: boolean;
+    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
   },
 ];
 
@@ -57,6 +59,8 @@ export default createRule<Options, MessageIds>({
         'This expression unnecessarily compares a boolean value to a boolean instead of using it directly.',
       negated:
         'This expression unnecessarily compares a boolean value to a boolean instead of negating it.',
+      noStrictNullCheck:
+        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
     },
     schema: [
       {
@@ -73,6 +77,11 @@ export default createRule<Options, MessageIds>({
             description:
               'Whether to allow comparisons between nullable boolean variables and `true`.',
           },
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+            type: 'boolean',
+            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`.',
+          },
         },
       },
     ],
@@ -81,11 +90,31 @@ export default createRule<Options, MessageIds>({
     {
       allowComparingNullableBooleansToFalse: true,
       allowComparingNullableBooleansToTrue: true,
+      allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
     },
   ],
   create(context, [options]) {
     const services = getParserServices(context);
     const checker = services.program.getTypeChecker();
+    const compilerOptions = services.program.getCompilerOptions();
+
+    const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(
+      compilerOptions,
+      'strictNullChecks',
+    );
+
+    if (
+      !isStrictNullChecks &&
+      options.allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true
+    ) {
+      context.report({
+        loc: {
+          start: { column: 0, line: 0 },
+          end: { column: 0, line: 0 },
+        },
+        messageId: 'noStrictNullCheck',
+      });
+    }
 
     function getBooleanComparison(
       node: TSESTree.BinaryExpression,

packages/eslint-plugin/tests/docs.test.ts

@@ -201,6 +201,7 @@ describe('Validating rule docs', () => {
     'switch-exhaustiveness-check',
     'switch-exhaustiveness-check',
     'unbound-method',
+    'no-unnecessary-boolean-literal-compare',
   ]);
 
   it('All rules must have a corresponding rule doc', () => {

packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts

@@ -1,4 +1,5 @@
 import { noFormat, RuleTester } from '@typescript-eslint/rule-tester';
+import * as path from 'node:path';
 
 import rule from '../../src/rules/no-unnecessary-boolean-literal-compare';
 import { getFixturesRootDir } from '../RuleTester';
@@ -123,6 +124,24 @@ const extendsUnknown: <T extends unknown>(
   }
 };
     `,
+    {
+      code: `
+function test(a?: boolean): boolean {
+  // eslint-disable-next-line
+  return a !== false;
+}
+      `,
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootDir, 'unstrict'),
+        },
+      },
+      options: [
+        {
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: true,
+        },
+      ],
+    },
   ],
 
   invalid: [
@@ -586,5 +605,25 @@ const extendsUnknown: <T extends unknown>(
         };
       `,
     },
+    {
+      code: `
+function foo(): boolean {}
+      `,
+      errors: [
+        {
+          messageId: 'noStrictNullCheck',
+        },
+      ],
+      languageOptions: {
+        parserOptions: {
+          tsconfigRootDir: path.join(rootDir, 'unstrict'),
+        },
+      },
+      options: [
+        {
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+        },
+      ],
+    },
   ],
 });