typescript-eslint · Zamiell · Apr 25, 2022 · Apr 28, 2022 · Apr 28, 2022 · Apr 28, 2022
diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
@@ -177,6 +177,7 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int
 | [`@typescript-eslint/restrict-template-expressions`](./docs/rules/restrict-template-expressions.md)                     | Enforce template literal expressions to be of string type                                                               | :white_check_mark: |          | :thought_balloon: |
 | [`@typescript-eslint/sort-type-union-intersection-members`](./docs/rules/sort-type-union-intersection-members.md)       | Enforces that members of a type union/intersection are sorted alphabetically                                            |                    | :wrench: |                   |
 | [`@typescript-eslint/strict-boolean-expressions`](./docs/rules/strict-boolean-expressions.md)                           | Restricts the types allowed in boolean expressions                                                                      |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/strict-enums`](./docs/rules/strict-enums.md)                                                       | Disallows the usage of unsafe enum patterns                                                                             |                    |          | :thought_balloon: |
 | [`@typescript-eslint/switch-exhaustiveness-check`](./docs/rules/switch-exhaustiveness-check.md)                         | Exhaustiveness checking in switch with union type                                                                       |                    |          | :thought_balloon: |
 | [`@typescript-eslint/triple-slash-reference`](./docs/rules/triple-slash-reference.md)                                   | Sets preference level for triple slash directives versus ES6-style import declarations                                  | :white_check_mark: |          |                   |
 | [`@typescript-eslint/type-annotation-spacing`](./docs/rules/type-annotation-spacing.md)                                 | Require consistent spacing around type annotations                                                                      |                    | :wrench: |                   |

diff --git a/packages/eslint-plugin/docs/rules/README.md b/packages/eslint-plugin/docs/rules/README.md
@@ -98,6 +98,7 @@ slug: /
 | [`@typescript-eslint/restrict-template-expressions`](./restrict-template-expressions.md)                     | Enforce template literal expressions to be of string type                                                               | :white_check_mark: |          | :thought_balloon: |
 | [`@typescript-eslint/sort-type-union-intersection-members`](./sort-type-union-intersection-members.md)       | Enforces that members of a type union/intersection are sorted alphabetically                                            |                    | :wrench: |                   |
 | [`@typescript-eslint/strict-boolean-expressions`](./strict-boolean-expressions.md)                           | Restricts the types allowed in boolean expressions                                                                      |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/strict-enums`](./docs/rules/strict-enums.md)                                            | Disallows the usage of unsafe enum patterns                                                                             |                    |          | :thought_balloon: |
 | [`@typescript-eslint/switch-exhaustiveness-check`](./switch-exhaustiveness-check.md)                         | Exhaustiveness checking in switch with union type                                                                       |                    |          | :thought_balloon: |
 | [`@typescript-eslint/triple-slash-reference`](./triple-slash-reference.md)                                   | Sets preference level for triple slash directives versus ES6-style import declarations                                  | :white_check_mark: |          |                   |
 | [`@typescript-eslint/type-annotation-spacing`](./type-annotation-spacing.md)                                 | Require consistent spacing around type annotations                                                                      |                    | :wrench: |                   |

diff --git a/packages/eslint-plugin/docs/rules/strict-enums.md b/packages/eslint-plugin/docs/rules/strict-enums.md
@@ -0,0 +1,149 @@
+# `strict-enums`
+
+Disallows the usage of unsafe enum patterns.
+
+## Rule Details
+
+Horrifyingly, the TypeScript compiler will allow you to set any number to a variable containing a number enum, like this:
+
+```ts
+enum Fruit {
+  Apple,
+  Banana,
+}
+
+let fruit = Fruit.Apple;
+fruit = 999; // No error
+```
+
+This has resulted in many TypeScript programmers avoiding the use of enums altogether. Instead, they should use this rule, which bans working with enums in potentially unsafe ways.
+
+See the examples below for the types of patterns that are prevented.
+
+## Goals
+
+The goal of this rule is to make enums work like they do in other languages. One of the main benefits of enums is that they allow you to write code that is future-safe, because enums are supposed to be resilient to reorganization. If you arbitrarily change the values of an enum (or change the ordering of an enum with computed values), the idea is that nothing in your code-base should break.
+
+## Banned Patterns
+
+This rule bans:
+
+1. Enum incrementing/decrementing - `incorrectIncrement`
+1. Mismatched enum declarations/assignments - `mismatchedAssignment`
+1. Mismatched enum comparisons - `mismatchedComparison`
+1. Mismatched enum function arguments - `mismatchedFunctionArgument`
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+let fruit = Fruit.Apple;
+fruit++;
+```
+
+```ts
+const fruit: Fruit = 0;
+```
+
+```ts
+if (fruit === 0) {
+}
+if (vegetable === 'lettuce') {
+}
+```
+
+```ts
+function useFruit(fruit: Fruit) {}
+useFruit(0);
+```
+
+### ✅ Correct
+
+```ts
+let fruit = Fruit.Apple;
+fruit = Fruit.Banana;
+```
+
+```ts
+const fruit = Fruit.Apple;
+```
+
+```ts
+let fruit = Fruit.Apple;
+fruit = Fruit.Banana;
+```
+
+```ts
+if (fruit === Fruit.Apple) {
+}
+if (vegetable === Vegetable.Lettuce) {
+}
+```
+
+```ts
+function useFruit(fruit: Fruit) {}
+useFruit(Fruit.Apple);
+```
+
+## Error Information
+
+- `incorrectIncrement` - You cannot increment or decrement an enum type.
+  - Enums are supposed to be resilient to reorganization, so you should explicitly assign a new value instead. For example, if someone someone reassigned/reordered the values of the enum, then it could potentially break your code.
+- `mismatchedAssignment` - The type of the assignment does not match the declared enum type of the variable.
+  - In other words, you are trying to assign a `Foo` enum value to a variable with a `Bar` type. Enums are supposed to be resilient to reorganization, so these kinds of assignments can be dangerous.
+- `mismatchedComparison` - The two things in the comparison do not have a shared enum type.
+  - You might be trying to compare using a number literal, like `Foo.Value1 === 1`. Or, you might be trying to compare use a disparate enum type, like `Foo.Value1 === Bar.Value1`. Either way, you need to use a value that corresponds to the correct enum, like `foo === Foo.Value1`, where `foo` is type `Foo`. Enums are supposed to be resilient to reorganization, so these types of comparisons can be dangerous.
+- `mismatchedFunctionArgument` - The argument in the function call does not match the declared enum type of the function signature.
+  - You might be trying to use a number literal, like `useFoo(1)`. Or, you might be trying to use a disparate enum type, like `useFoo(Bar.Value1)`. Either way, you need to use a value that corresponds to the correct enum, like `useFoo(Foo.Value1)`. Enums are supposed to be resilient to reorganization, so non-exact function calls like this can be dangerous.
+
+## Number Enums vs String Enums
+
+Surprisingly, the TypeScript compiler deals with string enums in a safer way than it does with number enums. If we duplicate the first example above by using a string enum, the TypeScript compiler will correctly throw an error:
+
+```ts
+enum Vegetable {
+  Lettuce = 'lettuce',
+  Carrot = 'carrot',
+}
+
+let vegetable = Vegetable.Lettuce;
+vegetable = 'definitelyNotAVegetable'; // Type '"definitelyNotAVegetable"' is not assignable to type 'Vegetable'.
+
+// Even "valid" strings will not work, which is good!
+vegetable = 'carrot'; // Type '"carrot"' is not assignable to type 'Vegetable'.
+```
+
+Thus, the `strict-enums` rule is mostly concerned with throwing errors for misused number enums. However, it still prevents mismatched comparison, which slips by the TypeScript compiler even for string enums:
+
+```ts
+// Bad
+if (vegetable === 'lettuce') {
+  // The TypeScript compiler allows this, but the `strict-enums` rule does not
+}
+
+// Good
+if (vegetable === Vegetable.Lettuce) {
+}
+```
+
+## Comparison Operators
+
+Since it is a common pattern, this rule allows using greater than or less than to compare numeric enums, like this:
+
+```ts
+if (fruit > Fruit.Banana) {
+}
+```
+
+This pattern allows you to select a subset of enums. However, it can lead to bugs when enum values are arbitrarily changed, because the subset will also change. The TypeScript compiler cannot warn you about this, so you should use this pattern with care.
+
+## Options
+
+No options are provided.
+
+## Attributes
+
+- [ ] ✅ Recommended
+- [ ] 🔧 Fixable
+- [x] 💭 Requires type information
diff --git a/packages/eslint-plugin/src/configs/all.ts b/packages/eslint-plugin/src/configs/all.ts
@@ -161,6 +161,7 @@ export = {
     'space-infix-ops': 'off',
     '@typescript-eslint/space-infix-ops': 'error',
     '@typescript-eslint/strict-boolean-expressions': 'error',
+    '@typescript-eslint/strict-enums': 'error',
     '@typescript-eslint/switch-exhaustiveness-check': 'error',
     '@typescript-eslint/triple-slash-reference': 'error',
     '@typescript-eslint/type-annotation-spacing': 'error',

diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
@@ -118,6 +118,7 @@ import spaceBeforeBlocks from './space-before-blocks';
 import spaceBeforeFunctionParen from './space-before-function-paren';
 import spaceInfixOps from './space-infix-ops';
 import strictBooleanExpressions from './strict-boolean-expressions';
+import strictEnums from './strict-enums';
 import switchExhaustivenessCheck from './switch-exhaustiveness-check';
 import tripleSlashReference from './triple-slash-reference';
 import typeAnnotationSpacing from './type-annotation-spacing';
@@ -246,6 +247,7 @@ export default {
   'space-before-function-paren': spaceBeforeFunctionParen,
   'space-infix-ops': spaceInfixOps,
   'strict-boolean-expressions': strictBooleanExpressions,
+  'strict-enums': strictEnums,
   'switch-exhaustiveness-check': switchExhaustivenessCheck,
   'triple-slash-reference': tripleSlashReference,
   'type-annotation-spacing': typeAnnotationSpacing,

diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
@@ -1,5 +1,4 @@
 import { AST_NODE_TYPES, TSESLint, TSESTree } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 import * as util from '../util';
 
@@ -82,7 +81,7 @@ export default util.createRule<Options, MessageId>({
         const checker = parserServices.program.getTypeChecker();
         const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
         const type = util.getConstrainedTypeAtLocation(checker, tsNode);
-        if (!tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike)) {
+        if (!util.isTypeFlagSet(type, ts.TypeFlags.VoidLike)) {
           // not a void expression
           return;
         }

diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -1,5 +1,6 @@
 import * as util from '../util';
 import { TSESLint } from '@typescript-eslint/utils';
+import { ScopeType } from '@typescript-eslint/scope-manager';
 
 type Options = [
   {
@@ -78,7 +79,7 @@ export default util.createRule<Options, MessageIds>({
             let useAutoFix = true;
             if (util.isDefinitionFile(filename)) {
               const scope = context.getScope();
-              if (scope.type === 'tsModule' && scope.block.declare) {
+              if (scope.type === ScopeType.tsModule && scope.block.declare) {
                 useAutoFix = false;
               }
             }

diff --git a/packages/eslint-plugin/src/rules/no-implied-eval.ts b/packages/eslint-plugin/src/rules/no-implied-eval.ts
@@ -1,6 +1,5 @@
 import * as ts from 'typescript';
 import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as util from '../util';
 
 const FUNCTION_CONSTRUCTOR = 'Function';
@@ -69,7 +68,7 @@ export default util.createRule({
 
       if (
         symbol &&
-        tsutils.isSymbolFlagSet(
+        util.isSymbolFlagSet(
           symbol,
           ts.SymbolFlags.Function | ts.SymbolFlags.Method,
         )

diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -549,7 +549,7 @@ function isVoidReturningFunctionType(
         return false;
       }
 
-      hadVoidReturn ||= tsutils.isTypeFlagSet(returnType, ts.TypeFlags.Void);
+      hadVoidReturn ||= util.isTypeFlagSet(returnType, ts.TypeFlags.Void);
     }
   }
 

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 { TSESTree, TSESLint, AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as util from '../util';
 
@@ -254,7 +255,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

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts b/packages/eslint-plugin/src/rules/no-unnecessary-boolean-literal-compare.ts
@@ -1,5 +1,4 @@
 import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 import * as util from '../util';
 
@@ -107,7 +106,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     function isBooleanType(expressionType: ts.Type): boolean {
-      return tsutils.isTypeFlagSet(
+      return util.isTypeFlagSetSimple(
         expressionType,
         ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral,
       );
@@ -128,7 +127,7 @@ export default util.createRule<Options, MessageIds>({
 
       const nonNullishTypes = types.filter(
         type =>
-          !tsutils.isTypeFlagSet(
+          !util.isTypeFlagSetSimple(
             type,
             ts.TypeFlags.Undefined | ts.TypeFlags.Null,
           ),

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -328,7 +328,7 @@ export default createRule<Options, MessageId>({
       if (isStrictNullChecks) {
         const UNDEFINED = ts.TypeFlags.Undefined;
         const NULL = ts.TypeFlags.Null;
-        const isComparable = (type: ts.Type, flag: ts.TypeFlags): boolean => {
+        const isComparable = (type: ts.Type, flag: number): boolean => {
           // Allow comparison to `any`, `unknown` or a naked type parameter.
           flag |=
             ts.TypeFlags.Any |

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts b/packages/eslint-plugin/src/rules/no-unnecessary-qualifier.ts
@@ -1,6 +1,5 @@
 import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
-import * as tsutils from 'tsutils';
 import * as util from '../util';
 
 export default util.createRule({
@@ -33,7 +32,7 @@ export default util.createRule({
       symbol: ts.Symbol,
       checker: ts.TypeChecker,
     ): ts.Symbol | null {
-      return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
+      return util.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
         ? checker.getAliasedSymbol(symbol)
         : null;
     }

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-arguments.ts
@@ -1,5 +1,4 @@
 import { TSESTree } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 import * as util from '../util';
 import { findFirstResult } from '../util';
@@ -179,7 +178,7 @@ function getAliasedSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
 ): ts.Symbol {
-  return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
+  return util.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
     ? checker.getAliasedSymbol(symbol)
     : symbol;
 }
diff --git a/packages/eslint-plugin/src/rules/no-use-before-define.ts b/packages/eslint-plugin/src/rules/no-use-before-define.ts
@@ -59,7 +59,7 @@ function isOuterEnum(
   reference: TSESLint.Scope.Reference,
 ): boolean {
   return (
-    variable.defs[0].type == DefinitionType.TSEnumName &&
+    variable.defs[0].type === DefinitionType.TSEnumName &&
     variable.scope.variableScope !== reference.from.variableScope
   );
 }

diff --git a/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts b/packages/eslint-plugin/src/rules/non-nullable-type-assertion-style.ts
@@ -1,7 +1,6 @@
 import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
 import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
-
 import * as util from '../util';
 
 export default util.createRule({
@@ -34,9 +33,7 @@ export default util.createRule({
         parserServices.esTreeNodeToTSNodeMap.get(node),
       );
 
-      if (
-        tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)
-      ) {
+      if (util.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
         return undefined;
       }
 

diff --git a/packages/eslint-plugin/src/rules/return-await.ts b/packages/eslint-plugin/src/rules/return-await.ts
@@ -172,6 +172,7 @@ export default util.createRule({
         ts.SyntaxKind.AwaitExpression,
         ts.SyntaxKind.Unknown,
       );
+
       return nodePrecedence > awaitPrecedence;
     }
 

diff --git a/packages/eslint-plugin/src/rules/sort-type-union-intersection-members.ts b/packages/eslint-plugin/src/rules/sort-type-union-intersection-members.ts
@@ -1,6 +1,6 @@
 import { AST_NODE_TYPES, TSESLint, TSESTree } from '@typescript-eslint/utils';
+import { getEnumNames } from '@typescript-eslint/type-utils';
 import * as util from '../util';
-import { getEnumNames } from '../util';
 
 enum Group {
   conditional = 'conditional',
-Original file line number
+Diff line change
@@ Expand Up / @@ -549,7 +549,7 @@ function isVoidReturningFunctionType( @@
             return false;
           }
-          hadVoidReturn ||= tsutils.isTypeFlagSet(returnType, ts.TypeFlags.Void);
+          hadVoidReturn ||= util.isTypeFlagSet(returnType, ts.TypeFlags.Void);
         }
       }
@@ Expand Down @@