typescript-eslint · JoshuaKGoldberg · Apr 25, 2022 · Apr 28, 2022 · Apr 28, 2022 · Apr 28, 2022
diff --git a/packages/eslint-plugin/docs/rules/no-unsafe-enum-assignment.md b/packages/eslint-plugin/docs/rules/no-unsafe-enum-assignment.md
@@ -0,0 +1,62 @@
+---
+description: 'Disallow providing non-enum values to enum typed locations.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-unsafe-enum-assignment** for documentation.
+
+The TypeScript compiler can be surprisingly lenient when working with enums.
+For example, it will allow you to assign any `number` value to a variable containing a numeric enum:
+
+```ts
+enum Fruit {
+  Apple,
+  Banana,
+}
+
+let fruit = Fruit.Apple;
+fruit = 999; // No error
+```
+
+This rule flags when a `number` value is provided in a location that expects an enum type.
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+let fruit = Fruit.Apple;
+fruit++;
+```
+
+```ts
+const fruit: Fruit = 0;
+```
+
+```ts
+function useFruit(fruit: Fruit) {}
+useFruit(0);
+```
+
+### ✅ Correct
+
+```ts
+let fruit = Fruit.Apple;
+fruit = Fruit.Banana;
+```
+
+```ts
+const fruit: Fruit = Fruit.Apple;
+```
+
+```ts
+function useFruit(fruit: Fruit) {}
+useFruit(Fruit.Apple);
+```
+
+<!--/tabs-->
+
+## When Not to Use It
+
+If you use enums as shorthands for numbers and don't mind potentially unsafe `number`-typed values assigned to them, you likely don't need this rule.
diff --git a/packages/eslint-plugin/src/configs/all.ts b/packages/eslint-plugin/src/configs/all.ts
@@ -110,6 +110,7 @@ export = {
     '@typescript-eslint/no-unsafe-assignment': 'error',
     '@typescript-eslint/no-unsafe-call': 'error',
     '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+    '@typescript-eslint/no-unsafe-enum-assignment': 'error',
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
     'no-unused-expressions': 'off',

diff --git a/packages/eslint-plugin/src/configs/strict.ts b/packages/eslint-plugin/src/configs/strict.ts
@@ -28,6 +28,7 @@ export = {
     '@typescript-eslint/no-unnecessary-condition': 'warn',
     '@typescript-eslint/no-unnecessary-type-arguments': 'warn',
     '@typescript-eslint/no-unsafe-declaration-merging': 'warn',
+    '@typescript-eslint/no-unsafe-enum-assignment': 'warn',
     'no-useless-constructor': 'off',
     '@typescript-eslint/no-useless-constructor': 'warn',
     '@typescript-eslint/non-nullable-type-assertion-style': 'warn',

diff --git a/packages/eslint-plugin/src/rules/enum-utils/shared.ts b/packages/eslint-plugin/src/rules/enum-utils/shared.ts
@@ -0,0 +1,46 @@
+import * as tsutils from 'tsutils';
+import * as ts from 'typescript';
+
+import * as util from '../../util';
+
+/*
+ * If passed an enum member, returns the type of the parent. Otherwise,
+ * returns itself.
+ *
+ * For example:
+ * - `Fruit` --> `Fruit`
+ * - `Fruit.Apple` --> `Fruit`
+ */
+export function getBaseEnumType(
+  typeChecker: ts.TypeChecker,
+  type: ts.Type,
+): ts.Type {
+  const symbol = type.getSymbol();
+  if (
+    !symbol?.valueDeclaration?.parent ||
+    !tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.EnumMember)
+  ) {
+    return type;
+  }
+
+  return typeChecker.getTypeAtLocation(symbol.valueDeclaration.parent);
+}
+
+/**
+ * A type can have 0 or more enum types. For example:
+ * - 123 --> []
+ * - {} --> []
+ * - Fruit.Apple --> [Fruit]
+ * - Fruit.Apple | Vegetable.Lettuce --> [Fruit, Vegetable]
+ * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit, Vegetable]
+ * - T extends Fruit --> [Fruit]
+ */
+export function getEnumTypes(
+  typeChecker: ts.TypeChecker,
+  type: ts.Type,
+): ts.Type[] {
+  return tsutils
+    .unionTypeParts(type)
+    .filter(subType => util.isTypeFlagSet(subType, ts.TypeFlags.EnumLike))
+    .map(type => getBaseEnumType(typeChecker, type));
+}
diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
@@ -81,6 +81,7 @@ import noUnsafeArgument from './no-unsafe-argument';
 import noUnsafeAssignment from './no-unsafe-assignment';
 import noUnsafeCall from './no-unsafe-call';
 import noUnsafeDeclarationMerging from './no-unsafe-declaration-merging';
+import noUnsafeEnumAssignment from './no-unsafe-enum-assignment';
 import noUnsafeMemberAccess from './no-unsafe-member-access';
 import noUnsafeReturn from './no-unsafe-return';
 import noUnusedExpressions from './no-unused-expressions';
@@ -214,6 +215,7 @@ export default {
   'no-unsafe-assignment': noUnsafeAssignment,
   'no-unsafe-call': noUnsafeCall,
   'no-unsafe-declaration-merging': noUnsafeDeclarationMerging,
+  'no-unsafe-enum-assignment': noUnsafeEnumAssignment,
   'no-unsafe-member-access': noUnsafeMemberAccess,
   'no-unsafe-return': noUnsafeReturn,
   'no-unused-expressions': noUnusedExpressions,

diff --git a/packages/eslint-plugin/src/rules/no-redeclare.ts b/packages/eslint-plugin/src/rules/no-redeclare.ts
@@ -1,3 +1,4 @@
+import { ScopeType } from '@typescript-eslint/scope-manager';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
@@ -256,7 +257,7 @@ export default util.createRule<Options, MessageIds>({
 
         // Node.js or ES modules has a special scope.
         if (
-          scope.type === 'global' &&
+          scope.type === ScopeType.global &&
           scope.childScopes[0] &&
           // The special scope's block is the Program node.
           scope.block === scope.childScopes[0].block