PR Checklist

• Addresses an existing open issue:fixesEnhancement: [no-redundant-type-constituents] Use assignability checking for redundancy checks #7742
• That issue was marked asaccepting prs
• Steps inContributing were taken

Overview

even cases where they're deeply equal, but declared as different object types.

This feature seems to overlap with this ruleno-duplicate-type-constituents so I'm not sure whether to include it.
For now, I'll remove it and proceed.

deeply equal

type ShallowEqual = number | number;type DeepEqual = { a: string } | { a: string };

Union
If x is assignable to y, then in the union x∣y, x is redundant and can be removed.
However, due to TypeScript'sExcess Property Checks feature, this logic did not work as expected.

For example, consider the union type{ a: 1 } | { a: 1, b: 1 }. Since{ a: 1, b: 1 } is assignable to{ a: 1 }
So{ a: 1, b: 1 } becomes redundant and can be removed.

However, if{ a: 1, b: 1 } is removed, the remaining type{ a: 1 } exhibits different behavior when declaring values.
For example,{ a: 1 } alone can only be assigned to variables of type{ a: 1 }, whereas{ a: 1 } | { a: 1, b: 1 } allows the declaration of both{ a: 1 } and{ a: 1, b: 1 }

Example code

type Foo = { a: 1 } | { a: 1, b: 1 }const foo: Foo = { a: 1 }const bar: Foo = { a: 1, b: 1 }type Foo2 = { a: 1 } const foo2: Foo2 = { a: 1 }const bar2: Foo2 = { a: 1, b: 1 } //error

So, before checking whether one type is assignable to another, I first verified that both objects have the same set of keys. Only then did I proceed with the assignability check.
ForA | B, i checks ifA andB have the same keys. If they do, it then checks assignability.

Union Types with Intersection Types

• Union with a Single Intersection:
  • If a union type contains an intersection, like A | (B & C & D), the intersection (B & C & D) is treated as a single object type.
• Union within an Intersection:
  • If an intersection includes a union, like A | (B & (C | D)), TypeScript simplifies the intersection into a union of intersections. B & (C | D) is equivalent to B & C | B & D,
  • This means the assignability check becomes: Is A assignable to (B & C) | (B & D)

Intersection
Unlike union types, intersection types did not need excess property checks.
A & B in this case ifA is assignable toB B is rebundant.

• If there is no union type within the intersection, I proceed the assignability check.A & B
• If there is union type, I check if every type in the union is compatible with the intersection and follows the same rules.
• A & ( B | C)

A >= B, A >= C  Then  A >= (B | C)B >= A, C >= A  Then   (B | C) >= A