feat(eslint-plugin): add no-duplicate-type-constituents rule

packages/eslint-plugin/docs/rules/no-duplicate-type-constituents.md

@@ -0,0 +1,49 @@
+---
+description: 'Disallow duplicate union/intersection type members.'
+---
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-duplicate-type-constituents** for documentation.
+
+Although TypeScript supports duplicate union and intersection member values, people usually expect members to have unique values within the same intersection and union. Duplicate values make the code redundant and generally reduce readability.
+
+## Rule Details
+
+This rule disallows duplicate union or intersection type members. It only checks duplication on the notation. Members with the same value but different names are not marked duplicates.
+
+<!--tabs-->
+
+### ❌ Incorrect
+
+```ts
+type T1 = A | A | B;
+
+type T2 = { a: string } & { a: string };
+
+type T3 = [1, 2, 3] & [1, 2, 3];
+
+type T4 = () => string | string;
+```
+
+### ✅ Correct
+
+```ts
+type T1 = A | B | C;
+
+type T2 = { a: string } & { b: string };
+
+type T3 = [1, 2, 3] & [1, 2, 3, 4];
+
+type T4 = () => string | number;
+```
+
+## Options
+
+### `ignoreIntersections`
+
+When set to true, duplicate checks on intersection type members are ignored.
+
+### `ignoreUnions`
+
+When set to true, duplicate checks on union type members are ignored.

packages/eslint-plugin/src/configs/all.ts

@@ -54,6 +54,7 @@ export = {
     '@typescript-eslint/no-dupe-class-members': 'error',
     '@typescript-eslint/no-duplicate-enum-values': 'error',
     'no-duplicate-imports': 'off',
+    '@typescript-eslint/no-duplicate-type-constituents': 'error',
     '@typescript-eslint/no-dynamic-delete': 'error',
     'no-empty-function': 'off',
     '@typescript-eslint/no-empty-function': 'error',

packages/eslint-plugin/src/rules/index.ts

@@ -35,6 +35,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';
@@ -164,6 +165,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,

packages/eslint-plugin/src/rules/no-duplicate-type-constituents.ts

@@ -0,0 +1,221 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import * as util from '../util';
+
+const nodeTypesAreEqual = <T extends TSESTree.Node>(
+  actualTypeNode: TSESTree.Node,
+  expectedTypeNode: T,
+): actualTypeNode is T => {
+  return actualTypeNode.type === expectedTypeNode.type;
+};
+
+const constituentsAreEqual = (
+  actualTypeNode: TSESTree.TypeNode,
+  expectedTypeNode: TSESTree.TypeNode,
+): boolean => {
+  switch (expectedTypeNode.type) {
+    // These types should never occur as constituents of a union/intersection
+    case AST_NODE_TYPES.TSAbstractKeyword:
+    case AST_NODE_TYPES.TSAsyncKeyword:
+    case AST_NODE_TYPES.TSDeclareKeyword:
+    case AST_NODE_TYPES.TSExportKeyword:
+    case AST_NODE_TYPES.TSNamedTupleMember:
+    case AST_NODE_TYPES.TSOptionalType:
+    case AST_NODE_TYPES.TSPrivateKeyword:
+    case AST_NODE_TYPES.TSProtectedKeyword:
+    case AST_NODE_TYPES.TSPublicKeyword:
+    case AST_NODE_TYPES.TSReadonlyKeyword:
+    case AST_NODE_TYPES.TSRestType:
+    case AST_NODE_TYPES.TSStaticKeyword:
+    case AST_NODE_TYPES.TSTypePredicate:
+      /* istanbul ignore next */
+      throw new Error(`Unexpected Type ${expectedTypeNode.type}`);
+
+    default:
+      if (nodeTypesAreEqual(actualTypeNode, expectedTypeNode)) {
+        return astNodesAreEquals(actualTypeNode, expectedTypeNode);
+      }
+      return false;
+  }
+};
+
+const astIgnoreKeys = ['range', 'loc', 'parent'];
+
+type NodeElementsType =
+  | number
+  | string
+  | bigint
+  | boolean
+  | null
+  | undefined
+  | RegExp
+  | TSESTree.BaseNode
+  | TSESTree.BaseNode[]
+  | [number, number];
+
+const astNodesAreEquals = <T extends NodeElementsType>(
+  actualNode: T,
+  expectedNode: T,
+): 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) => !astNodesAreEquals(nodeEle, expectedNode[index]),
+      );
+    }
+    if (isAstNodeType(actualNode) && isAstNodeType(expectedNode)) {
+      const actualNodeKeys = Object.keys(actualNode).filter(
+        key => !astIgnoreKeys.includes(key),
+      );
+      const expectedNodeKeys = Object.keys(expectedNode).filter(
+        key => !astIgnoreKeys.includes(key),
+      );
+      if (actualNodeKeys.length === expectedNodeKeys.length) {
+        return !actualNodeKeys.some(
+          actualNodeKey =>
+            !astNodesAreEquals(
+              actualNode[actualNodeKey],
+              expectedNode[actualNodeKey],
+            ),
+        );
+      }
+    }
+  }
+  return false;
+};
+
+const isAstNodeType = (node: object): node is Record<string, TSESTree.Node> => {
+  return node.constructor === Object;
+};
+
+export type Options = [
+  {
+    ignoreIntersections?: boolean;
+    ignoreUnions?: boolean;
+  },
+];
+
+export type MessageIds = 'duplicate' | 'suggestFix';
+
+export default util.createRule<Options, MessageIds>({
+  name: 'no-duplicate-type-constituents',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow duplicate union/intersection type members',
+      recommended: false,
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      duplicate: '{{type}} type member {{name}} is duplicated.',
+      suggestFix: 'Delete duplicated members of type (removes all comments).',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          ignoreIntersections: {
+            type: 'boolean',
+          },
+          ignoreUnions: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+  },
+  defaultOptions: [
+    {
+      ignoreIntersections: false,
+      ignoreUnions: false,
+    },
+  ],
+  create(context, [{ ignoreIntersections, ignoreUnions }]) {
+    const sourceCode = context.getSourceCode();
+    function checkDuplicate(
+      node: TSESTree.TSIntersectionType | TSESTree.TSUnionType,
+    ): void {
+      const duplicateConstituents: {
+        node: TSESTree.TypeNode;
+        index: number;
+      }[] = [];
+
+      node.types.reduce<TSESTree.TypeNode[]>((acc, cur, index) => {
+        if (acc.some(ele => constituentsAreEqual(ele, cur))) {
+          duplicateConstituents.push({ node: cur, index });
+          return acc;
+        }
+        return [...acc, cur];
+      }, []);
+
+      const hasComments = node.types.some(type => {
+        const count =
+          sourceCode.getCommentsBefore(type).length +
+          sourceCode.getCommentsAfter(type).length;
+        return count > 0;
+      });
+
+      const fix: TSESLint.ReportFixFunction = fixer => {
+        return duplicateConstituents.map(duplicateConstituent => {
+          const parent = duplicateConstituent.node.parent as
+            | TSESTree.TSUnionType
+            | TSESTree.TSIntersectionType;
+          const delteRangeStart =
+            parent.types[duplicateConstituent.index - 1].range[1];
+          return fixer.removeRange([
+            delteRangeStart,
+            duplicateConstituent.node.range[1],
+          ]);
+        });
+      };
+
+      duplicateConstituents.forEach(duplicateConstituent => {
+        context.report({
+          data: {
+            name: sourceCode.getText(duplicateConstituent.node),
+            type:
+              node.type === AST_NODE_TYPES.TSIntersectionType
+                ? 'Intersection'
+                : 'Union',
+          },
+          messageId: 'duplicate',
+          node,
+          // don't autofix if any of the types have leading/trailing comments
+          ...(hasComments
+            ? {
+                suggest: [
+                  {
+                    fix,
+                    messageId: 'suggestFix',
+                  },
+                ],
+              }
+            : {
+                fix,
+              }),
+        });
+      });
+    }
+    return {
+      ...(!ignoreIntersections && {
+        TSIntersectionType: checkDuplicate,
+      }),
+      ...(!ignoreUnions && {
+        TSUnionType: checkDuplicate,
+      }),
+    };
+  },
+});