`strictPropertyInitialization` should allow private initialization helpers

Search Terms

• strictPropertyInitialization
• class initialization helper

Suggestion

It's a common pattern to delegate class initialization to helper methods to reduce the size of the constructor. This makes it more maintainable. However, when using --strictNullChecks and --strictPropertyInitialization, TypeScript complains because it's unable to infer the initialization since it's in a helper function. The argument in https://github.com/microsoft/TypeScript/issues/21132 is that it's because of inheritance, but I think it should work if the helper method is marked a private (or private class field #), since a subclass would not be able to access it.

Not only is it annoying to have to do private foo!: string;, but it's also hard to know to do that, so most just end up either removing the helper methods or using // @ts-ignore. It's also TS's goal to support common JS pattern as best as possible.

Use Cases

Explained above.

Examples

class A {
	private foo: string; // <== TypeScript complains

	constructor() {
		this.initStuff();
	}

	private initStuff() {
		this.foo = 'foo';
	}
}

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Comienza reproduciendo el ejemplo mínimo de clase con strictNullChecks y strictPropertyInitialization habilitados; después, compara el comportamiento de los helpers de inicialización privados y accesibles. Se considera terminado cuando el patrón de helper privado se acepta sin una definite-assignment assertion, mientras que la herencia y otros casos de inicialización siguen siendo seguros.