feat(eslint-plugin): [strict-boolean-expressions] add allow nullable enum to strict boolean expressions

packages/eslint-plugin/src/rules/strict-boolean-expressions.ts

@@ -13,6 +13,7 @@ export type Options = [
     allowNullableBoolean?: boolean;
     allowNullableString?: boolean;
     allowNullableNumber?: boolean;
+    allowNullableEnum?: boolean;
     allowAny?: boolean;
     allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
   },
@@ -29,6 +30,7 @@ export type MessageId =
   | 'conditionErrorNullableNumber'
   | 'conditionErrorObject'
   | 'conditionErrorNullableObject'
+  | 'conditionErrorNullableEnum'
   | 'noStrictNullCheck'
   | 'conditionFixDefaultFalse'
   | 'conditionFixDefaultEmptyString'
@@ -63,6 +65,7 @@ export default util.createRule<Options, MessageId>({
           allowNullableBoolean: { type: 'boolean' },
           allowNullableString: { type: 'boolean' },
           allowNullableNumber: { type: 'boolean' },
+          allowNullableEnum: { type: 'boolean' },
           allowAny: { type: 'boolean' },
           allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
             type: 'boolean',
@@ -102,6 +105,9 @@ export default util.createRule<Options, MessageId>({
       conditionErrorNullableObject:
         'Unexpected nullable object value in conditional. ' +
         'An explicit null check is required.',
+      conditionErrorNullableEnum:
+        'Unexpected nullable enum value in conditional. ' +
+        'Please handle the nullish/zero/NaN cases explicitly.',
       noStrictNullCheck:
         'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
 
@@ -137,6 +143,7 @@ export default util.createRule<Options, MessageId>({
       allowNullableBoolean: false,
       allowNullableString: false,
       allowNullableNumber: false,
+      allowNullableEnum: true,
       allowAny: false,
       allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
     },
@@ -718,6 +725,37 @@ export default util.createRule<Options, MessageId>({
         return;
       }
 
+      // nullable enum
+      if (is('nullish', 'number', 'enum')) {
+        if (!options.allowNullableEnum) {
+          if (isLogicalNegationExpression(node.parent!)) {
+            // if (!nullableEnum)
+            context.report({
+              node,
+              messageId: 'conditionErrorNullableEnum',
+              fix: util.getWrappingFixer({
+                sourceCode,
+                node: node.parent,
+                innerNode: node,
+                wrap: code => `${code} == null`,
+              }),
+            });
+          } else {
+            // if (nullableEnum)
+            context.report({
+              node,
+              messageId: 'conditionErrorNullableEnum',
+              fix: util.getWrappingFixer({
+                sourceCode,
+                node,
+                wrap: code => `${code} != null`,
+              }),
+            });
+          }
+        }
+        return;
+      }
+
       // any
       if (is('any')) {
         if (!options.allowAny) {
@@ -753,6 +791,7 @@ export default util.createRule<Options, MessageId>({
       | 'number'
       | 'truthy number'
       | 'object'
+      | 'enum'
       | 'any'
       | 'never';
 
@@ -814,6 +853,17 @@ export default util.createRule<Options, MessageId>({
         }
       }
 
+      const enums = types.filter(type =>
+        tsutils.isTypeFlagSet(
+          type,
+          ts.TypeFlags.Enum | ts.TypeFlags.EnumLike | ts.TypeFlags.EnumLiteral,
+        ),
+      );
+
+      if (enums.length) {
+        variantTypes.add('enum');
+      }
+
       if (
         types.some(
           type =>

packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts

@@ -133,6 +133,25 @@ ruleTester.run('strict-boolean-expressions', rule, {
       `,
     }),
 
+    // nullable enum in boolean context
+    {
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (theEnum) {
+        }
+        if (!theEnum) {
+        }
+      `,
+      options: [{ allowNullableEnum: true }],
+    },
     {
       code: `
 declare const x: string[] | null;
@@ -965,6 +984,56 @@ if (y) {
       ],
     }),
 
+    // nullable enum in boolean context
+    {
+      options: [{ allowNullableEnum: false }],
+      code: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (theEnum) {
+        }
+        if (!theEnum) {
+        }
+      `,
+      errors: [
+        {
+          line: 11,
+          column: 13,
+          messageId: 'conditionErrorNullableEnum',
+          endLine: 11,
+          endColumn: 20,
+        },
+        {
+          line: 13,
+          column: 14,
+          messageId: 'conditionErrorNullableEnum',
+          endLine: 13,
+          endColumn: 21,
+        },
+      ],
+      output: `
+        enum ExampleEnum {
+          This = 0,
+          That = 1,
+        }
+        const rand = Math.random();
+        let theEnum: ExampleEnum | null = null;
+        if (rand < 0.3) {
+          theEnum = ExampleEnum.This;
+        }
+        if (theEnum != null) {
+        }
+        if (theEnum == null) {
+        }
+      `,
+    },
     // any in boolean context
     ...batchedSingleLineTests<MessageId, Options>({
       code: noFormat`