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.

The issue names no source file, test, or entry point. Start by reproducing the examples with --allowJs and --checkJs, then investigate how a const alias of this is currently treated. Done means the alias receives the same checking behavior as this without changing emitted JavaScript.