Skip to main content

no-redundant-type-constituents

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

Rule Details​

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

Examples of code for this rule:

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. It also does not provide an auto-fixer just yet.

Further Reading​

Attributes​

  • ✅ Recommended
  • 🔧 Fixable
  • 💭 Requires type information