feat(eslint-plugin): [no-unsafe-enum-comparison] add switch suggestion

packages/eslint-plugin/src/rules/enum-utils/shared.ts

@@ -20,6 +20,21 @@
   return typeChecker.getTypeAtLocation(symbol.valueDeclaration!.parent);
 }
 
+/**
+ * Retrieve only the Enum literals from a type. for example:
+ * - 123 --> []
+ * - {} --> []
+ * - Fruit.Apple --> [Fruit.Apple]
+ * - Fruit.Apple | Vegetable.Lettuce --> [Fruit.Apple, Vegetable.Lettuce]
+ * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit.Apple, Vegetable.Lettuce]
+ * - T extends Fruit --> [Fruit]
+ */
+export function getEnumLiterals(type: ts.Type): ts.Type[] {
+  return tsutils
+    .unionTypeParts(type)
+    .filter(subType => util.isTypeFlagSet(subType, ts.TypeFlags.EnumLiteral));
+}
+
 /**
  * A type can have 0 or more enum types. For example:
  * - 123 --> []
@@ -33,8 +48,36 @@
   typeChecker: ts.TypeChecker,
   type: ts.Type,
 ): ts.Type[] {
-  return tsutils
-    .unionTypeParts(type)
-    .filter(subType => util.isTypeFlagSet(subType, ts.TypeFlags.EnumLiteral))
-    .map(type => getBaseEnumType(typeChecker, type));
+  return getEnumLiterals(type).map(type => getBaseEnumType(typeChecker, type));
+}
+
+/**
+ * Returns the enum key that matches the given literal node, or null if none
+ * match. For example:
+ * ```ts
+ * enum Fruit {
+ *   Apple = 'apple',
+ *   Banana = 'banana',
+ * }
+ *
+ * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'apple') --> 'Fruit.Apple'
+ * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'banana') --> 'Fruit.Banana'
+ * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'orange') --> null
+ * ```
+ */
+export function getEnumKeyForLiteral(
+  enumLiterals: ts.Type[],
+  literal: unknown,
+): string | null {
+  for (const enumLiteral of enumLiterals) {
+    // @ts-expect-error Not sure why `value` is not on `enumLiteral`.
+    if (enumLiteral.value === literal) {
+      const { symbol } = enumLiteral;
+
+      // @ts-expect-error Not sure why `parent` is not on `symbol`.
+      return `${symbol.parent.name}.${symbol.name}`;
+    }
+  }
+
+  return null;
 }

packages/eslint-plugin/src/rules/no-unsafe-enum-comparison.ts

@@ -1,9 +1,13 @@
-import type { TSESTree } from '@typescript-eslint/utils';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
-import { getEnumTypes } from './enum-utils/shared';
+import {
+  getEnumKeyForLiteral,
+  getEnumLiterals,
+  getEnumTypes,
+} from './enum-utils/shared';
 
 /**
  * @returns Whether the right type is an unsafe comparison against any left type.
@@ -39,6 +43,7 @@ function getEnumValueType(type: ts.Type): ts.TypeFlags | undefined {
 export default util.createRule({
   name: 'no-unsafe-enum-comparison',
   meta: {
+    hasSuggestions: true,
     type: 'suggestion',
     docs: {
       description: 'Disallow comparing an enum value with a non-enum value',
@@ -48,6 +53,7 @@ export default util.createRule({
     messages: {
       mismatched:
         'The two values in this comparison do not have a shared enum type.',
+      replaceValueWithEnum: 'Replace with an enum value comparison.',
     },
     schema: [],
   },
@@ -107,6 +113,53 @@ export default util.createRule({
           context.report({
             messageId: 'mismatched',
             node,
+            suggest: [
+              {
+                messageId: 'replaceValueWithEnum',
+                fix(fixer): TSESLint.RuleFix | null {
+                  const sourceCode = context.getSourceCode();
+                  const leftExpression = sourceCode.getText(node.left);
+                  const rightExpression = sourceCode.getText(node.right);
+
+                  // Replace the right side with an enum key if possible:
+                  //
+                  // ```ts
+                  // Fruit.Apple === 'apple'; // Fruit.Apple === Fruit.Apple
+                  // ```
+                  const leftEnumKey = getEnumKeyForLiteral(
+                    getEnumLiterals(left),
+                    util.getStaticValue(node.right)?.value,
+                  );
+
+                  if (leftEnumKey != null) {
+                    return fixer.replaceText(
+                      node,
+                      `${leftExpression} ${node.operator} ${leftEnumKey}`,
+                    );
+                  }
+
+                  // Replace the left side with an enum key if possible:
+                  //
+                  // ```ts
+                  // declare const fruit: Fruit;
+                  // 'apple' === Fruit.Apple; // Fruit.Apple === Fruit.Apple
+                  // ```
+                  const rightEnumKey = getEnumKeyForLiteral(
+                    getEnumLiterals(right),
+                    util.getStaticValue(node.left)?.value,
+                  );
+
+                  if (rightEnumKey != null) {
+                    return fixer.replaceText(
+                      node,
+                      `${rightEnumKey} ${node.operator} ${rightExpression}`,
+                    );
+                  }
+
+                  return null;
+                },
+              },
+            ],
           });
         }
       },

packages/eslint-plugin/tests/rules/no-unsafe-enum-comparison.test.ts

@@ -565,5 +565,63 @@ ruleTester.run('strict-enums-comparison', rule, {
       `,
       errors: [{ messageId: 'mismatched' }],
     },
+    {
+      code:
+        `enum Str {A = 'a', B = 'b'} ` +
+        `declare const str: Str; ` +
+        `str === 'b';`,
+      errors: [
+        {
+          messageId: 'mismatched',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `enum Str {A = 'a', B = 'b'} declare const str: Str; str === Str.B;`,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code:
+        `enum Num {A = 1, B = 2} ` + `declare const num: Num; ` + `num === 1;`,
+      errors: [
+        {
+          messageId: 'mismatched',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `enum Num {A = 1, B = 2} declare const num: Num; num === Num.A;`,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code:
+        `enum Mixed {A = 1, B = 'b'} ` +
+        `declare const mixed: Mixed; ` +
+        `mixed === 1 || mixed === 'b';`,
+      errors: [
+        {
+          messageId: 'mismatched',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `enum Mixed {A = 1, B = 'b'} declare const mixed: Mixed; mixed === Mixed.A || mixed === 'b';`,
+            },
+          ],
+        },
+        {
+          messageId: 'mismatched',
+          suggestions: [
+            {
+              messageId: 'replaceValueWithEnum',
+              output: `enum Mixed {A = 1, B = 'b'} declare const mixed: Mixed; mixed === 1 || mixed === Mixed.B;`,
+            },
+          ],
+        },
+      ],
+    },
   ],
 });