Jun 1, 2025 · Jun 1, 2025
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import type * as ts from 'typescript';

 import * as tsutils from 'ts-api-utils';

 import {
  Awaitable,
  createRule,
  getConstrainedTypeAtLocation,
  getFixOrSuggest,
  getParserServices,
  isAwaitKeyword,
  NullThrowsReasons,
 } from '../util';
 import { getForStatementHeadLoc } from '../util/getForStatementHeadLoc';
 import { isPromiseAggregatorMethod } from '../util/isPromiseAggregatorMethod';

 export type MessageId =
  | 'await'
  | 'awaitUsingOfNonAsyncDisposable'
  | 'convertToOrdinaryFor'
  | 'forAwaitOfNonAsyncIterable'
  | 'invalidPromiseAggregatorInput'
  | 'removeAwait';

 export default createRule<[], MessageId>({
      convertToOrdinaryFor: 'Convert to an ordinary `for...of` loop.',
      forAwaitOfNonAsyncIterable:
        'Unexpected `for await...of` of a value that is not async iterable.',
      invalidPromiseAggregatorInput:
        'Unexpected iterator of non-Promise (non-"Thenable") values passed to promise aggregator.',
      removeAwait: 'Remove unnecessary `await`.',
    },
    schema: [],
        }
      },

      CallExpression(node: TSESTree.CallExpression): void {
        if (!isPromiseAggregatorMethod(context, services, node)) {
          return;
        }

        const argument = node.arguments.at(0);

        if (argument == null) {
          return;
        }

        const type = getConstrainedTypeAtLocation(services, argument);

        if (
          isInvalidPromiseAggregatorInput(
            checker,
            services.esTreeNodeToTSNodeMap.get(argument),
            type,
          )
        ) {
          context.report({
            node: argument,
            messageId: 'invalidPromiseAggregatorInput',
          });
        }
      },

      'ForOfStatement[await=true]'(node: TSESTree.ForOfStatement): void {
        const type = services.getTypeAtLocation(node.right);
        if (isTypeAnyType(type)) {
    };
  },
 });

 function isInvalidPromiseAggregatorInput(
  checker: ts.TypeChecker,
  node: ts.Node,
  type: ts.Type,
 ): boolean {
  for (const part of tsutils.unionConstituents(type)) {
    if (
      tsutils.isTypeReference(part) &&
      tsutils.getWellKnownSymbolPropertyOfType(part, 'iterator', checker)
    ) {
      for (const typeArgument of checker.getTypeArguments(part)) {
        if (
          tsutils.unionConstituents(typeArgument).some(typeArgumentPart => {
            return (
              needsToBeAwaited(checker, node, typeArgumentPart) ===
              Awaitable.Never
            );
          })
        ) {
          return true;
        }
      }
    }
  }

  return false;
 }
diff --git a/packages/eslint-plugin/src/util/isPromiseAggregatorMethod.ts b/packages/eslint-plugin/src/util/isPromiseAggregatorMethod.ts
 import type {
  ParserServicesWithTypeInformation,
  TSESTree,
 } from '@typescript-eslint/utils';
 import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';

 import {
  getConstrainedTypeAtLocation,
  isPromiseConstructorLike,
 } from '@typescript-eslint/type-utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';

 import { getStaticMemberAccessValue } from './misc';

 const PROMISE_CONSTRUCTOR_ARRAY_METHODS = new Set<unknown>([
  'all',
  'allSettled',
  'race',
  'any',
 ]);

 export function isPromiseAggregatorMethod(
  context: RuleContext<string, unknown[]>,
  services: ParserServicesWithTypeInformation,
  node: TSESTree.CallExpression,
 ): boolean {
  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
    return false;
  }

  const staticAccessValue = getStaticMemberAccessValue(node.callee, context);

  if (!PROMISE_CONSTRUCTOR_ARRAY_METHODS.has(staticAccessValue)) {
    return false;
  }

  return isPromiseConstructorLike(
    services.program,
    getConstrainedTypeAtLocation(services, node.callee.object),
  );
 }
Original file line number	Diff line number	Diff line change
		@@ -1,10 +1,12 @@
		import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
		import type * as ts from 'typescript';

		import * as tsutils from 'ts-api-utils';

		import {
		Awaitable,
		createRule,
		getConstrainedTypeAtLocation,
		getFixOrSuggest,
		getParserServices,
		isAwaitKeyword,
Expand All		@@ -14,12 +16,14 @@ import {
		NullThrowsReasons,
		} from '../util';
		import { getForStatementHeadLoc } from '../util/getForStatementHeadLoc';
		import { isPromiseAggregatorMethod } from '../util/isPromiseAggregatorMethod';

		export type MessageId =
		\| 'await'
		\| 'awaitUsingOfNonAsyncDisposable'
		\| 'convertToOrdinaryFor'
		\| 'forAwaitOfNonAsyncIterable'
		\| 'invalidPromiseAggregatorInput'
		\| 'removeAwait';

		export default createRule<[], MessageId>({
Expand All		@@ -39,6 +43,8 @@ export default createRule<[], MessageId>({
		convertToOrdinaryFor: 'Convert to an ordinary `for...of` loop.',
		forAwaitOfNonAsyncIterable:
		'Unexpected `for await...of` of a value that is not async iterable.',
		invalidPromiseAggregatorInput:
		'Unexpected iterator of non-Promise (non-"Thenable") values passed to promise aggregator.',
		removeAwait: 'Remove unnecessary `await`.',
		},
		schema: [],
Expand DownExpand Up		@@ -84,6 +90,33 @@ export default createRule<[], MessageId>({
		}
		},

		CallExpression(node: TSESTree.CallExpression): void {
		if (!isPromiseAggregatorMethod(context, services, node)) {
		return;
		}

		const argument = node.arguments.at(0);

		if (argument == null) {
		return;
		}

		const type = getConstrainedTypeAtLocation(services, argument);

		if (
		isInvalidPromiseAggregatorInput(
		checker,
		services.esTreeNodeToTSNodeMap.get(argument),
		type,
		)
		) {
		context.report({
		node: argument,
		messageId: 'invalidPromiseAggregatorInput',
		});
		}
		},

		'ForOfStatement[await=true]'(node: TSESTree.ForOfStatement): void {
		const type = services.getTypeAtLocation(node.right);
		if (isTypeAnyType(type)) {
Expand DownExpand Up		@@ -176,3 +209,31 @@ export default createRule<[], MessageId>({
		};
		},
		});

		function isInvalidPromiseAggregatorInput(
		checker: ts.TypeChecker,
		node: ts.Node,
		type: ts.Type,
		): boolean {
		for (const part of tsutils.unionConstituents(type)) {
		if (
		tsutils.isTypeReference(part) &&
		tsutils.getWellKnownSymbolPropertyOfType(part, 'iterator', checker)
		) {
		for (const typeArgument of checker.getTypeArguments(part)) {
		if (
		tsutils.unionConstituents(typeArgument).some(typeArgumentPart => {
		return (
		needsToBeAwaited(checker, node, typeArgumentPart) ===
		Awaitable.Never
		);
		})
		) {
		return true;
		}
		}
		}
		}

		return false;
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,41 @@
		import type {
		ParserServicesWithTypeInformation,
		TSESTree,
		} from '@typescript-eslint/utils';
		import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';

		import {
		getConstrainedTypeAtLocation,
		isPromiseConstructorLike,
		} from '@typescript-eslint/type-utils';
		import { AST_NODE_TYPES } from '@typescript-eslint/utils';

		import { getStaticMemberAccessValue } from './misc';

		const PROMISE_CONSTRUCTOR_ARRAY_METHODS = new Set<unknown>([
		'all',
		'allSettled',
		'race',
		'any',
		]);

		export function isPromiseAggregatorMethod(
		context: RuleContext<string, unknown[]>,
		services: ParserServicesWithTypeInformation,
		node: TSESTree.CallExpression,
		): boolean {
		if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
		return false;
		}

		const staticAccessValue = getStaticMemberAccessValue(node.callee, context);

		if (!PROMISE_CONSTRUCTOR_ARRAY_METHODS.has(staticAccessValue)) {
		return false;
		}

		return isPromiseConstructorLike(
		services.program,
		getConstrainedTypeAtLocation(services, node.callee.object),
		);
		}