Skip to content

Latest commit

 

History

History
84 lines (58 loc) · 2.52 KB

no-redundant-type-constituents.md

File metadata and controls

84 lines (58 loc) · 2.52 KB
Raw

Disallow members of unions and intersections that do nothing or override type information (no-redundant-type-constituents)

Some types can override some other types ("constituents") in a union or intersection and/or be overridden by some other types.

Rule Details

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:

❌ Incorrect

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';

✅ Correct

type UnionAny = any;
type UnionUnknown = unknown;
type UnionNever = never;

type UnionBooleanLiteral = boolean;
type UnionNumberLiteral = number;
type UnionStringLiteral = string;

type IntersectionAny = any;
type IntersectionUnknown = string;
type IntersectionNever = string;

type IntersectionBooleanLiteral = false;
type IntersectionNumberLiteral = 1;
type IntersectionStringLiteral = 'foo';

type ReturnUnionNever = () => string | never;

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