Allow assignment of void returning functions to appropriate construct signature types

[danquirk]

Consider an existing JS constructor function

var Foo = function (x,y) { 
    this.x = x;
    this.y = y;
}
var foo = new Foo(1,2);

This is allowed in TypeScript due to a specific exception which allows new to be called on non-constructor functions only if they're void returning. Now if you want to more strongly type this code, but without converting to full on classes yet, we do not allow you to do so in a fully typesafe manner:

interface FooInstance {
    x: number;
    y: number;
}
interface FooConstructor {
    new (x: number, y: number): FooInstance;
}
// this an error, new(x,y)=>FooInstance is not assignable to (x,y)=>void
var Foo: FooConstructor = function (x,y) {
    this.x = x;
    this.y = y;
}
var foo = new Foo(1,2);

We require you to cast the constructor function to any or Function in order for it to be assignable to the FooConstructor interface.

Given that we've made an exception for void returning functions already in order to accommodate this pattern it doesn't seem crazy to make one more exception for them through the assignability relation in order to complete the desired scenario.

See #2299 for another example from a customer.

[RyanCavanaugh]

If anything we'd rather remove the ability to new void functions. The inconsistency is unfortunate but we didn't want to add a large type safety hole for the sake of consistency with a facet we don't even like in the first place.

[nycdotnet]

Hi Ryan,

Very coincidentally, this came up again for me today while refactoring an old code base - this time with an Angular 1.x View Model written in the "call new on a void function to make a constructor" style that has fallen out of favor today, but is still floating around (it remains part of the Knockout tutorial at http://learn.knockoutjs.com/#/?tutorial=collections).

Anyway, we've gained the ability to strongly type this within a function since this issue was considered; with a strongly-typed this, I don't believe that this JS pattern represents a type-safety hole anymore. The rule could be: if a void function with an explicitly-typed this is called with new, the return type of the expression is the same type as the explicit this within that function, and error TS7009 does not apply.

Thanks either way!