fix(eslint-plugin): [no-redundant-type-constituents] incorrectly marks & string as redundant

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

@@ -272,6 +272,10 @@ export default createRule({
           PrimitiveTypeFlag,
           TSESTree.TypeNode[]
         >();
+        const seenUnionTypes = new Map<
+          TSESTree.TypeNode,
+          TypeFlagsWithName[]
+        >();
 
         function checkIntersectionBottomAndTopTypes(
           { typeFlags, typeName }: TypeFlagsWithName,
@@ -323,8 +327,58 @@ export default createRule({
               }
             }
           }
-        }
 
+          typePartFlags.length >= 2
+            ? seenUnionTypes.set(typeNode, typePartFlags)
+            : null;
+        }
+        const checkIfUnionsAreAssignable = (): undefined => {
+          let typeFlagsOfUnions: ts.TypeFlags[] = [];
+          let result = true;
+          let primitiveUnit: number;
+
+          seenUnionTypes.forEach((value, key) => {
+            value.forEach(union => {
+              typeFlagsOfUnions.push(union.typeFlags);
+            });
+            for (const iterator of typeFlagsOfUnions) {
+              if (
+                seenPrimitiveTypes.has(
+                  literalToPrimitiveTypeFlags[
+                    iterator as keyof typeof literalToPrimitiveTypeFlags
+                  ],
+                )
+              ) {
+                result = true;
+                primitiveUnit =
+                  literalToPrimitiveTypeFlags[
+                    iterator as keyof typeof literalToPrimitiveTypeFlags
+                  ];
+              } else {
+                result = false;
+                break;
+              }
+            }
+            if (result) {
+              context.report({
+                data: {
+                  literal: value.map(name => name.typeName).join(' | '),
+                  primitive:
+                    primitiveTypeFlagNames[
+                      primitiveUnit as keyof typeof primitiveTypeFlagNames
+                    ],
+                },
+                messageId: 'primitiveOverridden',
+                node: key,
+              });
+            }
+            typeFlagsOfUnions = [];
+          });
+        };
+        if (seenUnionTypes.size > 0) {
+          checkIfUnionsAreAssignable();
+          return;
+        }
         // For each primitive type of all the seen primitive types,
         // if there was a literal type seen that overrides it,
         // report each of the primitive type's type nodes

packages/eslint-plugin/tests/rules/no-redundant-type-constituents.test.ts

@@ -156,6 +156,10 @@ ruleTester.run('no-redundant-type-constituents', rule, {
       type B = string;
       type T = B & null;
     `,
+    `
+      type T = 'a' | 1;
+      type U = T & string;
+    `,
     {
       code: 'type T = `${string}` & null;',
       dependencyConstraints: {
@@ -804,5 +808,46 @@ ruleTester.run('no-redundant-type-constituents', rule, {
         },
       ],
     },
+    {
+      code: `
+        type T = 'a' | 'b';
+        type U = T & string;
+      `,
+      errors: [
+        {
+          column: 18,
+          data: {
+            literal: '"a" | "b"',
+            primitive: 'string',
+          },
+          messageId: 'primitiveOverridden',
+        },
+      ],
+    },
+    {
+      code: `
+        type S = 1 | 2;
+        type T = 'a' | 'b';
+        type U = S & T & string & number;
+      `,
+      errors: [
+        {
+          column: 18,
+          data: {
+            literal: '1 | 2',
+            primitive: 'number',
+          },
+          messageId: 'primitiveOverridden',
+        },
+        {
+          column: 22,
+          data: {
+            literal: '"a" | "b"',
+            primitive: 'string',
+          },
+          messageId: 'primitiveOverridden',
+        },
+      ],
+    },
   ],
 });