This PR implements a new--strictPropertyInitialization compiler option to guard against uninitialized properties in class instances. Strict property initialization checking verifies that each instance property declared in a class either (a) has a type that includesundefined or (b) has an explicit initializer or an assignment to the property in the constructor. The--strictPropertyInitialization option has no effect unless--strictNullChecks is also enabled.

The--strictPropertyInitialization switch is part of the--strict family of switches, meaning that it defaults to on in--strict mode. This PR is therefore a breaking change only in--strict mode.

In this example

// Compile with --strictclassTest{a:number;// Error, property not initializedb?:string;// Ok, type includes undefined}

an error is reported on propertya because its type doesn't includeundefined and the property declaration doesn't specify an initializer or assign a value to the property in the constructor. The error can be fixed by changing the type ofa to includeundefined, by specifying an initial value fora, or by assigning a value toa in the constructor. For example, this is ok:

// Compile with --strictclassTest{a:number=0;// Okb?:string;}

A strict property initialization check is satisfied by assignments in the constructor only when all possible code paths include assignments to the particular property.

// Compile with --strictclassTest{a:number;constructor(startAtZero:boolean){if(startAtZero){this.a=0;}else{this.a=1;}}}

In the example above, an error would occur if either of theif statement branches omitted the assignment tothis.a.

Strict property initialization checks guard against observing uninitialized properties in the constructor body. For example:

// Compile with --strictclassTest{a:number;constructor(){letx=this.a;// Errorthis.a=0;}}

Strict property initialization checks also guard against observing uninitialized propertiesafter the constructor returns. However, it is possible to observe uninitialized properties in methods that are called from the constructor (or from a base constructor). For example:

// Compile with --strictclassTest{a:number;constructor(){this.foo();this.a=0;}foo(){// Uninitialized value of 'a' observable here}}

Strict property initialization checks only apply to properties that are declared with proper identifiers. It does not apply to properties with computed names or properties with names specified as string or numeric literals (this is analogous to how control flow analysis isn't applied to properties accessed usingobj["foo"] syntax).

// Compile with --strictclassTest{a:number;// Error, not initialized"hello world":number;// No check}

In cases where the properties of a class instance are initialized by external means (such as dependency injection) or where it is known that an initialization method is always called before other methods, strict property initialization checks can be suppressed by includingdefinite assignment assertions (#20166) in the declarations of the properties.

// Compile with --strictclassC{a!:number;// Use ! to suppress errorb!:string;// Use ! to suppress errorinitialize(){this.a=0;this.b="hello";}}

Alternatively,// @ts-ignore comments can be used to suppress the errors, or the code can simply be compiled without the--strictPropertyInitialization option.

Fixes#8476.