Feb 24, 2025 · Jan 24, 2025 · Jan 27, 2025 · Jan 27, 2025 · Jan 28, 2025 · Feb 4, 2025
diff --git a/packages/eslint-plugin/src/rules/no-floating-promises.ts b/packages/eslint-plugin/src/rules/no-floating-promises.ts
  OperatorPrecedence,
  readonlynessOptionsDefaults,
  readonlynessOptionsSchema,
  skipChainExpression,
  typeMatchesSomeSpecifier,
 } from '../util';

          return;
        }

        let expression = node.expression;

        if (expression.type === AST_NODE_TYPES.ChainExpression) {
          expression = expression.expression;
        }
        const expression = skipChainExpression(node.expression);

        if (isKnownSafePromiseReturn(expression)) {
          return;
diff --git a/packages/eslint-plugin/src/rules/no-inferrable-types.ts b/packages/eslint-plugin/src/rules/no-inferrable-types.ts

 import { AST_NODE_TYPES } from '@typescript-eslint/utils';

 import { createRule, nullThrows, NullThrowsReasons } from '../util';
 import {
  createRule,
  nullThrows,
  NullThrowsReasons,
  skipChainExpression,
 } from '../util';

 export type Options = [
  {
      init: TSESTree.Expression,
      callName: string,
    ): boolean {
      if (init.type === AST_NODE_TYPES.ChainExpression) {
        return isFunctionCall(init.expression, callName);
      }
      const node = skipChainExpression(init);

      return (
 init.type === AST_NODE_TYPES.CallExpression &&
 init.callee.type === AST_NODE_TYPES.Identifier &&
 init.callee.name === callName
 node.type === AST_NODE_TYPES.CallExpression &&
 node.callee.type === AST_NODE_TYPES.Identifier &&
 node.callee.name === callName
      );
    }
    function isLiteral(init: TSESTree.Expression, typeName: string): boolean {
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
  getStaticValue,
  isStaticMemberAccessOfValue,
  nullThrows,
  skipChainExpression,
 } from '../util';

 export default createRule({
    function parseArrayFilterExpressions(
      expression: TSESTree.Expression,
    ): FilterExpressionData[] {
      if (expression.type === AST_NODE_TYPES.SequenceExpression) {
      const node = skipChainExpression(expression);

      if (node.type === AST_NODE_TYPES.SequenceExpression) {
        // Only the last expression in (a, b, [1, 2, 3].filter(condition))[0] matters
        const lastExpression = nullThrows(
 expression.expressions.at(-1),
 node.expressions.at(-1),
          'Expected to have more than zero expressions in a sequence expression',
        );
        return parseArrayFilterExpressions(lastExpression);
      }

      if (expression.type === AST_NODE_TYPES.ChainExpression) {
        return parseArrayFilterExpressions(expression.expression);
      }

      // This is the only reason we're returning a list rather than a single value.
      if (expression.type === AST_NODE_TYPES.ConditionalExpression) {
      if (node.type === AST_NODE_TYPES.ConditionalExpression) {
        // Both branches of the ternary _must_ return results.
        const consequentResult = parseArrayFilterExpressions(
          expression.consequent,
        );
        const consequentResult = parseArrayFilterExpressions(node.consequent);
        if (consequentResult.length === 0) {
          return [];
        }

        const alternateResult = parseArrayFilterExpressions(
          expression.alternate,
        );
        const alternateResult = parseArrayFilterExpressions(node.alternate);
        if (alternateResult.length === 0) {
          return [];
        }
      }

      // Check if it looks like <<stuff>>(...), but not <<stuff>>?.(...)
      if (
        expression.type === AST_NODE_TYPES.CallExpression &&
        !expression.optional
      ) {
        const callee = expression.callee;
      if (node.type === AST_NODE_TYPES.CallExpression && !node.optional) {
        const callee = node.callee;
        // Check if it looks like <<stuff>>.filter(...) or <<stuff>>['filter'](...),
        // or the optional chaining variants.
        if (callee.type === AST_NODE_TYPES.MemberExpression) {
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
  isUndefinedIdentifier,
  nullThrows,
  NullThrowsReasons,
  skipChainExpression,
 } from '../util';

 const isIdentifierOrMemberExpression = isNodeOfTypes([
 const isIdentifierOrMemberOrChainExpression = isNodeOfTypes([
  AST_NODE_TYPES.ChainExpression,
  AST_NODE_TYPES.Identifier,
  AST_NODE_TYPES.MemberExpression,
 ] as const);

 type NullishCheckOperator = '!' | '!=' | '!==' | '==' | '===' | undefined;

 export type Options = [
  {
    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
    const parserServices = getParserServices(context);
    const compilerOptions = parserServices.program.getCompilerOptions();

    const checker = parserServices.program.getTypeChecker();
    const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(
      compilerOptions,
      'strictNullChecks',
          return;
        }

        let operator:'!' | '!=' | '!==' | '==' | '===' | undefined;
        let operator:NullishCheckOperator;
        let nodesInsideTestExpression: TSESTree.Node[] = [];
        if (node.test.type === AST_NODE_TYPES.BinaryExpression) {
          nodesInsideTestExpression = [node.test.left, node.test.right];
          }
        }

        letidentifierOrMemberExpression: TSESTree.Node | undefined;
        letnullishCoalescingLeftNode: TSESTree.Node | undefined;
        let hasTruthinessCheck = false;
        let hasNullCheckWithoutTruthinessCheck = false;
        let hasUndefinedCheckWithoutTruthinessCheck = false;

        if (!operator) {
          let testNode: TSESTree.Node | undefined;
          hasTruthinessCheck = true;

          if (
            isIdentifierOrMemberExpression(node.test) &&
            isNodeEqual(node.test, node.consequent)
          ) {
            identifierOrMemberExpression = node.test;
          if (isIdentifierOrMemberOrChainExpression(node.test)) {
            testNode = node.test;
          } else if (
            node.test.type === AST_NODE_TYPES.UnaryExpression &&
            node.test.operator === '!' &&
            isIdentifierOrMemberExpression(node.test.argument) &&
            isNodeEqual(node.test.argument, node.alternate)
            isIdentifierOrMemberOrChainExpression(node.test.argument) &&
            node.test.operator === '!'
          ) {
 identifierOrMemberExpression = node.test.argument;
 testNode = node.test.argument;
            operator = '!';
          }

          if (
            testNode &&
            areNodesSimilarMemberAccess(
              testNode,
              getBranchNodes(node, operator).nonNullishBranch,
            )
          ) {
            nullishCoalescingLeftNode = testNode;
          }
        } else {
          // we check that the test only contains null, undefined and the identifier
          for (const testNode of nodesInsideTestExpression) {
            } else if (isUndefinedIdentifier(testNode)) {
              hasUndefinedCheckWithoutTruthinessCheck = true;
            } else if (
              (operator === '!==' || operator === '!=') &&
              isNodeEqual(testNode, node.consequent)
              areNodesSimilarMemberAccess(
                testNode,
                getBranchNodes(node, operator).nonNullishBranch,
              )
            ) {
              identifierOrMemberExpression = testNode;
            } else if (
              (operator === '===' || operator === '==') &&
              isNodeEqual(testNode, node.alternate)
            ) {
              identifierOrMemberExpression = testNode;
              // Only consider the first expression in a multi-part nullish check,
              // as subsequent expressions might not require all the optional chaining operators.
              // For example: a?.b?.c !== undefined && a.b.c !== null ? a.b.c : 'foo';
              // This works because `node.test` is always evaluated first in the loop
              // and has the same or more necessary optional chaining operators
              // than `node.alternate` or `node.consequent`.
              nullishCoalescingLeftNode ??= testNode;
            } else {
              return;
            }
          }
        }

        if (!identifierOrMemberExpression) {
        if (!nullishCoalescingLeftNode) {
          return;
        }

          if (hasTruthinessCheck) {
            return isTruthinessCheckEligibleForPreferNullish({
              node,
              testNode:identifierOrMemberExpression,
              testNode:nullishCoalescingLeftNode,
            });
          }

          const tsNode = parserServices.esTreeNodeToTSNodeMap.get(
            identifierOrMemberExpression,
          );
          const type = checker.getTypeAtLocation(tsNode);
          const flags = getTypeFlags(type);

          // it is fixable if we check for both null and undefined, or not if neither
          if (
            hasUndefinedCheckWithoutTruthinessCheck ===
            return true;
          }

          const type = parserServices.getTypeAtLocation(
            nullishCoalescingLeftNode,
          );
          const flags = getTypeFlags(type);

          if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
            return false;
          }
                messageId: 'suggestNullish',
                data: { equals: '' },
                fix(fixer: TSESLint.RuleFixer): TSESLint.RuleFix {
                  const [left, right] =
                    operator === '===' || operator === '==' || operator === '!'
                      ? [identifierOrMemberExpression, node.consequent]
                      : [identifierOrMemberExpression, node.alternate];
                  return fixer.replaceText(
                    node,
                    `${getTextWithParentheses(context.sourceCode,left)} ?? ${getTextWithParentheses(
                    `${getTextWithParentheses(context.sourceCode,nullishCoalescingLeftNode)} ?? ${getTextWithParentheses(
                      context.sourceCode,
 right,
 getBranchNodes(node, operator).nullishBranch,
                    )}`,
                  );
                },

  return false;
 }

 /**
 * Checks if two TSESTree nodes have the same member access sequence,
 * regardless of optional chaining differences.
 *
 * Note: This does not imply that the nodes are runtime-equivalent.
 *
 * Example: `a.b.c`, `a?.b.c`, `a.b?.c`, `(a?.b).c`, `(a.b)?.c` are considered similar.
 *
 * @param a First TSESTree node.
 * @param b Second TSESTree node.
 * @returns `true` if the nodes access members in the same order; otherwise, `false`.
 */
 function areNodesSimilarMemberAccess(
  a: TSESTree.Node,
  b: TSESTree.Node,
 ): boolean {
  if (
    a.type === AST_NODE_TYPES.MemberExpression &&
    b.type === AST_NODE_TYPES.MemberExpression
  ) {
    return (
      isNodeEqual(a.property, b.property) &&
      areNodesSimilarMemberAccess(a.object, b.object)
    );
  }
  if (
    a.type === AST_NODE_TYPES.ChainExpression ||
    b.type === AST_NODE_TYPES.ChainExpression
  ) {
    return areNodesSimilarMemberAccess(
      skipChainExpression(a),
      skipChainExpression(b),
    );
  }
  return isNodeEqual(a, b);
 }

 /**
 * Returns the branch nodes of a conditional expression:
 * - the "nonNullish branch" is the branch when test node is not nullish
 * - the "nullish branch" is the branch when test node is nullish
 */
 function getBranchNodes(
  node: TSESTree.ConditionalExpression,
  operator: NullishCheckOperator,
 ): {
  nonNullishBranch: TSESTree.Expression;
  nullishBranch: TSESTree.Expression;
 } {
  if (!operator || ['!=', '!=='].includes(operator)) {
    return { nonNullishBranch: node.consequent, nullishBranch: node.alternate };
  }
  return { nonNullishBranch: node.alternate, nullishBranch: node.consequent };
 }
diff --git a/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts b/packages/eslint-plugin/src/rules/prefer-promise-reject-errors.ts
  isPromiseLike,
  isReadonlyErrorLike,
  isStaticMemberAccessOfValue,
  skipChainExpression,
 } from '../util';

 export type MessageIds = 'rejectAnError';
      });
    }

    function skipChainExpression<T extends TSESTree.Node>(
      node: T,
    ): T | TSESTree.ChainElement {
      return node.type === AST_NODE_TYPES.ChainExpression
        ? node.expression
        : node;
    }

    function typeAtLocationIsLikePromise(node: TSESTree.Node): boolean {
      const type = services.getTypeAtLocation(node);
      return (
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
  isStaticMemberAccessOfValue,
  nullThrows,
  NullThrowsReasons,
  skipChainExpression,
 } from '../util';

 const EQ_OPERATORS = /^[=!]=/;
    }

    function getLeftNode(
 node: TSESTree.Expression | TSESTree.PrivateIdentifier,
 init: TSESTree.Expression | TSESTree.PrivateIdentifier,
    ): TSESTree.MemberExpression {
      if (node.type === AST_NODE_TYPES.ChainExpression) {
        return getLeftNode(node.expression);
      }

      let leftNode;
      if (node.type === AST_NODE_TYPES.CallExpression) {
        leftNode = node.callee;
      } else {
        leftNode = node;
      }
      const node = skipChainExpression(init);
      const leftNode =
        node.type === AST_NODE_TYPES.CallExpression ? node.callee : node;

      if (leftNode.type !== AST_NODE_TYPES.MemberExpression) {
        throw new Error(`Expected a MemberExpression, got ${leftNode.type}`);
Original file line number	Diff line number	Diff line change
Expand Up		@@ -15,6 +15,7 @@ import {
		OperatorPrecedence,
		readonlynessOptionsDefaults,
		readonlynessOptionsSchema,
		skipChainExpression,
		typeMatchesSomeSpecifier,
		} from '../util';

Expand DownExpand Up		@@ -135,11 +136,7 @@ export default createRule<Options, MessageId>({
		return;
		}

		let expression = node.expression;

		if (expression.type === AST_NODE_TYPES.ChainExpression) {
		expression = expression.expression;
		}
		const expression = skipChainExpression(node.expression);

		if (isKnownSafePromiseReturn(expression)) {
		return;
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,7 +3,12 @@ import type { TSESTree } from '@typescript-eslint/utils';

		import { AST_NODE_TYPES } from '@typescript-eslint/utils';

		import { createRule, nullThrows, NullThrowsReasons } from '../util';
		import {
		createRule,
		nullThrows,
		NullThrowsReasons,
		skipChainExpression,
		} from '../util';

		export type Options = [
		{
Expand DownExpand Up		@@ -55,14 +60,12 @@ export default createRule<Options, MessageIds>({
		init: TSESTree.Expression,
		callName: string,
		): boolean {
		if (init.type === AST_NODE_TYPES.ChainExpression) {
		return isFunctionCall(init.expression, callName);
		}
		const node = skipChainExpression(init);

		return (
		init.type === AST_NODE_TYPES.CallExpression &&
		init.callee.type === AST_NODE_TYPES.Identifier &&
		init.callee.name === callName
		node.type === AST_NODE_TYPES.CallExpression &&
		node.callee.type === AST_NODE_TYPES.Identifier &&
		node.callee.name === callName
		);
		}
		function isLiteral(init: TSESTree.Expression, typeName: string): boolean {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -12,6 +12,7 @@ import {
		getStaticValue,
		isStaticMemberAccessOfValue,
		nullThrows,
		skipChainExpression,
		} from '../util';

		export default createRule({
Expand DownExpand Up		@@ -47,32 +48,26 @@ export default createRule({
		function parseArrayFilterExpressions(
		expression: TSESTree.Expression,
		): FilterExpressionData[] {
		if (expression.type === AST_NODE_TYPES.SequenceExpression) {
		const node = skipChainExpression(expression);

		if (node.type === AST_NODE_TYPES.SequenceExpression) {
		// Only the last expression in (a, b, [1, 2, 3].filter(condition))[0] matters
		const lastExpression = nullThrows(
		expression.expressions.at(-1),
		node.expressions.at(-1),
		'Expected to have more than zero expressions in a sequence expression',
		);
		return parseArrayFilterExpressions(lastExpression);
		}

		if (expression.type === AST_NODE_TYPES.ChainExpression) {
		return parseArrayFilterExpressions(expression.expression);
		}

		// This is the only reason we're returning a list rather than a single value.
		if (expression.type === AST_NODE_TYPES.ConditionalExpression) {
		if (node.type === AST_NODE_TYPES.ConditionalExpression) {
		// Both branches of the ternary _must_ return results.
		const consequentResult = parseArrayFilterExpressions(
		expression.consequent,
		);
		const consequentResult = parseArrayFilterExpressions(node.consequent);
		if (consequentResult.length === 0) {
		return [];
		}

		const alternateResult = parseArrayFilterExpressions(
		expression.alternate,
		);
		const alternateResult = parseArrayFilterExpressions(node.alternate);
		if (alternateResult.length === 0) {
		return [];
		}
Expand All		@@ -82,11 +77,8 @@ export default createRule({
		}

		// Check if it looks like <<stuff>>(...), but not <<stuff>>?.(...)
		if (
		expression.type === AST_NODE_TYPES.CallExpression &&
		!expression.optional
		) {
		const callee = expression.callee;
		if (node.type === AST_NODE_TYPES.CallExpression && !node.optional) {
		const callee = node.callee;
		// Check if it looks like <<stuff>>.filter(...) or <<stuff>>['filter'](...),
		// or the optional chaining variants.
		if (callee.type === AST_NODE_TYPES.MemberExpression) {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -17,13 +17,17 @@ import {
		isUndefinedIdentifier,
		nullThrows,
		NullThrowsReasons,
		skipChainExpression,
		} from '../util';

		const isIdentifierOrMemberExpression = isNodeOfTypes([
		const isIdentifierOrMemberOrChainExpression = isNodeOfTypes([
		AST_NODE_TYPES.ChainExpression,
		AST_NODE_TYPES.Identifier,
		AST_NODE_TYPES.MemberExpression,
		] as const);

		type NullishCheckOperator = '!' \| '!=' \| '!==' \| '==' \| '===' \| undefined;

		export type Options = [
		{
		allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
Expand DownExpand Up		@@ -166,7 +170,6 @@ export default createRule<Options, MessageIds>({
		const parserServices = getParserServices(context);
		const compilerOptions = parserServices.program.getCompilerOptions();

		const checker = parserServices.program.getTypeChecker();
		const isStrictNullChecks = tsutils.isStrictCompilerOptionEnabled(
		compilerOptions,
		'strictNullChecks',
Expand DownExpand Up		@@ -340,7 +343,7 @@ export default createRule<Options, MessageIds>({
		return;
		}

		let operator:'!' \| '!=' \| '!==' \| '==' \| '===' \| undefined;
		let operator:NullishCheckOperator;
		let nodesInsideTestExpression: TSESTree.Node[] = [];
		if (node.test.type === AST_NODE_TYPES.BinaryExpression) {
		nodesInsideTestExpression = [node.test.left, node.test.right];
Expand DownExpand Up		@@ -398,28 +401,35 @@ export default createRule<Options, MessageIds>({
		}
		}

		letidentifierOrMemberExpression: TSESTree.Node \| undefined;
		letnullishCoalescingLeftNode: TSESTree.Node \| undefined;
		let hasTruthinessCheck = false;
		let hasNullCheckWithoutTruthinessCheck = false;
		let hasUndefinedCheckWithoutTruthinessCheck = false;

		if (!operator) {
		let testNode: TSESTree.Node \| undefined;
		hasTruthinessCheck = true;

		if (
		isIdentifierOrMemberExpression(node.test) &&
		isNodeEqual(node.test, node.consequent)
		) {
		identifierOrMemberExpression = node.test;
		if (isIdentifierOrMemberOrChainExpression(node.test)) {
		testNode = node.test;
		} else if (
		node.test.type === AST_NODE_TYPES.UnaryExpression &&
		node.test.operator === '!' &&
		isIdentifierOrMemberExpression(node.test.argument) &&
		isNodeEqual(node.test.argument, node.alternate)
		isIdentifierOrMemberOrChainExpression(node.test.argument) &&
		node.test.operator === '!'
		) {
		identifierOrMemberExpression = node.test.argument;
		testNode = node.test.argument;
		operator = '!';
		}

		if (
		testNode &&
		areNodesSimilarMemberAccess(
		testNode,
		getBranchNodes(node, operator).nonNullishBranch,
		)
		) {
		nullishCoalescingLeftNode = testNode;
		}
		} else {
		// we check that the test only contains null, undefined and the identifier
		for (const testNode of nodesInsideTestExpression) {
Expand All		@@ -428,22 +438,25 @@ export default createRule<Options, MessageIds>({
		} else if (isUndefinedIdentifier(testNode)) {
		hasUndefinedCheckWithoutTruthinessCheck = true;
		} else if (
		(operator === '!==' \|\| operator === '!=') &&
		isNodeEqual(testNode, node.consequent)
		areNodesSimilarMemberAccess(
		testNode,
		getBranchNodes(node, operator).nonNullishBranch,
		)
		) {
		identifierOrMemberExpression = testNode;
		} else if (
		(operator === '===' \|\| operator === '==') &&
		isNodeEqual(testNode, node.alternate)
		) {
		identifierOrMemberExpression = testNode;
		// Only consider the first expression in a multi-part nullish check,
		// as subsequent expressions might not require all the optional chaining operators.
		// For example: a?.b?.c !== undefined && a.b.c !== null ? a.b.c : 'foo';
		// This works because `node.test` is always evaluated first in the loop
		// and has the same or more necessary optional chaining operators
		// than `node.alternate` or `node.consequent`.
		nullishCoalescingLeftNode ??= testNode;
		} else {
		return;
		}
		}
		}

		if (!identifierOrMemberExpression) {
		if (!nullishCoalescingLeftNode) {
		return;
		}

Expand All		@@ -452,16 +465,10 @@ export default createRule<Options, MessageIds>({
		if (hasTruthinessCheck) {
		return isTruthinessCheckEligibleForPreferNullish({
		node,
		testNode:identifierOrMemberExpression,
		testNode:nullishCoalescingLeftNode,
		});
		}

		const tsNode = parserServices.esTreeNodeToTSNodeMap.get(
		identifierOrMemberExpression,
		);
		const type = checker.getTypeAtLocation(tsNode);
		const flags = getTypeFlags(type);

		// it is fixable if we check for both null and undefined, or not if neither
		if (
		hasUndefinedCheckWithoutTruthinessCheck ===
Expand All		@@ -475,6 +482,11 @@ export default createRule<Options, MessageIds>({
		return true;
		}

		const type = parserServices.getTypeAtLocation(
		nullishCoalescingLeftNode,
		);
		const flags = getTypeFlags(type);

		if (flags & (ts.TypeFlags.Any \| ts.TypeFlags.Unknown)) {
		return false;
		}
Expand DownExpand Up		@@ -503,15 +515,11 @@ export default createRule<Options, MessageIds>({
		messageId: 'suggestNullish',
		data: { equals: '' },
		fix(fixer: TSESLint.RuleFixer): TSESLint.RuleFix {
		const [left, right] =
		operator === '===' \|\| operator === '==' \|\| operator === '!'
		? [identifierOrMemberExpression, node.consequent]
		: [identifierOrMemberExpression, node.alternate];
		return fixer.replaceText(
		node,
		`${getTextWithParentheses(context.sourceCode,left)} ?? ${getTextWithParentheses(
		`${getTextWithParentheses(context.sourceCode,nullishCoalescingLeftNode)} ?? ${getTextWithParentheses(
		context.sourceCode,
		right,
		getBranchNodes(node, operator).nullishBranch,
		)}`,
		);
		},
Expand DownExpand Up		@@ -647,3 +655,58 @@ function isMixedLogicalExpression(

		return false;
		}

		/**
		* Checks if two TSESTree nodes have the same member access sequence,
		* regardless of optional chaining differences.
		*
		* Note: This does not imply that the nodes are runtime-equivalent.
		*
		* Example: `a.b.c`, `a?.b.c`, `a.b?.c`, `(a?.b).c`, `(a.b)?.c` are considered similar.
		*
		* @param a First TSESTree node.
		* @param b Second TSESTree node.
		* @returns `true` if the nodes access members in the same order; otherwise, `false`.
		*/
		function areNodesSimilarMemberAccess(
		a: TSESTree.Node,
		b: TSESTree.Node,
		): boolean {
		if (
		a.type === AST_NODE_TYPES.MemberExpression &&
		b.type === AST_NODE_TYPES.MemberExpression
		) {
		return (
		isNodeEqual(a.property, b.property) &&
		areNodesSimilarMemberAccess(a.object, b.object)
		);
		}
		if (
		a.type === AST_NODE_TYPES.ChainExpression \|\|
		b.type === AST_NODE_TYPES.ChainExpression
		) {
		return areNodesSimilarMemberAccess(
		skipChainExpression(a),
		skipChainExpression(b),
		);
		}
		return isNodeEqual(a, b);
		}

		/**
		* Returns the branch nodes of a conditional expression:
		* - the "nonNullish branch" is the branch when test node is not nullish
		* - the "nullish branch" is the branch when test node is nullish
		*/
		function getBranchNodes(
		node: TSESTree.ConditionalExpression,
		operator: NullishCheckOperator,
		): {
		nonNullishBranch: TSESTree.Expression;
		nullishBranch: TSESTree.Expression;
		} {
		if (!operator \|\| ['!=', '!=='].includes(operator)) {
		return { nonNullishBranch: node.consequent, nullishBranch: node.alternate };
		}
		return { nonNullishBranch: node.alternate, nullishBranch: node.consequent };
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -14,6 +14,7 @@ import {
		isPromiseLike,
		isReadonlyErrorLike,
		isStaticMemberAccessOfValue,
		skipChainExpression,
		} from '../util';

		export type MessageIds = 'rejectAnError';
Expand DownExpand Up		@@ -102,14 +103,6 @@ export default createRule<Options, MessageIds>({
		});
		}

		function skipChainExpression<T extends TSESTree.Node>(
		node: T,
		): T \| TSESTree.ChainElement {
		return node.type === AST_NODE_TYPES.ChainExpression
		? node.expression
		: node;
		}

		function typeAtLocationIsLikePromise(node: TSESTree.Node): boolean {
		const type = services.getTypeAtLocation(node);
		return (
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -13,6 +13,7 @@ import {
		isStaticMemberAccessOfValue,
		nullThrows,
		NullThrowsReasons,
		skipChainExpression,
		} from '../util';

		const EQ_OPERATORS = /^[=!]=/;
Expand DownExpand Up		@@ -306,18 +307,11 @@ export default createRule<Options, MessageIds>({
		}

		function getLeftNode(
		node: TSESTree.Expression \| TSESTree.PrivateIdentifier,
		init: TSESTree.Expression \| TSESTree.PrivateIdentifier,
		): TSESTree.MemberExpression {
		if (node.type === AST_NODE_TYPES.ChainExpression) {
		return getLeftNode(node.expression);
		}

		let leftNode;
		if (node.type === AST_NODE_TYPES.CallExpression) {
		leftNode = node.callee;
		} else {
		leftNode = node;
		}
		const node = skipChainExpression(init);
		const leftNode =
		node.type === AST_NODE_TYPES.CallExpression ? node.callee : node;

		if (leftNode.type !== AST_NODE_TYPES.MemberExpression) {
		throw new Error(`Expected a MemberExpression, got ${leftNode.type}`);
Expand Down