Apr 25, 2022 · Apr 28, 2022 · Apr 28, 2022 · Apr 28, 2022 · Apr 28, 2022 · Apr 29, 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
 ---
 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
    '@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
    '@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
 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
 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';
  '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
 import { ScopeType } from '@typescript-eslint/scope-manager';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';


        // 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
Original file line number	Diff line number	Diff line change
		@@ -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.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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',
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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',
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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));
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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';
Expand DownExpand Up		@@ -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,
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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';

Expand DownExpand Up		@@ -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
Expand Down