Sep 25, 2022 · Sep 25, 2022 · 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
 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) {
        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
 import* as tsutils from 'tsutils';
 import{ isThenableType } from '@typescript-eslint/type-utils';

 import * as util from '../util';

        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
 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 {
      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
 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';
        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
 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';

  }

  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
 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';
 //   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 oftsutils.unionTypeParts(checker.getApparentType(type))) {
  for (const ty of unionTypeParts(checker.getApparentType(type))) {
    const then = ty.getProperty('then');
    if (then === undefined) {
      continue;
  type: ts.Type,
  matcher: (signature: ts.Signature) => boolean,
 ): boolean {
  for (const t oftsutils.unionTypeParts(type)) {
  for (const t of unionTypeParts(type)) {
    if (t.getCallSignatures().some(matcher)) {
      return true;
    }
  const type: ts.Type | undefined = checker.getApparentType(
    checker.getTypeOfSymbolAtLocation(param, node),
  );
  for (const t oftsutils.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
 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';

      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
 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';
          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
 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';
 function isSometimesThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
  const type = checker.getTypeAtLocation(node);

  for (const subType oftsutils.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;
    }
  }
 function isAlwaysThenable(checker: ts.TypeChecker, node: ts.Node): boolean {
  const type = checker.getTypeAtLocation(node);

  for (const subType oftsutils.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
    // be of the right form to consider it thenable.
    const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node);
    let hasThenableSignature = false;
    for (const subType oftsutils.unionTypeParts(thenType)) {
    for (const subType of unionTypeParts(thenType)) {
      for (const signature of subType.getCallSignatures()) {
        if (
          signature.parameters.length !== 0 &&
  const type: ts.Type | undefined = checker.getApparentType(
    checker.getTypeOfSymbolAtLocation(param, node),
  );
  for (const subType oftsutils.unionTypeParts(type)) {
  for (const subType of unionTypeParts(type)) {
    if (subType.getCallSignatures().length !== 0) {
      return true;
    }
  // 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 oftsutils.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) {
 ): boolean {
  for (const signature of type.getCallSignatures()) {
    const returnType = signature.getReturnType();
    if (tsutils.isThenableType(checker, node, returnType)) {
    if (isThenableType(checker, node, returnType)) {
      return true;
    }
  }
  node: ts.Node,
  type: ts.Type,
 ): boolean {
  for (const subType oftsutils.unionTypeParts(type)) {
  for (const subType of unionTypeParts(type)) {
    if (anySignatureIsThenableType(checker, node, subType)) {
      return true;
    }
 ): boolean {
  let hadVoidReturn = false;

  for (const subType oftsutils.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
 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';
    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';
  }

 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
 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';
    }

    function isBooleanType(expressionType: ts.Type): boolean {
      returntsutils.isTypeFlagSet(
      return isTypeFlagSet(
        expressionType,
        ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral,
      );

      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
 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
 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';
      symbol: ts.Symbol,
      checker: ts.TypeChecker,
    ): ts.Symbol | null {
      returntsutils.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
 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';
    return getTypeParametersFromType(node.typeName, checker);
  }

  if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
  if (isCallExpression(node) || ts.isNewExpression(node)) {
    return getTypeParametersFromCall(node, checker);
  }

  symbol: ts.Symbol,
  checker: ts.TypeChecker,
 ): ts.Symbol {
  returntsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
  return isSymbolFlagSet(symbol, ts.SymbolFlags.Alias)
    ? checker.getAliasedSymbol(symbol)
    : symbol;
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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) {
Expand All		@@ -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,
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,4 +1,4 @@
		import* as tsutils from 'tsutils';
		import{ isThenableType } from '@typescript-eslint/type-utils';

		import * as util from '../util';

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

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

Expand DownExpand Up		@@ -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)
		);
		}
Original file line number	Diff line number	Diff line change
		@@ -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';
Expand DownExpand Up		@@ -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 oftsutils.unionTypeParts(checker.getApparentType(type))) {
		for (const ty of unionTypeParts(checker.getApparentType(type))) {
		const then = ty.getProperty('then');
		if (then === undefined) {
		continue;
Expand All		@@ -209,7 +209,7 @@ function hasMatchingSignature(
		type: ts.Type,
		matcher: (signature: ts.Signature) => boolean,
		): boolean {
		for (const t oftsutils.unionTypeParts(type)) {
		for (const t of unionTypeParts(type)) {
		if (t.getCallSignatures().some(matcher)) {
		return true;
		}
Expand All		@@ -226,7 +226,7 @@ function isFunctionParam(
		const type: ts.Type \| undefined = checker.getApparentType(
		checker.getTypeOfSymbolAtLocation(param, node),
		);
		for (const t oftsutils.unionTypeParts(type)) {
		for (const t of unionTypeParts(type)) {
		if (t.getCallSignatures().length !== 0) {
		return true;
		}
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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';
Expand DownExpand Up		@@ -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;
		}
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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';
Expand DownExpand Up		@@ -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 oftsutils.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;
		}
		}
Expand All		@@ -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 oftsutils.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
Expand 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 oftsutils.unionTypeParts(thenType)) {
		for (const subType of unionTypeParts(thenType)) {
		for (const signature of subType.getCallSignatures()) {
		if (
		signature.parameters.length !== 0 &&
Expand DownExpand Up		@@ -478,7 +483,7 @@ function isFunctionParam(
		const type: ts.Type \| undefined = checker.getApparentType(
		checker.getTypeOfSymbolAtLocation(param, node),
		);
		for (const subType oftsutils.unionTypeParts(type)) {
		for (const subType of unionTypeParts(type)) {
		if (subType.getCallSignatures().length !== 0) {
		return true;
		}
Expand All		@@ -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 oftsutils.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) {
Expand DownExpand Up		@@ -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;
		}
		}
Expand All		@@ -556,7 +561,7 @@ function isThenableReturningFunctionType(
		node: ts.Node,
		type: ts.Type,
		): boolean {
		for (const subType oftsutils.unionTypeParts(type)) {
		for (const subType of unionTypeParts(type)) {
		if (anySignatureIsThenableType(checker, node, subType)) {
		return true;
		}
Expand All		@@ -575,17 +580,17 @@ function isVoidReturningFunctionType(
		): boolean {
		let hadVoidReturn = false;

		for (const subType oftsutils.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);
		}
		}

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

Expand DownExpand Up		@@ -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({
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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 {
Expand Down