This PR introduces a number of changes affecting control flow analysis of truthy, equality, and typeof checks involving typeunknown and unconstrained type variables in--strictNullChecks mode. Key to these changes is the fact that{}, the empty object type literal, is a supertype of all types exceptnull andundefined. Thus,{} | null | undefined is effectively equivalent tounknown, and for an arbitrary typeT, the intersectionT & {} represents the non-nullable form ofT.

The PR introduces the following new behaviors:

• An unconstrained type parameter is no longer assignable to{}.
• The predefined typeNonNullable<T> is now an alias forT & {}.
• An intersectionT & {}, whereT is non-generic and notnull orundefined, reduces to justT (null & {} andundefined & {} already reduce tonever). See below for exceptions forstring & {},number & {}, andbigint & {}.
• An intersectionundefined & void reduces to justundefined.
• Any type is assignable to a union type that contains{},null, andundefined.
• In control flow analysis,unknown behaves similarly to the union type{} | null | undefined.
• In control flow analysis of truthy checks, generic types are intersected with{} in the true branch.
• In control flow analysis of equality comparisons withnull orundefined, generic types are intersected with{},{} | null, or{} | undefined in the false branch.
• In control flow analysis oftypeof x === "object" expressions, generic types are intersected withobject and/ornull in the true branch (typeof checks for other types already produce intersections in a similar manner).

Some examples:

typeT1={}&string;// stringtypeT2={}&'a';// 'a'typeT3={}&object;// objecttypeT4={}&{x:number};// { x: number }typeT5={}&null;// nevertypeT6={}&undefined;// nevertypeT7=undefined&void;// undefinedfunctionf1(u:unknown){letx1:{}=u;// Errorletx2:{}|null|undefined=u;// Okletx3:{}|{x:string}|null|undefined=u;// Ok}functionf2(x:unknown){if(x){x;// {}}else{x;// unknown}}functionf3<T>(x:T){if(x){x;// T & {}}else{x;// T}}functionf4(x:unknown){if(x!==undefined){x;// {} | null}else{x;// undefined}if(x!==null){x;// {} | undefined}else{x;// null}if(x!==undefined&&x!==null){x;// {}}else{x;// null | undefined}if(x!=undefined){x;// {}}else{x;// null | undefined}if(x!=null){x;// {}}else{x;// null | undefined}}functionf5<T>(x:T){if(x!==undefined){x;// T & ({} | null)}else{x;// T}if(x!==null){x;// T & ({} | undefined)}else{x;// T}if(x!==undefined&&x!==null){x;// {}}else{x;// T}if(x!=undefined){x;// {}}else{x;// T}if(x!=null){x;// {}}else{x;// T}}functionf6<T>(x:T){if(typeofx==="object"){x;// T & object | T & null}if(x&&typeofx==="object"){x;// T & object}if(typeofx==="object"&&x){x;// T & object}}functionensureNotNull<T>(x:T){if(x===null)throwError();returnx;// T & ({} | undefined)}functionensureNotUndefined<T>(x:T){if(x===undefined)throwError();returnx;// T & ({} | null)}functionensureNotNullOrUndefined<T>(x:T){returnensureNotUndefined(ensureNotNull(x));// T & {}}functionf7(a:string|undefined,b:number|null|undefined){leta1=ensureNotNullOrUndefined(a);// stringletb1=ensureNotNullOrUndefined(b);// number}

Note the manner in which types are properly inferred, combined, and reduced in theensureNotXXX functions. This contrasts with theNonNullable<T> conditional type provided inlib.d.ts, which unfortunately combines and reduces poorly. For example,NonNullable<NonNullable<T>> doesn't inherently reduce toNonNullable<T>, sometimes leading to needlessly complex types. For this and other reasons we intend to investigate switchingNonNullable<T> to be an alias forT & {}.

For backwards compatibility, special exceptions to theT & {} type reduction rules existing for intersections written explicitly asstring & {},number & {}, andbigint & {} (as opposed to created through instantiation of a generic typeT & {}). These types are used in a few frameworks (e.g.react andcsstype) to construct types that permit anystring,number, orbigint, but has statement completion hints for common literal values. For example:

typeAlignment=string&{}|"left"|"center"|"right";

The specialstring & {} type prevents subtype reduction from taking place in the union type, thus preserving the literal types, but otherwise anystring value is assignable to the type.

This PR reinstatates#48366 (which was removed from 4.7 due to concerns over breaking changes).

Fixes#23368.
Fixes#31908.
Fixes#32347.
Fixes#43997.
Fixes#44446.
Fixes#48048.
Fixes#48468.
Fixes#48691.
Fixes#49005.
Fixes#49191.