In JS, constructor functions without property assignments aren't recognised as classes

[mjbvz]

TypeScript Version: 2.5.1

Code

For the JS:

function Foo() {
	this.init();
}

Foo.prototype.init = function () {
	// code
}

const a = new Foo();
a.init()

Expected behavior:
In the function Foo, this is the type of Foo and you can run go to definition on this.init

Actual behavior:
this is any. go to definition does not work on this.init but does on a.init

[AlCalzone]

I believe I'm running into a similar issue:

function Foo() {
	if (!(this instanceof Foo)) return new Foo();
	
	this.method1 = (abc) => {
		console.log(abc);
	};
	this.method1();

	this.method2 = () => {
		this.method1();
	};
}

method1 and method2 are correctly detected as properties of Foo:

However, inside the constructor and the methods, this is any and so is this.method1. Thus calling method1 with no parameters is not detected as an error.

[trusktr]

Hello! How do we write ES5 constructor classes in TypeScript?

[sandersn]

@trusktr This issue tracks detection of ES5 constructor functions in Javascript.

For example, the original example works if you put /** @class */ above it, but it's not detected otherwise because there's no this-property assignment, which is the other thing the compiler looks for.

To write an ES5 constructor function in Typescript, use this parameters. However, when you new this function, it'll still have type any, and an error in strict mode. You should use classes in Typescript if you want classes:

function Class(this: { x: number }, x: number) {
    this.x = x
}

var c = new Class(12) // this line is still an error in strict mode

[moll]

It's rather surprising the prototypical inheritance model with constructors isn't supported well in TypeScript. From https://github.com/microsoft/TypeScript/wiki/Type-Checking-JavaScript-Files#constructor-functions-are-equivalent-to-classes I got the impression the ES5 style is properly handled with new and this propagated as expected.

If the verbose solution of https://stackoverflow.com/questions/49799192/how-can-i-make-old-style-classes-work-in-typescript is truly by design, in what way are ES5 constructors functions equivalent as claimed in the wiki link)? It's nice that the methods get type checked, but a little useless if one can't instantiate the object with proper type inference. :P

Here's a test case for one parent and one inherited object: https://www.typescriptlang.org/play/index.html#code/GYVwdgxgLglg9mABABQKYCcDOCAUYCGAtqgFyKZToxgDmAlIgN4BQibiUAFjJgHQHFEAXkQDUzAL7NmoSLASIAqpgw4YAEzJgQhAEYYANKKKlylavSat2aLAl4R8AGyc4uPI2LrW27vhuFEDUlpZQxeAAd0OCgYgE8I1ECAeV0AK1RoB3RUfChUHFtsMEjo2KgE1CMWNggECnQQaDh0MkYAN2cQUzD0IzqwYBgaEHR8XSdTSm6jAHcqfPHJsmnUKQlvZk70RES7JBEwVFmUDGKcACIAKThOMAvvPeLeYDg4Zif7MWltxDTbg6iY5KFToHAAFgATEZrgCHsx-ndeMFESVvqiXm8gA

[moll]

I noticed that TypeScript behaves differently when its input language is set to .js and fortunately the basic Person instance seems properly type inferred in that case:
https://www.typescriptlang.org/play/index.html?target=1&useJavaScript=true#code/PQKhCgAIUgBBjANgQwM6sgBQKYCdUD2AdlDLAA7K7IC2kA3qgC64CWRA5gL6RG3alg4AGYBXIvCatiWPISIAKPjWwBKBlEhamAC1aoAdMuyQAvL37gu4cKAjQ4SNBgCqqPKTjYAHk2xEAEwwcfGJPCipaBiJRGgAjPB5WAPDKajpGFnZuCxVBEXFJaSJINzwFZIAaXLUNLS0Q+QN4ZEREBV19auNVTW09Q2SzSGSrGzLcA3JcAiZZgE9yE3MAeTiAK2xJZtxsZD8FRuIpmbmmRexq+k14YmZcUUkCXAAuBgA3VtFsN4nq26IwlYHFE1DiiB+kBY32qAHc2H5kODIdDsNYuL1wJ9cJAlqESuYiNhYbJ8QoAEQAKQIOiI5N6eKawgIBHAjOOxhs2NxchkhOJpPkCgALAAmTHc9Y0gm8AUTEWi6pU6X08BS2kGUbqohGSzagzMghAA

Unfortunately both Object.create nor JSDoc's @extends isn't understood and instantiating User does not infer existence of Person's properties. This seems mentioned on https://www.typescriptlang.org/docs/handbook/type-checking-javascript-files.html#extends, too. That's very unfortunate.

[sandersn]

#39447 fixes the original example and the one from @AlCalzone, so I think it's fair to close this bug. However, the fix doesn't do exactly what the bug title requests. The fix types this: this inside any function that is known to be a constructor function, unlike 3.9, which only types this: this inside functions that have this-property assignments.

Almost every constructor function will have methods or a prototype assignment (or this-property assignments), so it covers basically all constructor functions.

@moll You are looking for #13206 or #36369
Please upvote and consider contributing some analysis of patterns you would like supported.