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 includes undefined 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 --strict
class Test {
    a: number;  // Error, property not initialized
    b?: string;  // Ok, type includes undefined
}

an error is reported on property a because its type doesn't include undefined 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 of a to include undefined, by specifying an initial value for a, or by assigning a value to a in the constructor. For example, this is ok:

// Compile with --strict
class Test {
    a: number = 0;  // Ok
    b?: 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 --strict
class Test {
    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 the if statement branches omitted the assignment to this.a.

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

// Compile with --strict
class Test {
    a: number;
    constructor() {
        let x = this.a;  // Error
        this.a = 0;
    }
}

Strict property initialization checks also guard against observing uninitialized properties after 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 --strict
class Test {
    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 using obj["foo"] syntax).

// Compile with --strict
class Test {
    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 including definite assignment assertions (#20166) in the declarations of the properties.

// Compile with --strict
class C {
    a!: number;  // Use ! to suppress error
    b!: string;  // Use ! to suppress error
    initialize() {
        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.