typescript-eslint · JoshuaKGoldberg · Mar 24, 2023 · Oct 1, 2022 · Oct 1, 2022 · Oct 1, 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
@@ -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.
diff --git a/packages/eslint-plugin/src/configs/all.ts b/packages/eslint-plugin/src/configs/all.ts
@@ -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',

diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
@@ -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';
@@ -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,

diff --git a/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts b/packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts
@@ -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;
+};
+
+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,
+      }),
+    };
+  },
+});