Rule proposal: Disallow unions with unknown or any

[fregante]

Description

From what I understand, T | unknown and T | any resolve to just unknown and any respectively, so I don't think they're particularly useful.

However maybe it's still useful as suggested type documentation, because such types would still appear as X | unknown in some cases.

Thoughts?

Fail

type MaybeNumber = number | unknown;

function isNumber(value: number | any): value is number {
	return typeof value === 'number';
}

Pass

type MaybeNumber = unknown;

function isNumber(value: any): value is number {
	return typeof value === 'number';
}

[bradzacher]

I think that this would be pretty valuable.

There are the following cases for any, unknown, and `never:

• any and unknown "override" all other union members:
  • any | 'foo' === any, unknown | 'foo' === unknown
• any and never "override" all other intersection members.
  • any & 'foo' === any, never | 'foo' === never

And the two special cases:

• unknown is dropped from intersections:
  • string & unknown === string
• never is dropped from unions in any position EXCEPT when in a return type position:
  • type T = string | never === string but type T = () => string | never !== () => string

This is also cases for literal + primitive types:

• primitive types "override" any literal types in a union:
  • string | 'foo' === string, number | 1 === number, boolean | false === boolean
• literal types "override" any primitive types in an intersection
  • string & 'foo' === 'foo', number & 1 === 1, boolean & false === false

With so many cases and edge cases - this goes beyond just banning specific syntax - so I think this makes sense as an entire rule.

Maybe something like no-redundant-union-or-intersection-members?