fix(eslint-plugin): [switch-exhaustiveness-check] enum members with new line or single quotes are not being fixed correctly

packages/eslint-plugin/docs/rules/switch-exhaustiveness-check.md

@@ -1,15 +1,15 @@
 ---
-description: 'Require switch-case statements to be exhaustive with union type.'
+description: 'Require switch-case statements to be exhaustive with union type or enum.'
 ---
 
 > 🛑 This file is source code, not the primary documentation location! 🛑
 >
 > See **https://typescript-eslint.io/rules/switch-exhaustiveness-check** for documentation.
 
-When working with union types in TypeScript, it's common to want to write a `switch` statement intended to contain a `case` for each constituent (possible type in the union).
-However, if the union type changes, it's easy to forget to modify the cases to account for any new types.
+When working with union types or enums in TypeScript, it's common to want to write a `switch` statement intended to contain a `case` for each constituent (possible type in the union or the enum).
+However, if the union type or the enum changes, it's easy to forget to modify the cases to account for any new types.
 
-This rule reports when a `switch` statement over a value typed as a union of literals is missing a case for any of those literal types and does not have a `default` clause.
+This rule reports when a `switch` statement over a value typed as a union of literals or as an enum is missing a case for any of those literal types and does not have a `default` clause.
 
 ## Examples
 
@@ -101,6 +101,74 @@ switch (day) {
 }
 ```
 
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+enum Fruit {
+  Apple,
+  Banana,
+  Cherry,
+}
+
+const fruit = Fruit.Cherry as Fruit;
+
+switch (fruit) {
+  case Fruit.Apple:
+    console.log('an apple');
+    break;
+}
+```
+
+### ✅ Correct
+
+```ts
+enum Fruit {
+  Apple,
+  Banana,
+  Cherry,
+}
+
+const fruit = Fruit.Cherry as Fruit;
+
+switch (fruit) {
+  case Fruit.Apple:
+    console.log('an apple');
+    break;
+
+  case Fruit.Banana:
+    console.log('a banana');
+    break;
+
+  case Fruit.Cherry:
+    console.log('a cherry');
+    break;
+}
+```
+
+### ✅ Correct
+
+```ts
+enum Fruit {
+  Apple,
+  Banana,
+  Cherry,
+}
+
+const fruit = Fruit.Cherry as Fruit;
+
+switch (fruit) {
+  case Fruit.Apple:
+    console.log('an apple');
+    break;
+
+  default:
+    console.log('a fruit');
+    break;
+}
+```
+
 ## When Not To Use It
 
-If you don't frequently `switch` over union types with many parts, or intentionally wish to leave out some parts.
+If you don't frequently `switch` over union types or enums with many parts, or intentionally wish to leave out some parts.

packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts

@@ -17,7 +17,7 @@ export default createRule({
     type: 'suggestion',
     docs: {
       description:
-        'Require switch-case statements to be exhaustive with union type',
+        'Require switch-case statements to be exhaustive with union type or enum',
       requiresTypeChecking: true,
     },
     hasSuggestions: true,
@@ -66,17 +66,26 @@ export default createRule({
         }
 
         const missingBranchName = missingBranchType.getSymbol()?.escapedName;
+        const requiresBackticks = missingBranchName?.match(/[\r\n]/g);
         let caseTest = checker.typeToString(missingBranchType);
 
         if (
           symbolName &&
           (missingBranchName || missingBranchName === '') &&
           requiresQuoting(missingBranchName.toString(), compilerOptions.target)
         ) {
-          caseTest = `${symbolName}['${missingBranchName}']`;
+          caseTest = requiresBackticks
+            ? `${symbolName}[\`${missingBranchName}\`]`
+            : `${symbolName}['${missingBranchName}']`;
         }
 
-        const errorMessage = `Not implemented yet: ${caseTest} case`;
+        // escape single quotes and newlines, so that the error message is a readable and valid code.
+        const escapedCaseTest = caseTest
+          .replace(/'/g, "\\'")
+          .replace(/\n/g, '\\n')
+          .replace(/\r/g, '\\r');
+
+        const errorMessage = `Not implemented yet: ${escapedCaseTest} case`;
 
         missingCases.push(
           `case ${caseTest}: { throw new Error('${errorMessage}') }`,

packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts

@@ -518,7 +518,7 @@ export enum Enum {
 
 function test(arg: Enum): string {
   switch (arg) {
-  case Enum['test-test']: { throw new Error('Not implemented yet: Enum['test-test'] case') }
+  case Enum['test-test']: { throw new Error('Not implemented yet: Enum[\\'test-test\\'] case') }
   case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
   }
 }
@@ -555,7 +555,7 @@ export enum Enum {
 
 function test(arg: Enum): string {
   switch (arg) {
-  case Enum['']: { throw new Error('Not implemented yet: Enum[''] case') }
+  case Enum['']: { throw new Error('Not implemented yet: Enum[\\'\\'] case') }
   case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
   }
 }
@@ -592,7 +592,7 @@ export enum Enum {
 
 function test(arg: Enum): string {
   switch (arg) {
-  case Enum['9test']: { throw new Error('Not implemented yet: Enum['9test'] case') }
+  case Enum['9test']: { throw new Error('Not implemented yet: Enum[\\'9test\\'] case') }
   case Enum.test: { throw new Error('Not implemented yet: Enum.test case') }
   }
 }
@@ -602,5 +602,47 @@ function test(arg: Enum): string {
         },
       ],
     },
+    {
+      code: `
+        enum Enum {
+          'a' = 1,
+          [\`key-with
+
+          new-line\`] = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        }
+      `,
+      errors: [
+        {
+          messageId: 'switchIsNotExhaustive',
+          suggestions: [
+            {
+              messageId: 'addMissingCases',
+              output: `
+        enum Enum {
+          'a' = 1,
+          [\`key-with
+
+          new-line\`] = 2,
+        }
+
+        declare const a: Enum;
+
+        switch (a) {
+        case Enum.a: { throw new Error('Not implemented yet: Enum.a case') }
+        case Enum[\`key-with
+
+          new-line\`]: { throw new Error('Not implemented yet: Enum[\`key-with\\n\\n          new-line\`] case') }
+        }
+      `,
+            },
+          ],
+        },
+      ],
+    },
   ],
 });