@typescript-eslint/eslint-plugin 8.48.1-alpha.9 → 8.48.2-alpha.0

package/dist/index.d.ts

@@ -764,7 +764,7 @@ declare const _default: {
         'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-non-null-assertion").MessageIds, [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-redeclare").MessageIds, import("./rules/no-redeclare").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./rules/no-require-imports").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-restricted-types").MessageIds, import("./rules/no-restricted-types").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/raw-plugin.d.ts

@@ -787,7 +787,7 @@ declare const _default: {
             'no-non-null-asserted-optional-chain': TSESLint.RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-non-null-assertion': TSESLint.RuleModule<import("./rules/no-non-null-assertion").MessageIds, [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-redeclare': TSESLint.RuleModule<import("./rules/no-redeclare").MessageIds, import("./rules/no-redeclare").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
-            'no-redundant-type-constituents': TSESLint.RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+            'no-redundant-type-constituents': TSESLint.RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-require-imports': TSESLint.RuleModule<"noRequireImports", import("./rules/no-require-imports").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-restricted-imports': TSESLint.RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-restricted-types': TSESLint.RuleModule<import("./rules/no-restricted-types").MessageIds, import("./rules/no-restricted-types").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

package/dist/rules/index.d.ts

@@ -92,7 +92,7 @@ declare const rules: {
     'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-non-null-assertion").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-redeclare").MessageIds, import("./no-redeclare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./no-require-imports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-restricted-types").MessageIds, import("./no-restricted-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/rules/no-redundant-type-constituents.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 export default _default;

package/dist/rules/no-redundant-type-constituents.js

@@ -37,6 +37,47 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
+const literalToPrimitiveTypeFlags = {
+    [ts.TypeFlags.BigIntLiteral]: ts.TypeFlags.BigInt,
+    [ts.TypeFlags.BooleanLiteral]: ts.TypeFlags.Boolean,
+    [ts.TypeFlags.NumberLiteral]: ts.TypeFlags.Number,
+    [ts.TypeFlags.StringLiteral]: ts.TypeFlags.String,
+    [ts.TypeFlags.TemplateLiteral]: ts.TypeFlags.String,
+};
+const literalTypeFlags = [
+    ts.TypeFlags.BigIntLiteral,
+    ts.TypeFlags.BooleanLiteral,
+    ts.TypeFlags.NumberLiteral,
+    ts.TypeFlags.StringLiteral,
+    ts.TypeFlags.TemplateLiteral,
+];
+const primitiveTypeFlags = [
+    ts.TypeFlags.BigInt,
+    ts.TypeFlags.Boolean,
+    ts.TypeFlags.Number,
+    ts.TypeFlags.String,
+];
+const primitiveTypeFlagNames = {
+    [ts.TypeFlags.BigInt]: 'bigint',
+    [ts.TypeFlags.Boolean]: 'boolean',
+    [ts.TypeFlags.Number]: 'number',
+    [ts.TypeFlags.String]: 'string',
+};
+const primitiveTypeFlagTypes = {
+    bigint: ts.TypeFlags.BigIntLiteral,
+    boolean: ts.TypeFlags.BooleanLiteral,
+    number: ts.TypeFlags.NumberLiteral,
+    string: ts.TypeFlags.StringLiteral,
+};
+const keywordNodeTypesToTsTypes = new Map([
+    [utils_1.TSESTree.AST_NODE_TYPES.TSAnyKeyword, ts.TypeFlags.Any],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSBigIntKeyword, ts.TypeFlags.BigInt],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSBooleanKeyword, ts.TypeFlags.Boolean],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSNeverKeyword, ts.TypeFlags.Never],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSNumberKeyword, ts.TypeFlags.Number],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSStringKeyword, ts.TypeFlags.String],
+    [utils_1.TSESTree.AST_NODE_TYPES.TSUnknownKeyword, ts.TypeFlags.Unknown],
+]);
 function addToMapGroup(map, key, value) {
     const existing = map.get(key);
     if (existing) {
@@ -46,270 +87,88 @@ function addToMapGroup(map, key, value) {
         map.set(key, [value]);
     }
 }
-function isUnionNodeInsideReturnType(node) {
-    if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType) {
-        return isUnionNodeInsideReturnType(node.parent);
+function describeLiteralType(type) {
+    if (type.isStringLiteral()) {
+        return JSON.stringify(type.value);
     }
-    return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
-        (0, util_1.isFunctionOrFunctionType)(node.parent.parent));
-}
-function isObjectOrIntersectionType(type) {
-    return tsutils.isObjectType(type) || tsutils.isIntersectionType(type);
-}
-function shouldCheckTypeRedundancy(type, checker, depth = 0) {
-    if (depth > 10) {
-        return false;
+    if ((0, util_1.isTypeBigIntLiteralType)(type)) {
+        return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`;
     }
-    if (tsutils.isObjectType(type)) {
-        const symbol = type.getSymbol();
-        if (checker.isArrayLikeType(type)) {
-            return true;
-        }
-        if (!symbol) {
-            return false;
-        }
-        const declarations = symbol.getDeclarations();
-        const declaration = declarations?.[0];
-        if (!declaration) {
-            return false;
-        }
-        if (declaration.kind !== ts.SyntaxKind.TypeLiteral &&
-            declaration.kind !== ts.SyntaxKind.InterfaceDeclaration &&
-            declaration.kind !== ts.SyntaxKind.MappedType) {
-            return false;
-        }
+    if (type.isLiteral()) {
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        return type.value.toString();
     }
-    if (isObjectOrIntersectionType(type)) {
-        const props = type.getProperties();
-        for (const prop of props) {
-            const type = checker.getTypeOfSymbol(prop);
-            if (!shouldCheckTypeRedundancy(type, checker, depth + 1)) {
-                return false;
-            }
-        }
-        return true;
+    if (tsutils.isIntrinsicErrorType(type) && type.aliasSymbol) {
+        return type.aliasSymbol.escapedName.toString();
     }
-    if (tsutils.isUnionType(type)) {
-        return type.types.every(typePart => shouldCheckTypeRedundancy(typePart, checker, depth));
+    if ((0, util_1.isTypeAnyType)(type)) {
+        return 'any';
     }
-    return true;
-}
-function isTargetTypeRedundantInIntersection(sourceType, targetType, checker) {
-    if (!shouldCheckTypeRedundancy(sourceType, checker) ||
-        !shouldCheckTypeRedundancy(targetType, checker)) {
-        return false;
+    if ((0, util_1.isTypeNeverType)(type)) {
+        return 'never';
     }
-    if (tsutils.isUnionType(sourceType)) {
-        for (const typePart of sourceType.types) {
-            if (!tsutils.isObjectType(typePart)) {
-                continue;
-            }
-            const isRedundant = isTargetTypeRedundantInIntersection(typePart, targetType, checker);
-            if (!isRedundant) {
-                return false;
-            }
-        }
-        return checker.isTypeAssignableTo(sourceType, targetType);
+    if ((0, util_1.isTypeUnknownType)(type)) {
+        return 'unknown';
     }
-    if (tsutils.isUnionType(targetType) &&
-        !tsutils.isIntrinsicBooleanType(targetType)) {
-        for (const typePart of targetType.types) {
-            if (!tsutils.isObjectType(typePart)) {
-                continue;
-            }
-            const isRedundant = isTargetTypeRedundantInIntersection(sourceType, typePart, checker);
-            if (!isRedundant) {
-                return false;
-            }
-        }
-        return checker.isTypeAssignableTo(sourceType, targetType);
+    if ((0, util_1.isTypeTemplateLiteralType)(type)) {
+        return 'template literal type';
     }
-    if (checker.isTupleType(targetType)) {
-        if (checker.isTupleType(sourceType)) {
-            const sourceArguments = sourceType.typeArguments;
-            const targetArguments = targetType.typeArguments;
-            if (!sourceArguments || !targetArguments) {
-                return false;
-            }
-            if (targetArguments.length !== sourceArguments.length) {
-                return false;
-            }
-            for (let i = 0; i < targetArguments.length; ++i) {
-                const sourceTypeArgument = sourceArguments[i];
-                const targetTypeArgument = targetArguments[i];
-                if (!isTargetTypeRedundantInIntersection(sourceTypeArgument, targetTypeArgument, checker)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
+    if ((0, util_1.isTypeBigIntLiteralType)(type)) {
+        return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`;
     }
-    if (checker.isArrayType(targetType)) {
-        if (checker.isArrayType(sourceType)) {
-            const sourceArgumentType = sourceType.typeArguments?.[0];
-            const targetArgumentType = targetType.typeArguments?.[0];
-            if (!sourceArgumentType || !targetArgumentType) {
-                return false;
-            }
-            return isTargetTypeRedundantInIntersection(sourceArgumentType, targetArgumentType, checker);
-        }
-        if (checker.isTupleType(sourceType)) {
-            const targetArgumentType = targetType.typeArguments?.[0];
-            if (!targetArgumentType) {
-                return false;
-            }
-            const sourceArgumentTypes = sourceType.typeArguments;
-            if (!sourceArgumentTypes) {
-                return true;
-            }
-            for (const sourceTypeArgument of sourceArgumentTypes) {
-                if (!isTargetTypeRedundantInIntersection(sourceTypeArgument, targetArgumentType, checker)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
+    if (tsutils.isTrueLiteralType(type)) {
+        return 'true';
     }
-    if (tsutils.isObjectType(sourceType) && tsutils.isObjectType(targetType)) {
-        const sourceProps = sourceType.getProperties();
-        const targetProps = targetType.getProperties();
-        if (targetProps.length === 0) {
-            return false;
-        }
-        for (const targetProp of targetProps) {
-            const sourceProp = sourceProps.find(prop => prop.getName() === targetProp.getName());
-            if (!sourceProp) {
-                return false;
-            }
-            const sourcePropType = checker.getTypeOfSymbol(sourceProp);
-            const targetPropType = checker.getTypeOfSymbol(targetProp);
-            const targetPropTypeIsRedundant = isTargetTypeRedundantInIntersection(sourcePropType, targetPropType, checker);
-            if (!targetPropTypeIsRedundant) {
-                return false;
-            }
-        }
-        return true;
+    if (tsutils.isFalseLiteralType(type)) {
+        return 'false';
     }
-    return checker.isTypeAssignableTo(sourceType, targetType);
+    return 'literal type';
 }
-function isTargetTypeRedundantInUnion(sourceType, targetType, checker) {
-    if (!shouldCheckTypeRedundancy(sourceType, checker) ||
-        !shouldCheckTypeRedundancy(targetType, checker)) {
-        return false;
-    }
-    if (tsutils.isUnionType(targetType) &&
-        !tsutils.isIntrinsicBooleanType(targetType)) {
-        for (const typePart of targetType.types) {
-            const isRedundant = isTargetTypeRedundantInUnion(sourceType, typePart, checker);
-            if (!isRedundant) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if (tsutils.isUnionType(sourceType)) {
-        for (const typePart of sourceType.types) {
-            const isRedundant = isTargetTypeRedundantInUnion(typePart, targetType, checker);
-            if (isRedundant) {
-                return true;
-            }
-        }
-        return false;
-    }
-    if (checker.isTupleType(targetType)) {
-        if (checker.isArrayType(sourceType)) {
-            const sourceArgumentType = sourceType.typeArguments?.[0];
-            if (!sourceArgumentType) {
-                return false;
-            }
-            const targetArguments = targetType.typeArguments;
-            if (!targetArguments) {
-                return true;
-            }
-            for (const targetTypeArgument of targetArguments) {
-                if (!isTargetTypeRedundantInUnion(sourceArgumentType, targetTypeArgument, checker)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        if (checker.isTupleType(sourceType)) {
-            const sourceArguments = sourceType.typeArguments;
-            const targetArguments = targetType.typeArguments;
-            if (!sourceArguments || !targetArguments) {
-                return false;
-            }
-            if (targetArguments.length !== sourceArguments.length) {
-                return false;
-            }
-            for (let i = 0; i < targetArguments.length; ++i) {
-                const sourceTypeArgument = sourceArguments[i];
-                const targetTypeArgument = targetArguments[i];
-                if (!isTargetTypeRedundantInUnion(sourceTypeArgument, targetTypeArgument, checker)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-    if (checker.isArrayType(sourceType) && checker.isArrayType(targetType)) {
-        const sourceArgumentType = sourceType.typeArguments?.[0];
-        const targetArgumentType = targetType.typeArguments?.[0];
-        if (!sourceArgumentType || !targetArgumentType) {
-            return false;
-        }
-        return isTargetTypeRedundantInUnion(sourceArgumentType, targetArgumentType, checker);
-    }
-    if (isObjectOrIntersectionType(sourceType) &&
-        isObjectOrIntersectionType(targetType)) {
-        const sourceProps = sourceType.getProperties();
-        const targetProps = targetType.getProperties();
-        if (sourceProps.length !== targetProps.length) {
-            return false;
-        }
-        if (targetProps.length === 0) {
-            return false;
-        }
-        for (const targetProp of targetProps) {
-            const sourceProp = sourceProps.find(prop => prop.getName() === targetProp.getName());
-            if (!sourceProp) {
-                return false;
-            }
-            const sourcePropType = checker.getTypeOfSymbol(sourceProp);
-            const targetPropType = checker.getTypeOfSymbol(targetProp);
-            const targetPropTypeIsRedundant = isTargetTypeRedundantInUnion(sourcePropType, targetPropType, checker);
-            if (!targetPropTypeIsRedundant) {
-                return false;
+function describeLiteralTypeNode(typeNode) {
+    switch (typeNode.type) {
+        case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+            return 'any';
+        case utils_1.AST_NODE_TYPES.TSBooleanKeyword:
+            return 'boolean';
+        case utils_1.AST_NODE_TYPES.TSNeverKeyword:
+            return 'never';
+        case utils_1.AST_NODE_TYPES.TSNumberKeyword:
+            return 'number';
+        case utils_1.AST_NODE_TYPES.TSStringKeyword:
+            return 'string';
+        case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+            return 'unknown';
+        case utils_1.AST_NODE_TYPES.TSLiteralType:
+            switch (typeNode.literal.type) {
+                case utils_1.TSESTree.AST_NODE_TYPES.Literal:
+                    switch (typeof typeNode.literal.value) {
+                        case 'bigint':
+                            return `${typeNode.literal.value < 0 ? '-' : ''}${typeNode.literal.value}n`;
+                        case 'string':
+                            return JSON.stringify(typeNode.literal.value);
+                        default:
+                            return `${typeNode.literal.value}`;
+                    }
+                case utils_1.TSESTree.AST_NODE_TYPES.TemplateLiteral:
+                    return 'template literal type';
             }
-        }
-        return true;
     }
-    return checker.isTypeAssignableTo(targetType, sourceType);
+    return 'literal type';
 }
-function mergeTypeNames(typeWithNames, operator) {
-    if (typeWithNames.length === 1) {
-        return typeWithNames[0].typeName;
-    }
-    const wrapType = (typeWithName) => {
-        if (operator === '|' && typeWithName.type.isIntersection()) {
-            return `(${typeWithName.typeName})`;
-        }
-        if (operator === '&' && typeWithName.type.isUnion()) {
-            return `(${typeWithName.typeName})`;
-        }
-        return typeWithName.typeName;
-    };
-    return typeWithNames.map(wrapType).join(` ${operator} `);
+function isNodeInsideReturnType(node) {
+    return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+        (0, util_1.isFunctionOrFunctionType)(node.parent.parent));
 }
-function getGroupTypeRelationsByNonRedundantType(typeRedundancyRelations) {
-    const groups = new Map();
-    for (const typeRedundancyRelation of typeRedundancyRelations) {
-        addToMapGroup(groups, typeRedundancyRelation.nonRedundantTypeWithName.type, typeRedundancyRelation);
-    }
-    return groups;
+/**
+ * @remarks TypeScript stores boolean types as the union false | true, always.
+ */
+function unionTypePartsUnlessBoolean(type) {
+    return type.isUnion() &&
+        type.types.length === 2 &&
+        tsutils.isFalseLiteralType(type.types[0]) &&
+        tsutils.isTrueLiteralType(type.types[1])
+        ? [type]
+        : tsutils.unionConstituents(type);
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-redundant-type-constituents',
@@ -322,68 +181,61 @@ exports.default = (0, util_1.createRule)({
         },
         messages: {
             errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
+            literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`,
             overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`,
             overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
-            typeOverridden: `{{redundantType}} is overridden by {{nonRedundantType}} in this {{container}} type.`,
+            primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
         },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
         const services = (0, util_1.getParserServices)(context);
-        const checker = services.program.getTypeChecker();
-        function reportRedundantTypes(redundantTypes, container) {
-            for (const [typeNode, typeRelations] of redundantTypes) {
-                const groupTypeRelationsByNonRedundantType = getGroupTypeRelationsByNonRedundantType(typeRelations);
-                for (const [nonRedundantType, typeRelationAndNames,] of groupTypeRelationsByNonRedundantType) {
-                    const nonRedundantTypeName = checker.typeToString(nonRedundantType);
-                    const mergedRedundantTypeName = mergeTypeNames(typeRelationAndNames.map(({ redundantTypeWithName }) => redundantTypeWithName), container === 'union' ? '|' : '&');
-                    context.report({
-                        node: typeNode,
-                        messageId: 'typeOverridden',
-                        data: {
-                            container,
-                            nonRedundantType: nonRedundantTypeName,
-                            redundantType: mergedRedundantTypeName,
-                        },
-                    });
-                }
+        const typesCache = new Map();
+        function getTypeNodeTypePartFlags(typeNode) {
+            const keywordTypeFlags = keywordNodeTypesToTsTypes.get(typeNode.type);
+            if (keywordTypeFlags) {
+                return [
+                    {
+                        typeFlags: keywordTypeFlags,
+                        typeName: describeLiteralTypeNode(typeNode),
+                    },
+                ];
             }
-        }
-        function getUnionTypePart(typeNode, checker) {
-            if (ts.isParenthesizedTypeNode(typeNode)) {
-                return getUnionTypePart(typeNode.type, checker);
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                typeNode.literal.type === utils_1.AST_NODE_TYPES.Literal) {
+                return [
+                    {
+                        typeFlags: primitiveTypeFlagTypes[typeof typeNode.literal
+                            .value],
+                        typeName: describeLiteralTypeNode(typeNode),
+                    },
+                ];
             }
-            if (ts.isUnionTypeNode(typeNode)) {
-                return typeNode.types.flatMap(typeNode => getUnionTypePart(typeNode, checker));
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                return typeNode.types.flatMap(getTypeNodeTypePartFlags);
             }
-            const type = checker.getTypeAtLocation(typeNode);
-            return [
-                {
-                    type,
-                    typeName: checker.typeToString(type),
-                },
-            ];
+            const nodeType = services.getTypeAtLocation(typeNode);
+            const typeParts = unionTypePartsUnlessBoolean(nodeType);
+            return typeParts.map(typePart => ({
+                typeFlags: typePart.flags,
+                typeName: describeLiteralType(typePart),
+            }));
         }
-        function getIntersectionTypePart(typeNode, checker) {
-            if (ts.isParenthesizedTypeNode(typeNode)) {
-                return getIntersectionTypePart(typeNode.type, checker);
-            }
-            if (ts.isIntersectionTypeNode(typeNode)) {
-                return typeNode.types.flatMap(typeNode => getIntersectionTypePart(typeNode, checker));
+        function getTypeNodeTypePartFlagsCached(typeNode) {
+            const existing = typesCache.get(typeNode);
+            if (existing) {
+                return existing;
             }
-            const type = checker.getTypeAtLocation(typeNode);
-            return [
-                {
-                    type,
-                    typeName: checker.typeToString(type),
-                },
-            ];
+            const created = getTypeNodeTypePartFlags(typeNode);
+            typesCache.set(typeNode, created);
+            return created;
         }
         return {
-            TSIntersectionType(node) {
-                const seenTypes = new Set();
-                const redundantTypes = new Map();
+            'TSIntersectionType:exit'(node) {
+                const seenLiteralTypes = new Map();
+                const seenPrimitiveTypes = new Map();
+                const seenUnionTypes = new Map();
                 function checkIntersectionBottomAndTopTypes({ typeFlags, typeName }, typeNode) {
                     for (const [messageId, checkFlag] of [
                         ['overrides', ts.TypeFlags.Any],
@@ -407,70 +259,87 @@ exports.default = (0, util_1.createRule)({
                     return false;
                 }
                 for (const typeNode of node.types) {
-                    const tsTypeNode = services.esTreeNodeToTSNodeMap.get(typeNode);
-                    const typeParts = getIntersectionTypePart(tsTypeNode, checker);
-                    for (const typePart of typeParts) {
-                        if (typePart.type.flags & ts.TypeFlags.Never ||
-                            typePart.type.flags & ts.TypeFlags.Any ||
-                            typePart.type.flags & ts.TypeFlags.Unknown) {
-                            checkIntersectionBottomAndTopTypes({
-                                typeFlags: typePart.type.flags,
-                                typeName: typePart.typeName,
-                            }, typeNode);
+                    const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode);
+                    for (const typePart of typePartFlags) {
+                        if (checkIntersectionBottomAndTopTypes(typePart, typeNode)) {
                             continue;
                         }
-                        const { type: targetType, typeName: targetTypeName } = typePart;
-                        for (const seenType of seenTypes) {
-                            const { type: sourceType, parentTypeNode, typeName: sourceTypeName, } = seenType;
-                            const targetTypeIsRedundant = isTargetTypeRedundantInIntersection(sourceType, targetType, checker);
-                            const sourceTypeIsRedundant = isTargetTypeRedundantInIntersection(targetType, sourceType, checker);
-                            if (targetTypeIsRedundant &&
-                                targetTypeIsRedundant === sourceTypeIsRedundant) {
-                                continue;
+                        for (const literalTypeFlag of literalTypeFlags) {
+                            if (typePart.typeFlags === literalTypeFlag) {
+                                addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], typePart.typeName);
+                                break;
                             }
-                            if (sourceTypeIsRedundant) {
-                                addToMapGroup(redundantTypes, parentTypeNode, {
-                                    nonRedundantTypeWithName: {
-                                        type: targetType,
-                                        typeName: targetTypeName,
-                                    },
-                                    redundantTypeWithName: {
-                                        type: sourceType,
-                                        typeName: sourceTypeName,
-                                    },
-                                });
+                        }
+                        for (const primitiveTypeFlag of primitiveTypeFlags) {
+                            if (typePart.typeFlags === primitiveTypeFlag) {
+                                addToMapGroup(seenPrimitiveTypes, primitiveTypeFlag, typeNode);
                             }
-                            if (targetTypeIsRedundant) {
-                                addToMapGroup(redundantTypes, typeNode, {
-                                    nonRedundantTypeWithName: {
-                                        type: sourceType,
-                                        typeName: sourceTypeName,
-                                    },
-                                    redundantTypeWithName: {
-                                        type: targetType,
-                                        typeName: targetTypeName,
-                                    },
-                                });
+                        }
+                    }
+                    // if any typeNode is TSTypeReference and typePartFlags have more than 1 element, than the referenced type is definitely a union.
+                    if (typePartFlags.length >= 2) {
+                        seenUnionTypes.set(typeNode, typePartFlags);
+                    }
+                }
+                /**
+                 * @example
+                 * ```ts
+                 * type F = "a"|2|"b";
+                 * type I = F & string;
+                 * ```
+                 * This function checks if all the union members of `F` are assignable to the other member of `I`. If every member is assignable, then its reported else not.
+                 */
+                const checkIfUnionsAreAssignable = () => {
+                    for (const [typeRef, typeValues] of seenUnionTypes) {
+                        let primitive = undefined;
+                        for (const { typeFlags } of typeValues) {
+                            if (seenPrimitiveTypes.has(literalToPrimitiveTypeFlags[typeFlags])) {
+                                primitive =
+                                    literalToPrimitiveTypeFlags[typeFlags];
+                            }
+                            else {
+                                primitive = undefined;
+                                break;
                             }
                         }
+                        if (Number.isInteger(primitive)) {
+                            context.report({
+                                node: typeRef,
+                                messageId: 'primitiveOverridden',
+                                data: {
+                                    literal: typeValues.map(name => name.typeName).join(' | '),
+                                    primitive: primitiveTypeFlagNames[primitive],
+                                },
+                            });
+                        }
                     }
-                    for (const typePart of typeParts) {
-                        if (typePart.type.flags === ts.TypeFlags.Any ||
-                            typePart.type.flags === ts.TypeFlags.Unknown ||
-                            typePart.type.flags === ts.TypeFlags.Never) {
-                            continue;
+                };
+                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
+                for (const [primitiveTypeFlag, typeNodes] of seenPrimitiveTypes) {
+                    const matchedLiteralTypes = seenLiteralTypes.get(primitiveTypeFlag);
+                    if (matchedLiteralTypes) {
+                        for (const typeNode of typeNodes) {
+                            context.report({
+                                node: typeNode,
+                                messageId: 'primitiveOverridden',
+                                data: {
+                                    literal: matchedLiteralTypes.join(' | '),
+                                    primitive: primitiveTypeFlagNames[primitiveTypeFlag],
+                                },
+                            });
                         }
-                        seenTypes.add({
-                            ...typePart,
-                            parentTypeNode: typeNode,
-                        });
                     }
                 }
-                reportRedundantTypes(redundantTypes, 'intersection');
             },
-            TSUnionType(node) {
-                const seenTypes = new Set();
-                const redundantTypes = new Map();
+            'TSUnionType:exit'(node) {
+                const seenLiteralTypes = new Map();
+                const seenPrimitiveTypes = new Set();
                 function checkUnionBottomAndTopTypes({ typeFlags, typeName }, typeNode) {
                     for (const checkFlag of [
                         ts.TypeFlags.Any,
@@ -491,7 +360,7 @@ exports.default = (0, util_1.createRule)({
                         }
                     }
                     if (typeFlags === ts.TypeFlags.Never &&
-                        !isUnionNodeInsideReturnType(node)) {
+                        !isNodeInsideReturnType(node)) {
                         context.report({
                             node: typeNode,
                             messageId: 'overridden',
@@ -505,66 +374,57 @@ exports.default = (0, util_1.createRule)({
                     return false;
                 }
                 for (const typeNode of node.types) {
-                    const tsTypeNode = services.esTreeNodeToTSNodeMap.get(typeNode);
-                    const typeParts = getUnionTypePart(tsTypeNode, checker);
-                    for (const typePart of typeParts) {
-                        if (typePart.type.flags & ts.TypeFlags.Never ||
-                            typePart.type.flags & ts.TypeFlags.Any ||
-                            typePart.type.flags & ts.TypeFlags.Unknown) {
-                            checkUnionBottomAndTopTypes({
-                                typeFlags: typePart.type.flags,
-                                typeName: typePart.typeName,
-                            }, typeNode);
+                    const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode);
+                    for (const typePart of typePartFlags) {
+                        if (checkUnionBottomAndTopTypes(typePart, typeNode)) {
                             continue;
                         }
-                        const { type: targetType, typeName: targetTypeName } = typePart;
-                        for (const seenType of seenTypes) {
-                            const { type: sourceType, parentTypeNode, typeName: sourceTypeName, } = seenType;
-                            const targetTypeIsRedundant = isTargetTypeRedundantInUnion(sourceType, targetType, checker);
-                            const sourceTypeIsRedundant = isTargetTypeRedundantInUnion(targetType, sourceType, checker);
-                            if (targetTypeIsRedundant &&
-                                targetTypeIsRedundant === sourceTypeIsRedundant) {
-                                continue;
-                            }
-                            if (sourceTypeIsRedundant) {
-                                addToMapGroup(redundantTypes, parentTypeNode, {
-                                    nonRedundantTypeWithName: {
-                                        type: targetType,
-                                        typeName: targetTypeName,
-                                    },
-                                    redundantTypeWithName: {
-                                        type: sourceType,
-                                        typeName: sourceTypeName,
-                                    },
+                        for (const literalTypeFlag of literalTypeFlags) {
+                            if (typePart.typeFlags === literalTypeFlag) {
+                                addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], {
+                                    literalValue: typePart.typeName,
+                                    typeNode,
                                 });
+                                break;
                             }
-                            if (targetTypeIsRedundant) {
-                                addToMapGroup(redundantTypes, typeNode, {
-                                    nonRedundantTypeWithName: {
-                                        type: sourceType,
-                                        typeName: sourceTypeName,
-                                    },
-                                    redundantTypeWithName: {
-                                        type: targetType,
-                                        typeName: targetTypeName,
-                                    },
-                                });
+                        }
+                        for (const primitiveTypeFlag of primitiveTypeFlags) {
+                            if ((typePart.typeFlags & primitiveTypeFlag) !== 0) {
+                                seenPrimitiveTypes.add(primitiveTypeFlag);
                             }
                         }
                     }
-                    for (const typePart of typeParts) {
-                        if (typePart.type.flags === ts.TypeFlags.Any ||
-                            typePart.type.flags === ts.TypeFlags.Unknown ||
-                            typePart.type.flags === ts.TypeFlags.Never) {
-                            continue;
+                }
+                const overriddenTypeNodes = new Map();
+                // For each primitive type of all the seen literal types,
+                // if there was a primitive type seen that overrides it,
+                // upsert the literal text and primitive type under the backing type node
+                for (const [primitiveTypeFlag, typeNodesWithText] of seenLiteralTypes) {
+                    if (seenPrimitiveTypes.has(primitiveTypeFlag)) {
+                        for (const { literalValue, typeNode } of typeNodesWithText) {
+                            addToMapGroup(overriddenTypeNodes, typeNode, {
+                                literalValue,
+                                primitiveTypeFlag,
+                            });
                         }
-                        seenTypes.add({
-                            ...typePart,
-                            parentTypeNode: typeNode,
+                    }
+                }
+                // For each type node that had at least one overridden literal,
+                // group those literals by their primitive type,
+                // then report each primitive type with all its literals
+                for (const [typeNode, typeFlagsWithText] of overriddenTypeNodes) {
+                    const grouped = (0, util_1.arrayGroupByToMap)(typeFlagsWithText, pair => pair.primitiveTypeFlag);
+                    for (const [primitiveTypeFlag, pairs] of grouped) {
+                        context.report({
+                            node: typeNode,
+                            messageId: 'literalOverridden',
+                            data: {
+                                literal: pairs.map(pair => pair.literalValue).join(' | '),
+                                primitive: primitiveTypeFlagNames[primitiveTypeFlag],
+                            },
                         });
                     }
                 }
-                reportRedundantTypes(redundantTypes, 'union');
             },
         };
     },

package/dist/rules/restrict-template-expressions.d.ts

@@ -5,7 +5,7 @@ type OptionTester = (type: Type, checker: TypeChecker, recursivelyCheckType: (ty
 declare const optionTesters: {
     type: "Array" | "RegExp" | "Boolean" | "Number" | "Any" | "Nullish" | "Never";
     option: "allowAny" | "allowBoolean" | "allowNullish" | "allowRegExp" | "allowNever" | "allowNumber" | "allowArray";
-    tester: typeof isTypeAnyType | OptionTester | ((type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean) | ((type: Type, checker: TypeChecker) => boolean) | typeof isTypeNeverType;
+    tester: typeof isTypeAnyType | typeof isTypeNeverType | OptionTester | ((type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean) | ((type: Type, checker: TypeChecker) => boolean);
 }[];
 export type Options = [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.48.1-alpha.9",
+  "version": "8.48.2-alpha.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.48.1-alpha.9",
-    "@typescript-eslint/type-utils": "8.48.1-alpha.9",
-    "@typescript-eslint/utils": "8.48.1-alpha.9",
-    "@typescript-eslint/visitor-keys": "8.48.1-alpha.9",
+    "@typescript-eslint/scope-manager": "8.48.2-alpha.0",
+    "@typescript-eslint/type-utils": "8.48.2-alpha.0",
+    "@typescript-eslint/utils": "8.48.2-alpha.0",
+    "@typescript-eslint/visitor-keys": "8.48.2-alpha.0",
     "graphemer": "^1.4.0",
     "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
@@ -71,8 +71,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.48.1-alpha.9",
-    "@typescript-eslint/rule-tester": "8.48.1-alpha.9",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.48.2-alpha.0",
+    "@typescript-eslint/rule-tester": "8.48.2-alpha.0",
     "@vitest/coverage-v8": "^3.1.3",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
@@ -92,7 +92,7 @@
     "vitest": "^3.1.3"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.48.1-alpha.9",
+    "@typescript-eslint/parser": "^8.48.2-alpha.0",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },