Skip to main content

no-redundant-type-constituents

Disallow members of unions and intersections that do nothing or override type information.

✅

Extending "plugin:@typescript-eslint/recommended-type-checked" in an ESLint configuration enables this rule.

💭

This rule requires type information to run.

Some types can override some other types ("constituents") in a union or intersection and/or be overridden by some other types. TypeScript's set theory of types includes cases where a constituent type might be useless in the parent union or intersection.

Within | unions:

  • any and unknown "override" all other union members
  • never is dropped from unions in any position except when in a return type position
  • primitive types such as string "override" any of their literal types such as ""

Within & intersections:

  • any and never "override" all other intersection members
  • unknown is dropped from intersections
  • literal types "override" any primitive types in an intersection
  • literal types such as "" "override" any of their primitive types such as string
.eslintrc.cjs
module.exports = {
  "rules": {
    "@typescript-eslint/no-redundant-type-constituents": "error"
  }
};
Try this rule in the playground ↗

Examples​

type UnionAny = any | 'foo';
type UnionUnknown = unknown | 'foo';
type UnionNever = never | 'foo';

type UnionBooleanLiteral = boolean | false;
type UnionNumberLiteral = number | 1;
type UnionStringLiteral = string | 'foo';

type IntersectionAny = any & 'foo';
type IntersectionUnknown = string & unknown;
type IntersectionNever = string | never;

type IntersectionBooleanLiteral = boolean & false;
type IntersectionNumberLiteral = number & 1;
type IntersectionStringLiteral = string & 'foo';

Limitations​

This rule plays it safe and only works with bottom types, top types, and comparing literal types to primitive types.

Further Reading​

Options​

This rule is not configurable.

Resources​