This PR introducescontrol flow based type analysis for local variables and parameters as initially suggested in#2388 and prototyped in#6959. Previously, the type analysis performed for type guards was limited toif statements and?: conditional expressions and didn't include effects of assignments and control flow constructs such asreturn andbreak statements. With this PR, the type checker analyses all possible flows of control in statements and expressions to produce the most specific type possible (thenarrowed type) at any given location for a local variable or parameter that is declared to have a union type.

Some examples:

functionfoo(x:string|number|boolean){if(typeofx==="string"){x;// type of x is string herex=1;x;// type of x is number here}x;// type of x is number | boolean here}functionbar(x:string|number){if(typeofx==="number"){return;}x;// type of x is string here}

Control flow based type analysis is particuarly relevant in--strictNullChecks mode because nullable types are represented using union types:

functiontest(x:string|null){if(x===null){return;}x;// type of x is string in remainder of function}

Furthermore, in--strictNullChecks mode, control flow based type analysis includesdefinite assignment analysis for local variables of types that don't permit the valueundefined.

functionmumble(check:boolean){letx:number;// Type doesn't permit undefinedx;// Error, x is undefinedif(check){x=1;x;// Ok}x;// Error, x is possibly undefinedx=2;x;// Ok}

The narrowed type of a local variable or parameter at a given source code location is computed by starting with the initial type of the variable and then following each possible code path that leads to the given location, narrowing the type of the variable as appropriate based on type guards and assignments.

• The initial type of local variable isundefined.
• The initial type of a parameter is the declared type of the parameter.
• The initial type of an outer local variable or a global variable is the declared type of that variable.
• A type guard narrows the type of a variable in the code path that follows the type guard.
• An assignment (including an initializer in a declaration) of a value of type S to a variable of type T changes the type of that variable to Tnarrowed by S in the code path that follows the assignment.
• When multiple code paths lead to a particular location, the narrowed type of a given variable at that location is the union type of the narrowed types of the variable in those code paths.

The type Tnarrowed by S is computed as follows:

• If T is not a union type, the result is T.
• If T is a union type, the result is the union of each constituent type in T to which S is assignable.

Thanks to@ivogabe for providing inspiration and tests for this PR.

Fixes#2388.