typescript-eslint · varwasabi · Sep 25, 2022 · Sep 25, 2022 · Sep 25, 2022 · Sep 25, 2022
diff --git a/docs/development/CUSTOM_RULES.md b/docs/development/CUSTOM_RULES.md
@@ -222,9 +222,9 @@ By mapping from ESTree nodes to TypeScript nodes and retrieving the TypeScript p
 This rule bans for-of looping over an enum by using the type-checker via typescript-eslint and TypeScript APIs:
 
 ```ts
+import { isTypeFlagSet } from '@typescript-eslint/type-utils';
 import { ESLintUtils } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
-import * as tsutils from 'tsutils';
 
 export const rule = createRule({
   create(context) {
@@ -241,7 +241,7 @@ export const rule = createRule({
         const nodeType = checker.getTypeAtLocation(originalNode);
 
         // 3. Check the TS node type using the TypeScript APIs
-        if (tsutils.isTypeFlagSet(nodeType, ts.TypeFlags.EnumLike)) {
+        if (isTypeFlagSet(nodeType, ts.TypeFlags.EnumLike)) {
           context.report({
             messageId: 'loopOverEnum',
             node: node.right,

diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -1,4 +1,4 @@
-import * as tsutils from 'tsutils';
+import { isThenableType } from '@typescript-eslint/type-utils';
 
 import * as util from '../util';
 
@@ -30,7 +30,7 @@ export default util.createRule({
         if (
           !util.isTypeAnyType(type) &&
           !util.isTypeUnknownType(type) &&
-          !tsutils.isThenableType(checker, originalNode.expression, type)
+          !isThenableType(checker, originalNode.expression, type)
         ) {
           context.report({
             messageId: 'await',

diff --git a/packages/eslint-plugin/src/rules/dot-notation.ts b/packages/eslint-plugin/src/rules/dot-notation.ts
@@ -1,5 +1,5 @@
+import { isCompilerOptionEnabled } from '@typescript-eslint/type-utils';
 import type { TSESTree } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import type {
@@ -77,9 +77,8 @@ export default createRule<Options, MessageIds>({
       options.allowProtectedClassPropertyAccess;
     const allowIndexSignaturePropertyAccess =
       (options.allowIndexSignaturePropertyAccess ?? false) ||
-      tsutils.isCompilerOptionEnabled(
+      isCompilerOptionEnabled(
         program.getCompilerOptions(),
-        // @ts-expect-error - TS is refining the type to never for some reason
         'noPropertyAccessFromIndexSignature',
       );
 

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,6 +1,6 @@
+import { isTypeFlagSet } from '@typescript-eslint/type-utils';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -84,7 +84,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 (!isTypeFlagSet(type, ts.TypeFlags.VoidLike)) {
           // not a void expression
           return;
         }

diff --git a/packages/eslint-plugin/src/rules/no-dynamic-delete.ts b/packages/eslint-plugin/src/rules/no-dynamic-delete.ts
@@ -1,6 +1,6 @@
+import { isValidPropertyAccess } from '@typescript-eslint/type-utils';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 
 import * as util from '../util';
 
@@ -96,7 +96,6 @@ function isNecessaryDynamicAccess(property: TSESTree.Expression): boolean {
   }
 
   return (
-    typeof property.value === 'string' &&
-    !tsutils.isValidPropertyAccess(property.value)
+    typeof property.value === 'string' && !isValidPropertyAccess(property.value)
   );
 }
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
@@ -1,6 +1,6 @@
+import { unionTypeParts } from '@typescript-eslint/type-utils';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import type * as ts from 'typescript';
 
 import * as util from '../util';
@@ -183,7 +183,7 @@ export default util.createRule<Options, MessageId>({
 //   https://github.com/ajafff/tsutils/blob/49d0d31050b44b81e918eae4fbaf1dfe7b7286af/util/type.ts#L95-L125
 function isPromiseLike(checker: ts.TypeChecker, node: ts.Node): boolean {
   const type = checker.getTypeAtLocation(node);
-  for (const ty of tsutils.unionTypeParts(checker.getApparentType(type))) {
+  for (const ty of unionTypeParts(checker.getApparentType(type))) {
     const then = ty.getProperty('then');
     if (then === undefined) {
       continue;
@@ -209,7 +209,7 @@ function hasMatchingSignature(
   type: ts.Type,
   matcher: (signature: ts.Signature) => boolean,
 ): boolean {
-  for (const t of tsutils.unionTypeParts(type)) {
+  for (const t of unionTypeParts(type)) {
     if (t.getCallSignatures().some(matcher)) {
       return true;
     }
@@ -226,7 +226,7 @@ function isFunctionParam(
   const type: ts.Type | undefined = checker.getApparentType(
     checker.getTypeOfSymbolAtLocation(param, node),
   );
-  for (const t of tsutils.unionTypeParts(type)) {
+  for (const t of unionTypeParts(type)) {
     if (t.getCallSignatures().length !== 0) {
       return true;
     }

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,6 @@
+import { isSymbolFlagSet } from '@typescript-eslint/type-utils';
 import type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -71,10 +71,7 @@ export default util.createRule({
 
       if (
         symbol &&
-        tsutils.isSymbolFlagSet(
-          symbol,
-          ts.SymbolFlags.Function | ts.SymbolFlags.Method,
-        )
+        isSymbolFlagSet(symbol, ts.SymbolFlags.Function | ts.SymbolFlags.Method)
       ) {
         return true;
       }

diff --git a/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts b/packages/eslint-plugin/src/rules/no-meaningless-void-operator.ts
@@ -1,6 +1,6 @@
+import { unionTypeParts } from '@typescript-eslint/type-utils';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { ESLintUtils } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -64,7 +64,7 @@ export default util.createRule<
           node.argument,
         );
         const argType = checker.getTypeAtLocation(argTsNode);
-        const unionParts = tsutils.unionTypeParts(argType);
+        const unionParts = unionTypeParts(argType);
         if (
           unionParts.every(
             part => part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined),

diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -1,6 +1,11 @@
+import {
+  isCallExpression,
+  isThenableType,
+  isTypeFlagSet,
+  unionTypeParts,
+} from '@typescript-eslint/type-utils';
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -410,8 +415,8 @@ export default util.createRule<Options, MessageId>({
 function isSometimesThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
   const type = checker.getTypeAtLocation(node);
 
-  for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
-    if (tsutils.isThenableType(checker, node, subType)) {
+  for (const subType of unionTypeParts(checker.getApparentType(type))) {
+    if (isThenableType(checker, node, subType)) {
       return true;
     }
   }
@@ -426,7 +431,7 @@ function isSometimesThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
 function isAlwaysThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
   const type = checker.getTypeAtLocation(node);
 
-  for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
+  for (const subType of unionTypeParts(checker.getApparentType(type))) {
     const thenProp = subType.getProperty('then');
 
     // If one of the alternates has no then property, it is not thenable in all
@@ -440,7 +445,7 @@ function isAlwaysThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
     // be of the right form to consider it thenable.
     const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node);
     let hasThenableSignature = false;
-    for (const subType of tsutils.unionTypeParts(thenType)) {
+    for (const subType of unionTypeParts(thenType)) {
       for (const signature of subType.getCallSignatures()) {
         if (
           signature.parameters.length !== 0 &&
@@ -478,7 +483,7 @@ function isFunctionParam(
   const type: ts.Type | undefined = checker.getApparentType(
     checker.getTypeOfSymbolAtLocation(param, node),
   );
-  for (const subType of tsutils.unionTypeParts(type)) {
+  for (const subType of unionTypeParts(type)) {
     if (subType.getCallSignatures().length !== 0) {
       return true;
     }
@@ -500,9 +505,9 @@ function voidFunctionParams(
   // We can't use checker.getResolvedSignature because it prefers an early '() => void' over a later '() => Promise<void>'
   // See https://github.com/microsoft/TypeScript/issues/48077
 
-  for (const subType of tsutils.unionTypeParts(type)) {
+  for (const subType of unionTypeParts(type)) {
     // Standard function calls and `new` have two different types of signatures
-    const signatures = ts.isCallExpression(node)
+    const signatures = isCallExpression(node)
       ? subType.getCallSignatures()
       : subType.getConstructSignatures();
     for (const signature of signatures) {
@@ -540,7 +545,7 @@ function anySignatureIsThenableType(
 ): boolean {
   for (const signature of type.getCallSignatures()) {
     const returnType = signature.getReturnType();
-    if (tsutils.isThenableType(checker, node, returnType)) {
+    if (isThenableType(checker, node, returnType)) {
       return true;
     }
   }
@@ -556,7 +561,7 @@ function isThenableReturningFunctionType(
   node: ts.Node,
   type: ts.Type,
 ): boolean {
-  for (const subType of tsutils.unionTypeParts(type)) {
+  for (const subType of unionTypeParts(type)) {
     if (anySignatureIsThenableType(checker, node, subType)) {
       return true;
     }
@@ -575,17 +580,17 @@ function isVoidReturningFunctionType(
 ): boolean {
   let hadVoidReturn = false;
 
-  for (const subType of tsutils.unionTypeParts(type)) {
+  for (const subType of unionTypeParts(type)) {
     for (const signature of subType.getCallSignatures()) {
       const returnType = signature.getReturnType();
 
       // If a certain positional argument accepts both thenable and void returns,
       // a promise-returning function is valid
-      if (tsutils.isThenableType(checker, node, returnType)) {
+      if (isThenableType(checker, node, returnType)) {
         return false;
       }
 
-      hadVoidReturn ||= tsutils.isTypeFlagSet(returnType, ts.TypeFlags.Void);
+      hadVoidReturn ||= isTypeFlagSet(returnType, ts.TypeFlags.Void);
     }
   }
 

diff --git a/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts b/packages/eslint-plugin/src/rules/no-redundant-type-constituents.ts
@@ -1,5 +1,8 @@
+import {
+  isBooleanLiteralType,
+  unionTypeParts,
+} from '@typescript-eslint/type-utils';
 import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -106,11 +109,11 @@ function describeLiteralType(type: ts.Type): string {
     return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`;
   }
 
-  if (tsutils.isBooleanLiteralType(type, true)) {
+  if (isBooleanLiteralType(type, true)) {
     return 'true';
   }
 
-  if (tsutils.isBooleanLiteralType(type, false)) {
+  if (isBooleanLiteralType(type, false)) {
     return 'false';
   }
 
@@ -167,10 +170,10 @@ function isNodeInsideReturnType(node: TSESTree.TSUnionType): boolean {
 function unionTypePartsUnlessBoolean(type: ts.Type): ts.Type[] {
   return type.isUnion() &&
     type.types.length === 2 &&
-    tsutils.isBooleanLiteralType(type.types[0], false) &&
-    tsutils.isBooleanLiteralType(type.types[1], true)
+    isBooleanLiteralType(type.types[0], false) &&
+    isBooleanLiteralType(type.types[1], true)
     ? [type]
-    : tsutils.unionTypeParts(type);
+    : unionTypeParts(type);
 }
 
 export default util.createRule({

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,6 +1,6 @@
 import type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
+import { isTypeFlagSet } from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -113,7 +113,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     function isBooleanType(expressionType: ts.Type): boolean {
-      return tsutils.isTypeFlagSet(
+      return isTypeFlagSet(
         expressionType,
         ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral,
       );
@@ -134,10 +134,7 @@ export default util.createRule<Options, MessageIds>({
 
       const nonNullishTypes = types.filter(
         type =>
-          !tsutils.isTypeFlagSet(
-            type,
-            ts.TypeFlags.Undefined | ts.TypeFlags.Null,
-          ),
+          !isTypeFlagSet(type, ts.TypeFlags.Undefined | ts.TypeFlags.Null),
       );
 
       const hasNonNullishType = nonNullishTypes.length > 0;

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -1,13 +1,13 @@
-import type { TSESTree } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import {
   getCallSignaturesOfType,
   isBooleanLiteralType,
   isFalsyType,
   isLiteralType,
   isStrictCompilerOptionEnabled,
   unionTypeParts,
-} from 'tsutils';
+} from '@typescript-eslint/type-utils';
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
 
 import {

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,6 @@
+import { isSymbolFlagSet } from '@typescript-eslint/type-utils';
 import type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -35,7 +35,7 @@ export default util.createRule({
       symbol: ts.Symbol,
       checker: ts.TypeChecker,
     ): ts.Symbol | null {
-      return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
+      return 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,8 @@
+import {
+  isCallExpression,
+  isSymbolFlagSet,
+} from '@typescript-eslint/type-utils';
 import type { TSESTree } from '@typescript-eslint/utils';
-import * as tsutils from 'tsutils';
 import * as ts from 'typescript';
 
 import * as util from '../util';
@@ -129,7 +132,7 @@ function getTypeParametersFromNode(
     return getTypeParametersFromType(node.typeName, checker);
   }
 
-  if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+  if (isCallExpression(node) || ts.isNewExpression(node)) {
     return getTypeParametersFromCall(node, checker);
   }
 
@@ -180,7 +183,7 @@ function getAliasedSymbol(
   symbol: ts.Symbol,
   checker: ts.TypeChecker,
 ): ts.Symbol {
-  return tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
+  return isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
     ? checker.getAliasedSymbol(symbol)
     : symbol;
 }