Sep 2, 2024 · Jul 2, 2024 · Jul 2, 2024 · Jul 2, 2024 · Jul 2, 2024 · Jul 2, 2024
diff --git a/packages/eslint-plugin/docs/rules/no-duplicate-type-constituents.mdx b/packages/eslint-plugin/docs/rules/no-duplicate-type-constituents.mdx
 We consider types to be duplicate if they evaluate to the same result in the type system.
 For example, given `type A = string` and `type T = string | A`, this rule would flag that `A` is the same type as `string`.

 This rule also disallows explicitly listing `undefined` in a type union when a function parameter is marked as optional.
 Doing so is unnecessary.

 <Tabs>
 <TabItem value="❌ Incorrect">

 type StringA = string;
 type StringB = string;
 type T5 = StringA | StringB;

 const fn = (a?: string | undefined) => {};
 ```

 </TabItem>
 type StringA = string;
 type NumberB = number;
 type T5 = StringA | NumberB;

 const fn = (a?: string) => {};
 ```

 </TabItem>
diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import type { Type } from 'typescript';
 import * as ts from 'typescript';

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

 export type Options = [
  {
  },
 ];

 export type MessageIds = 'duplicate';
 export type MessageIds = 'duplicate' | 'unnecessary';

 const astIgnoreKeys = new Set(['range', 'loc', 'parent']);

    fixable: 'code',
    messages: {
      duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
      unnecessary:
        'Explicit undefined is unnecessary on an optional parameter.',
    },
    schema: [
      {
  ],
  create(context, [{ ignoreIntersections, ignoreUnions }]) {
    const parserServices = getParserServices(context);
    const { sourceCode } = context;

    function checkDuplicate(
      node: TSESTree.TSIntersectionType | TSESTree.TSUnionType,
      forEachNodeType?: (
        constituentNodeType: Type,
        report: (messageId: MessageIds) => void,
      ) => void,
    ): void {
      const cachedTypeMap = new Map<Type, TSESTree.TypeNode>();
      node.types.reduce<TSESTree.TypeNode[]>(
            return uniqueConstituents;
          }

          const duplicatedPreviousConstituentInAst = uniqueConstituents.find(
            ele => isSameAstNode(ele, constituentNode),
          );
          if (duplicatedPreviousConstituentInAst) {
            reportDuplicate(
              {
                duplicated: constituentNode,
                duplicatePrevious: duplicatedPreviousConstituentInAst,
              },
              node,
          const report = (
            messageId: MessageIds,
            data?: Record<string, unknown>,
          ): void => {
            const getUnionOrIntersectionToken = (
              where: 'Before' | 'After',
              at: number,
            ): TSESTree.Token | undefined =>
              sourceCode[`getTokens${where}`](constituentNode, {
                filter: token => ['|', '&'].includes(token.value),
              }).at(at);

            const beforeUnionOrIntersectionToken = getUnionOrIntersectionToken(
              'Before',
              -1,
            );
            return uniqueConstituents;
          }
          const duplicatedPreviousConstituentInType =
            cachedTypeMap.get(constituentNodeType);
          if (duplicatedPreviousConstituentInType) {
            reportDuplicate(
              {
                duplicated: constituentNode,
                duplicatePrevious: duplicatedPreviousConstituentInType,
            let afterUnionOrIntersectionToken: TSESTree.Token | undefined;
            let bracketBeforeTokens;
            let bracketAfterTokens;
            if (beforeUnionOrIntersectionToken) {
              bracketBeforeTokens = sourceCode.getTokensBetween(
                beforeUnionOrIntersectionToken,
                constituentNode,
              );
              bracketAfterTokens = sourceCode.getTokensAfter(constituentNode, {
                count: bracketBeforeTokens.length,
              });
            } else {
              afterUnionOrIntersectionToken = nullThrows(
                getUnionOrIntersectionToken('After', 0),
                NullThrowsReasons.MissingToken(
                  'union or intersection token',
                  'duplicate type constituent',
                ),
              );
              bracketAfterTokens = sourceCode.getTokensBetween(
                constituentNode,
                afterUnionOrIntersectionToken,
              );
              bracketBeforeTokens = sourceCode.getTokensBefore(
                constituentNode,
                {
                  count: bracketAfterTokens.length,
                },
              );
            }
            context.report({
              data,
              messageId,
              node: constituentNode,
              loc: {
                start: constituentNode.loc.start,
                end: (bracketAfterTokens.at(-1) ?? constituentNode).loc.end,
              },
              node,
            );
              fix: fixer =>
                [
                  beforeUnionOrIntersectionToken,
                  ...bracketBeforeTokens,
                  constituentNode,
                  ...bracketAfterTokens,
                  afterUnionOrIntersectionToken,
                ].flatMap(token => (token ? fixer.remove(token) : [])),
            });
          };
          const duplicatePrevious =
            uniqueConstituents.find(ele =>
              isSameAstNode(ele, constituentNode),
            ) ?? cachedTypeMap.get(constituentNodeType);
          if (duplicatePrevious) {
            report('duplicate', {
              type:
                node.type === AST_NODE_TYPES.TSIntersectionType
                  ? 'Intersection'
                  : 'Union',
              previous: sourceCode.getText(duplicatePrevious),
            });
            return uniqueConstituents;
          }
          forEachNodeType?.(constituentNodeType, report);
          cachedTypeMap.set(constituentNodeType, constituentNode);
          return [...uniqueConstituents, constituentNode];
        },
        [],
      );
    }
    function reportDuplicate(
      duplicateConstituent: {
        duplicated: TSESTree.TypeNode;
        duplicatePrevious: TSESTree.TypeNode;
      },
      parentNode: TSESTree.TSIntersectionType | TSESTree.TSUnionType,
    ): void {
      const beforeTokens = context.sourceCode.getTokensBefore(
        duplicateConstituent.duplicated,
        { filter: token => token.value === '|' || token.value === '&' },
      );
      const beforeUnionOrIntersectionToken =
        beforeTokens[beforeTokens.length - 1];
      const bracketBeforeTokens = context.sourceCode.getTokensBetween(
        beforeUnionOrIntersectionToken,
        duplicateConstituent.duplicated,
      );
      const bracketAfterTokens = context.sourceCode.getTokensAfter(
        duplicateConstituent.duplicated,
        { count: bracketBeforeTokens.length },
      );
      const reportLocation: TSESTree.SourceLocation = {
        start: duplicateConstituent.duplicated.loc.start,
        end:
          bracketAfterTokens.length > 0
            ? bracketAfterTokens[bracketAfterTokens.length - 1].loc.end
            : duplicateConstituent.duplicated.loc.end,
      };
      context.report({
        data: {
          type:
            parentNode.type === AST_NODE_TYPES.TSIntersectionType
              ? 'Intersection'
              : 'Union',
          previous: context.sourceCode.getText(
            duplicateConstituent.duplicatePrevious,
          ),
        },
        messageId: 'duplicate',
        node: duplicateConstituent.duplicated,
        loc: reportLocation,
        fix: fixer => {
          return [
            beforeUnionOrIntersectionToken,
            ...bracketBeforeTokens,
            duplicateConstituent.duplicated,
            ...bracketAfterTokens,
          ].map(token => fixer.remove(token));
        },
      });
    }

    return {
      ...(!ignoreIntersections && {
        TSIntersectionType: checkDuplicate,
      }),
      ...(!ignoreUnions && {
        TSUnionType: checkDuplicate,
        TSUnionType: (node): void =>
          checkDuplicate(node, (constituentNodeType, report) => {
            const maybeTypeAnnotation = node.parent;
            if (maybeTypeAnnotation.type === AST_NODE_TYPES.TSTypeAnnotation) {
              const maybeIdentifier = maybeTypeAnnotation.parent;
              if (
                maybeIdentifier.type === AST_NODE_TYPES.Identifier &&
                maybeIdentifier.optional
              ) {
                const maybeFunction = maybeIdentifier.parent;
                if (
                  isFunctionOrFunctionType(maybeFunction) &&
                  maybeFunction.params.includes(maybeIdentifier) &&
                  tsutils.isTypeFlagSet(
                    constituentNodeType,
                    ts.TypeFlags.Undefined,
                  )
                ) {
                  report('unnecessary');
                }
              }
            }
          }),
      }),
    };
  },
diff --git a/packages/eslint-plugin/src/rules/prefer-find.ts b/packages/eslint-plugin/src/rules/prefer-find.ts
    | TSESTree.MemberExpressionComputedName
    | TSESTree.MemberExpressionNonComputedName,
  value: string,
  scope?: Scope.Scope | undefined,
  scope?: Scope.Scope,
 ): boolean {
  if (!memberExpression.computed) {
    // x.memberName case.
diff --git a/...ages/eslint-plugin/tests/docs-eslint-output-snapshots/no-duplicate-type-constituents.shot b/...ages/eslint-plugin/tests/docs-eslint-output-snapshots/no-duplicate-type-constituents.shot
Original file line number	Diff line number	Diff line change
Expand Up		@@ -17,6 +17,9 @@ This rule disallows duplicate union or intersection constituents.
		We consider types to be duplicate if they evaluate to the same result in the type system.
		For example, given `type A = string` and `type T = string \| A`, this rule would flag that `A` is the same type as `string`.

		This rule also disallows explicitly listing `undefined` in a type union when a function parameter is marked as optional.
		Doing so is unnecessary.

		<Tabs>
		<TabItem value="❌ Incorrect">

Expand All		@@ -32,6 +35,8 @@ type T4 = [1, 2, 3] \| [1, 2, 3];
		type StringA = string;
		type StringB = string;
		type T5 = StringA \| StringB;

		const fn = (a?: string \| undefined) => {};
		```

		</TabItem>
Expand All		@@ -49,6 +54,8 @@ type T4 = [1, 2, 3] \| [1, 2, 3, 4];
		type StringA = string;
		type NumberB = number;
		type T5 = StringA \| NumberB;

		const fn = (a?: string) => {};
		```

		</TabItem>
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,8 +2,15 @@ import type { TSESTree } from '@typescript-eslint/utils';
		import { AST_NODE_TYPES } from '@typescript-eslint/utils';
		import * as tsutils from 'ts-api-utils';
		import type { Type } from 'typescript';
		import * as ts from 'typescript';

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

		export type Options = [
		{
Expand All		@@ -12,7 +19,7 @@ export type Options = [
		},
		];

		export type MessageIds = 'duplicate';
		export type MessageIds = 'duplicate' \| 'unnecessary';

		const astIgnoreKeys = new Set(['range', 'loc', 'parent']);

Expand DownExpand Up		@@ -79,6 +86,8 @@ export default createRule<Options, MessageIds>({
		fixable: 'code',
		messages: {
		duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
		unnecessary:
		'Explicit undefined is unnecessary on an optional parameter.',
		},
		schema: [
		{
Expand All		@@ -103,9 +112,14 @@ export default createRule<Options, MessageIds>({
		],
		create(context, [{ ignoreIntersections, ignoreUnions }]) {
		const parserServices = getParserServices(context);
		const { sourceCode } = context;

		function checkDuplicate(
		node: TSESTree.TSIntersectionType \| TSESTree.TSUnionType,
		forEachNodeType?: (
		constituentNodeType: Type,
		report: (messageId: MessageIds) => void,
		) => void,
		): void {
		const cachedTypeMap = new Map<Type, TSESTree.TypeNode>();
		node.types.reduce<TSESTree.TypeNode[]>(
Expand All		@@ -116,94 +130,120 @@ export default createRule<Options, MessageIds>({
		return uniqueConstituents;
		}

		const duplicatedPreviousConstituentInAst = uniqueConstituents.find(
		ele => isSameAstNode(ele, constituentNode),
		);
		if (duplicatedPreviousConstituentInAst) {
		reportDuplicate(
		{
		duplicated: constituentNode,
		duplicatePrevious: duplicatedPreviousConstituentInAst,
		},
		node,
		const report = (
		messageId: MessageIds,
		data?: Record<string, unknown>,
		): void => {
		const getUnionOrIntersectionToken = (
		where: 'Before' \| 'After',
		at: number,
		): TSESTree.Token \| undefined =>
		sourceCode[`getTokens${where}`](constituentNode, {
		filter: token => ['\|', '&'].includes(token.value),
		}).at(at);

		const beforeUnionOrIntersectionToken = getUnionOrIntersectionToken(
		'Before',
		-1,
		);
		return uniqueConstituents;
		}
		const duplicatedPreviousConstituentInType =
		cachedTypeMap.get(constituentNodeType);
		if (duplicatedPreviousConstituentInType) {
		reportDuplicate(
		{
		duplicated: constituentNode,
		duplicatePrevious: duplicatedPreviousConstituentInType,
		let afterUnionOrIntersectionToken: TSESTree.Token \| undefined;
		let bracketBeforeTokens;
		let bracketAfterTokens;
		if (beforeUnionOrIntersectionToken) {
		bracketBeforeTokens = sourceCode.getTokensBetween(
		beforeUnionOrIntersectionToken,
		constituentNode,
		);
		bracketAfterTokens = sourceCode.getTokensAfter(constituentNode, {
		count: bracketBeforeTokens.length,
		});
		} else {
		afterUnionOrIntersectionToken = nullThrows(
		getUnionOrIntersectionToken('After', 0),
		NullThrowsReasons.MissingToken(
		'union or intersection token',
		'duplicate type constituent',
		),
		);
		bracketAfterTokens = sourceCode.getTokensBetween(
		constituentNode,
		afterUnionOrIntersectionToken,
		);
		bracketBeforeTokens = sourceCode.getTokensBefore(
		constituentNode,
		{
		count: bracketAfterTokens.length,
		},
		);
		}
		context.report({
		data,
		messageId,
		node: constituentNode,
		loc: {
		start: constituentNode.loc.start,
		end: (bracketAfterTokens.at(-1) ?? constituentNode).loc.end,
		},
		node,
		);
		fix: fixer =>
		[
		beforeUnionOrIntersectionToken,
		...bracketBeforeTokens,
		constituentNode,
		...bracketAfterTokens,
		afterUnionOrIntersectionToken,
		].flatMap(token => (token ? fixer.remove(token) : [])),
		});
		};
		const duplicatePrevious =
		uniqueConstituents.find(ele =>
		isSameAstNode(ele, constituentNode),
		) ?? cachedTypeMap.get(constituentNodeType);
		if (duplicatePrevious) {
		report('duplicate', {
		type:
		node.type === AST_NODE_TYPES.TSIntersectionType
		? 'Intersection'
		: 'Union',
		previous: sourceCode.getText(duplicatePrevious),
		});
		return uniqueConstituents;
		}
		forEachNodeType?.(constituentNodeType, report);
		cachedTypeMap.set(constituentNodeType, constituentNode);
		return [...uniqueConstituents, constituentNode];
		},
		[],
		);
		}
		function reportDuplicate(
		duplicateConstituent: {
		duplicated: TSESTree.TypeNode;
		duplicatePrevious: TSESTree.TypeNode;
		},
		parentNode: TSESTree.TSIntersectionType \| TSESTree.TSUnionType,
		): void {
		const beforeTokens = context.sourceCode.getTokensBefore(
		duplicateConstituent.duplicated,
		{ filter: token => token.value === '\|' \|\| token.value === '&' },
		);
		const beforeUnionOrIntersectionToken =
		beforeTokens[beforeTokens.length - 1];
		const bracketBeforeTokens = context.sourceCode.getTokensBetween(
		beforeUnionOrIntersectionToken,
		duplicateConstituent.duplicated,
		);
		const bracketAfterTokens = context.sourceCode.getTokensAfter(
		duplicateConstituent.duplicated,
		{ count: bracketBeforeTokens.length },
		);
		const reportLocation: TSESTree.SourceLocation = {
		start: duplicateConstituent.duplicated.loc.start,
		end:
		bracketAfterTokens.length > 0
		? bracketAfterTokens[bracketAfterTokens.length - 1].loc.end
		: duplicateConstituent.duplicated.loc.end,
		};
		context.report({
		data: {
		type:
		parentNode.type === AST_NODE_TYPES.TSIntersectionType
		? 'Intersection'
		: 'Union',
		previous: context.sourceCode.getText(
		duplicateConstituent.duplicatePrevious,
		),
		},
		messageId: 'duplicate',
		node: duplicateConstituent.duplicated,
		loc: reportLocation,
		fix: fixer => {
		return [
		beforeUnionOrIntersectionToken,
		...bracketBeforeTokens,
		duplicateConstituent.duplicated,
		...bracketAfterTokens,
		].map(token => fixer.remove(token));
		},
		});
		}

		return {
		...(!ignoreIntersections && {
		TSIntersectionType: checkDuplicate,
		}),
		...(!ignoreUnions && {
		TSUnionType: checkDuplicate,
		TSUnionType: (node): void =>
		checkDuplicate(node, (constituentNodeType, report) => {
		const maybeTypeAnnotation = node.parent;
		if (maybeTypeAnnotation.type === AST_NODE_TYPES.TSTypeAnnotation) {
		const maybeIdentifier = maybeTypeAnnotation.parent;
		if (
		maybeIdentifier.type === AST_NODE_TYPES.Identifier &&
		maybeIdentifier.optional
		) {
		const maybeFunction = maybeIdentifier.parent;
		if (
		isFunctionOrFunctionType(maybeFunction) &&
		maybeFunction.params.includes(maybeIdentifier) &&
		tsutils.isTypeFlagSet(
		constituentNodeType,
		ts.TypeFlags.Undefined,
		)
		) {
		report('unnecessary');
		}
		}
		}
		}),
		}),
		};
		},
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -332,7 +332,7 @@ function isStaticMemberAccessOfValue(
		\| TSESTree.MemberExpressionComputedName
		\| TSESTree.MemberExpressionNonComputedName,
		value: string,
		scope?: Scope.Scope \| undefined,
		scope?: Scope.Scope,
		): boolean {
		if (!memberExpression.computed) {
		// x.memberName case.
Expand Down