Mar 24, 2023 · Oct 1, 2022 · Oct 1, 2022 · Oct 1, 2022 · Oct 5, 2022 · Oct 5, 2022
diff --git a/packages/eslint-plugin/docs/rules/no-duplicate-type-constituents.md b/packages/eslint-plugin/docs/rules/no-duplicate-type-constituents.md
 ---
 description: 'Disallow duplicate constituents of union or intersection types.'
 ---

 > 🛑 This file is source code, not the primary documentation location! 🛑
 >
 > See **https://typescript-eslint.io/rules/no-duplicate-type-constituents** for documentation.

 TypeScript supports types ("constituents") within union and intersection types being duplicates of each other.
 However, developers typically expect each constituent to be unique within its intersection or union.
 Duplicate values make the code overly verbose and generally reduce readability.

 ## Rule Details

 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`.

 <!--tabs-->

 ### ❌ Incorrect

 ```ts
 type T1 = 'A' | 'A';

 type T2 = A | A | B;

 type T3 = { a: string } & { a: string };

 type T4 = [1, 2, 3] | [1, 2, 3];

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

 ### ✅ Correct

 ```ts
 type T1 = 'A' | 'B';

 type T2 = A | B | C;

 type T3 = { a: string } & { b: string };

 type T4 = [1, 2, 3] | [1, 2, 3, 4];

 type StringA = string;
 type NumberB = number;
 type T5 = StringA | NumberB;
 ```

 ## Options

 ### `ignoreIntersections`

 When set to true, duplicate checks on intersection type constituents are ignored.

 ### `ignoreUnions`

 When set to true, duplicate checks on union type constituents are ignored.
diff --git a/packages/eslint-plugin/src/configs/all.ts b/packages/eslint-plugin/src/configs/all.ts
    'no-dupe-class-members': 'off',
    '@typescript-eslint/no-dupe-class-members': 'error',
    '@typescript-eslint/no-duplicate-enum-values': 'error',
    '@typescript-eslint/no-duplicate-type-constituents': 'error',
    '@typescript-eslint/no-dynamic-delete': 'error',
    'no-empty-function': 'off',
    '@typescript-eslint/no-empty-function': 'error',
diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
 import noDupeClassMembers from './no-dupe-class-members';
 import noDuplicateEnumValues from './no-duplicate-enum-values';
 import noDuplicateImports from './no-duplicate-imports';
 import noDuplicateTypeConstituents from './no-duplicate-type-constituents';
 import noDynamicDelete from './no-dynamic-delete';
 import noEmptyFunction from './no-empty-function';
 import noEmptyInterface from './no-empty-interface';
  'no-dupe-class-members': noDupeClassMembers,
  'no-duplicate-enum-values': noDuplicateEnumValues,
  'no-duplicate-imports': noDuplicateImports,
  'no-duplicate-type-constituents': noDuplicateTypeConstituents,
  'no-dynamic-delete': noDynamicDelete,
  'no-empty-function': noEmptyFunction,
  'no-empty-interface': noEmptyInterface,
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 type { TSESTree } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import type { Type } from 'typescript';

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

 export type Options = [
  {
    ignoreIntersections?: boolean;
    ignoreUnions?: boolean;
  },
 ];

 export type MessageIds = 'duplicate';

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

 const isSameAstNode = (actualNode: unknown, expectedNode: unknown): boolean => {
  if (actualNode === expectedNode) {
    return true;
  }
  if (
    actualNode &&
    expectedNode &&
    typeof actualNode === 'object' &&
    typeof expectedNode === 'object'
  ) {
    if (Array.isArray(actualNode) && Array.isArray(expectedNode)) {
      if (actualNode.length !== expectedNode.length) {
        return false;
      }
      return !actualNode.some(
        (nodeEle, index) => !isSameAstNode(nodeEle, expectedNode[index]),
      );
    }
    const actualNodeKeys = Object.keys(actualNode).filter(
      key => !astIgnoreKeys.has(key),
    );
    const expectedNodeKeys = Object.keys(expectedNode).filter(
      key => !astIgnoreKeys.has(key),
    );
    if (actualNodeKeys.length !== expectedNodeKeys.length) {
      return false;
    }
    if (
      actualNodeKeys.some(
        actualNodeKey =>
          !Object.prototype.hasOwnProperty.call(expectedNode, actualNodeKey),
      )
    ) {
      return false;
    }
    if (
      actualNodeKeys.some(
        actualNodeKey =>
          !isSameAstNode(
            actualNode[actualNodeKey as keyof typeof actualNode],
            expectedNode[actualNodeKey as keyof typeof expectedNode],
          ),
      )
    ) {
      return false;
    }
    return true;
  }
  return false;
 };

 export default util.createRule<Options, MessageIds>({
  name: 'no-duplicate-type-constituents',
  meta: {
    type: 'suggestion',
    docs: {
      description:
        'Disallow duplicate constituents of union or intersection types',
      recommended: false,
      requiresTypeChecking: true,
    },
    fixable: 'code',
    messages: {
      duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
    },
    schema: [
      {
        additionalProperties: false,
        type: 'object',
        properties: {
          ignoreIntersections: {
            type: 'boolean',
          },
          ignoreUnions: {
            type: 'boolean',
          },
        },
      },
    ],
  },
  defaultOptions: [
    {
      ignoreIntersections: false,
      ignoreUnions: false,
    },
  ],
  create(context, [{ ignoreIntersections, ignoreUnions }]) {
    const parserServices = util.getParserServices(context);
    const checker = parserServices.program.getTypeChecker();

    function checkDuplicate(
      node: TSESTree.TSIntersectionType | TSESTree.TSUnionType,
    ): void {
      const cachedTypeMap: Map<Type, TSESTree.TypeNode> = new Map();
      node.types.reduce<TSESTree.TypeNode[]>(
        (uniqueConstituents, constituentNode) => {
          const duplicatedPreviousConstituentInAst = uniqueConstituents.find(
            ele => isSameAstNode(ele, constituentNode),
          );
          if (duplicatedPreviousConstituentInAst) {
            reportDuplicate(
              {
                duplicated: constituentNode,
                duplicatePrevious: duplicatedPreviousConstituentInAst,
              },
              node,
            );
            return uniqueConstituents;
          }
          const constituentNodeType = checker.getTypeAtLocation(
            parserServices.esTreeNodeToTSNodeMap.get(constituentNode),
          );
          const duplicatedPreviousConstituentInType =
            cachedTypeMap.get(constituentNodeType);
          if (duplicatedPreviousConstituentInType) {
            reportDuplicate(
              {
                duplicated: constituentNode,
                duplicatePrevious: duplicatedPreviousConstituentInType,
              },
              node,
            );
            return uniqueConstituents;
          }
          cachedTypeMap.set(constituentNodeType, constituentNode);
          return [...uniqueConstituents, constituentNode];
        },
        [],
      );
    }
    function reportDuplicate(
      duplicateConstituent: {
        duplicated: TSESTree.TypeNode;
        duplicatePrevious: TSESTree.TypeNode;
      },
      parentNode: TSESTree.TSIntersectionType | TSESTree.TSUnionType,
    ): void {
      const sourceCode = context.getSourceCode();
      const beforeTokens = sourceCode.getTokensBefore(
        duplicateConstituent.duplicated,
        { filter: token => token.value === '|' || token.value === '&' },
      );
      const beforeUnionOrIntersectionToken =
        beforeTokens[beforeTokens.length - 1];
      const bracketBeforeTokens = sourceCode.getTokensBetween(
        beforeUnionOrIntersectionToken,
        duplicateConstituent.duplicated,
      );
      const bracketAfterTokens = 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: 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,
      }),
    };
  },
 });
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,61 @@
		---
		description: 'Disallow duplicate constituents of union or intersection types.'
		---

		> 🛑 This file is source code, not the primary documentation location! 🛑
		>
		> See https://typescript-eslint.io/rules/no-duplicate-type-constituents for documentation.

		TypeScript supports types ("constituents") within union and intersection types being duplicates of each other.
		However, developers typically expect each constituent to be unique within its intersection or union.
		Duplicate values make the code overly verbose and generally reduce readability.

		## Rule Details

		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`.

		<!--tabs-->

		### ❌ Incorrect

		```ts
		type T1 = 'A' \| 'A';

		type T2 = A \| A \| B;

		type T3 = { a: string } & { a: string };

		type T4 = [1, 2, 3] \| [1, 2, 3];

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

		### ✅ Correct

		```ts
		type T1 = 'A' \| 'B';

		type T2 = A \| B \| C;

		type T3 = { a: string } & { b: string };

		type T4 = [1, 2, 3] \| [1, 2, 3, 4];

		type StringA = string;
		type NumberB = number;
		type T5 = StringA \| NumberB;
		```

		## Options

		### `ignoreIntersections`

		When set to true, duplicate checks on intersection type constituents are ignored.

		### `ignoreUnions`

		When set to true, duplicate checks on union type constituents are ignored.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -59,6 +59,7 @@ export = {
		'no-dupe-class-members': 'off',
		'@typescript-eslint/no-dupe-class-members': 'error',
		'@typescript-eslint/no-duplicate-enum-values': 'error',
		'@typescript-eslint/no-duplicate-type-constituents': 'error',
		'@typescript-eslint/no-dynamic-delete': 'error',
		'no-empty-function': 'off',
		'@typescript-eslint/no-empty-function': 'error',
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -38,6 +38,7 @@ import noConfusingVoidExpression from './no-confusing-void-expression';
		import noDupeClassMembers from './no-dupe-class-members';
		import noDuplicateEnumValues from './no-duplicate-enum-values';
		import noDuplicateImports from './no-duplicate-imports';
		import noDuplicateTypeConstituents from './no-duplicate-type-constituents';
		import noDynamicDelete from './no-dynamic-delete';
		import noEmptyFunction from './no-empty-function';
		import noEmptyInterface from './no-empty-interface';
Expand DownExpand Up		@@ -174,6 +175,7 @@ export default {
		'no-dupe-class-members': noDupeClassMembers,
		'no-duplicate-enum-values': noDuplicateEnumValues,
		'no-duplicate-imports': noDuplicateImports,
		'no-duplicate-type-constituents': noDuplicateTypeConstituents,
		'no-dynamic-delete': noDynamicDelete,
		'no-empty-function': noEmptyFunction,
		'no-empty-interface': noEmptyInterface,
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,207 @@
		import type { TSESTree } from '@typescript-eslint/utils';
		import { AST_NODE_TYPES } from '@typescript-eslint/utils';
		import type { Type } from 'typescript';

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

		export type Options = [
		{
		ignoreIntersections?: boolean;
		ignoreUnions?: boolean;
		},
		];

		export type MessageIds = 'duplicate';

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

		const isSameAstNode = (actualNode: unknown, expectedNode: unknown): boolean => {
		if (actualNode === expectedNode) {
		return true;
		}
		if (
		actualNode &&
		expectedNode &&
		typeof actualNode === 'object' &&
		typeof expectedNode === 'object'
		) {
		if (Array.isArray(actualNode) && Array.isArray(expectedNode)) {
		if (actualNode.length !== expectedNode.length) {
		return false;
		}
		return !actualNode.some(
		(nodeEle, index) => !isSameAstNode(nodeEle, expectedNode[index]),
		);
		}
		const actualNodeKeys = Object.keys(actualNode).filter(
		key => !astIgnoreKeys.has(key),
		);
		const expectedNodeKeys = Object.keys(expectedNode).filter(
		key => !astIgnoreKeys.has(key),
		);
		if (actualNodeKeys.length !== expectedNodeKeys.length) {
		return false;
		}
		if (
		actualNodeKeys.some(
		actualNodeKey =>
		!Object.prototype.hasOwnProperty.call(expectedNode, actualNodeKey),
		)
		) {
		return false;
		}
		if (
		actualNodeKeys.some(
		actualNodeKey =>
		!isSameAstNode(
		actualNode[actualNodeKey as keyof typeof actualNode],
		expectedNode[actualNodeKey as keyof typeof expectedNode],
		),
		)
		) {
		return false;
		}
		return true;
		}
		return false;
		};
JoshuaKGoldberg marked this conversation as resolved. Show resolvedHide resolved

		export default util.createRule<Options, MessageIds>({
		name: 'no-duplicate-type-constituents',
		meta: {
		type: 'suggestion',
		docs: {
		description:
		'Disallow duplicate constituents of union or intersection types',
		recommended: false,
		requiresTypeChecking: true,
		},
		fixable: 'code',
		messages: {
		duplicate: '{{type}} type constituent is duplicated with {{previous}}.',
		},
		schema: [
		{
		additionalProperties: false,
		type: 'object',
JoshuaKGoldberg marked this conversation as resolved. Show resolvedHide resolved
		properties: {
		ignoreIntersections: {
		type: 'boolean',
		},
		ignoreUnions: {
		type: 'boolean',
		},
		},
		},
		],
		},
		defaultOptions: [
		{
		ignoreIntersections: false,
		ignoreUnions: false,
		},
		],
		create(context, [{ ignoreIntersections, ignoreUnions }]) {
		const parserServices = util.getParserServices(context);
		const checker = parserServices.program.getTypeChecker();

		function checkDuplicate(
		node: TSESTree.TSIntersectionType \| TSESTree.TSUnionType,
		): void {
		const cachedTypeMap: Map<Type, TSESTree.TypeNode> = new Map();
		node.types.reduce<TSESTree.TypeNode[]>(
		(uniqueConstituents, constituentNode) => {
		const duplicatedPreviousConstituentInAst = uniqueConstituents.find(
		ele => isSameAstNode(ele, constituentNode),
		);
		if (duplicatedPreviousConstituentInAst) {
		reportDuplicate(
		{
		duplicated: constituentNode,
		duplicatePrevious: duplicatedPreviousConstituentInAst,
		},
		node,
		);
		return uniqueConstituents;
		}
		const constituentNodeType = checker.getTypeAtLocation(
		parserServices.esTreeNodeToTSNodeMap.get(constituentNode),
		);
		const duplicatedPreviousConstituentInType =
		cachedTypeMap.get(constituentNodeType);
		if (duplicatedPreviousConstituentInType) {
		reportDuplicate(
		{
		duplicated: constituentNode,
		duplicatePrevious: duplicatedPreviousConstituentInType,
		},
		node,
		);
		return uniqueConstituents;
		}
		cachedTypeMap.set(constituentNodeType, constituentNode);
		return [...uniqueConstituents, constituentNode];
		},
		[],
		);
		}
		function reportDuplicate(
		duplicateConstituent: {
		duplicated: TSESTree.TypeNode;
		duplicatePrevious: TSESTree.TypeNode;
		},
		parentNode: TSESTree.TSIntersectionType \| TSESTree.TSUnionType,
		): void {
		const sourceCode = context.getSourceCode();
		const beforeTokens = sourceCode.getTokensBefore(
		duplicateConstituent.duplicated,
		{ filter: token => token.value === '\|' \|\| token.value === '&' },
		);
		const beforeUnionOrIntersectionToken =
		beforeTokens[beforeTokens.length - 1];
		const bracketBeforeTokens = sourceCode.getTokensBetween(
		beforeUnionOrIntersectionToken,
		duplicateConstituent.duplicated,
		);
		const bracketAfterTokens = 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: 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,
		}),
		};
		},
		});