Nov 26, 2025 · Nov 26, 2025 · Nov 26, 2025 · Nov 26, 2025 · Nov 26, 2025
diff --git a/packages/eslint-plugin/docs/rules/no-unnecessary-condition.mdx b/packages/eslint-plugin/docs/rules/no-unnecessary-condition.mdx
 }

 assertIsString(s); // Unnecessary; s is always a string.

 declare function assertIsStringOrNumber(
  value: unknown,
 ): asserts value is string | number;

 assertIsStringOrNumber(s); // Unnecessary; s is assignable to string | number.
 ```

 Whether this option makes sense for your project may vary.
diff --git a/packages/eslint-plugin/src/rules/class-methods-use-this.ts b/packages/eslint-plugin/src/rules/class-methods-use-this.ts
     */
    function isIncludedInstanceMethod(
      node: NonNullable<Stack['member']>,
    ):node is NonNullable<Stack['member']> {
    ):boolean {
      if (
        node.static ||
        (node.type === AST_NODE_TYPES.MethodDefinition &&
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
  isPossiblyTruthy,
  isTypeAnyType,
  isTypeFlagSet,
  isTypeNeverType,
  isTypeUnknownType,
  nullThrows,
  NullThrowsReasons,
  toWidenedType,
 } from '../util';
 import {
  findTruthinessAssertedArgument,
  | 'noOverlapBooleanExpression'
  | 'noStrictNullCheck'
  | 'suggestRemoveOptionalChain'
  | 'typeGuardAlreadyIsType';
  | 'typeAssertionArgumentAlreadyAssignable';

 export default createRule<Options, MessageId>({
  name: 'no-unnecessary-condition',
      noStrictNullCheck:
        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
      suggestRemoveOptionalChain: 'Remove unnecessary optional chain',
 typeGuardAlreadyIsType:
        'Unnecessary conditional, expression alreadyhasthe type being checked by the {{typeGuardOrAssertionFunction}}.',
 typeAssertionArgumentAlreadyAssignable:
        'Unnecessary conditional, expressionisalreadyassignable tothe type being checked by {{typeGuardOrAssertionFunction}}.',
    },
    schema: [
      {
          node,
        );
        if (typeGuardAssertedArgument != null) {
          const typeOfArgument = getConstrainedTypeAtLocation(
            services,
            typeGuardAssertedArgument.argument,
          );
          if (typeOfArgument === typeGuardAssertedArgument.type) {
          const shouldReport = (() => {
            const argumentType = services.getTypeAtLocation(
              typeGuardAssertedArgument.argument,
            );

            const assertedType = typeGuardAssertedArgument.type;
            if (isTypeAnyType(argumentType) && isTypeAnyType(assertedType)) {
              return true;
            }

            if (isTypeAnyType(argumentType)) {
              return false;
            }

            if (
              isTypeNeverType(argumentType) &&
              isTypeNeverType(assertedType)
            ) {
              return true;
            }

            if (isTypeNeverType(argumentType)) {
              return false;
            }

            if (
              checker.isTypeAssignableTo(
                // Use the widened type to bypass excess property checking
                toWidenedType(checker, argumentType),
                assertedType,
              )
            ) {
              // ... unless the asserted type actually does narrow the argument,
              // for example by granting it additional optional properties?
              return true;
            }

            return false;
          })();

          if (shouldReport) {
            context.report({
              node: typeGuardAssertedArgument.argument,
              messageId: 'typeGuardAlreadyIsType',
              messageId: 'typeAssertionArgumentAlreadyAssignable',
              data: {
                typeGuardOrAssertionFunction: typeGuardAssertedArgument.asserts
                  ? 'assertion function'
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
      const properties = type.getProperties();
      visitSymbolsListOnce(properties, false);

      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- TODO revisit this
      if (isMappedType(type)) {
        visitType(type.typeParameter, false);
        if (properties.length === 0) {
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unsafe-type-assertion.ts
 import type { TSESTree } from '@typescript-eslint/utils';
 import type * as ts from 'typescript';

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

 import {
  createRule,
  getParserServices,
  isObjectLiteralType,
  isTypeAnyType,
  isTypeUnknownType,
  isUnsafeAssignment,
  toWidenedType,
 } from '../util';

 export default createRule({
      return tsutils.isIntrinsicErrorType(type) ? 'error typed' : '`any`';
    }

    function isObjectLiteralType(type: ts.Type): boolean {
      return (
        tsutils.isObjectType(type) &&
        tsutils.isObjectFlagSet(type, ts.ObjectFlags.ObjectLiteral)
      );
    }

    function checkExpression(
      node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion,
    ): void {
        return;
      }

      // Use the widened type in case of an object literal so `isTypeAssignableTo()`
      // won't fail on excess property check.
      const expressionWidenedType = isObjectLiteralType(expressionType)
        ? checker.getWidenedType(expressionType)
        : expressionType;
      // Use the widened type to bypass excess property checking
      const expressionWidenedType = toWidenedType(checker, expressionType);

      const isAssertionSafe = checker.isTypeAssignableTo(
        expressionWidenedType,
diff --git a/packages/eslint-plugin/src/util/index.ts b/packages/eslint-plugin/src/util/index.ts
 export * from './isHigherPrecedenceThanAwait';
 export * from './skipChainExpression';
 export * from './truthinessUtils';
 export * from './isObjectType.js';

 // this is done for convenience - saves migrating all of the old rules
 export * from '@typescript-eslint/type-utils';
diff --git a/packages/eslint-plugin/src/util/isObjectType.ts b/packages/eslint-plugin/src/util/isObjectType.ts
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';

 /**
 * Returns whether the type is a fresh object literal, which will be subject to
 * excess property checking.
 *
 * For example, in the following snippet, the first function call has an object
 * literal type, and therefore is disallowed by excess property checking,
 * whereas the second function call is allowed, because the argument is not an
 * object literal type:
 *
 * ```ts
 * declare function f(x: { a: string });
 *
 * f({ a: 'foo', excess: 'property' }); // TS error
 *
 * const allowed = { a: 'foo', excess: 'property' };
 *
 * f(allowed); // allowed
 * ```
 */
 export function isObjectLiteralType(type: ts.Type): boolean {
  return (
    tsutils.isObjectType(type) &&
    tsutils.isObjectFlagSet(type, ts.ObjectFlags.ObjectLiteral)
  );
 }

 /**
 * Maps object literal types into ordinary types, in order to be able to avoid
 * spurious results from `checker.isTypeAssignableTo()` due to excess property
 * checking.
 */
 export function toWidenedType(checker: ts.TypeChecker, type: ts.Type): ts.Type {
  return isObjectLiteralType(type) ? checker.getWidenedType(type) : type;
 }
diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-unnecessary-condition.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-unnecessary-condition.shot
Original file line number	Diff line number	Diff line change
Expand Up		@@ -188,6 +188,12 @@ function assertIsString(value: unknown): asserts value is string {
		}

		assertIsString(s); // Unnecessary; s is always a string.

		declare function assertIsStringOrNumber(
		value: unknown,
		): asserts value is string \| number;

		assertIsStringOrNumber(s); // Unnecessary; s is assignable to string \| number.
		```

		Whether this option makes sense for your project may vary.
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -173,7 +173,7 @@ export default createRule<Options, MessageIds>({
		*/
		function isIncludedInstanceMethod(
		node: NonNullable<Stack['member']>,
		):node is NonNullable<Stack['member']> {
		):boolean {
		if (
		node.static \|\|
		(node.type === AST_NODE_TYPES.MethodDefinition &&
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -19,9 +19,11 @@ import {
		isPossiblyTruthy,
		isTypeAnyType,
		isTypeFlagSet,
		isTypeNeverType,
		isTypeUnknownType,
		nullThrows,
		NullThrowsReasons,
		toWidenedType,
		} from '../util';
		import {
		findTruthinessAssertedArgument,
Expand DownExpand Up		@@ -153,7 +155,7 @@ export type MessageId =
		\| 'noOverlapBooleanExpression'
		\| 'noStrictNullCheck'
		\| 'suggestRemoveOptionalChain'
		\| 'typeGuardAlreadyIsType';
		\| 'typeAssertionArgumentAlreadyAssignable';

		export default createRule<Options, MessageId>({
		name: 'no-unnecessary-condition',
Expand DownExpand Up		@@ -186,8 +188,8 @@ export default createRule<Options, MessageId>({
		noStrictNullCheck:
		'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
		suggestRemoveOptionalChain: 'Remove unnecessary optional chain',
		typeGuardAlreadyIsType:
		'Unnecessary conditional, expression alreadyhasthe type being checked by the {{typeGuardOrAssertionFunction}}.',
		typeAssertionArgumentAlreadyAssignable:
		'Unnecessary conditional, expressionisalreadyassignable tothe type being checked by {{typeGuardOrAssertionFunction}}.',
		},
		schema: [
		{
Expand DownExpand Up		@@ -595,14 +597,50 @@ export default createRule<Options, MessageId>({
		node,
		);
		if (typeGuardAssertedArgument != null) {
		const typeOfArgument = getConstrainedTypeAtLocation(
		services,
		typeGuardAssertedArgument.argument,
		);
		if (typeOfArgument === typeGuardAssertedArgument.type) {
		const shouldReport = (() => {
		const argumentType = services.getTypeAtLocation(
		typeGuardAssertedArgument.argument,
		);

		const assertedType = typeGuardAssertedArgument.type;
		if (isTypeAnyType(argumentType) && isTypeAnyType(assertedType)) {
		return true;
		}

		if (isTypeAnyType(argumentType)) {
		return false;
		}

		if (
		isTypeNeverType(argumentType) &&
		isTypeNeverType(assertedType)
		) {
		return true;
		}

		if (isTypeNeverType(argumentType)) {
		return false;
		}

		if (
		checker.isTypeAssignableTo(
		// Use the widened type to bypass excess property checking
		toWidenedType(checker, argumentType),
		assertedType,
		)
		) {
		// ... unless the asserted type actually does narrow the argument,
		// for example by granting it additional optional properties?
		return true;
		}

		return false;
		})();

		if (shouldReport) {
		context.report({
		node: typeGuardAssertedArgument.argument,
		messageId: 'typeGuardAlreadyIsType',
		messageId: 'typeAssertionArgumentAlreadyAssignable',
		data: {
		typeGuardOrAssertionFunction: typeGuardAssertedArgument.asserts
		? 'assertion function'
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -452,6 +452,7 @@ function collectTypeParameterUsageCounts(
		const properties = type.getProperties();
		visitSymbolsListOnce(properties, false);

		// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- TODO revisit this
		if (isMappedType(type)) {
		visitType(type.typeParameter, false);
		if (properties.length === 0) {
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,14 +1,16 @@
		import type { TSESTree } from '@typescript-eslint/utils';
		import type * as ts from 'typescript';

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

		import {
		createRule,
		getParserServices,
		isObjectLiteralType,
		isTypeAnyType,
		isTypeUnknownType,
		isUnsafeAssignment,
		toWidenedType,
		} from '../util';

		export default createRule({
Expand DownExpand Up		@@ -42,13 +44,6 @@ export default createRule({
		return tsutils.isIntrinsicErrorType(type) ? 'error typed' : '`any`';
		}

		function isObjectLiteralType(type: ts.Type): boolean {
		return (
		tsutils.isObjectType(type) &&
		tsutils.isObjectFlagSet(type, ts.ObjectFlags.ObjectLiteral)
		);
		}

		function checkExpression(
		node: TSESTree.TSAsExpression \| TSESTree.TSTypeAssertion,
		): void {
Expand DownExpand Up		@@ -110,11 +105,8 @@ export default createRule({
		return;
		}

		// Use the widened type in case of an object literal so `isTypeAssignableTo()`
		// won't fail on excess property check.
		const expressionWidenedType = isObjectLiteralType(expressionType)
		? checker.getWidenedType(expressionType)
		: expressionType;
		// Use the widened type to bypass excess property checking
		const expressionWidenedType = toWidenedType(checker, expressionType);

		const isAssertionSafe = checker.isTypeAssignableTo(
		expressionWidenedType,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -29,6 +29,7 @@ export * from './getValueOfLiteralType';
		export * from './isHigherPrecedenceThanAwait';
		export * from './skipChainExpression';
		export * from './truthinessUtils';
		export * from './isObjectType.js';

		// this is done for convenience - saves migrating all of the old rules
		export * from '@typescript-eslint/type-utils';
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,37 @@
		import * as tsutils from 'ts-api-utils';
		import * as ts from 'typescript';

		/**
		* Returns whether the type is a fresh object literal, which will be subject to
		* excess property checking.
		*
		* For example, in the following snippet, the first function call has an object
		* literal type, and therefore is disallowed by excess property checking,
		* whereas the second function call is allowed, because the argument is not an
		* object literal type:
		*
		* ```ts
		* declare function f(x: { a: string });
		*
		* f({ a: 'foo', excess: 'property' }); // TS error
		*
		* const allowed = { a: 'foo', excess: 'property' };
		*
		* f(allowed); // allowed
		* ```
		*/
		export function isObjectLiteralType(type: ts.Type): boolean {
		return (
		tsutils.isObjectType(type) &&
		tsutils.isObjectFlagSet(type, ts.ObjectFlags.ObjectLiteral)
		);
		}

		/**
		* Maps object literal types into ordinary types, in order to be able to avoid
		* spurious results from `checker.isTypeAssignableTo()` due to excess property
		* checking.
		*/
		export function toWidenedType(checker: ts.TypeChecker, type: ts.Type): ts.Type {
		return isObjectLiteralType(type) ? checker.getWidenedType(type) : type;
		}