Add getEffectiveConstructSignatures

[sandersn]

• getEffectiveConstructSignatures gets construct signatures from type, and call signatures from constructor functions if there are no construct signatures.
• getEffectiveConstructSignatureReturnType gets the "JS Class type" for constructor functions, and the return type of signatures for all other declarations.

This is a first step toward making constructor functions have construct signatures instead of call signatures, which will also contribute to fixing instantiation of generic constructor functions, which is basically broken right now.

Note that the baselines improve but, because of the previously mentioned generic problem, are still not correct. Construct signatures for constructor functions and generic constructor functions turns out to be an intertwined problem.

Specifically, a non-generic class that inherits from a generic constructor function now finds a signature, but can't yet instantiate it, so it just returns any for now. However, the constructor signature itself is correctly instantiated in the ad-hoc code in resolveNewExpression, so in the following example, the arguments are correctly checked but the resulting instance type is any:

/** @template T
 * @param {T} val
 */
function B(val) {
  this.val = val
}
/** @extends {B<number>} */
class C extends B {
}
new C() // error
new C('hi') // error

I'll fix this in a separate PR, which will probably be much bigger.

[weswigham]

Rather than adding another pair of getEffectiveX, in this case, could we not just add the construct signatures to the type directly in resolveAnonymousTypeMembers? We should just need to amend

                if (symbol.flags & (SymbolFlags.Function | SymbolFlags.Method)) {
                    type.callSignatures = getSignaturesOfSymbol(symbol);
                }

with

type.constructSignatures = filter(type.callSignatures, sig => isJSConstructor(sig.declaration));

and getReturnTypeOfSignature around

let type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper!) :
                    signature.unionSignatures ? getUnionType(map(signature.unionSignatures, getReturnTypeOfSignature), UnionReduction.Subtype) :
                    getReturnTypeFromAnnotation(signature.declaration!) ||
                    (nodeIsMissing((<FunctionLikeDeclaration>signature.declaration).body) ? anyType : getReturnTypeFromBody(<FunctionLikeDeclaration>signature.declaration));

with

let type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper!) :
                    signature.unionSignatures ? getUnionType(map(signature.unionSignatures, getReturnTypeOfSignature), UnionReduction.Subtype) :
                    isJSConstructor(signature.declaration) ? getJSClassType(getSymbolOfNode(signature.declaration!)) :
                    getReturnTypeFromAnnotation(signature.declaration!) ||
                    (nodeIsMissing((<FunctionLikeDeclaration>signature.declaration).body) ? anyType : getReturnTypeFromBody(<FunctionLikeDeclaration>signature.declaration));

no?

[sandersn]

The latter should definitely work, although I decided to favour @return {Type} over @constructor as a marker of the type.

The former might have odd effects through out the system, but it is where I want to go, so I'll try it out.

[sandersn]

After testing: the results keep the improvements without changing baselines too much, so I think this is a good solution. Thanks @weswigham !