Feb 1, 2025 · Feb 1, 2024 · Feb 2, 2024 · Jan 22, 2025 · Jan 22, 2025
diff --git a/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts b/packages/eslint-plugin/src/rules/switch-exhaustiveness-check.ts
      return;
    }

    function typeToString(type: ts.Type): string {
      return checker.typeToString(
        type,
        undefined,
        ts.TypeFormatFlags.AllowUniqueESSymbolType |
          ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope |
          ts.TypeFormatFlags.UseFullyQualifiedType,
      );
    }

    function getSwitchMetadata(node: TSESTree.SwitchStatement): SwitchMetadata {
      const defaultCase = node.cases.find(
        switchCase => switchCase.test == null,
              .map(missingType =>
                tsutils.isTypeFlagSet(missingType, ts.TypeFlags.ESSymbolLike)
                  ? `typeof ${missingType.getSymbol()?.escapedName as string}`
                  :checker.typeToString(missingType),
                  : typeToString(missingType),
              )
              .join(' | '),
          },
        )
          ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
            missingBranchName!
          :checker.typeToString(missingBranchType);
          : typeToString(missingBranchType);

        if (
          symbolName &&
diff --git a/packages/eslint-plugin/tests/fixtures/switch-exhaustiveness-check.ts b/packages/eslint-plugin/tests/fixtures/switch-exhaustiveness-check.ts
 export namespace A {
  export enum B {
    C,
    D,
  }
 }
diff --git a/packages/eslint-plugin/tests/fixtures/tsconfig.json b/packages/eslint-plugin/tests/fixtures/tsconfig.json
    "mixed-enums-decl.ts",
    "react.tsx",
    "var-declaration.ts",
    "errors.ts"
    "errors.ts",
    "switch-exhaustiveness-check.ts"
  ]
 }
diff --git a/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts b/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
        },
      ],
    },
    {
      code: `
        export namespace A {
          export enum B {
            C,
            D,
          }
        }
        declare const foo: A.B;
        switch (foo) {
          case A.B.C: {
            break;
          }
        }
      `,
      errors: [
        {
          column: 17,
          data: {
            missingBranches: 'A.B.D',
          },
          line: 9,
          messageId: 'switchIsNotExhaustive',
          suggestions: [
            {
              messageId: 'addMissingCases',
              output: `
        export namespace A {
          export enum B {
            C,
            D,
          }
        }
        declare const foo: A.B;
        switch (foo) {
          case A.B.C: {
            break;
          }
          case A.B.D: { throw new Error('Not implemented yet: A.B.D case') }
        }
      `,
            },
          ],
        },
      ],
    },
    {
      code: `
        import { A } from './switch-exhaustiveness-check';
        declare const foo: A.B;
        switch (foo) {
          case A.B.C: {
            break;
          }
        }
      `,
      errors: [
        {
          column: 17,
          data: {
            missingBranches: 'A.B.D',
          },
          line: 4,
          messageId: 'switchIsNotExhaustive',
          suggestions: [
            {
              messageId: 'addMissingCases',
              output: `
        import { A } from './switch-exhaustiveness-check';
        declare const foo: A.B;
        switch (foo) {
          case A.B.C: {
            break;
          }
          case A.B.D: { throw new Error('Not implemented yet: A.B.D case') }
        }
      `,
            },
          ],
        },
      ],
    },
  ],
 });
Original file line number	Diff line number	Diff line change
Expand Up		@@ -142,6 +142,16 @@ export default createRule<Options, MessageIds>({
		return;
		}

		function typeToString(type: ts.Type): string {
		return checker.typeToString(
		type,
		undefined,
		ts.TypeFormatFlags.AllowUniqueESSymbolType \|
		ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope \|
		ts.TypeFormatFlags.UseFullyQualifiedType,
		);
		}

		function getSwitchMetadata(node: TSESTree.SwitchStatement): SwitchMetadata {
		const defaultCase = node.cases.find(
		switchCase => switchCase.test == null,
Expand DownExpand Up		@@ -230,7 +240,7 @@ export default createRule<Options, MessageIds>({
		.map(missingType =>
		tsutils.isTypeFlagSet(missingType, ts.TypeFlags.ESSymbolLike)
		? `typeof ${missingType.getSymbol()?.escapedName as string}`
		:checker.typeToString(missingType),
		: typeToString(missingType),
		)
		.join(' \| '),
		},
Expand DownExpand Up		@@ -282,7 +292,7 @@ export default createRule<Options, MessageIds>({
		)
		? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
		missingBranchName!
		:checker.typeToString(missingBranchType);
		: typeToString(missingBranchType);

		if (
		symbolName &&
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -15,6 +15,7 @@
		"mixed-enums-decl.ts",
		"react.tsx",
		"var-declaration.ts",
		"errors.ts"
		"errors.ts",
		"switch-exhaustiveness-check.ts"
		]
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2947,5 +2947,87 @@ switch (literal) {
		},
		],
		},
		{
		code: `
		export namespace A {
		export enum B {
		C,
		D,
		}
		}
		declare const foo: A.B;
		switch (foo) {
		case A.B.C: {
		break;
		}
		}
		`,
		errors: [
		{
		column: 17,
		data: {
		missingBranches: 'A.B.D',
		},
		line: 9,
		messageId: 'switchIsNotExhaustive',
		suggestions: [
		{
		messageId: 'addMissingCases',
		output: `
		export namespace A {
		export enum B {
		C,
		D,
		}
		}
		declare const foo: A.B;
		switch (foo) {
		case A.B.C: {
		break;
		}
		case A.B.D: { throw new Error('Not implemented yet: A.B.D case') }
		}
		`,
		},
		],
		},
		],
		},
		{
		code: `
		import { A } from './switch-exhaustiveness-check';
		declare const foo: A.B;
		switch (foo) {
		case A.B.C: {
		break;
		}
		}
		`,
		errors: [
		{
		column: 17,
		data: {
		missingBranches: 'A.B.D',
		},
		line: 4,
		messageId: 'switchIsNotExhaustive',
		suggestions: [
		{
		messageId: 'addMissingCases',
		output: `
		import { A } from './switch-exhaustiveness-check';
		declare const foo: A.B;
		switch (foo) {
		case A.B.C: {
		break;
		}
		case A.B.D: { throw new Error('Not implemented yet: A.B.D case') }
		}
		`,
		},
		],
		},
		],
		},
		],
		});