Variable aliasing this should be treated the same as this

Search Terms

this alias

Suggestion

If I do const me = this; then me should be treated the same as this especially since it's a constant and cannot be updated to another value

Use Cases

I'm using --allowJs and --checkJs. Right now TypeScript makes us do this:

	constructor(chart, datasetIndex) {
		this.chart = chart;
		this._ctx = chart.ctx;
		this.index = datasetIndex;
		this._cachedAnimations = {};
		this._cachedDataOpts = {};
		this._cachedMeta = this.getMeta();
		this._type = this._cachedMeta.type;
		this._config = undefined;
		this._parsing = false;
		this._data = undefined;
		this._dataCopy = undefined;
		this._objectData = undefined;
		this._labels = undefined;
		this._scaleStacked = {};

		this.initialize();
	}

Examples

I would like to be able to do this:

	constructor(chart, datasetIndex) {
		const me = this;
		me.chart = chart;
		me._ctx = chart.ctx;
		me.index = datasetIndex;
		me._cachedAnimations = {};
		me._cachedDataOpts = {};
		me._cachedMeta = this.getMeta();
		me._type = this._cachedMeta.type;
		me._config = undefined;
		me._parsing = false;
		me._data = undefined;
		me._dataCopy = undefined;
		me._objectData = undefined;
		me._labels = undefined;
		me._scaleStacked = {};

		me.initialize();
	}

This would make our transition to TypeScript much easier since our code follows this pattern throughout the codebase. It would also result in a smaller file size, which is why we'd adopted this pattern.

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.

L’issue ne mentionne aucun fichier source, test ou point d’entrée. Commencez par reproduire les exemples avec --allowJs et --checkJs, puis examinez comment un alias const de this est actuellement traité. Le travail est considéré comme terminé lorsque l’alias reçoit le même comportement de vérification que this sans modifier le JavaScript généré.